drivers/mfd/stmpe.c

   1 /*
   2  * ST Microelectronics MFD: stmpe's driver
   3  *
   4  * Copyright (C) ST-Ericsson SA 2010
   5  *
   6  * License Terms: GNU General Public License, version 2
   7  * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
   8  */
   9
  10 #include <linux/gpio.h>
  11 #include <linux/export.h>
  12 #include <linux/kernel.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/irq.h>
  15 #include <linux/pm.h>
  16 #include <linux/slab.h>
  17 #include <linux/mfd/core.h>
  18 #include "stmpe.h"
  19
  20 static int __stmpe_enable(struct stmpe *stmpe, unsigned int blocks)
  21 {
  22         return stmpe->variant->enable(stmpe, blocks, true);
  23 }
  24
  25 static int __stmpe_disable(struct stmpe *stmpe, unsigned int blocks)
  26 {
  27         return stmpe->variant->enable(stmpe, blocks, false);
  28 }
  29
  30 static int __stmpe_reg_read(struct stmpe *stmpe, u8 reg)
  31 {
  32         int ret;
  33
  34         ret = stmpe->ci->read_byte(stmpe, reg);
  35         if (ret < 0)
  36                 dev_err(stmpe->dev, "failed to read reg %#x: %d\n", reg, ret);
  37
  38         dev_vdbg(stmpe->dev, "rd: reg %#x => data %#x\n", reg, ret);
  39
  40         return ret;
  41 }
  42
  43 static int __stmpe_reg_write(struct stmpe *stmpe, u8 reg, u8 val)
  44 {
  45         int ret;
  46
  47         dev_vdbg(stmpe->dev, "wr: reg %#x <= %#x\n", reg, val);
  48
  49         ret = stmpe->ci->write_byte(stmpe, reg, val);
  50         if (ret < 0)
  51                 dev_err(stmpe->dev, "failed to write reg %#x: %d\n", reg, ret);
  52
  53         return ret;
  54 }
  55
  56 static int __stmpe_set_bits(struct stmpe *stmpe, u8 reg, u8 mask, u8 val)
  57 {
  58         int ret;
  59
  60         ret = __stmpe_reg_read(stmpe, reg);
  61         if (ret < 0)
  62                 return ret;
  63
  64         ret &= ~mask;
  65         ret |= val;
  66
  67         return __stmpe_reg_write(stmpe, reg, ret);
  68 }
  69
  70 static int __stmpe_block_read(struct stmpe *stmpe, u8 reg, u8 length,
  71                               u8 *values)
  72 {
  73         int ret;
  74
  75         ret = stmpe->ci->read_block(stmpe, reg, length, values);
  76         if (ret < 0)
  77                 dev_err(stmpe->dev, "failed to read regs %#x: %d\n", reg, ret);
  78
  79         dev_vdbg(stmpe->dev, "rd: reg %#x (%d) => ret %#x\n", reg, length, ret);
  80         stmpe_dump_bytes("stmpe rd: ", values, length);
  81
  82         return ret;
  83 }
  84
  85 static int __stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length,
  86                         const u8 *values)
  87 {
  88         int ret;
  89
  90         dev_vdbg(stmpe->dev, "wr: regs %#x (%d)\n", reg, length);
  91         stmpe_dump_bytes("stmpe wr: ", values, length);
  92
  93         ret = stmpe->ci->write_block(stmpe, reg, length, values);
  94         if (ret < 0)
  95                 dev_err(stmpe->dev, "failed to write regs %#x: %d\n", reg, ret);
  96
  97         return ret;
  98 }
  99
 100 /**
 101  * stmpe_enable - enable blocks on an STMPE device
 102  * @stmpe:      Device to work on
 103  * @blocks:     Mask of blocks (enum stmpe_block values) to enable
 104  */
 105 int stmpe_enable(struct stmpe *stmpe, unsigned int blocks)
 106 {
 107         int ret;
 108
 109         mutex_lock(&stmpe->lock);
 110         ret = __stmpe_enable(stmpe, blocks);
 111         mutex_unlock(&stmpe->lock);
 112
 113         return ret;
 114 }
 115 EXPORT_SYMBOL_GPL(stmpe_enable);
 116
 117 /**
 118  * stmpe_disable - disable blocks on an STMPE device
 119  * @stmpe:      Device to work on
 120  * @blocks:     Mask of blocks (enum stmpe_block values) to enable
 121  */
 122 int stmpe_disable(struct stmpe *stmpe, unsigned int blocks)
 123 {
 124         int ret;
 125
 126         mutex_lock(&stmpe->lock);
 127         ret = __stmpe_disable(stmpe, blocks);
 128         mutex_unlock(&stmpe->lock);
 129
 130         return ret;
 131 }
 132 EXPORT_SYMBOL_GPL(stmpe_disable);
 133
 134 /**
 135  * stmpe_reg_read() - read a single STMPE register
 136  * @stmpe:      Device to read from
 137  * @reg:        Register to read
 138  */
 139 int stmpe_reg_read(struct stmpe *stmpe, u8 reg)
 140 {
 141         int ret;
 142
 143         mutex_lock(&stmpe->lock);
 144         ret = __stmpe_reg_read(stmpe, reg);
 145         mutex_unlock(&stmpe->lock);
 146
 147         return ret;
 148 }
 149 EXPORT_SYMBOL_GPL(stmpe_reg_read);
 150
 151 /**
 152  * stmpe_reg_write() - write a single STMPE register
 153  * @stmpe:      Device to write to
 154  * @reg:        Register to write
 155  * @val:        Value to write
 156  */
 157 int stmpe_reg_write(struct stmpe *stmpe, u8 reg, u8 val)
 158 {
 159         int ret;
 160
 161         mutex_lock(&stmpe->lock);
 162         ret = __stmpe_reg_write(stmpe, reg, val);
 163         mutex_unlock(&stmpe->lock);
 164
 165         return ret;
 166 }
 167 EXPORT_SYMBOL_GPL(stmpe_reg_write);
 168
 169 /**
 170  * stmpe_set_bits() - set the value of a bitfield in a STMPE register
 171  * @stmpe:      Device to write to
 172  * @reg:        Register to write
 173  * @mask:       Mask of bits to set
 174  * @val:        Value to set
 175  */
 176 int stmpe_set_bits(struct stmpe *stmpe, u8 reg, u8 mask, u8 val)
 177 {
 178         int ret;
 179
 180         mutex_lock(&stmpe->lock);
 181         ret = __stmpe_set_bits(stmpe, reg, mask, val);
 182         mutex_unlock(&stmpe->lock);
 183
 184         return ret;
 185 }
 186 EXPORT_SYMBOL_GPL(stmpe_set_bits);
 187
 188 /**
 189  * stmpe_block_read() - read multiple STMPE registers
 190  * @stmpe:      Device to read from
 191  * @reg:        First register
 192  * @length:     Number of registers
 193  * @values:     Buffer to write to
 194  */
 195 int stmpe_block_read(struct stmpe *stmpe, u8 reg, u8 length, u8 *values)
 196 {
 197         int ret;
 198
 199         mutex_lock(&stmpe->lock);
 200         ret = __stmpe_block_read(stmpe, reg, length, values);
 201         mutex_unlock(&stmpe->lock);
 202
 203         return ret;
 204 }
 205 EXPORT_SYMBOL_GPL(stmpe_block_read);
 206
 207 /**
 208  * stmpe_block_write() - write multiple STMPE registers
 209  * @stmpe:      Device to write to
 210  * @reg:        First register
 211  * @length:     Number of registers
 212  * @values:     Values to write
 213  */
 214 int stmpe_block_write(struct stmpe *stmpe, u8 reg, u8 length,
 215                       const u8 *values)
 216 {
 217         int ret;
 218
 219         mutex_lock(&stmpe->lock);
 220         ret = __stmpe_block_write(stmpe, reg, length, values);
 221         mutex_unlock(&stmpe->lock);
 222
 223         return ret;
 224 }
 225 EXPORT_SYMBOL_GPL(stmpe_block_write);
 226
 227 /**
 228  * stmpe_set_altfunc()- set the alternate function for STMPE pins
 229  * @stmpe:      Device to configure
 230  * @pins:       Bitmask of pins to affect
 231  * @block:      block to enable alternate functions for
 232  *
 233  * @pins is assumed to have a bit set for each of the bits whose alternate
 234  * function is to be changed, numbered according to the GPIOXY numbers.
 235  *
 236  * If the GPIO module is not enabled, this function automatically enables it in
 237  * order to perform the change.
 238  */
 239 int stmpe_set_altfunc(struct stmpe *stmpe, u32 pins, enum stmpe_block block)
 240 {
 241         struct stmpe_variant_info *variant = stmpe->variant;
 242         u8 regaddr = stmpe->regs[STMPE_IDX_GPAFR_U_MSB];
 243         int af_bits = variant->af_bits;
 244         int numregs = DIV_ROUND_UP(stmpe->num_gpios * af_bits, 8);
 245         int mask = (1 << af_bits) - 1;
 246         u8 regs[numregs];
 247         int af, afperreg, ret;
 248
 249         if (!variant->get_altfunc)
 250                 return 0;
 251
 252         afperreg = 8 / af_bits;
 253         mutex_lock(&stmpe->lock);
 254
 255         ret = __stmpe_enable(stmpe, STMPE_BLOCK_GPIO);
 256         if (ret < 0)
 257                 goto out;
 258
 259         ret = __stmpe_block_read(stmpe, regaddr, numregs, regs);
 260         if (ret < 0)
 261                 goto out;
 262
 263         af = variant->get_altfunc(stmpe, block);
 264
 265         while (pins) {
 266                 int pin = __ffs(pins);
 267                 int regoffset = numregs - (pin / afperreg) - 1;
 268                 int pos = (pin % afperreg) * (8 / afperreg);
 269
 270                 regs[regoffset] &= ~(mask << pos);
 271                 regs[regoffset] |= af << pos;
 272
 273                 pins &= ~(1 << pin);
 274         }
 275
 276         ret = __stmpe_block_write(stmpe, regaddr, numregs, regs);
 277
 278 out:
 279         mutex_unlock(&stmpe->lock);
 280         return ret;
 281 }
 282 EXPORT_SYMBOL_GPL(stmpe_set_altfunc);
 283
 284 /*
 285  * GPIO (all variants)
 286  */
 287
 288 static struct resource stmpe_gpio_resources[] = {
 289         /* Start and end filled dynamically */
 290         {
 291                 .flags  = IORESOURCE_IRQ,
 292         },
 293 };
 294
 295 static struct mfd_cell stmpe_gpio_cell = {
 296         .name           = "stmpe-gpio",
 297         .resources      = stmpe_gpio_resources,
 298         .num_resources  = ARRAY_SIZE(stmpe_gpio_resources),
 299 };
 300
 301 /*
 302  * Keypad (1601, 2401, 2403)
 303  */
 304
 305 static struct resource stmpe_keypad_resources[] = {
 306         {
 307                 .name   = "KEYPAD",
 308                 .start  = 0,
 309                 .end    = 0,
 310                 .flags  = IORESOURCE_IRQ,
 311         },
 312         {
 313                 .name   = "KEYPAD_OVER",
 314                 .start  = 1,
 315                 .end    = 1,
 316                 .flags  = IORESOURCE_IRQ,
 317         },
 318 };
 319
 320 static struct mfd_cell stmpe_keypad_cell = {
 321         .name           = "stmpe-keypad",
 322         .resources      = stmpe_keypad_resources,
 323         .num_resources  = ARRAY_SIZE(stmpe_keypad_resources),
 324 };
 325
 326 /*
 327  * STMPE801
 328  */
 329 static const u8 stmpe801_regs[] = {
 330         [STMPE_IDX_CHIP_ID]     = STMPE801_REG_CHIP_ID,
 331         [STMPE_IDX_ICR_LSB]     = STMPE801_REG_SYS_CTRL,
 332         [STMPE_IDX_GPMR_LSB]    = STMPE801_REG_GPIO_MP_STA,
 333         [STMPE_IDX_GPSR_LSB]    = STMPE801_REG_GPIO_SET_PIN,
 334         [STMPE_IDX_GPCR_LSB]    = STMPE801_REG_GPIO_SET_PIN,
 335         [STMPE_IDX_GPDR_LSB]    = STMPE801_REG_GPIO_DIR,
 336         [STMPE_IDX_IEGPIOR_LSB] = STMPE801_REG_GPIO_INT_EN,
 337         [STMPE_IDX_ISGPIOR_MSB] = STMPE801_REG_GPIO_INT_STA,
 338
 339 };
 340
 341 static struct stmpe_variant_block stmpe801_blocks[] = {
 342         {
 343                 .cell   = &stmpe_gpio_cell,
 344                 .irq    = 0,
 345                 .block  = STMPE_BLOCK_GPIO,
 346         },
 347 };
 348
 349 static int stmpe801_enable(struct stmpe *stmpe, unsigned int blocks,
 350                            bool enable)
 351 {
 352         if (blocks & STMPE_BLOCK_GPIO)
 353                 return 0;
 354         else
 355                 return -EINVAL;
 356 }
 357
 358 static struct stmpe_variant_info stmpe801 = {
 359         .name           = "stmpe801",
 360         .id_val         = STMPE801_ID,
 361         .id_mask        = 0xffff,
 362         .num_gpios      = 8,
 363         .regs           = stmpe801_regs,
 364         .blocks         = stmpe801_blocks,
 365         .num_blocks     = ARRAY_SIZE(stmpe801_blocks),
 366         .num_irqs       = STMPE801_NR_INTERNAL_IRQS,
 367         .enable         = stmpe801_enable,
 368 };
 369
 370 /*
 371  * Touchscreen (STMPE811 or STMPE610)
 372  */
 373
 374 static struct resource stmpe_ts_resources[] = {
 375         {
 376                 .name   = "TOUCH_DET",
 377                 .start  = 0,
 378                 .end    = 0,
 379                 .flags  = IORESOURCE_IRQ,
 380         },
 381         {
 382                 .name   = "FIFO_TH",
 383                 .start  = 1,
 384                 .end    = 1,
 385                 .flags  = IORESOURCE_IRQ,
 386         },
 387 };
 388
 389 static struct mfd_cell stmpe_ts_cell = {
 390         .name           = "stmpe-ts",
 391         .resources      = stmpe_ts_resources,
 392         .num_resources  = ARRAY_SIZE(stmpe_ts_resources),
 393 };
 394
 395 /*
 396  * STMPE811 or STMPE610
 397  */
 398
 399 static const u8 stmpe811_regs[] = {
 400         [STMPE_IDX_CHIP_ID]     = STMPE811_REG_CHIP_ID,
 401         [STMPE_IDX_ICR_LSB]     = STMPE811_REG_INT_CTRL,
 402         [STMPE_IDX_IER_LSB]     = STMPE811_REG_INT_EN,
 403         [STMPE_IDX_ISR_MSB]     = STMPE811_REG_INT_STA,
 404         [STMPE_IDX_GPMR_LSB]    = STMPE811_REG_GPIO_MP_STA,
 405         [STMPE_IDX_GPSR_LSB]    = STMPE811_REG_GPIO_SET_PIN,
 406         [STMPE_IDX_GPCR_LSB]    = STMPE811_REG_GPIO_CLR_PIN,
 407         [STMPE_IDX_GPDR_LSB]    = STMPE811_REG_GPIO_DIR,
 408         [STMPE_IDX_GPRER_LSB]   = STMPE811_REG_GPIO_RE,
 409         [STMPE_IDX_GPFER_LSB]   = STMPE811_REG_GPIO_FE,
 410         [STMPE_IDX_GPAFR_U_MSB] = STMPE811_REG_GPIO_AF,
 411         [STMPE_IDX_IEGPIOR_LSB] = STMPE811_REG_GPIO_INT_EN,
 412         [STMPE_IDX_ISGPIOR_MSB] = STMPE811_REG_GPIO_INT_STA,
 413         [STMPE_IDX_GPEDR_MSB]   = STMPE811_REG_GPIO_ED,
 414 };
 415
 416 static struct stmpe_variant_block stmpe811_blocks[] = {
 417         {
 418                 .cell   = &stmpe_gpio_cell,
 419                 .irq    = STMPE811_IRQ_GPIOC,
 420                 .block  = STMPE_BLOCK_GPIO,
 421         },
 422         {
 423                 .cell   = &stmpe_ts_cell,
 424                 .irq    = STMPE811_IRQ_TOUCH_DET,
 425                 .block  = STMPE_BLOCK_TOUCHSCREEN,
 426         },
 427 };
 428
 429 static int stmpe811_enable(struct stmpe *stmpe, unsigned int blocks,
 430                            bool enable)
 431 {
 432         unsigned int mask = 0;
 433
 434         if (blocks & STMPE_BLOCK_GPIO)
 435                 mask |= STMPE811_SYS_CTRL2_GPIO_OFF;
 436
 437         if (blocks & STMPE_BLOCK_ADC)
 438                 mask |= STMPE811_SYS_CTRL2_ADC_OFF;
 439
 440         if (blocks & STMPE_BLOCK_TOUCHSCREEN)
 441                 mask |= STMPE811_SYS_CTRL2_TSC_OFF;
 442
 443         return __stmpe_set_bits(stmpe, STMPE811_REG_SYS_CTRL2, mask,
 444                                 enable ? 0 : mask);
 445 }
 446
 447 static int stmpe811_get_altfunc(struct stmpe *stmpe, enum stmpe_block block)
 448 {
 449         /* 0 for touchscreen, 1 for GPIO */
 450         return block != STMPE_BLOCK_TOUCHSCREEN;
 451 }
 452
 453 static struct stmpe_variant_info stmpe811 = {
 454         .name           = "stmpe811",
 455         .id_val         = 0x0811,
 456         .id_mask        = 0xffff,
 457         .num_gpios      = 8,
 458         .af_bits        = 1,
 459         .regs           = stmpe811_regs,
 460         .blocks         = stmpe811_blocks,
 461         .num_blocks     = ARRAY_SIZE(stmpe811_blocks),
 462         .num_irqs       = STMPE811_NR_INTERNAL_IRQS,
 463         .enable         = stmpe811_enable,
 464         .get_altfunc    = stmpe811_get_altfunc,
 465 };
 466
 467 /* Similar to 811, except number of gpios */
 468 static struct stmpe_variant_info stmpe610 = {
 469         .name           = "stmpe610",
 470         .id_val         = 0x0811,
 471         .id_mask        = 0xffff,
 472         .num_gpios      = 6,
 473         .af_bits        = 1,
 474         .regs           = stmpe811_regs,
 475         .blocks         = stmpe811_blocks,
 476         .num_blocks     = ARRAY_SIZE(stmpe811_blocks),
 477         .num_irqs       = STMPE811_NR_INTERNAL_IRQS,
 478         .enable         = stmpe811_enable,
 479         .get_altfunc    = stmpe811_get_altfunc,
 480 };
 481
 482 /*
 483  * STMPE1601
 484  */
 485
 486 static const u8 stmpe1601_regs[] = {
 487         [STMPE_IDX_CHIP_ID]     = STMPE1601_REG_CHIP_ID,
 488         [STMPE_IDX_ICR_LSB]     = STMPE1601_REG_ICR_LSB,
 489         [STMPE_IDX_IER_LSB]     = STMPE1601_REG_IER_LSB,
 490         [STMPE_IDX_ISR_MSB]     = STMPE1601_REG_ISR_MSB,
 491         [STMPE_IDX_GPMR_LSB]    = STMPE1601_REG_GPIO_MP_LSB,
 492         [STMPE_IDX_GPSR_LSB]    = STMPE1601_REG_GPIO_SET_LSB,
 493         [STMPE_IDX_GPCR_LSB]    = STMPE1601_REG_GPIO_CLR_LSB,
 494         [STMPE_IDX_GPDR_LSB]    = STMPE1601_REG_GPIO_SET_DIR_LSB,
 495         [STMPE_IDX_GPRER_LSB]   = STMPE1601_REG_GPIO_RE_LSB,
 496         [STMPE_IDX_GPFER_LSB]   = STMPE1601_REG_GPIO_FE_LSB,
 497         [STMPE_IDX_GPAFR_U_MSB] = STMPE1601_REG_GPIO_AF_U_MSB,
 498         [STMPE_IDX_IEGPIOR_LSB] = STMPE1601_REG_INT_EN_GPIO_MASK_LSB,
 499         [STMPE_IDX_ISGPIOR_MSB] = STMPE1601_REG_INT_STA_GPIO_MSB,
 500         [STMPE_IDX_GPEDR_MSB]   = STMPE1601_REG_GPIO_ED_MSB,
 501 };
 502
 503 static struct stmpe_variant_block stmpe1601_blocks[] = {
 504         {
 505                 .cell   = &stmpe_gpio_cell,
 506                 .irq    = STMPE24XX_IRQ_GPIOC,
 507                 .block  = STMPE_BLOCK_GPIO,
 508         },
 509         {
 510                 .cell   = &stmpe_keypad_cell,
 511                 .irq    = STMPE24XX_IRQ_KEYPAD,
 512                 .block  = STMPE_BLOCK_KEYPAD,
 513         },
 514 };
 515
 516 /* supported autosleep timeout delay (in msecs) */
 517 static const int stmpe_autosleep_delay[] = {
 518         4, 16, 32, 64, 128, 256, 512, 1024,
 519 };
 520
 521 static int stmpe_round_timeout(int timeout)
 522 {
 523         int i;
 524
 525         for (i = 0; i < ARRAY_SIZE(stmpe_autosleep_delay); i++) {
 526                 if (stmpe_autosleep_delay[i] >= timeout)
 527                         return i;
 528         }
 529
 530         /*
 531          * requests for delays longer than supported should not return the
 532          * longest supported delay
 533          */
 534         return -EINVAL;
 535 }
 536
 537 static int stmpe_autosleep(struct stmpe *stmpe, int autosleep_timeout)
 538 {
 539         int ret;
 540
 541         if (!stmpe->variant->enable_autosleep)
 542                 return -ENOSYS;
 543
 544         mutex_lock(&stmpe->lock);
 545         ret = stmpe->variant->enable_autosleep(stmpe, autosleep_timeout);
 546         mutex_unlock(&stmpe->lock);
 547
 548         return ret;
 549 }
 550
 551 /*
 552  * Both stmpe 1601/2403 support same layout for autosleep
 553  */
 554 static int stmpe1601_autosleep(struct stmpe *stmpe,
 555                 int autosleep_timeout)
 556 {
 557         int ret, timeout;
 558
 559         /* choose the best available timeout */
 560         timeout = stmpe_round_timeout(autosleep_timeout);
 561         if (timeout < 0) {
 562                 dev_err(stmpe->dev, "invalid timeout\n");
 563                 return timeout;
 564         }
 565
 566         ret = __stmpe_set_bits(stmpe, STMPE1601_REG_SYS_CTRL2,
 567                         STMPE1601_AUTOSLEEP_TIMEOUT_MASK,
 568                         timeout);
 569         if (ret < 0)
 570                 return ret;
 571
 572         return __stmpe_set_bits(stmpe, STMPE1601_REG_SYS_CTRL2,
 573                         STPME1601_AUTOSLEEP_ENABLE,
 574                         STPME1601_AUTOSLEEP_ENABLE);
 575 }
 576
 577 static int stmpe1601_enable(struct stmpe *stmpe, unsigned int blocks,
 578                             bool enable)
 579 {
 580         unsigned int mask = 0;
 581
 582         if (blocks & STMPE_BLOCK_GPIO)
 583                 mask |= STMPE1601_SYS_CTRL_ENABLE_GPIO;
 584
 585         if (blocks & STMPE_BLOCK_KEYPAD)
 586                 mask |= STMPE1601_SYS_CTRL_ENABLE_KPC;
 587
 588         return __stmpe_set_bits(stmpe, STMPE1601_REG_SYS_CTRL, mask,
 589                                 enable ? mask : 0);
 590 }
 591
 592 static int stmpe1601_get_altfunc(struct stmpe *stmpe, enum stmpe_block block)
 593 {
 594         switch (block) {
 595         case STMPE_BLOCK_PWM:
 596                 return 2;
 597
 598         case STMPE_BLOCK_KEYPAD:
 599                 return 1;
 600
 601         case STMPE_BLOCK_GPIO:
 602         default:
 603                 return 0;
 604         }
 605 }
 606
 607 static struct stmpe_variant_info stmpe1601 = {
 608         .name           = "stmpe1601",
 609         .id_val         = 0x0210,
 610         .id_mask        = 0xfff0,       /* at least 0x0210 and 0x0212 */
 611         .num_gpios      = 16,
 612         .af_bits        = 2,
 613         .regs           = stmpe1601_regs,
 614         .blocks         = stmpe1601_blocks,
 615         .num_blocks     = ARRAY_SIZE(stmpe1601_blocks),
 616         .num_irqs       = STMPE1601_NR_INTERNAL_IRQS,
 617         .enable         = stmpe1601_enable,
 618         .get_altfunc    = stmpe1601_get_altfunc,
 619         .enable_autosleep       = stmpe1601_autosleep,
 620 };
 621
 622 /*
 623  * STMPE24XX
 624  */
 625
 626 static const u8 stmpe24xx_regs[] = {
 627         [STMPE_IDX_CHIP_ID]     = STMPE24XX_REG_CHIP_ID,
 628         [STMPE_IDX_ICR_LSB]     = STMPE24XX_REG_ICR_LSB,
 629         [STMPE_IDX_IER_LSB]     = STMPE24XX_REG_IER_LSB,
 630         [STMPE_IDX_ISR_MSB]     = STMPE24XX_REG_ISR_MSB,
 631         [STMPE_IDX_GPMR_LSB]    = STMPE24XX_REG_GPMR_LSB,
 632         [STMPE_IDX_GPSR_LSB]    = STMPE24XX_REG_GPSR_LSB,
 633         [STMPE_IDX_GPCR_LSB]    = STMPE24XX_REG_GPCR_LSB,
 634         [STMPE_IDX_GPDR_LSB]    = STMPE24XX_REG_GPDR_LSB,
 635         [STMPE_IDX_GPRER_LSB]   = STMPE24XX_REG_GPRER_LSB,
 636         [STMPE_IDX_GPFER_LSB]   = STMPE24XX_REG_GPFER_LSB,
 637         [STMPE_IDX_GPAFR_U_MSB] = STMPE24XX_REG_GPAFR_U_MSB,
 638         [STMPE_IDX_IEGPIOR_LSB] = STMPE24XX_REG_IEGPIOR_LSB,
 639         [STMPE_IDX_ISGPIOR_MSB] = STMPE24XX_REG_ISGPIOR_MSB,
 640         [STMPE_IDX_GPEDR_MSB]   = STMPE24XX_REG_GPEDR_MSB,
 641 };
 642
 643 static struct stmpe_variant_block stmpe24xx_blocks[] = {
 644         {
 645                 .cell   = &stmpe_gpio_cell,
 646                 .irq    = STMPE24XX_IRQ_GPIOC,
 647                 .block  = STMPE_BLOCK_GPIO,
 648         },
 649         {
 650                 .cell   = &stmpe_keypad_cell,
 651                 .irq    = STMPE24XX_IRQ_KEYPAD,
 652                 .block  = STMPE_BLOCK_KEYPAD,
 653         },
 654 };
 655
 656 static int stmpe24xx_enable(struct stmpe *stmpe, unsigned int blocks,
 657                             bool enable)
 658 {
 659         unsigned int mask = 0;
 660
 661         if (blocks & STMPE_BLOCK_GPIO)
 662                 mask |= STMPE24XX_SYS_CTRL_ENABLE_GPIO;
 663
 664         if (blocks & STMPE_BLOCK_KEYPAD)
 665                 mask |= STMPE24XX_SYS_CTRL_ENABLE_KPC;
 666
 667         return __stmpe_set_bits(stmpe, STMPE24XX_REG_SYS_CTRL, mask,
 668                                 enable ? mask : 0);
 669 }
 670
 671 static int stmpe24xx_get_altfunc(struct stmpe *stmpe, enum stmpe_block block)
 672 {
 673         switch (block) {
 674         case STMPE_BLOCK_ROTATOR:
 675                 return 2;
 676
 677         case STMPE_BLOCK_KEYPAD:
 678                 return 1;
 679
 680         case STMPE_BLOCK_GPIO:
 681         default:
 682                 return 0;
 683         }
 684 }
 685
 686 static struct stmpe_variant_info stmpe2401 = {
 687         .name           = "stmpe2401",
 688         .id_val         = 0x0101,
 689         .id_mask        = 0xffff,
 690         .num_gpios      = 24,
 691         .af_bits        = 2,
 692         .regs           = stmpe24xx_regs,
 693         .blocks         = stmpe24xx_blocks,
 694         .num_blocks     = ARRAY_SIZE(stmpe24xx_blocks),
 695         .num_irqs       = STMPE24XX_NR_INTERNAL_IRQS,
 696         .enable         = stmpe24xx_enable,
 697         .get_altfunc    = stmpe24xx_get_altfunc,
 698 };
 699
 700 static struct stmpe_variant_info stmpe2403 = {
 701         .name           = "stmpe2403",
 702         .id_val         = 0x0120,
 703         .id_mask        = 0xffff,
 704         .num_gpios      = 24,
 705         .af_bits        = 2,
 706         .regs           = stmpe24xx_regs,
 707         .blocks         = stmpe24xx_blocks,
 708         .num_blocks     = ARRAY_SIZE(stmpe24xx_blocks),
 709         .num_irqs       = STMPE24XX_NR_INTERNAL_IRQS,
 710         .enable         = stmpe24xx_enable,
 711         .get_altfunc    = stmpe24xx_get_altfunc,
 712         .enable_autosleep       = stmpe1601_autosleep, /* same as stmpe1601 */
 713 };
 714
 715 static struct stmpe_variant_info *stmpe_variant_info[] = {
 716         [STMPE610]      = &stmpe610,
 717         [STMPE801]      = &stmpe801,
 718         [STMPE811]      = &stmpe811,
 719         [STMPE1601]     = &stmpe1601,
 720         [STMPE2401]     = &stmpe2401,
 721         [STMPE2403]     = &stmpe2403,
 722 };
 723
 724 static irqreturn_t stmpe_irq(int irq, void *data)
 725 {
 726         struct stmpe *stmpe = data;
 727         struct stmpe_variant_info *variant = stmpe->variant;
 728         int num = DIV_ROUND_UP(variant->num_irqs, 8);
 729         u8 israddr = stmpe->regs[STMPE_IDX_ISR_MSB];
 730         u8 isr[num];
 731         int ret;
 732         int i;
 733
 734         if (variant->id_val == STMPE801_ID) {
 735                 handle_nested_irq(stmpe->irq_base);
 736                 return IRQ_HANDLED;
 737         }
 738
 739         ret = stmpe_block_read(stmpe, israddr, num, isr);
 740         if (ret < 0)
 741                 return IRQ_NONE;
 742
 743         for (i = 0; i < num; i++) {
 744                 int bank = num - i - 1;
 745                 u8 status = isr[i];
 746                 u8 clear;
 747
 748                 status &= stmpe->ier[bank];
 749                 if (!status)
 750                         continue;
 751
 752                 clear = status;
 753                 while (status) {
 754                         int bit = __ffs(status);
 755                         int line = bank * 8 + bit;
 756
 757                         handle_nested_irq(stmpe->irq_base + line);
 758                         status &= ~(1 << bit);
 759                 }
 760
 761                 stmpe_reg_write(stmpe, israddr + i, clear);
 762         }
 763
 764         return IRQ_HANDLED;
 765 }
 766
 767 static void stmpe_irq_lock(struct irq_data *data)
 768 {
 769         struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
 770
 771         mutex_lock(&stmpe->irq_lock);
 772 }
 773
 774 static void stmpe_irq_sync_unlock(struct irq_data *data)
 775 {
 776         struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
 777         struct stmpe_variant_info *variant = stmpe->variant;
 778         int num = DIV_ROUND_UP(variant->num_irqs, 8);
 779         int i;
 780
 781         for (i = 0; i < num; i++) {
 782                 u8 new = stmpe->ier[i];
 783                 u8 old = stmpe->oldier[i];
 784
 785                 if (new == old)
 786                         continue;
 787
 788                 stmpe->oldier[i] = new;
 789                 stmpe_reg_write(stmpe, stmpe->regs[STMPE_IDX_IER_LSB] - i, new);
 790         }
 791
 792         mutex_unlock(&stmpe->irq_lock);
 793 }
 794
 795 static void stmpe_irq_mask(struct irq_data *data)
 796 {
 797         struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
 798         int offset = data->irq - stmpe->irq_base;
 799         int regoffset = offset / 8;
 800         int mask = 1 << (offset % 8);
 801
 802         stmpe->ier[regoffset] &= ~mask;
 803 }
 804
 805 static void stmpe_irq_unmask(struct irq_data *data)
 806 {
 807         struct stmpe *stmpe = irq_data_get_irq_chip_data(data);
 808         int offset = data->irq - stmpe->irq_base;
 809         int regoffset = offset / 8;
 810         int mask = 1 << (offset % 8);
 811
 812         stmpe->ier[regoffset] |= mask;
 813 }
 814
 815 static struct irq_chip stmpe_irq_chip = {
 816         .name                   = "stmpe",
 817         .irq_bus_lock           = stmpe_irq_lock,
 818         .irq_bus_sync_unlock    = stmpe_irq_sync_unlock,
 819         .irq_mask               = stmpe_irq_mask,
 820         .irq_unmask             = stmpe_irq_unmask,
 821 };
 822
 823 static int __devinit stmpe_irq_init(struct stmpe *stmpe)
 824 {
 825         struct irq_chip *chip = NULL;
 826         int num_irqs = stmpe->variant->num_irqs;
 827         int base = stmpe->irq_base;
 828         int irq;
 829
 830         if (stmpe->variant->id_val != STMPE801_ID)
 831                 chip = &stmpe_irq_chip;
 832
 833         for (irq = base; irq < base + num_irqs; irq++) {
 834                 irq_set_chip_data(irq, stmpe);
 835                 irq_set_chip_and_handler(irq, chip, handle_edge_irq);
 836                 irq_set_nested_thread(irq, 1);
 837 #ifdef CONFIG_ARM
 838                 set_irq_flags(irq, IRQF_VALID);
 839 #else
 840                 irq_set_noprobe(irq);
 841 #endif
 842         }
 843
 844         return 0;
 845 }
 846
 847 static void stmpe_irq_remove(struct stmpe *stmpe)
 848 {
 849         int num_irqs = stmpe->variant->num_irqs;
 850         int base = stmpe->irq_base;
 851         int irq;
 852
 853         for (irq = base; irq < base + num_irqs; irq++) {
 854 #ifdef CONFIG_ARM
 855                 set_irq_flags(irq, 0);
 856 #endif
 857                 irq_set_chip_and_handler(irq, NULL, NULL);
 858                 irq_set_chip_data(irq, NULL);
 859         }
 860 }
 861
 862 static int __devinit stmpe_chip_init(struct stmpe *stmpe)
 863 {
 864         unsigned int irq_trigger = stmpe->pdata->irq_trigger;
 865         int autosleep_timeout = stmpe->pdata->autosleep_timeout;
 866         struct stmpe_variant_info *variant = stmpe->variant;
 867         u8 icr;
 868         unsigned int id;
 869         u8 data[2];
 870         int ret;
 871
 872         ret = stmpe_block_read(stmpe, stmpe->regs[STMPE_IDX_CHIP_ID],
 873                                ARRAY_SIZE(data), data);
 874         if (ret < 0)
 875                 return ret;
 876
 877         id = (data[0] << 8) | data[1];
 878         if ((id & variant->id_mask) != variant->id_val) {
 879                 dev_err(stmpe->dev, "unknown chip id: %#x\n", id);
 880                 return -EINVAL;
 881         }
 882
 883         dev_info(stmpe->dev, "%s detected, chip id: %#x\n", variant->name, id);
 884
 885         /* Disable all modules -- subdrivers should enable what they need. */
 886         ret = stmpe_disable(stmpe, ~0);
 887         if (ret)
 888                 return ret;
 889
 890         if (id == STMPE801_ID)
 891                 icr = STMPE801_REG_SYS_CTRL_INT_EN;
 892         else
 893                 icr = STMPE_ICR_LSB_GIM;
 894
 895         /* STMPE801 doesn't support Edge interrupts */
 896         if (id != STMPE801_ID) {
 897                 if (irq_trigger == IRQF_TRIGGER_FALLING ||
 898                                 irq_trigger == IRQF_TRIGGER_RISING)
 899                         icr |= STMPE_ICR_LSB_EDGE;
 900         }
 901
 902         if (irq_trigger == IRQF_TRIGGER_RISING ||
 903                         irq_trigger == IRQF_TRIGGER_HIGH) {
 904                 if (id == STMPE801_ID)
 905                         icr |= STMPE801_REG_SYS_CTRL_INT_HI;
 906                 else
 907                         icr |= STMPE_ICR_LSB_HIGH;
 908         }
 909
 910         if (stmpe->pdata->irq_invert_polarity) {
 911                 if (id == STMPE801_ID)
 912                         icr ^= STMPE801_REG_SYS_CTRL_INT_HI;
 913                 else
 914                         icr ^= STMPE_ICR_LSB_HIGH;
 915         }
 916
 917         if (stmpe->pdata->autosleep) {
 918                 ret = stmpe_autosleep(stmpe, autosleep_timeout);
 919                 if (ret)
 920                         return ret;
 921         }
 922
 923         return stmpe_reg_write(stmpe, stmpe->regs[STMPE_IDX_ICR_LSB], icr);
 924 }
 925
 926 static int __devinit stmpe_add_device(struct stmpe *stmpe,
 927                                       struct mfd_cell *cell, int irq)
 928 {
 929         return mfd_add_devices(stmpe->dev, stmpe->pdata->id, cell, 1,
 930                                NULL, stmpe->irq_base + irq);
 931 }
 932
 933 static int __devinit stmpe_devices_init(struct stmpe *stmpe)
 934 {
 935         struct stmpe_variant_info *variant = stmpe->variant;
 936         unsigned int platform_blocks = stmpe->pdata->blocks;
 937         int ret = -EINVAL;
 938         int i;
 939
 940         for (i = 0; i < variant->num_blocks; i++) {
 941                 struct stmpe_variant_block *block = &variant->blocks[i];
 942
 943                 if (!(platform_blocks & block->block))
 944                         continue;
 945
 946                 platform_blocks &= ~block->block;
 947                 ret = stmpe_add_device(stmpe, block->cell, block->irq);
 948                 if (ret)
 949                         return ret;
 950         }
 951
 952         if (platform_blocks)
 953                 dev_warn(stmpe->dev,
 954                          "platform wants blocks (%#x) not present on variant",
 955                          platform_blocks);
 956
 957         return ret;
 958 }
 959
 960 /* Called from client specific probe routines */
 961 int __devinit stmpe_probe(struct stmpe_client_info *ci, int partnum)
 962 {
 963         struct stmpe_platform_data *pdata = dev_get_platdata(ci->dev);
 964         struct stmpe *stmpe;
 965         int ret;
 966
 967         if (!pdata)
 968                 return -EINVAL;
 969
 970         stmpe = kzalloc(sizeof(struct stmpe), GFP_KERNEL);
 971         if (!stmpe)
 972                 return -ENOMEM;
 973
 974         mutex_init(&stmpe->irq_lock);
 975         mutex_init(&stmpe->lock);
 976
 977         stmpe->dev = ci->dev;
 978         stmpe->client = ci->client;
 979         stmpe->pdata = pdata;
 980         stmpe->irq_base = pdata->irq_base;
 981         stmpe->ci = ci;
 982         stmpe->partnum = partnum;
 983         stmpe->variant = stmpe_variant_info[partnum];
 984         stmpe->regs = stmpe->variant->regs;
 985         stmpe->num_gpios = stmpe->variant->num_gpios;
 986         dev_set_drvdata(stmpe->dev, stmpe);
 987
 988         if (ci->init)
 989                 ci->init(stmpe);
 990
 991         if (pdata->irq_over_gpio) {
 992                 ret = gpio_request_one(pdata->irq_gpio, GPIOF_DIR_IN, "stmpe");
 993                 if (ret) {
 994                         dev_err(stmpe->dev, "failed to request IRQ GPIO: %d\n",
 995                                         ret);
 996                         goto out_free;
 997                 }
 998
 999                 stmpe->irq = gpio_to_irq(pdata->irq_gpio);
1000         } else {
1001                 stmpe->irq = ci->irq;
1002         }
1003
1004         ret = stmpe_chip_init(stmpe);
1005         if (ret)
1006                 goto free_gpio;
1007
1008         ret = stmpe_irq_init(stmpe);
1009         if (ret)
1010                 goto free_gpio;
1011
1012         ret = request_threaded_irq(stmpe->irq, NULL, stmpe_irq,
1013                         pdata->irq_trigger | IRQF_ONESHOT, "stmpe", stmpe);
1014         if (ret) {
1015                 dev_err(stmpe->dev, "failed to request IRQ: %d\n", ret);
1016                 goto out_removeirq;
1017         }
1018
1019         ret = stmpe_devices_init(stmpe);
1020         if (ret) {
1021                 dev_err(stmpe->dev, "failed to add children\n");
1022                 goto out_removedevs;
1023         }
1024
1025         return 0;
1026
1027 out_removedevs:
1028         mfd_remove_devices(stmpe->dev);
1029         free_irq(stmpe->irq, stmpe);
1030 out_removeirq:
1031         stmpe_irq_remove(stmpe);
1032 free_gpio:
1033         if (pdata->irq_over_gpio)
1034                 gpio_free(pdata->irq_gpio);
1035 out_free:
1036         kfree(stmpe);
1037         return ret;
1038 }
1039
1040 int stmpe_remove(struct stmpe *stmpe)
1041 {
1042         mfd_remove_devices(stmpe->dev);
1043
1044         free_irq(stmpe->irq, stmpe);
1045         stmpe_irq_remove(stmpe);
1046
1047         if (stmpe->pdata->irq_over_gpio)
1048                 gpio_free(stmpe->pdata->irq_gpio);
1049
1050         kfree(stmpe);
1051
1052         return 0;
1053 }
1054
1055 #ifdef CONFIG_PM
1056 static int stmpe_suspend(struct device *dev)
1057 {
1058         struct stmpe *stmpe = dev_get_drvdata(dev);
1059
1060         if (device_may_wakeup(dev))
1061                 enable_irq_wake(stmpe->irq);
1062
1063         return 0;
1064 }
1065
1066 static int stmpe_resume(struct device *dev)
1067 {
1068         struct stmpe *stmpe = dev_get_drvdata(dev);
1069
1070         if (device_may_wakeup(dev))
1071                 disable_irq_wake(stmpe->irq);
1072
1073         return 0;
1074 }
1075
1076 const struct dev_pm_ops stmpe_dev_pm_ops = {
1077         .suspend        = stmpe_suspend,
1078         .resume         = stmpe_resume,
1079 };
1080 #endif