1/*
2 * Synaptics NavPoint (PXA27x SSP/SPI) driver.
3 *
4 * Copyright (C) 2012 Paul Parsons <lost.distance@yahoo.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <linux/platform_device.h>
14#include <linux/clk.h>
15#include <linux/delay.h>
16#include <linux/gpio.h>
17#include <linux/input.h>
18#include <linux/input/navpoint.h>
19#include <linux/interrupt.h>
20#include <linux/mutex.h>
21#include <linux/pxa2xx_ssp.h>
22#include <linux/slab.h>
23
24/*
25 * Synaptics Modular Embedded Protocol: Module Packet Format.
26 * Module header byte 2:0 = Length (# bytes that follow)
27 * Module header byte 4:3 = Control
28 * Module header byte 7:5 = Module Address
29 */
30#define HEADER_LENGTH(byte)	((byte) & 0x07)
31#define HEADER_CONTROL(byte)	(((byte) >> 3) & 0x03)
32#define HEADER_ADDRESS(byte)	((byte) >> 5)
33
34struct navpoint {
35	struct ssp_device	*ssp;
36	struct input_dev	*input;
37	struct device		*dev;
38	int			gpio;
39	int			index;
40	u8			data[1 + HEADER_LENGTH(0xff)];
41};
42
43/*
44 * Initialization values for SSCR0_x, SSCR1_x, SSSR_x.
45 */
46static const u32 sscr0 = 0
47	| SSCR0_TUM		/* TIM = 1; No TUR interrupts */
48	| SSCR0_RIM		/* RIM = 1; No ROR interrupts */
49	| SSCR0_SSE		/* SSE = 1; SSP enabled */
50	| SSCR0_Motorola	/* FRF = 0; Motorola SPI */
51	| SSCR0_DataSize(16)	/* DSS = 15; Data size = 16-bit */
52	;
53static const u32 sscr1 = 0
54	| SSCR1_SCFR		/* SCFR = 1; SSPSCLK only during transfers */
55	| SSCR1_SCLKDIR		/* SCLKDIR = 1; Slave mode */
56	| SSCR1_SFRMDIR		/* SFRMDIR = 1; Slave mode */
57	| SSCR1_RWOT		/* RWOT = 1; Receive without transmit mode */
58	| SSCR1_RxTresh(1)	/* RFT = 0; Receive FIFO threshold = 1 */
59	| SSCR1_SPH		/* SPH = 1; SSPSCLK inactive 0.5 + 1 cycles */
60	| SSCR1_RIE		/* RIE = 1; Receive FIFO interrupt enabled */
61	;
62static const u32 sssr = 0
63	| SSSR_BCE		/* BCE = 1; Clear BCE */
64	| SSSR_TUR		/* TUR = 1; Clear TUR */
65	| SSSR_EOC		/* EOC = 1; Clear EOC */
66	| SSSR_TINT		/* TINT = 1; Clear TINT */
67	| SSSR_PINT		/* PINT = 1; Clear PINT */
68	| SSSR_ROR		/* ROR = 1; Clear ROR */
69	;
70
71/*
72 * MEP Query $22: Touchpad Coordinate Range Query is not supported by
73 * the NavPoint module, so sampled values provide the default limits.
74 */
75#define NAVPOINT_X_MIN		1278
76#define NAVPOINT_X_MAX		5340
77#define NAVPOINT_Y_MIN		1572
78#define NAVPOINT_Y_MAX		4396
79#define NAVPOINT_PRESSURE_MIN	0
80#define NAVPOINT_PRESSURE_MAX	255
81
82static void navpoint_packet(struct navpoint *navpoint)
83{
84	int finger;
85	int gesture;
86	int x, y, z;
87
88	switch (navpoint->data[0]) {
89	case 0xff:	/* Garbage (packet?) between reset and Hello packet */
90	case 0x00:	/* Module 0, NULL packet */
91		break;
92
93	case 0x0e:	/* Module 0, Absolute packet */
94		finger = (navpoint->data[1] & 0x01);
95		gesture = (navpoint->data[1] & 0x02);
96		x = ((navpoint->data[2] & 0x1f) << 8) | navpoint->data[3];
97		y = ((navpoint->data[4] & 0x1f) << 8) | navpoint->data[5];
98		z = navpoint->data[6];
99		input_report_key(navpoint->input, BTN_TOUCH, finger);
100		input_report_abs(navpoint->input, ABS_X, x);
101		input_report_abs(navpoint->input, ABS_Y, y);
102		input_report_abs(navpoint->input, ABS_PRESSURE, z);
103		input_report_key(navpoint->input, BTN_TOOL_FINGER, finger);
104		input_report_key(navpoint->input, BTN_LEFT, gesture);
105		input_sync(navpoint->input);
106		break;
107
108	case 0x19:	/* Module 0, Hello packet */
109		if ((navpoint->data[1] & 0xf0) == 0x10)
110			break;
111		/* FALLTHROUGH */
112	default:
113		dev_warn(navpoint->dev,
114			 "spurious packet: data=0x%02x,0x%02x,...\n",
115			 navpoint->data[0], navpoint->data[1]);
116		break;
117	}
118}
119
120static irqreturn_t navpoint_irq(int irq, void *dev_id)
121{
122	struct navpoint *navpoint = dev_id;
123	struct ssp_device *ssp = navpoint->ssp;
124	irqreturn_t ret = IRQ_NONE;
125	u32 status;
126
127	status = pxa_ssp_read_reg(ssp, SSSR);
128	if (status & sssr) {
129		dev_warn(navpoint->dev,
130			 "unexpected interrupt: status=0x%08x\n", status);
131		pxa_ssp_write_reg(ssp, SSSR, (status & sssr));
132		ret = IRQ_HANDLED;
133	}
134
135	while (status & SSSR_RNE) {
136		u32 data;
137
138		data = pxa_ssp_read_reg(ssp, SSDR);
139		navpoint->data[navpoint->index + 0] = (data >> 8);
140		navpoint->data[navpoint->index + 1] = data;
141		navpoint->index += 2;
142		if (HEADER_LENGTH(navpoint->data[0]) < navpoint->index) {
143			navpoint_packet(navpoint);
144			navpoint->index = 0;
145		}
146		status = pxa_ssp_read_reg(ssp, SSSR);
147		ret = IRQ_HANDLED;
148	}
149
150	return ret;
151}
152
153static void navpoint_up(struct navpoint *navpoint)
154{
155	struct ssp_device *ssp = navpoint->ssp;
156	int timeout;
157
158	clk_prepare_enable(ssp->clk);
159
160	pxa_ssp_write_reg(ssp, SSCR1, sscr1);
161	pxa_ssp_write_reg(ssp, SSSR, sssr);
162	pxa_ssp_write_reg(ssp, SSTO, 0);
163	pxa_ssp_write_reg(ssp, SSCR0, sscr0);	/* SSCR0_SSE written last */
164
165	/* Wait until SSP port is ready for slave clock operations */
166	for (timeout = 100; timeout != 0; --timeout) {
167		if (!(pxa_ssp_read_reg(ssp, SSSR) & SSSR_CSS))
168			break;
169		msleep(1);
170	}
171
172	if (timeout == 0)
173		dev_err(navpoint->dev,
174			"timeout waiting for SSSR[CSS] to clear\n");
175
176	if (gpio_is_valid(navpoint->gpio))
177		gpio_set_value(navpoint->gpio, 1);
178}
179
180static void navpoint_down(struct navpoint *navpoint)
181{
182	struct ssp_device *ssp = navpoint->ssp;
183
184	if (gpio_is_valid(navpoint->gpio))
185		gpio_set_value(navpoint->gpio, 0);
186
187	pxa_ssp_write_reg(ssp, SSCR0, 0);
188
189	clk_disable_unprepare(ssp->clk);
190}
191
192static int navpoint_open(struct input_dev *input)
193{
194	struct navpoint *navpoint = input_get_drvdata(input);
195
196	navpoint_up(navpoint);
197
198	return 0;
199}
200
201static void navpoint_close(struct input_dev *input)
202{
203	struct navpoint *navpoint = input_get_drvdata(input);
204
205	navpoint_down(navpoint);
206}
207
208static int navpoint_probe(struct platform_device *pdev)
209{
210	const struct navpoint_platform_data *pdata =
211					dev_get_platdata(&pdev->dev);
212	struct ssp_device *ssp;
213	struct input_dev *input;
214	struct navpoint *navpoint;
215	int error;
216
217	if (!pdata) {
218		dev_err(&pdev->dev, "no platform data\n");
219		return -EINVAL;
220	}
221
222	if (gpio_is_valid(pdata->gpio)) {
223		error = gpio_request_one(pdata->gpio, GPIOF_OUT_INIT_LOW,
224					 "SYNAPTICS_ON");
225		if (error)
226			return error;
227	}
228
229	ssp = pxa_ssp_request(pdata->port, pdev->name);
230	if (!ssp) {
231		error = -ENODEV;
232		goto err_free_gpio;
233	}
234
235	/* HaRET does not disable devices before jumping into Linux */
236	if (pxa_ssp_read_reg(ssp, SSCR0) & SSCR0_SSE) {
237		pxa_ssp_write_reg(ssp, SSCR0, 0);
238		dev_warn(&pdev->dev, "ssp%d already enabled\n", pdata->port);
239	}
240
241	navpoint = kzalloc(sizeof(*navpoint), GFP_KERNEL);
242	input = input_allocate_device();
243	if (!navpoint || !input) {
244		error = -ENOMEM;
245		goto err_free_mem;
246	}
247
248	navpoint->ssp = ssp;
249	navpoint->input = input;
250	navpoint->dev = &pdev->dev;
251	navpoint->gpio = pdata->gpio;
252
253	input->name = pdev->name;
254	input->dev.parent = &pdev->dev;
255
256	__set_bit(EV_KEY, input->evbit);
257	__set_bit(EV_ABS, input->evbit);
258	__set_bit(BTN_LEFT, input->keybit);
259	__set_bit(BTN_TOUCH, input->keybit);
260	__set_bit(BTN_TOOL_FINGER, input->keybit);
261
262	input_set_abs_params(input, ABS_X,
263			     NAVPOINT_X_MIN, NAVPOINT_X_MAX, 0, 0);
264	input_set_abs_params(input, ABS_Y,
265			     NAVPOINT_Y_MIN, NAVPOINT_Y_MAX, 0, 0);
266	input_set_abs_params(input, ABS_PRESSURE,
267			     NAVPOINT_PRESSURE_MIN, NAVPOINT_PRESSURE_MAX,
268			     0, 0);
269
270	input->open = navpoint_open;
271	input->close = navpoint_close;
272
273	input_set_drvdata(input, navpoint);
274
275	error = request_irq(ssp->irq, navpoint_irq, 0, pdev->name, navpoint);
276	if (error)
277		goto err_free_mem;
278
279	error = input_register_device(input);
280	if (error)
281		goto err_free_irq;
282
283	platform_set_drvdata(pdev, navpoint);
284	dev_dbg(&pdev->dev, "ssp%d, irq %d\n", pdata->port, ssp->irq);
285
286	return 0;
287
288err_free_irq:
289	free_irq(ssp->irq, navpoint);
290err_free_mem:
291	input_free_device(input);
292	kfree(navpoint);
293	pxa_ssp_free(ssp);
294err_free_gpio:
295	if (gpio_is_valid(pdata->gpio))
296		gpio_free(pdata->gpio);
297
298	return error;
299}
300
301static int navpoint_remove(struct platform_device *pdev)
302{
303	const struct navpoint_platform_data *pdata =
304					dev_get_platdata(&pdev->dev);
305	struct navpoint *navpoint = platform_get_drvdata(pdev);
306	struct ssp_device *ssp = navpoint->ssp;
307
308	free_irq(ssp->irq, navpoint);
309
310	input_unregister_device(navpoint->input);
311	kfree(navpoint);
312
313	pxa_ssp_free(ssp);
314
315	if (gpio_is_valid(pdata->gpio))
316		gpio_free(pdata->gpio);
317
318	return 0;
319}
320
321static int __maybe_unused navpoint_suspend(struct device *dev)
322{
323	struct platform_device *pdev = to_platform_device(dev);
324	struct navpoint *navpoint = platform_get_drvdata(pdev);
325	struct input_dev *input = navpoint->input;
326
327	mutex_lock(&input->mutex);
328	if (input->users)
329		navpoint_down(navpoint);
330	mutex_unlock(&input->mutex);
331
332	return 0;
333}
334
335static int __maybe_unused navpoint_resume(struct device *dev)
336{
337	struct platform_device *pdev = to_platform_device(dev);
338	struct navpoint *navpoint = platform_get_drvdata(pdev);
339	struct input_dev *input = navpoint->input;
340
341	mutex_lock(&input->mutex);
342	if (input->users)
343		navpoint_up(navpoint);
344	mutex_unlock(&input->mutex);
345
346	return 0;
347}
348
349static SIMPLE_DEV_PM_OPS(navpoint_pm_ops, navpoint_suspend, navpoint_resume);
350
351static struct platform_driver navpoint_driver = {
352	.probe		= navpoint_probe,
353	.remove		= navpoint_remove,
354	.driver = {
355		.name	= "navpoint",
356		.pm	= &navpoint_pm_ops,
357	},
358};
359
360module_platform_driver(navpoint_driver);
361
362MODULE_AUTHOR("Paul Parsons <lost.distance@yahoo.com>");
363MODULE_DESCRIPTION("Synaptics NavPoint (PXA27x SSP/SPI) driver");
364MODULE_LICENSE("GPL");
365MODULE_ALIAS("platform:navpoint");
366