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(unsigned int irq) 703 { 704 struct stmpe *stmpe = get_irq_chip_data(irq); 705 706 mutex_lock(&stmpe->irq_lock); 707 } 708 709 static void stmpe_irq_sync_unlock(unsigned int irq) 710 { 711 struct stmpe *stmpe = get_irq_chip_data(irq); 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(unsigned int irq) 731 { 732 struct stmpe *stmpe = get_irq_chip_data(irq); 733 int offset = 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(unsigned int irq) 741 { 742 struct stmpe *stmpe = get_irq_chip_data(irq); 743 int offset = 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 .bus_lock = stmpe_irq_lock, 753 .bus_sync_unlock = stmpe_irq_sync_unlock, 754 .mask = stmpe_irq_mask, 755 .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 set_irq_chip_data(irq, stmpe); 766 set_irq_chip_and_handler(irq, &stmpe_irq_chip, 767 handle_edge_irq); 768 set_irq_nested_thread(irq, 1); 769 #ifdef CONFIG_ARM 770 set_irq_flags(irq, IRQF_VALID); 771 #else 772 set_irq_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 set_irq_chip_and_handler(irq, NULL, NULL); 790 set_irq_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 static int __devinit stmpe_probe(struct i2c_client *i2c, 877 const struct i2c_device_id *id) 878 { 879 struct stmpe_platform_data *pdata = i2c->dev.platform_data; 880 struct stmpe *stmpe; 881 int ret; 882 883 if (!pdata) 884 return -EINVAL; 885 886 stmpe = kzalloc(sizeof(struct stmpe), GFP_KERNEL); 887 if (!stmpe) 888 return -ENOMEM; 889 890 mutex_init(&stmpe->irq_lock); 891 mutex_init(&stmpe->lock); 892 893 stmpe->dev = &i2c->dev; 894 stmpe->i2c = i2c; 895 896 stmpe->pdata = pdata; 897 stmpe->irq_base = pdata->irq_base; 898 899 stmpe->partnum = id->driver_data; 900 stmpe->variant = stmpe_variant_info[stmpe->partnum]; 901 stmpe->regs = stmpe->variant->regs; 902 stmpe->num_gpios = stmpe->variant->num_gpios; 903 904 i2c_set_clientdata(i2c, stmpe); 905 906 ret = stmpe_chip_init(stmpe); 907 if (ret) 908 goto out_free; 909 910 ret = stmpe_irq_init(stmpe); 911 if (ret) 912 goto out_free; 913 914 ret = request_threaded_irq(stmpe->i2c->irq, NULL, stmpe_irq, 915 pdata->irq_trigger | IRQF_ONESHOT, 916 "stmpe", stmpe); 917 if (ret) { 918 dev_err(stmpe->dev, "failed to request IRQ: %d\n", ret); 919 goto out_removeirq; 920 } 921 922 ret = stmpe_devices_init(stmpe); 923 if (ret) { 924 dev_err(stmpe->dev, "failed to add children\n"); 925 goto out_removedevs; 926 } 927 928 return 0; 929 930 out_removedevs: 931 mfd_remove_devices(stmpe->dev); 932 free_irq(stmpe->i2c->irq, stmpe); 933 out_removeirq: 934 stmpe_irq_remove(stmpe); 935 out_free: 936 kfree(stmpe); 937 return ret; 938 } 939 940 static int __devexit stmpe_remove(struct i2c_client *client) 941 { 942 struct stmpe *stmpe = i2c_get_clientdata(client); 943 944 mfd_remove_devices(stmpe->dev); 945 946 free_irq(stmpe->i2c->irq, stmpe); 947 stmpe_irq_remove(stmpe); 948 949 kfree(stmpe); 950 951 return 0; 952 } 953 954 static const struct i2c_device_id stmpe_id[] = { 955 { "stmpe811", STMPE811 }, 956 { "stmpe1601", STMPE1601 }, 957 { "stmpe2401", STMPE2401 }, 958 { "stmpe2403", STMPE2403 }, 959 { } 960 }; 961 MODULE_DEVICE_TABLE(i2c, stmpe_id); 962 963 static struct i2c_driver stmpe_driver = { 964 .driver.name = "stmpe", 965 .driver.owner = THIS_MODULE, 966 .probe = stmpe_probe, 967 .remove = __devexit_p(stmpe_remove), 968 .id_table = stmpe_id, 969 }; 970 971 static int __init stmpe_init(void) 972 { 973 return i2c_add_driver(&stmpe_driver); 974 } 975 subsys_initcall(stmpe_init); 976 977 static void __exit stmpe_exit(void) 978 { 979 i2c_del_driver(&stmpe_driver); 980 } 981 module_exit(stmpe_exit); 982 983 MODULE_LICENSE("GPL v2"); 984 MODULE_DESCRIPTION("STMPE MFD core driver"); 985 MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>"); 986