Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 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

Linux/drivers/input/touchscreen/mcs5000_ts.c

  1 /*
  2  * mcs5000_ts.c - Touchscreen driver for MELFAS MCS-5000 controller
  3  *
  4  * Copyright (C) 2009 Samsung Electronics Co.Ltd
  5  * Author: Joonyoung Shim <jy0922.shim@samsung.com>
  6  *
  7  * Based on wm97xx-core.c
  8  *
  9  *  This program is free software; you can redistribute  it and/or modify it
 10  *  under  the terms of  the GNU General  Public License as published by the
 11  *  Free Software Foundation;  either version 2 of the  License, or (at your
 12  *  option) any later version.
 13  *
 14  */
 15 
 16 #include <linux/module.h>
 17 #include <linux/i2c.h>
 18 #include <linux/i2c/mcs.h>
 19 #include <linux/interrupt.h>
 20 #include <linux/input.h>
 21 #include <linux/irq.h>
 22 #include <linux/slab.h>
 23 
 24 /* Registers */
 25 #define MCS5000_TS_STATUS               0x00
 26 #define STATUS_OFFSET                   0
 27 #define STATUS_NO                       (0 << STATUS_OFFSET)
 28 #define STATUS_INIT                     (1 << STATUS_OFFSET)
 29 #define STATUS_SENSING                  (2 << STATUS_OFFSET)
 30 #define STATUS_COORD                    (3 << STATUS_OFFSET)
 31 #define STATUS_GESTURE                  (4 << STATUS_OFFSET)
 32 #define ERROR_OFFSET                    4
 33 #define ERROR_NO                        (0 << ERROR_OFFSET)
 34 #define ERROR_POWER_ON_RESET            (1 << ERROR_OFFSET)
 35 #define ERROR_INT_RESET                 (2 << ERROR_OFFSET)
 36 #define ERROR_EXT_RESET                 (3 << ERROR_OFFSET)
 37 #define ERROR_INVALID_REG_ADDRESS       (8 << ERROR_OFFSET)
 38 #define ERROR_INVALID_REG_VALUE         (9 << ERROR_OFFSET)
 39 
 40 #define MCS5000_TS_OP_MODE              0x01
 41 #define RESET_OFFSET                    0
 42 #define RESET_NO                        (0 << RESET_OFFSET)
 43 #define RESET_EXT_SOFT                  (1 << RESET_OFFSET)
 44 #define OP_MODE_OFFSET                  1
 45 #define OP_MODE_SLEEP                   (0 << OP_MODE_OFFSET)
 46 #define OP_MODE_ACTIVE                  (1 << OP_MODE_OFFSET)
 47 #define GESTURE_OFFSET                  4
 48 #define GESTURE_DISABLE                 (0 << GESTURE_OFFSET)
 49 #define GESTURE_ENABLE                  (1 << GESTURE_OFFSET)
 50 #define PROXIMITY_OFFSET                5
 51 #define PROXIMITY_DISABLE               (0 << PROXIMITY_OFFSET)
 52 #define PROXIMITY_ENABLE                (1 << PROXIMITY_OFFSET)
 53 #define SCAN_MODE_OFFSET                6
 54 #define SCAN_MODE_INTERRUPT             (0 << SCAN_MODE_OFFSET)
 55 #define SCAN_MODE_POLLING               (1 << SCAN_MODE_OFFSET)
 56 #define REPORT_RATE_OFFSET              7
 57 #define REPORT_RATE_40                  (0 << REPORT_RATE_OFFSET)
 58 #define REPORT_RATE_80                  (1 << REPORT_RATE_OFFSET)
 59 
 60 #define MCS5000_TS_SENS_CTL             0x02
 61 #define MCS5000_TS_FILTER_CTL           0x03
 62 #define PRI_FILTER_OFFSET               0
 63 #define SEC_FILTER_OFFSET               4
 64 
 65 #define MCS5000_TS_X_SIZE_UPPER         0x08
 66 #define MCS5000_TS_X_SIZE_LOWER         0x09
 67 #define MCS5000_TS_Y_SIZE_UPPER         0x0A
 68 #define MCS5000_TS_Y_SIZE_LOWER         0x0B
 69 
 70 #define MCS5000_TS_INPUT_INFO           0x10
 71 #define INPUT_TYPE_OFFSET               0
 72 #define INPUT_TYPE_NONTOUCH             (0 << INPUT_TYPE_OFFSET)
 73 #define INPUT_TYPE_SINGLE               (1 << INPUT_TYPE_OFFSET)
 74 #define INPUT_TYPE_DUAL                 (2 << INPUT_TYPE_OFFSET)
 75 #define INPUT_TYPE_PALM                 (3 << INPUT_TYPE_OFFSET)
 76 #define INPUT_TYPE_PROXIMITY            (7 << INPUT_TYPE_OFFSET)
 77 #define GESTURE_CODE_OFFSET             3
 78 #define GESTURE_CODE_NO                 (0 << GESTURE_CODE_OFFSET)
 79 
 80 #define MCS5000_TS_X_POS_UPPER          0x11
 81 #define MCS5000_TS_X_POS_LOWER          0x12
 82 #define MCS5000_TS_Y_POS_UPPER          0x13
 83 #define MCS5000_TS_Y_POS_LOWER          0x14
 84 #define MCS5000_TS_Z_POS                0x15
 85 #define MCS5000_TS_WIDTH                0x16
 86 #define MCS5000_TS_GESTURE_VAL          0x17
 87 #define MCS5000_TS_MODULE_REV           0x20
 88 #define MCS5000_TS_FIRMWARE_VER         0x21
 89 
 90 /* Touchscreen absolute values */
 91 #define MCS5000_MAX_XC                  0x3ff
 92 #define MCS5000_MAX_YC                  0x3ff
 93 
 94 enum mcs5000_ts_read_offset {
 95         READ_INPUT_INFO,
 96         READ_X_POS_UPPER,
 97         READ_X_POS_LOWER,
 98         READ_Y_POS_UPPER,
 99         READ_Y_POS_LOWER,
100         READ_BLOCK_SIZE,
101 };
102 
103 /* Each client has this additional data */
104 struct mcs5000_ts_data {
105         struct i2c_client *client;
106         struct input_dev *input_dev;
107         const struct mcs_platform_data *platform_data;
108 };
109 
110 static irqreturn_t mcs5000_ts_interrupt(int irq, void *dev_id)
111 {
112         struct mcs5000_ts_data *data = dev_id;
113         struct i2c_client *client = data->client;
114         u8 buffer[READ_BLOCK_SIZE];
115         int err;
116         int x;
117         int y;
118 
119         err = i2c_smbus_read_i2c_block_data(client, MCS5000_TS_INPUT_INFO,
120                         READ_BLOCK_SIZE, buffer);
121         if (err < 0) {
122                 dev_err(&client->dev, "%s, err[%d]\n", __func__, err);
123                 goto out;
124         }
125 
126         switch (buffer[READ_INPUT_INFO]) {
127         case INPUT_TYPE_NONTOUCH:
128                 input_report_key(data->input_dev, BTN_TOUCH, 0);
129                 input_sync(data->input_dev);
130                 break;
131 
132         case INPUT_TYPE_SINGLE:
133                 x = (buffer[READ_X_POS_UPPER] << 8) | buffer[READ_X_POS_LOWER];
134                 y = (buffer[READ_Y_POS_UPPER] << 8) | buffer[READ_Y_POS_LOWER];
135 
136                 input_report_key(data->input_dev, BTN_TOUCH, 1);
137                 input_report_abs(data->input_dev, ABS_X, x);
138                 input_report_abs(data->input_dev, ABS_Y, y);
139                 input_sync(data->input_dev);
140                 break;
141 
142         case INPUT_TYPE_DUAL:
143                 /* TODO */
144                 break;
145 
146         case INPUT_TYPE_PALM:
147                 /* TODO */
148                 break;
149 
150         case INPUT_TYPE_PROXIMITY:
151                 /* TODO */
152                 break;
153 
154         default:
155                 dev_err(&client->dev, "Unknown ts input type %d\n",
156                                 buffer[READ_INPUT_INFO]);
157                 break;
158         }
159 
160  out:
161         return IRQ_HANDLED;
162 }
163 
164 static void mcs5000_ts_phys_init(struct mcs5000_ts_data *data,
165                                  const struct mcs_platform_data *platform_data)
166 {
167         struct i2c_client *client = data->client;
168 
169         /* Touch reset & sleep mode */
170         i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE,
171                         RESET_EXT_SOFT | OP_MODE_SLEEP);
172 
173         /* Touch size */
174         i2c_smbus_write_byte_data(client, MCS5000_TS_X_SIZE_UPPER,
175                         platform_data->x_size >> 8);
176         i2c_smbus_write_byte_data(client, MCS5000_TS_X_SIZE_LOWER,
177                         platform_data->x_size & 0xff);
178         i2c_smbus_write_byte_data(client, MCS5000_TS_Y_SIZE_UPPER,
179                         platform_data->y_size >> 8);
180         i2c_smbus_write_byte_data(client, MCS5000_TS_Y_SIZE_LOWER,
181                         platform_data->y_size & 0xff);
182 
183         /* Touch active mode & 80 report rate */
184         i2c_smbus_write_byte_data(data->client, MCS5000_TS_OP_MODE,
185                         OP_MODE_ACTIVE | REPORT_RATE_80);
186 }
187 
188 static int mcs5000_ts_probe(struct i2c_client *client,
189                             const struct i2c_device_id *id)
190 {
191         const struct mcs_platform_data *pdata;
192         struct mcs5000_ts_data *data;
193         struct input_dev *input_dev;
194         int error;
195 
196         pdata = dev_get_platdata(&client->dev);
197         if (!pdata)
198                 return -EINVAL;
199 
200         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
201         if (!data) {
202                 dev_err(&client->dev, "Failed to allocate memory\n");
203                 return -ENOMEM;
204         }
205 
206         data->client = client;
207 
208         input_dev = devm_input_allocate_device(&client->dev);
209         if (!input_dev) {
210                 dev_err(&client->dev, "Failed to allocate input device\n");
211                 return -ENOMEM;
212         }
213 
214         input_dev->name = "MELFAS MCS-5000 Touchscreen";
215         input_dev->id.bustype = BUS_I2C;
216         input_dev->dev.parent = &client->dev;
217 
218         __set_bit(EV_ABS, input_dev->evbit);
219         __set_bit(EV_KEY, input_dev->evbit);
220         __set_bit(BTN_TOUCH, input_dev->keybit);
221         input_set_abs_params(input_dev, ABS_X, 0, MCS5000_MAX_XC, 0, 0);
222         input_set_abs_params(input_dev, ABS_Y, 0, MCS5000_MAX_YC, 0, 0);
223 
224         input_set_drvdata(input_dev, data);
225         data->input_dev = input_dev;
226 
227         if (pdata->cfg_pin)
228                 pdata->cfg_pin();
229 
230         error = devm_request_threaded_irq(&client->dev, client->irq,
231                                           NULL, mcs5000_ts_interrupt,
232                                           IRQF_TRIGGER_LOW | IRQF_ONESHOT,
233                                           "mcs5000_ts", data);
234         if (error) {
235                 dev_err(&client->dev, "Failed to register interrupt\n");
236                 return error;
237         }
238 
239         error = input_register_device(data->input_dev);
240         if (error) {
241                 dev_err(&client->dev, "Failed to register input device\n");
242                 return error;
243         }
244 
245         mcs5000_ts_phys_init(data, pdata);
246         i2c_set_clientdata(client, data);
247 
248         return 0;
249 }
250 
251 #ifdef CONFIG_PM
252 static int mcs5000_ts_suspend(struct device *dev)
253 {
254         struct i2c_client *client = to_i2c_client(dev);
255 
256         /* Touch sleep mode */
257         i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE, OP_MODE_SLEEP);
258 
259         return 0;
260 }
261 
262 static int mcs5000_ts_resume(struct device *dev)
263 {
264         struct i2c_client *client = to_i2c_client(dev);
265         struct mcs5000_ts_data *data = i2c_get_clientdata(client);
266         const struct mcs_platform_data *pdata = dev_get_platdata(dev);
267 
268         mcs5000_ts_phys_init(data, pdata);
269 
270         return 0;
271 }
272 #endif
273 
274 static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume);
275 
276 static const struct i2c_device_id mcs5000_ts_id[] = {
277         { "mcs5000_ts", 0 },
278         { }
279 };
280 MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
281 
282 static struct i2c_driver mcs5000_ts_driver = {
283         .probe          = mcs5000_ts_probe,
284         .driver = {
285                 .name = "mcs5000_ts",
286                 .pm   = &mcs5000_ts_pm,
287         },
288         .id_table       = mcs5000_ts_id,
289 };
290 
291 module_i2c_driver(mcs5000_ts_driver);
292 
293 /* Module information */
294 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
295 MODULE_DESCRIPTION("Touchscreen driver for MELFAS MCS-5000 controller");
296 MODULE_LICENSE("GPL");
297 

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