2 * ST Microelectronics MFD: stmpe's driver
4 * Copyright (C) ST-Ericsson SA 2010
6 * License Terms: GNU General Public License, version 2
7 * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson
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>
16 #include <linux/slab.h>
17 #include <linux/mfd/core.h>
20 static int __stmpe_enable(struct stmpe
*stmpe
, unsigned int blocks
)
22 return stmpe
->variant
->enable(stmpe
, blocks
, true);
25 static int __stmpe_disable(struct stmpe
*stmpe
, unsigned int blocks
)
27 return stmpe
->variant
->enable(stmpe
, blocks
, false);
30 static int __stmpe_reg_read(struct stmpe
*stmpe
, u8 reg
)
34 ret
= stmpe
->ci
->read_byte(stmpe
, reg
);
36 dev_err(stmpe
->dev
, "failed to read reg %#x: %d\n", reg
, ret
);
38 dev_vdbg(stmpe
->dev
, "rd: reg %#x => data %#x\n", reg
, ret
);
43 static int __stmpe_reg_write(struct stmpe
*stmpe
, u8 reg
, u8 val
)
47 dev_vdbg(stmpe
->dev
, "wr: reg %#x <= %#x\n", reg
, val
);
49 ret
= stmpe
->ci
->write_byte(stmpe
, reg
, val
);
51 dev_err(stmpe
->dev
, "failed to write reg %#x: %d\n", reg
, ret
);
56 static int __stmpe_set_bits(struct stmpe
*stmpe
, u8 reg
, u8 mask
, u8 val
)
60 ret
= __stmpe_reg_read(stmpe
, reg
);
67 return __stmpe_reg_write(stmpe
, reg
, ret
);
70 static int __stmpe_block_read(struct stmpe
*stmpe
, u8 reg
, u8 length
,
75 ret
= stmpe
->ci
->read_block(stmpe
, reg
, length
, values
);
77 dev_err(stmpe
->dev
, "failed to read regs %#x: %d\n", reg
, ret
);
79 dev_vdbg(stmpe
->dev
, "rd: reg %#x (%d) => ret %#x\n", reg
, length
, ret
);
80 stmpe_dump_bytes("stmpe rd: ", values
, length
);
85 static int __stmpe_block_write(struct stmpe
*stmpe
, u8 reg
, u8 length
,
90 dev_vdbg(stmpe
->dev
, "wr: regs %#x (%d)\n", reg
, length
);
91 stmpe_dump_bytes("stmpe wr: ", values
, length
);
93 ret
= stmpe
->ci
->write_block(stmpe
, reg
, length
, values
);
95 dev_err(stmpe
->dev
, "failed to write regs %#x: %d\n", reg
, ret
);
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
105 int stmpe_enable(struct stmpe
*stmpe
, unsigned int blocks
)
109 mutex_lock(&stmpe
->lock
);
110 ret
= __stmpe_enable(stmpe
, blocks
);
111 mutex_unlock(&stmpe
->lock
);
115 EXPORT_SYMBOL_GPL(stmpe_enable
);
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
122 int stmpe_disable(struct stmpe
*stmpe
, unsigned int blocks
)
126 mutex_lock(&stmpe
->lock
);
127 ret
= __stmpe_disable(stmpe
, blocks
);
128 mutex_unlock(&stmpe
->lock
);
132 EXPORT_SYMBOL_GPL(stmpe_disable
);
135 * stmpe_reg_read() - read a single STMPE register
136 * @stmpe: Device to read from
137 * @reg: Register to read
139 int stmpe_reg_read(struct stmpe
*stmpe
, u8 reg
)
143 mutex_lock(&stmpe
->lock
);
144 ret
= __stmpe_reg_read(stmpe
, reg
);
145 mutex_unlock(&stmpe
->lock
);
149 EXPORT_SYMBOL_GPL(stmpe_reg_read
);
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
157 int stmpe_reg_write(struct stmpe
*stmpe
, u8 reg
, u8 val
)
161 mutex_lock(&stmpe
->lock
);
162 ret
= __stmpe_reg_write(stmpe
, reg
, val
);
163 mutex_unlock(&stmpe
->lock
);
167 EXPORT_SYMBOL_GPL(stmpe_reg_write
);
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
176 int stmpe_set_bits(struct stmpe
*stmpe
, u8 reg
, u8 mask
, u8 val
)
180 mutex_lock(&stmpe
->lock
);
181 ret
= __stmpe_set_bits(stmpe
, reg
, mask
, val
);
182 mutex_unlock(&stmpe
->lock
);
186 EXPORT_SYMBOL_GPL(stmpe_set_bits
);
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
195 int stmpe_block_read(struct stmpe
*stmpe
, u8 reg
, u8 length
, u8
*values
)
199 mutex_lock(&stmpe
->lock
);
200 ret
= __stmpe_block_read(stmpe
, reg
, length
, values
);
201 mutex_unlock(&stmpe
->lock
);
205 EXPORT_SYMBOL_GPL(stmpe_block_read
);
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
214 int stmpe_block_write(struct stmpe
*stmpe
, u8 reg
, u8 length
,
219 mutex_lock(&stmpe
->lock
);
220 ret
= __stmpe_block_write(stmpe
, reg
, length
, values
);
221 mutex_unlock(&stmpe
->lock
);
225 EXPORT_SYMBOL_GPL(stmpe_block_write
);
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
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.
236 * If the GPIO module is not enabled, this function automatically enables it in
237 * order to perform the change.
239 int stmpe_set_altfunc(struct stmpe
*stmpe
, u32 pins
, enum stmpe_block block
)
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;
247 int af
, afperreg
, ret
;
249 if (!variant
->get_altfunc
)
252 afperreg
= 8 / af_bits
;
253 mutex_lock(&stmpe
->lock
);
255 ret
= __stmpe_enable(stmpe
, STMPE_BLOCK_GPIO
);
259 ret
= __stmpe_block_read(stmpe
, regaddr
, numregs
, regs
);
263 af
= variant
->get_altfunc(stmpe
, block
);
266 int pin
= __ffs(pins
);
267 int regoffset
= numregs
- (pin
/ afperreg
) - 1;
268 int pos
= (pin
% afperreg
) * (8 / afperreg
);
270 regs
[regoffset
] &= ~(mask
<< pos
);
271 regs
[regoffset
] |= af
<< pos
;
276 ret
= __stmpe_block_write(stmpe
, regaddr
, numregs
, regs
);
279 mutex_unlock(&stmpe
->lock
);
282 EXPORT_SYMBOL_GPL(stmpe_set_altfunc
);
285 * GPIO (all variants)
288 static struct resource stmpe_gpio_resources
[] = {
289 /* Start and end filled dynamically */
291 .flags
= IORESOURCE_IRQ
,
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
),
301 static struct mfd_cell stmpe_gpio_cell_noirq
= {
302 .name
= "stmpe-gpio",
303 /* gpio cell resources consist of an irq only so no resources here */
307 * Keypad (1601, 2401, 2403)
310 static struct resource stmpe_keypad_resources
[] = {
313 .flags
= IORESOURCE_IRQ
,
316 .name
= "KEYPAD_OVER",
317 .flags
= IORESOURCE_IRQ
,
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
),
330 static const u8 stmpe801_regs
[] = {
331 [STMPE_IDX_CHIP_ID
] = STMPE801_REG_CHIP_ID
,
332 [STMPE_IDX_ICR_LSB
] = STMPE801_REG_SYS_CTRL
,
333 [STMPE_IDX_GPMR_LSB
] = STMPE801_REG_GPIO_MP_STA
,
334 [STMPE_IDX_GPSR_LSB
] = STMPE801_REG_GPIO_SET_PIN
,
335 [STMPE_IDX_GPCR_LSB
] = STMPE801_REG_GPIO_SET_PIN
,
336 [STMPE_IDX_GPDR_LSB
] = STMPE801_REG_GPIO_DIR
,
337 [STMPE_IDX_IEGPIOR_LSB
] = STMPE801_REG_GPIO_INT_EN
,
338 [STMPE_IDX_ISGPIOR_MSB
] = STMPE801_REG_GPIO_INT_STA
,
342 static struct stmpe_variant_block stmpe801_blocks
[] = {
344 .cell
= &stmpe_gpio_cell
,
346 .block
= STMPE_BLOCK_GPIO
,
350 static struct stmpe_variant_block stmpe801_blocks_noirq
[] = {
352 .cell
= &stmpe_gpio_cell_noirq
,
353 .block
= STMPE_BLOCK_GPIO
,
357 static int stmpe801_enable(struct stmpe
*stmpe
, unsigned int blocks
,
360 if (blocks
& STMPE_BLOCK_GPIO
)
366 static struct stmpe_variant_info stmpe801
= {
368 .id_val
= STMPE801_ID
,
371 .regs
= stmpe801_regs
,
372 .blocks
= stmpe801_blocks
,
373 .num_blocks
= ARRAY_SIZE(stmpe801_blocks
),
374 .num_irqs
= STMPE801_NR_INTERNAL_IRQS
,
375 .enable
= stmpe801_enable
,
378 static struct stmpe_variant_info stmpe801_noirq
= {
380 .id_val
= STMPE801_ID
,
383 .regs
= stmpe801_regs
,
384 .blocks
= stmpe801_blocks_noirq
,
385 .num_blocks
= ARRAY_SIZE(stmpe801_blocks_noirq
),
386 .enable
= stmpe801_enable
,
390 * Touchscreen (STMPE811 or STMPE610)
393 static struct resource stmpe_ts_resources
[] = {
396 .flags
= IORESOURCE_IRQ
,
400 .flags
= IORESOURCE_IRQ
,
404 static struct mfd_cell stmpe_ts_cell
= {
406 .resources
= stmpe_ts_resources
,
407 .num_resources
= ARRAY_SIZE(stmpe_ts_resources
),
411 * STMPE811 or STMPE610
414 static const u8 stmpe811_regs
[] = {
415 [STMPE_IDX_CHIP_ID
] = STMPE811_REG_CHIP_ID
,
416 [STMPE_IDX_ICR_LSB
] = STMPE811_REG_INT_CTRL
,
417 [STMPE_IDX_IER_LSB
] = STMPE811_REG_INT_EN
,
418 [STMPE_IDX_ISR_MSB
] = STMPE811_REG_INT_STA
,
419 [STMPE_IDX_GPMR_LSB
] = STMPE811_REG_GPIO_MP_STA
,
420 [STMPE_IDX_GPSR_LSB
] = STMPE811_REG_GPIO_SET_PIN
,
421 [STMPE_IDX_GPCR_LSB
] = STMPE811_REG_GPIO_CLR_PIN
,
422 [STMPE_IDX_GPDR_LSB
] = STMPE811_REG_GPIO_DIR
,
423 [STMPE_IDX_GPRER_LSB
] = STMPE811_REG_GPIO_RE
,
424 [STMPE_IDX_GPFER_LSB
] = STMPE811_REG_GPIO_FE
,
425 [STMPE_IDX_GPAFR_U_MSB
] = STMPE811_REG_GPIO_AF
,
426 [STMPE_IDX_IEGPIOR_LSB
] = STMPE811_REG_GPIO_INT_EN
,
427 [STMPE_IDX_ISGPIOR_MSB
] = STMPE811_REG_GPIO_INT_STA
,
428 [STMPE_IDX_GPEDR_MSB
] = STMPE811_REG_GPIO_ED
,
431 static struct stmpe_variant_block stmpe811_blocks
[] = {
433 .cell
= &stmpe_gpio_cell
,
434 .irq
= STMPE811_IRQ_GPIOC
,
435 .block
= STMPE_BLOCK_GPIO
,
438 .cell
= &stmpe_ts_cell
,
439 .irq
= STMPE811_IRQ_TOUCH_DET
,
440 .block
= STMPE_BLOCK_TOUCHSCREEN
,
444 static int stmpe811_enable(struct stmpe
*stmpe
, unsigned int blocks
,
447 unsigned int mask
= 0;
449 if (blocks
& STMPE_BLOCK_GPIO
)
450 mask
|= STMPE811_SYS_CTRL2_GPIO_OFF
;
452 if (blocks
& STMPE_BLOCK_ADC
)
453 mask
|= STMPE811_SYS_CTRL2_ADC_OFF
;
455 if (blocks
& STMPE_BLOCK_TOUCHSCREEN
)
456 mask
|= STMPE811_SYS_CTRL2_TSC_OFF
;
458 return __stmpe_set_bits(stmpe
, STMPE811_REG_SYS_CTRL2
, mask
,
462 static int stmpe811_get_altfunc(struct stmpe
*stmpe
, enum stmpe_block block
)
464 /* 0 for touchscreen, 1 for GPIO */
465 return block
!= STMPE_BLOCK_TOUCHSCREEN
;
468 static struct stmpe_variant_info stmpe811
= {
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
,
482 /* Similar to 811, except number of gpios */
483 static struct stmpe_variant_info stmpe610
= {
489 .regs
= stmpe811_regs
,
490 .blocks
= stmpe811_blocks
,
491 .num_blocks
= ARRAY_SIZE(stmpe811_blocks
),
492 .num_irqs
= STMPE811_NR_INTERNAL_IRQS
,
493 .enable
= stmpe811_enable
,
494 .get_altfunc
= stmpe811_get_altfunc
,
501 static const u8 stmpe1601_regs
[] = {
502 [STMPE_IDX_CHIP_ID
] = STMPE1601_REG_CHIP_ID
,
503 [STMPE_IDX_ICR_LSB
] = STMPE1601_REG_ICR_LSB
,
504 [STMPE_IDX_IER_LSB
] = STMPE1601_REG_IER_LSB
,
505 [STMPE_IDX_ISR_MSB
] = STMPE1601_REG_ISR_MSB
,
506 [STMPE_IDX_GPMR_LSB
] = STMPE1601_REG_GPIO_MP_LSB
,
507 [STMPE_IDX_GPSR_LSB
] = STMPE1601_REG_GPIO_SET_LSB
,
508 [STMPE_IDX_GPCR_LSB
] = STMPE1601_REG_GPIO_CLR_LSB
,
509 [STMPE_IDX_GPDR_LSB
] = STMPE1601_REG_GPIO_SET_DIR_LSB
,
510 [STMPE_IDX_GPRER_LSB
] = STMPE1601_REG_GPIO_RE_LSB
,
511 [STMPE_IDX_GPFER_LSB
] = STMPE1601_REG_GPIO_FE_LSB
,
512 [STMPE_IDX_GPAFR_U_MSB
] = STMPE1601_REG_GPIO_AF_U_MSB
,
513 [STMPE_IDX_IEGPIOR_LSB
] = STMPE1601_REG_INT_EN_GPIO_MASK_LSB
,
514 [STMPE_IDX_ISGPIOR_MSB
] = STMPE1601_REG_INT_STA_GPIO_MSB
,
515 [STMPE_IDX_GPEDR_MSB
] = STMPE1601_REG_GPIO_ED_MSB
,
518 static struct stmpe_variant_block stmpe1601_blocks
[] = {
520 .cell
= &stmpe_gpio_cell
,
521 .irq
= STMPE24XX_IRQ_GPIOC
,
522 .block
= STMPE_BLOCK_GPIO
,
525 .cell
= &stmpe_keypad_cell
,
526 .irq
= STMPE24XX_IRQ_KEYPAD
,
527 .block
= STMPE_BLOCK_KEYPAD
,
531 /* supported autosleep timeout delay (in msecs) */
532 static const int stmpe_autosleep_delay
[] = {
533 4, 16, 32, 64, 128, 256, 512, 1024,
536 static int stmpe_round_timeout(int timeout
)
540 for (i
= 0; i
< ARRAY_SIZE(stmpe_autosleep_delay
); i
++) {
541 if (stmpe_autosleep_delay
[i
] >= timeout
)
546 * requests for delays longer than supported should not return the
547 * longest supported delay
552 static int stmpe_autosleep(struct stmpe
*stmpe
, int autosleep_timeout
)
556 if (!stmpe
->variant
->enable_autosleep
)
559 mutex_lock(&stmpe
->lock
);
560 ret
= stmpe
->variant
->enable_autosleep(stmpe
, autosleep_timeout
);
561 mutex_unlock(&stmpe
->lock
);
567 * Both stmpe 1601/2403 support same layout for autosleep
569 static int stmpe1601_autosleep(struct stmpe
*stmpe
,
570 int autosleep_timeout
)
574 /* choose the best available timeout */
575 timeout
= stmpe_round_timeout(autosleep_timeout
);
577 dev_err(stmpe
->dev
, "invalid timeout\n");
581 ret
= __stmpe_set_bits(stmpe
, STMPE1601_REG_SYS_CTRL2
,
582 STMPE1601_AUTOSLEEP_TIMEOUT_MASK
,
587 return __stmpe_set_bits(stmpe
, STMPE1601_REG_SYS_CTRL2
,
588 STPME1601_AUTOSLEEP_ENABLE
,
589 STPME1601_AUTOSLEEP_ENABLE
);
592 static int stmpe1601_enable(struct stmpe
*stmpe
, unsigned int blocks
,
595 unsigned int mask
= 0;
597 if (blocks
& STMPE_BLOCK_GPIO
)
598 mask
|= STMPE1601_SYS_CTRL_ENABLE_GPIO
;
600 if (blocks
& STMPE_BLOCK_KEYPAD
)
601 mask
|= STMPE1601_SYS_CTRL_ENABLE_KPC
;
603 return __stmpe_set_bits(stmpe
, STMPE1601_REG_SYS_CTRL
, mask
,
607 static int stmpe1601_get_altfunc(struct stmpe
*stmpe
, enum stmpe_block block
)
610 case STMPE_BLOCK_PWM
:
613 case STMPE_BLOCK_KEYPAD
:
616 case STMPE_BLOCK_GPIO
:
622 static struct stmpe_variant_info stmpe1601
= {
625 .id_mask
= 0xfff0, /* at least 0x0210 and 0x0212 */
628 .regs
= stmpe1601_regs
,
629 .blocks
= stmpe1601_blocks
,
630 .num_blocks
= ARRAY_SIZE(stmpe1601_blocks
),
631 .num_irqs
= STMPE1601_NR_INTERNAL_IRQS
,
632 .enable
= stmpe1601_enable
,
633 .get_altfunc
= stmpe1601_get_altfunc
,
634 .enable_autosleep
= stmpe1601_autosleep
,
641 static const u8 stmpe24xx_regs
[] = {
642 [STMPE_IDX_CHIP_ID
] = STMPE24XX_REG_CHIP_ID
,
643 [STMPE_IDX_ICR_LSB
] = STMPE24XX_REG_ICR_LSB
,
644 [STMPE_IDX_IER_LSB
] = STMPE24XX_REG_IER_LSB
,
645 [STMPE_IDX_ISR_MSB
] = STMPE24XX_REG_ISR_MSB
,
646 [STMPE_IDX_GPMR_LSB
] = STMPE24XX_REG_GPMR_LSB
,
647 [STMPE_IDX_GPSR_LSB
] = STMPE24XX_REG_GPSR_LSB
,
648 [STMPE_IDX_GPCR_LSB
] = STMPE24XX_REG_GPCR_LSB
,
649 [STMPE_IDX_GPDR_LSB
] = STMPE24XX_REG_GPDR_LSB
,
650 [STMPE_IDX_GPRER_LSB
] = STMPE24XX_REG_GPRER_LSB
,
651 [STMPE_IDX_GPFER_LSB
] = STMPE24XX_REG_GPFER_LSB
,
652 [STMPE_IDX_GPAFR_U_MSB
] = STMPE24XX_REG_GPAFR_U_MSB
,
653 [STMPE_IDX_IEGPIOR_LSB
] = STMPE24XX_REG_IEGPIOR_LSB
,
654 [STMPE_IDX_ISGPIOR_MSB
] = STMPE24XX_REG_ISGPIOR_MSB
,
655 [STMPE_IDX_GPEDR_MSB
] = STMPE24XX_REG_GPEDR_MSB
,
658 static struct stmpe_variant_block stmpe24xx_blocks
[] = {
660 .cell
= &stmpe_gpio_cell
,
661 .irq
= STMPE24XX_IRQ_GPIOC
,
662 .block
= STMPE_BLOCK_GPIO
,
665 .cell
= &stmpe_keypad_cell
,
666 .irq
= STMPE24XX_IRQ_KEYPAD
,
667 .block
= STMPE_BLOCK_KEYPAD
,
671 static int stmpe24xx_enable(struct stmpe
*stmpe
, unsigned int blocks
,
674 unsigned int mask
= 0;
676 if (blocks
& STMPE_BLOCK_GPIO
)
677 mask
|= STMPE24XX_SYS_CTRL_ENABLE_GPIO
;
679 if (blocks
& STMPE_BLOCK_KEYPAD
)
680 mask
|= STMPE24XX_SYS_CTRL_ENABLE_KPC
;
682 return __stmpe_set_bits(stmpe
, STMPE24XX_REG_SYS_CTRL
, mask
,
686 static int stmpe24xx_get_altfunc(struct stmpe
*stmpe
, enum stmpe_block block
)
689 case STMPE_BLOCK_ROTATOR
:
692 case STMPE_BLOCK_KEYPAD
:
695 case STMPE_BLOCK_GPIO
:
701 static struct stmpe_variant_info stmpe2401
= {
707 .regs
= stmpe24xx_regs
,
708 .blocks
= stmpe24xx_blocks
,
709 .num_blocks
= ARRAY_SIZE(stmpe24xx_blocks
),
710 .num_irqs
= STMPE24XX_NR_INTERNAL_IRQS
,
711 .enable
= stmpe24xx_enable
,
712 .get_altfunc
= stmpe24xx_get_altfunc
,
715 static struct stmpe_variant_info stmpe2403
= {
721 .regs
= stmpe24xx_regs
,
722 .blocks
= stmpe24xx_blocks
,
723 .num_blocks
= ARRAY_SIZE(stmpe24xx_blocks
),
724 .num_irqs
= STMPE24XX_NR_INTERNAL_IRQS
,
725 .enable
= stmpe24xx_enable
,
726 .get_altfunc
= stmpe24xx_get_altfunc
,
727 .enable_autosleep
= stmpe1601_autosleep
, /* same as stmpe1601 */
730 static struct stmpe_variant_info
*stmpe_variant_info
[STMPE_NBR_PARTS
] = {
731 [STMPE610
] = &stmpe610
,
732 [STMPE801
] = &stmpe801
,
733 [STMPE811
] = &stmpe811
,
734 [STMPE1601
] = &stmpe1601
,
735 [STMPE2401
] = &stmpe2401
,
736 [STMPE2403
] = &stmpe2403
,
740 * These devices can be connected in a 'no-irq' configuration - the irq pin
741 * is not used and the device cannot interrupt the CPU. Here we only list
742 * devices which support this configuration - the driver will fail probing
743 * for any devices not listed here which are configured in this way.
745 static struct stmpe_variant_info
*stmpe_noirq_variant_info
[STMPE_NBR_PARTS
] = {
746 [STMPE801
] = &stmpe801_noirq
,
749 static irqreturn_t
stmpe_irq(int irq
, void *data
)
751 struct stmpe
*stmpe
= data
;
752 struct stmpe_variant_info
*variant
= stmpe
->variant
;
753 int num
= DIV_ROUND_UP(variant
->num_irqs
, 8);
754 u8 israddr
= stmpe
->regs
[STMPE_IDX_ISR_MSB
];
759 if (variant
->id_val
== STMPE801_ID
) {
760 handle_nested_irq(stmpe
->irq_base
);
764 ret
= stmpe_block_read(stmpe
, israddr
, num
, isr
);
768 for (i
= 0; i
< num
; i
++) {
769 int bank
= num
- i
- 1;
773 status
&= stmpe
->ier
[bank
];
779 int bit
= __ffs(status
);
780 int line
= bank
* 8 + bit
;
782 handle_nested_irq(stmpe
->irq_base
+ line
);
783 status
&= ~(1 << bit
);
786 stmpe_reg_write(stmpe
, israddr
+ i
, clear
);
792 static void stmpe_irq_lock(struct irq_data
*data
)
794 struct stmpe
*stmpe
= irq_data_get_irq_chip_data(data
);
796 mutex_lock(&stmpe
->irq_lock
);
799 static void stmpe_irq_sync_unlock(struct irq_data
*data
)
801 struct stmpe
*stmpe
= irq_data_get_irq_chip_data(data
);
802 struct stmpe_variant_info
*variant
= stmpe
->variant
;
803 int num
= DIV_ROUND_UP(variant
->num_irqs
, 8);
806 for (i
= 0; i
< num
; i
++) {
807 u8
new = stmpe
->ier
[i
];
808 u8 old
= stmpe
->oldier
[i
];
813 stmpe
->oldier
[i
] = new;
814 stmpe_reg_write(stmpe
, stmpe
->regs
[STMPE_IDX_IER_LSB
] - i
, new);
817 mutex_unlock(&stmpe
->irq_lock
);
820 static void stmpe_irq_mask(struct irq_data
*data
)
822 struct stmpe
*stmpe
= irq_data_get_irq_chip_data(data
);
823 int offset
= data
->irq
- stmpe
->irq_base
;
824 int regoffset
= offset
/ 8;
825 int mask
= 1 << (offset
% 8);
827 stmpe
->ier
[regoffset
] &= ~mask
;
830 static void stmpe_irq_unmask(struct irq_data
*data
)
832 struct stmpe
*stmpe
= irq_data_get_irq_chip_data(data
);
833 int offset
= data
->irq
- stmpe
->irq_base
;
834 int regoffset
= offset
/ 8;
835 int mask
= 1 << (offset
% 8);
837 stmpe
->ier
[regoffset
] |= mask
;
840 static struct irq_chip stmpe_irq_chip
= {
842 .irq_bus_lock
= stmpe_irq_lock
,
843 .irq_bus_sync_unlock
= stmpe_irq_sync_unlock
,
844 .irq_mask
= stmpe_irq_mask
,
845 .irq_unmask
= stmpe_irq_unmask
,
848 static int __devinit
stmpe_irq_init(struct stmpe
*stmpe
)
850 struct irq_chip
*chip
= NULL
;
851 int num_irqs
= stmpe
->variant
->num_irqs
;
852 int base
= stmpe
->irq_base
;
855 if (stmpe
->variant
->id_val
!= STMPE801_ID
)
856 chip
= &stmpe_irq_chip
;
858 for (irq
= base
; irq
< base
+ num_irqs
; irq
++) {
859 irq_set_chip_data(irq
, stmpe
);
860 irq_set_chip_and_handler(irq
, chip
, handle_edge_irq
);
861 irq_set_nested_thread(irq
, 1);
863 set_irq_flags(irq
, IRQF_VALID
);
865 irq_set_noprobe(irq
);
872 static void stmpe_irq_remove(struct stmpe
*stmpe
)
874 int num_irqs
= stmpe
->variant
->num_irqs
;
875 int base
= stmpe
->irq_base
;
878 for (irq
= base
; irq
< base
+ num_irqs
; irq
++) {
880 set_irq_flags(irq
, 0);
882 irq_set_chip_and_handler(irq
, NULL
, NULL
);
883 irq_set_chip_data(irq
, NULL
);
887 static int __devinit
stmpe_chip_init(struct stmpe
*stmpe
)
889 unsigned int irq_trigger
= stmpe
->pdata
->irq_trigger
;
890 int autosleep_timeout
= stmpe
->pdata
->autosleep_timeout
;
891 struct stmpe_variant_info
*variant
= stmpe
->variant
;
897 ret
= stmpe_block_read(stmpe
, stmpe
->regs
[STMPE_IDX_CHIP_ID
],
898 ARRAY_SIZE(data
), data
);
902 id
= (data
[0] << 8) | data
[1];
903 if ((id
& variant
->id_mask
) != variant
->id_val
) {
904 dev_err(stmpe
->dev
, "unknown chip id: %#x\n", id
);
908 dev_info(stmpe
->dev
, "%s detected, chip id: %#x\n", variant
->name
, id
);
910 /* Disable all modules -- subdrivers should enable what they need. */
911 ret
= stmpe_disable(stmpe
, ~0);
915 if (stmpe
->irq
>= 0) {
916 if (id
== STMPE801_ID
)
917 icr
= STMPE801_REG_SYS_CTRL_INT_EN
;
919 icr
= STMPE_ICR_LSB_GIM
;
921 /* STMPE801 doesn't support Edge interrupts */
922 if (id
!= STMPE801_ID
) {
923 if (irq_trigger
== IRQF_TRIGGER_FALLING
||
924 irq_trigger
== IRQF_TRIGGER_RISING
)
925 icr
|= STMPE_ICR_LSB_EDGE
;
928 if (irq_trigger
== IRQF_TRIGGER_RISING
||
929 irq_trigger
== IRQF_TRIGGER_HIGH
) {
930 if (id
== STMPE801_ID
)
931 icr
|= STMPE801_REG_SYS_CTRL_INT_HI
;
933 icr
|= STMPE_ICR_LSB_HIGH
;
936 if (stmpe
->pdata
->irq_invert_polarity
) {
937 if (id
== STMPE801_ID
)
938 icr
^= STMPE801_REG_SYS_CTRL_INT_HI
;
940 icr
^= STMPE_ICR_LSB_HIGH
;
944 if (stmpe
->pdata
->autosleep
) {
945 ret
= stmpe_autosleep(stmpe
, autosleep_timeout
);
950 return stmpe_reg_write(stmpe
, stmpe
->regs
[STMPE_IDX_ICR_LSB
], icr
);
953 static int __devinit
stmpe_add_device(struct stmpe
*stmpe
,
954 struct mfd_cell
*cell
)
956 return mfd_add_devices(stmpe
->dev
, stmpe
->pdata
->id
, cell
, 1,
957 NULL
, stmpe
->irq_base
, NULL
);
960 static int __devinit
stmpe_devices_init(struct stmpe
*stmpe
)
962 struct stmpe_variant_info
*variant
= stmpe
->variant
;
963 unsigned int platform_blocks
= stmpe
->pdata
->blocks
;
967 for (i
= 0; i
< variant
->num_blocks
; i
++) {
968 struct stmpe_variant_block
*block
= &variant
->blocks
[i
];
970 if (!(platform_blocks
& block
->block
))
973 for (j
= 0; j
< block
->cell
->num_resources
; j
++) {
974 struct resource
*res
=
975 (struct resource
*) &block
->cell
->resources
[j
];
977 /* Dynamically fill in a variant's IRQ. */
978 if (res
->flags
& IORESOURCE_IRQ
)
979 res
->start
= res
->end
= block
->irq
+ j
;
982 platform_blocks
&= ~block
->block
;
983 ret
= stmpe_add_device(stmpe
, block
->cell
);
990 "platform wants blocks (%#x) not present on variant",
996 /* Called from client specific probe routines */
997 int __devinit
stmpe_probe(struct stmpe_client_info
*ci
, int partnum
)
999 struct stmpe_platform_data
*pdata
= dev_get_platdata(ci
->dev
);
1000 struct stmpe
*stmpe
;
1006 stmpe
= kzalloc(sizeof(struct stmpe
), GFP_KERNEL
);
1010 mutex_init(&stmpe
->irq_lock
);
1011 mutex_init(&stmpe
->lock
);
1013 stmpe
->dev
= ci
->dev
;
1014 stmpe
->client
= ci
->client
;
1015 stmpe
->pdata
= pdata
;
1016 stmpe
->irq_base
= pdata
->irq_base
;
1018 stmpe
->partnum
= partnum
;
1019 stmpe
->variant
= stmpe_variant_info
[partnum
];
1020 stmpe
->regs
= stmpe
->variant
->regs
;
1021 stmpe
->num_gpios
= stmpe
->variant
->num_gpios
;
1022 dev_set_drvdata(stmpe
->dev
, stmpe
);
1027 if (pdata
->irq_over_gpio
) {
1028 ret
= gpio_request_one(pdata
->irq_gpio
, GPIOF_DIR_IN
, "stmpe");
1030 dev_err(stmpe
->dev
, "failed to request IRQ GPIO: %d\n",
1035 stmpe
->irq
= gpio_to_irq(pdata
->irq_gpio
);
1037 stmpe
->irq
= ci
->irq
;
1040 if (stmpe
->irq
< 0) {
1041 /* use alternate variant info for no-irq mode, if supported */
1042 dev_info(stmpe
->dev
,
1043 "%s configured in no-irq mode by platform data\n",
1044 stmpe
->variant
->name
);
1045 if (!stmpe_noirq_variant_info
[stmpe
->partnum
]) {
1047 "%s does not support no-irq mode!\n",
1048 stmpe
->variant
->name
);
1052 stmpe
->variant
= stmpe_noirq_variant_info
[stmpe
->partnum
];
1055 ret
= stmpe_chip_init(stmpe
);
1059 if (stmpe
->irq
>= 0) {
1060 ret
= stmpe_irq_init(stmpe
);
1064 ret
= request_threaded_irq(stmpe
->irq
, NULL
, stmpe_irq
,
1065 pdata
->irq_trigger
| IRQF_ONESHOT
,
1068 dev_err(stmpe
->dev
, "failed to request IRQ: %d\n",
1074 ret
= stmpe_devices_init(stmpe
);
1076 dev_err(stmpe
->dev
, "failed to add children\n");
1077 goto out_removedevs
;
1083 mfd_remove_devices(stmpe
->dev
);
1084 if (stmpe
->irq
>= 0)
1085 free_irq(stmpe
->irq
, stmpe
);
1087 if (stmpe
->irq
>= 0)
1088 stmpe_irq_remove(stmpe
);
1090 if (pdata
->irq_over_gpio
)
1091 gpio_free(pdata
->irq_gpio
);
1097 int stmpe_remove(struct stmpe
*stmpe
)
1099 mfd_remove_devices(stmpe
->dev
);
1101 if (stmpe
->irq
>= 0) {
1102 free_irq(stmpe
->irq
, stmpe
);
1103 stmpe_irq_remove(stmpe
);
1106 if (stmpe
->pdata
->irq_over_gpio
)
1107 gpio_free(stmpe
->pdata
->irq_gpio
);
1115 static int stmpe_suspend(struct device
*dev
)
1117 struct stmpe
*stmpe
= dev_get_drvdata(dev
);
1119 if (stmpe
->irq
>= 0 && device_may_wakeup(dev
))
1120 enable_irq_wake(stmpe
->irq
);
1125 static int stmpe_resume(struct device
*dev
)
1127 struct stmpe
*stmpe
= dev_get_drvdata(dev
);
1129 if (stmpe
->irq
>= 0 && device_may_wakeup(dev
))
1130 disable_irq_wake(stmpe
->irq
);
1135 const struct dev_pm_ops stmpe_dev_pm_ops
= {
1136 .suspend
= stmpe_suspend
,
1137 .resume
= stmpe_resume
,