drivers/input/touchscreen/wm9713.c

   1 /*
   2  * wm9713.c  --  Codec touch driver for Wolfson WM9713 AC97 Codec.
   3  *
   4  * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC.
   5  * Author: Liam Girdwood
   6  *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
   7  * Parts Copyright : Ian Molton <spyro@f2s.com>
   8  *                   Andrew Zabolotny <zap@homelink.ru>
   9  *                   Russell King <rmk@arm.linux.org.uk>
  10  *
  11  *  This program is free software; you can redistribute  it and/or modify it
  12  *  under  the terms of  the GNU General  Public License as published by the
  13  *  Free Software Foundation;  either version 2 of the  License, or (at your
  14  *  option) any later version.
  15  *
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/moduleparam.h>
  20 #include <linux/version.h>
  21 #include <linux/kernel.h>
  22 #include <linux/input.h>
  23 #include <linux/delay.h>
  24 #include <linux/bitops.h>
  25 #include <linux/wm97xx.h>
  26
  27 #define TS_NAME                 "wm97xx"
  28 #define WM9713_VERSION          "1.00"
  29 #define DEFAULT_PRESSURE        0xb0c0
  30
  31 /*
  32  * Module parameters
  33  */
  34
  35 /*
  36  * Set internal pull up for pen detect.
  37  *
  38  * Pull up is in the range 1.02k (least sensitive) to 64k (most sensitive)
  39  * i.e. pull up resistance = 64k Ohms / rpu.
  40  *
  41  * Adjust this value if you are having problems with pen detect not
  42  * detecting any down event.
  43  */
  44 static int rpu = 8;
  45 module_param(rpu, int, 0);
  46 MODULE_PARM_DESC(rpu, "Set internal pull up resitor for pen detect.");
  47
  48 /*
  49  * Set current used for pressure measurement.
  50  *
  51  * Set pil = 2 to use 400uA
  52  *     pil = 1 to use 200uA and
  53  *     pil = 0 to disable pressure measurement.
  54  *
  55  * This is used to increase the range of values returned by the adc
  56  * when measureing touchpanel pressure.
  57  */
  58 static int pil;
  59 module_param(pil, int, 0);
  60 MODULE_PARM_DESC(pil, "Set current used for pressure measurement.");
  61
  62 /*
  63  * Set threshold for pressure measurement.
  64  *
  65  * Pen down pressure below threshold is ignored.
  66  */
  67 static int pressure = DEFAULT_PRESSURE & 0xfff;
  68 module_param(pressure, int, 0);
  69 MODULE_PARM_DESC(pressure, "Set threshold for pressure measurement.");
  70
  71 /*
  72  * Set adc sample delay.
  73  *
  74  * For accurate touchpanel measurements, some settling time may be
  75  * required between the switch matrix applying a voltage across the
  76  * touchpanel plate and the ADC sampling the signal.
  77  *
  78  * This delay can be set by setting delay = n, where n is the array
  79  * position of the delay in the array delay_table below.
  80  * Long delays > 1ms are supported for completeness, but are not
  81  * recommended.
  82  */
  83 static int delay = 4;
  84 module_param(delay, int, 0);
  85 MODULE_PARM_DESC(delay, "Set adc sample delay.");
  86
  87 /*
  88  * Set adc mask function.
  89  *
  90  * Sources of glitch noise, such as signals driving an LCD display, may feed
  91  * through to the touch screen plates and affect measurement accuracy. In
  92  * order to minimise this, a signal may be applied to the MASK pin to delay or
  93  * synchronise the sampling.
  94  *
  95  * 0 = No delay or sync
  96  * 1 = High on pin stops conversions
  97  * 2 = Edge triggered, edge on pin delays conversion by delay param (above)
  98  * 3 = Edge triggered, edge on pin starts conversion after delay param
  99  */
 100 static int mask;
 101 module_param(mask, int, 0);
 102 MODULE_PARM_DESC(mask, "Set adc mask function.");
 103
 104 /*
 105  * Coordinate Polling Enable.
 106  *
 107  * Set to 1 to enable coordinate polling. e.g. x,y[,p] is sampled together
 108  * for every poll.
 109  */
 110 static int coord;
 111 module_param(coord, int, 0);
 112 MODULE_PARM_DESC(coord, "Polling coordinate mode");
 113
 114 /*
 115  * ADC sample delay times in uS
 116  */
 117 static const int delay_table[] = {
 118         21,    /* 1 AC97 Link frames */
 119         42,    /* 2 */
 120         84,    /* 4 */
 121         167,   /* 8 */
 122         333,   /* 16 */
 123         667,   /* 32 */
 124         1000,  /* 48 */
 125         1333,  /* 64 */
 126         2000,  /* 96 */
 127         2667,  /* 128 */
 128         3333,  /* 160 */
 129         4000,  /* 192 */
 130         4667,  /* 224 */
 131         5333,  /* 256 */
 132         6000,  /* 288 */
 133         0      /* No delay, switch matrix always on */
 134 };
 135
 136 /*
 137  * Delay after issuing a POLL command.
 138  *
 139  * The delay is 3 AC97 link frames + the touchpanel settling delay
 140  */
 141 static inline void poll_delay(int d)
 142 {
 143         udelay(3 * AC97_LINK_FRAME + delay_table[d]);
 144 }
 145
 146 /*
 147  * set up the physical settings of the WM9713
 148  */
 149 static void wm9713_phy_init(struct wm97xx *wm)
 150 {
 151         u16 dig1 = 0, dig2, dig3;
 152
 153         /* default values */
 154         dig2 = WM97XX_DELAY(4) | WM97XX_SLT(5);
 155         dig3 = WM9712_RPU(1);
 156
 157         /* rpu */
 158         if (rpu) {
 159                 dig3 &= 0xffc0;
 160                 dig3 |= WM9712_RPU(rpu);
 161                 dev_info(wm->dev, "setting pen detect pull-up to %d Ohms\n",
 162                          64000 / rpu);
 163         }
 164
 165         /* touchpanel pressure */
 166         if (pil == 2) {
 167                 dig3 |= WM9712_PIL;
 168                 dev_info(wm->dev,
 169                          "setting pressure measurement current to 400uA.");
 170         } else if (pil)
 171                 dev_info(wm->dev,
 172                          "setting pressure measurement current to 200uA.");
 173         if (!pil)
 174                 pressure = 0;
 175
 176         /* sample settling delay */
 177         if (delay < 0 || delay > 15) {
 178                 dev_info(wm->dev, "supplied delay out of range.");
 179                 delay = 4;
 180                 dev_info(wm->dev, "setting adc sample delay to %d u Secs.",
 181                          delay_table[delay]);
 182         }
 183         dig2 &= 0xff0f;
 184         dig2 |= WM97XX_DELAY(delay);
 185
 186         /* mask */
 187         dig3 |= ((mask & 0x3) << 4);
 188         if (coord)
 189                 dig3 |= WM9713_WAIT;
 190
 191         wm->misc = wm97xx_reg_read(wm, 0x5a);
 192
 193         wm97xx_reg_write(wm, AC97_WM9713_DIG1, dig1);
 194         wm97xx_reg_write(wm, AC97_WM9713_DIG2, dig2);
 195         wm97xx_reg_write(wm, AC97_WM9713_DIG3, dig3);
 196         wm97xx_reg_write(wm, AC97_GPIO_STICKY, 0x0);
 197 }
 198
 199 static void wm9713_dig_enable(struct wm97xx *wm, int enable)
 200 {
 201         u16 val;
 202
 203         if (enable) {
 204                 val = wm97xx_reg_read(wm, AC97_EXTENDED_MID);
 205                 wm97xx_reg_write(wm, AC97_EXTENDED_MID, val & 0x7fff);
 206                 wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2] |
 207                                  WM97XX_PRP_DET_DIG);
 208                 wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD); /* dummy read */
 209         } else {
 210                 wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2] &
 211                                         ~WM97XX_PRP_DET_DIG);
 212                 val = wm97xx_reg_read(wm, AC97_EXTENDED_MID);
 213                 wm97xx_reg_write(wm, AC97_EXTENDED_MID, val | 0x8000);
 214         }
 215 }
 216
 217 static void wm9713_dig_restore(struct wm97xx *wm)
 218 {
 219         wm97xx_reg_write(wm, AC97_WM9713_DIG1, wm->dig_save[0]);
 220         wm97xx_reg_write(wm, AC97_WM9713_DIG2, wm->dig_save[1]);
 221         wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig_save[2]);
 222 }
 223
 224 static void wm9713_aux_prepare(struct wm97xx *wm)
 225 {
 226         memcpy(wm->dig_save, wm->dig, sizeof(wm->dig));
 227         wm97xx_reg_write(wm, AC97_WM9713_DIG1, 0);
 228         wm97xx_reg_write(wm, AC97_WM9713_DIG2, 0);
 229         wm97xx_reg_write(wm, AC97_WM9713_DIG3, WM97XX_PRP_DET_DIG);
 230 }
 231
 232 static inline int is_pden(struct wm97xx *wm)
 233 {
 234         return wm->dig[2] & WM9713_PDEN;
 235 }
 236
 237 /*
 238  * Read a sample from the WM9713 adc in polling mode.
 239  */
 240 static int wm9713_poll_sample(struct wm97xx *wm, int adcsel, int *sample)
 241 {
 242         u16 dig1;
 243         int timeout = 5 * delay;
 244
 245         if (!wm->pen_probably_down) {
 246                 u16 data = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 247                 if (!(data & WM97XX_PEN_DOWN))
 248                         return RC_PENUP;
 249                 wm->pen_probably_down = 1;
 250         }
 251
 252         /* set up digitiser */
 253         if (adcsel & 0x8000)
 254                 adcsel = 1 << ((adcsel & 0x7fff) + 3);
 255
 256         dig1 = wm97xx_reg_read(wm, AC97_WM9713_DIG1);
 257         dig1 &= ~WM9713_ADCSEL_MASK;
 258
 259         if (wm->mach_ops && wm->mach_ops->pre_sample)
 260                 wm->mach_ops->pre_sample(adcsel);
 261         wm97xx_reg_write(wm, AC97_WM9713_DIG1, dig1 | adcsel | WM9713_POLL);
 262
 263         /* wait 3 AC97 time slots + delay for conversion */
 264         poll_delay(delay);
 265
 266         /* wait for POLL to go low */
 267         while ((wm97xx_reg_read(wm, AC97_WM9713_DIG1) & WM9713_POLL) &&
 268                 timeout) {
 269                 udelay(AC97_LINK_FRAME);
 270                 timeout--;
 271         }
 272
 273         if (timeout <= 0) {
 274                 /* If PDEN is set, we can get a timeout when pen goes up */
 275                 if (is_pden(wm))
 276                         wm->pen_probably_down = 0;
 277                 else
 278                         dev_dbg(wm->dev, "adc sample timeout");
 279                 return RC_PENUP;
 280         }
 281
 282         *sample = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 283         if (wm->mach_ops && wm->mach_ops->post_sample)
 284                 wm->mach_ops->post_sample(adcsel);
 285
 286         /* check we have correct sample */
 287         if ((*sample & WM97XX_ADCSRC_MASK) != ffs(adcsel >> 1) << 12) {
 288                 dev_dbg(wm->dev, "adc wrong sample, read %x got %x", adcsel,
 289                         *sample & WM97XX_ADCSRC_MASK);
 290                 return RC_PENUP;
 291         }
 292
 293         if (!(*sample & WM97XX_PEN_DOWN)) {
 294                 wm->pen_probably_down = 0;
 295                 return RC_PENUP;
 296         }
 297
 298         return RC_VALID;
 299 }
 300
 301 /*
 302  * Read a coordinate from the WM9713 adc in polling mode.
 303  */
 304 static int wm9713_poll_coord(struct wm97xx *wm, struct wm97xx_data *data)
 305 {
 306         u16 dig1;
 307         int timeout = 5 * delay;
 308
 309         if (!wm->pen_probably_down) {
 310                 u16 val = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 311                 if (!(val & WM97XX_PEN_DOWN))
 312                         return RC_PENUP;
 313                 wm->pen_probably_down = 1;
 314         }
 315
 316         /* set up digitiser */
 317         dig1 = wm97xx_reg_read(wm, AC97_WM9713_DIG1);
 318         dig1 &= ~WM9713_ADCSEL_MASK;
 319         if (pil)
 320                 dig1 |= WM9713_ADCSEL_PRES;
 321
 322         if (wm->mach_ops && wm->mach_ops->pre_sample)
 323                 wm->mach_ops->pre_sample(WM97XX_ADCSEL_X | WM97XX_ADCSEL_Y);
 324         wm97xx_reg_write(wm, AC97_WM9713_DIG1,
 325                          dig1 | WM9713_POLL | WM9713_COO);
 326
 327         /* wait 3 AC97 time slots + delay for conversion */
 328         poll_delay(delay);
 329         data->x = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 330         /* wait for POLL to go low */
 331         while ((wm97xx_reg_read(wm, AC97_WM9713_DIG1) & WM9713_POLL)
 332                && timeout) {
 333                 udelay(AC97_LINK_FRAME);
 334                 timeout--;
 335         }
 336
 337         if (timeout <= 0) {
 338                 /* If PDEN is set, we can get a timeout when pen goes up */
 339                 if (is_pden(wm))
 340                         wm->pen_probably_down = 0;
 341                 else
 342                         dev_dbg(wm->dev, "adc sample timeout");
 343                 return RC_PENUP;
 344         }
 345
 346         /* read back data */
 347         data->y = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 348         if (pil)
 349                 data->p = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD);
 350         else
 351                 data->p = DEFAULT_PRESSURE;
 352
 353         if (wm->mach_ops && wm->mach_ops->post_sample)
 354                 wm->mach_ops->post_sample(WM97XX_ADCSEL_X | WM97XX_ADCSEL_Y);
 355
 356         /* check we have correct sample */
 357         if (!(data->x & WM97XX_ADCSEL_X) || !(data->y & WM97XX_ADCSEL_Y))
 358                 goto err;
 359         if (pil && !(data->p & WM97XX_ADCSEL_PRES))
 360                 goto err;
 361
 362         if (!(data->x & WM97XX_PEN_DOWN) || !(data->y & WM97XX_PEN_DOWN)) {
 363                 wm->pen_probably_down = 0;
 364                 return RC_PENUP;
 365         }
 366         return RC_VALID;
 367 err:
 368         return 0;
 369 }
 370
 371 /*
 372  * Sample the WM9713 touchscreen in polling mode
 373  */
 374 static int wm9713_poll_touch(struct wm97xx *wm, struct wm97xx_data *data)
 375 {
 376         int rc;
 377
 378         if (coord) {
 379                 rc = wm9713_poll_coord(wm, data);
 380                 if (rc != RC_VALID)
 381                         return rc;
 382         } else {
 383                 rc = wm9713_poll_sample(wm, WM9713_ADCSEL_X, &data->x);
 384                 if (rc != RC_VALID)
 385                         return rc;
 386                 rc = wm9713_poll_sample(wm, WM9713_ADCSEL_Y, &data->y);
 387                 if (rc != RC_VALID)
 388                         return rc;
 389                 if (pil) {
 390                         rc = wm9713_poll_sample(wm, WM9713_ADCSEL_PRES,
 391                                                 &data->p);
 392                         if (rc != RC_VALID)
 393                                 return rc;
 394                 } else
 395                         data->p = DEFAULT_PRESSURE;
 396         }
 397         return RC_VALID;
 398 }
 399
 400 /*
 401  * Enable WM9713 continuous mode, i.e. touch data is streamed across
 402  * an AC97 slot
 403  */
 404 static int wm9713_acc_enable(struct wm97xx *wm, int enable)
 405 {
 406         u16 dig1, dig2, dig3;
 407         int ret = 0;
 408
 409         dig1 = wm->dig[0];
 410         dig2 = wm->dig[1];
 411         dig3 = wm->dig[2];
 412
 413         if (enable) {
 414                 /* continous mode */
 415                 if (wm->mach_ops->acc_startup &&
 416                         (ret = wm->mach_ops->acc_startup(wm)) < 0)
 417                         return ret;
 418
 419                 dig1 &= ~WM9713_ADCSEL_MASK;
 420                 dig1 |= WM9713_CTC | WM9713_COO | WM9713_ADCSEL_X |
 421                         WM9713_ADCSEL_Y;
 422                 if (pil)
 423                         dig1 |= WM9713_ADCSEL_PRES;
 424                 dig2 &= ~(WM97XX_DELAY_MASK | WM97XX_SLT_MASK  |
 425                         WM97XX_CM_RATE_MASK);
 426                 dig2 |= WM97XX_SLEN | WM97XX_DELAY(delay) |
 427                 WM97XX_SLT(wm->acc_slot) | WM97XX_RATE(wm->acc_rate);
 428                 dig3 |= WM9713_PDEN;
 429         } else {
 430                 dig1 &= ~(WM9713_CTC | WM9713_COO);
 431                 dig2 &= ~WM97XX_SLEN;
 432                 dig3 &= ~WM9713_PDEN;
 433                 if (wm->mach_ops->acc_shutdown)
 434                         wm->mach_ops->acc_shutdown(wm);
 435         }
 436
 437         wm97xx_reg_write(wm, AC97_WM9713_DIG1, dig1);
 438         wm97xx_reg_write(wm, AC97_WM9713_DIG2, dig2);
 439         wm97xx_reg_write(wm, AC97_WM9713_DIG3, dig3);
 440
 441         return ret;
 442 }
 443
 444 struct wm97xx_codec_drv wm9713_codec = {
 445         .id = WM9713_ID2,
 446         .name = "wm9713",
 447         .poll_sample = wm9713_poll_sample,
 448         .poll_touch = wm9713_poll_touch,
 449         .acc_enable = wm9713_acc_enable,
 450         .phy_init = wm9713_phy_init,
 451         .dig_enable = wm9713_dig_enable,
 452         .dig_restore = wm9713_dig_restore,
 453         .aux_prepare = wm9713_aux_prepare,
 454 };
 455 EXPORT_SYMBOL_GPL(wm9713_codec);
 456
 457 /* Module information */
 458 MODULE_AUTHOR("Liam Girdwood <liam.girdwood@wolfsonmicro.com>");
 459 MODULE_DESCRIPTION("WM9713 Touch Screen Driver");
 460 MODULE_LICENSE("GPL");