drivers/mfd/stmpe.c

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