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/mouse/navpoint.c

  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 
 34 struct 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  */
 46 static 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         ;
 53 static 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         ;
 62 static 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 
 82 static 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 
120 static 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 
153 static 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 
180 static 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 
192 static 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 
201 static void navpoint_close(struct input_dev *input)
202 {
203         struct navpoint *navpoint = input_get_drvdata(input);
204 
205         navpoint_down(navpoint);
206 }
207 
208 static 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 
288 err_free_irq:
289         free_irq(ssp->irq, navpoint);
290 err_free_mem:
291         input_free_device(input);
292         kfree(navpoint);
293         pxa_ssp_free(ssp);
294 err_free_gpio:
295         if (gpio_is_valid(pdata->gpio))
296                 gpio_free(pdata->gpio);
297 
298         return error;
299 }
300 
301 static 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 
321 #ifdef CONFIG_PM_SLEEP
322 static int navpoint_suspend(struct device *dev)
323 {
324         struct platform_device *pdev = to_platform_device(dev);
325         struct navpoint *navpoint = platform_get_drvdata(pdev);
326         struct input_dev *input = navpoint->input;
327 
328         mutex_lock(&input->mutex);
329         if (input->users)
330                 navpoint_down(navpoint);
331         mutex_unlock(&input->mutex);
332 
333         return 0;
334 }
335 
336 static int navpoint_resume(struct device *dev)
337 {
338         struct platform_device *pdev = to_platform_device(dev);
339         struct navpoint *navpoint = platform_get_drvdata(pdev);
340         struct input_dev *input = navpoint->input;
341 
342         mutex_lock(&input->mutex);
343         if (input->users)
344                 navpoint_up(navpoint);
345         mutex_unlock(&input->mutex);
346 
347         return 0;
348 }
349 #endif
350 
351 static SIMPLE_DEV_PM_OPS(navpoint_pm_ops, navpoint_suspend, navpoint_resume);
352 
353 static struct platform_driver navpoint_driver = {
354         .probe          = navpoint_probe,
355         .remove         = navpoint_remove,
356         .driver = {
357                 .name   = "navpoint",
358                 .owner  = THIS_MODULE,
359                 .pm     = &navpoint_pm_ops,
360         },
361 };
362 
363 module_platform_driver(navpoint_driver);
364 
365 MODULE_AUTHOR("Paul Parsons <lost.distance@yahoo.com>");
366 MODULE_DESCRIPTION("Synaptics NavPoint (PXA27x SSP/SPI) driver");
367 MODULE_LICENSE("GPL");
368 MODULE_ALIAS("platform:navpoint");
369 

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