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 static 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
 335 static 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
 349 static SIMPLE_DEV_PM_OPS(navpoint_pm_ops, navpoint_suspend, navpoint_resume);
 350
 351 static 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
 360 module_platform_driver(navpoint_driver);
 361
 362 MODULE_AUTHOR("Paul Parsons <lost.distance@yahoo.com>");
 363 MODULE_DESCRIPTION("Synaptics NavPoint (PXA27x SSP/SPI) driver");
 364 MODULE_LICENSE("GPL");
 365 MODULE_ALIAS("platform:navpoint");