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 {
166 	const struct mcs_platform_data *platform_data =
167 		data->platform_data;
168 	struct i2c_client *client = data->client;
169 
170 	/* Touch reset & sleep mode */
171 	i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE,
172 			RESET_EXT_SOFT | OP_MODE_SLEEP);
173 
174 	/* Touch size */
175 	i2c_smbus_write_byte_data(client, MCS5000_TS_X_SIZE_UPPER,
176 			platform_data->x_size >> 8);
177 	i2c_smbus_write_byte_data(client, MCS5000_TS_X_SIZE_LOWER,
178 			platform_data->x_size & 0xff);
179 	i2c_smbus_write_byte_data(client, MCS5000_TS_Y_SIZE_UPPER,
180 			platform_data->y_size >> 8);
181 	i2c_smbus_write_byte_data(client, MCS5000_TS_Y_SIZE_LOWER,
182 			platform_data->y_size & 0xff);
183 
184 	/* Touch active mode & 80 report rate */
185 	i2c_smbus_write_byte_data(data->client, MCS5000_TS_OP_MODE,
186 			OP_MODE_ACTIVE | REPORT_RATE_80);
187 }
188 
189 static int mcs5000_ts_probe(struct i2c_client *client,
190 		const struct i2c_device_id *id)
191 {
192 	struct mcs5000_ts_data *data;
193 	struct input_dev *input_dev;
194 	int ret;
195 
196 	if (!dev_get_platdata(&client->dev))
197 		return -EINVAL;
198 
199 	data = kzalloc(sizeof(struct mcs5000_ts_data), GFP_KERNEL);
200 	input_dev = input_allocate_device();
201 	if (!data || !input_dev) {
202 		dev_err(&client->dev, "Failed to allocate memory\n");
203 		ret = -ENOMEM;
204 		goto err_free_mem;
205 	}
206 
207 	data->client = client;
208 	data->input_dev = input_dev;
209 	data->platform_data = dev_get_platdata(&client->dev);
210 
211 	input_dev->name = "MELPAS MCS-5000 Touchscreen";
212 	input_dev->id.bustype = BUS_I2C;
213 	input_dev->dev.parent = &client->dev;
214 
215 	__set_bit(EV_ABS, input_dev->evbit);
216 	__set_bit(EV_KEY, input_dev->evbit);
217 	__set_bit(BTN_TOUCH, input_dev->keybit);
218 	input_set_abs_params(input_dev, ABS_X, 0, MCS5000_MAX_XC, 0, 0);
219 	input_set_abs_params(input_dev, ABS_Y, 0, MCS5000_MAX_YC, 0, 0);
220 
221 	input_set_drvdata(input_dev, data);
222 
223 	if (data->platform_data->cfg_pin)
224 		data->platform_data->cfg_pin();
225 
226 	ret = request_threaded_irq(client->irq, NULL, mcs5000_ts_interrupt,
227 			IRQF_TRIGGER_LOW | IRQF_ONESHOT, "mcs5000_ts", data);
228 
229 	if (ret < 0) {
230 		dev_err(&client->dev, "Failed to register interrupt\n");
231 		goto err_free_mem;
232 	}
233 
234 	ret = input_register_device(data->input_dev);
235 	if (ret < 0)
236 		goto err_free_irq;
237 
238 	mcs5000_ts_phys_init(data);
239 	i2c_set_clientdata(client, data);
240 
241 	return 0;
242 
243 err_free_irq:
244 	free_irq(client->irq, data);
245 err_free_mem:
246 	input_free_device(input_dev);
247 	kfree(data);
248 	return ret;
249 }
250 
251 static int mcs5000_ts_remove(struct i2c_client *client)
252 {
253 	struct mcs5000_ts_data *data = i2c_get_clientdata(client);
254 
255 	free_irq(client->irq, data);
256 	input_unregister_device(data->input_dev);
257 	kfree(data);
258 
259 	return 0;
260 }
261 
262 #ifdef CONFIG_PM
263 static int mcs5000_ts_suspend(struct device *dev)
264 {
265 	struct i2c_client *client = to_i2c_client(dev);
266 
267 	/* Touch sleep mode */
268 	i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE, OP_MODE_SLEEP);
269 
270 	return 0;
271 }
272 
273 static int mcs5000_ts_resume(struct device *dev)
274 {
275 	struct i2c_client *client = to_i2c_client(dev);
276 	struct mcs5000_ts_data *data = i2c_get_clientdata(client);
277 
278 	mcs5000_ts_phys_init(data);
279 
280 	return 0;
281 }
282 
283 static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume);
284 #endif
285 
286 static const struct i2c_device_id mcs5000_ts_id[] = {
287 	{ "mcs5000_ts", 0 },
288 	{ }
289 };
290 MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
291 
292 static struct i2c_driver mcs5000_ts_driver = {
293 	.probe		= mcs5000_ts_probe,
294 	.remove		= mcs5000_ts_remove,
295 	.driver = {
296 		.name = "mcs5000_ts",
297 #ifdef CONFIG_PM
298 		.pm   = &mcs5000_ts_pm,
299 #endif
300 	},
301 	.id_table	= mcs5000_ts_id,
302 };
303 
304 module_i2c_driver(mcs5000_ts_driver);
305 
306 /* Module information */
307 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
308 MODULE_DESCRIPTION("Touchscreen driver for MELFAS MCS-5000 controller");
309 MODULE_LICENSE("GPL");
310