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