2 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License version 2 and
6 * only version 2 as published by the Free Software Foundation.
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
14 #define pr_fmt(fmt) "%s: " fmt, __func__
16 #include <linux/kernel.h>
17 #include <linux/interrupt.h>
18 #include <linux/irqchip/chained_irq.h>
19 #include <linux/irq.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/slab.h>
23 #include <linux/err.h>
24 #include <linux/ssbi.h>
25 #include <linux/mfd/core.h>
26 #include <linux/mfd/pm8xxx/pm8921.h>
27 #include <linux/mfd/pm8xxx/core.h>
28 #include <linux/mfd/pm8xxx/irq.h>
30 #define SSBI_REG_ADDR_IRQ_BASE 0x1BB
32 #define SSBI_REG_ADDR_IRQ_ROOT (SSBI_REG_ADDR_IRQ_BASE + 0)
33 #define SSBI_REG_ADDR_IRQ_M_STATUS1 (SSBI_REG_ADDR_IRQ_BASE + 1)
34 #define SSBI_REG_ADDR_IRQ_M_STATUS2 (SSBI_REG_ADDR_IRQ_BASE + 2)
35 #define SSBI_REG_ADDR_IRQ_M_STATUS3 (SSBI_REG_ADDR_IRQ_BASE + 3)
36 #define SSBI_REG_ADDR_IRQ_M_STATUS4 (SSBI_REG_ADDR_IRQ_BASE + 4)
37 #define SSBI_REG_ADDR_IRQ_BLK_SEL (SSBI_REG_ADDR_IRQ_BASE + 5)
38 #define SSBI_REG_ADDR_IRQ_IT_STATUS (SSBI_REG_ADDR_IRQ_BASE + 6)
39 #define SSBI_REG_ADDR_IRQ_CONFIG (SSBI_REG_ADDR_IRQ_BASE + 7)
40 #define SSBI_REG_ADDR_IRQ_RT_STATUS (SSBI_REG_ADDR_IRQ_BASE + 8)
42 #define PM_IRQF_LVL_SEL 0x01 /* level select */
43 #define PM_IRQF_MASK_FE 0x02 /* mask falling edge */
44 #define PM_IRQF_MASK_RE 0x04 /* mask rising edge */
45 #define PM_IRQF_CLR 0x08 /* clear interrupt */
46 #define PM_IRQF_BITS_MASK 0x70
47 #define PM_IRQF_BITS_SHIFT 4
48 #define PM_IRQF_WRITE 0x80
50 #define PM_IRQF_MASK_ALL (PM_IRQF_MASK_FE | \
53 #define REG_HWREV 0x002 /* PMIC4 revision */
54 #define REG_HWREV_2 0x0E8 /* PMIC4 revision 2 */
58 spinlock_t pm_irq_lock
;
60 unsigned int irq_base
;
61 unsigned int num_irqs
;
62 unsigned int num_blocks
;
63 unsigned int num_masters
;
69 struct pm_irq_chip
*irq_chip
;
72 static int pm8xxx_read_root_irq(const struct pm_irq_chip
*chip
, u8
*rp
)
74 return pm8xxx_readb(chip
->dev
, SSBI_REG_ADDR_IRQ_ROOT
, rp
);
77 static int pm8xxx_read_master_irq(const struct pm_irq_chip
*chip
, u8 m
, u8
*bp
)
79 return pm8xxx_readb(chip
->dev
,
80 SSBI_REG_ADDR_IRQ_M_STATUS1
+ m
, bp
);
83 static int pm8xxx_read_block_irq(struct pm_irq_chip
*chip
, u8 bp
, u8
*ip
)
87 spin_lock(&chip
->pm_irq_lock
);
88 rc
= pm8xxx_writeb(chip
->dev
, SSBI_REG_ADDR_IRQ_BLK_SEL
, bp
);
90 pr_err("Failed Selecting Block %d rc=%d\n", bp
, rc
);
94 rc
= pm8xxx_readb(chip
->dev
, SSBI_REG_ADDR_IRQ_IT_STATUS
, ip
);
96 pr_err("Failed Reading Status rc=%d\n", rc
);
98 spin_unlock(&chip
->pm_irq_lock
);
102 static int pm8xxx_config_irq(struct pm_irq_chip
*chip
, u8 bp
, u8 cp
)
106 spin_lock(&chip
->pm_irq_lock
);
107 rc
= pm8xxx_writeb(chip
->dev
, SSBI_REG_ADDR_IRQ_BLK_SEL
, bp
);
109 pr_err("Failed Selecting Block %d rc=%d\n", bp
, rc
);
114 rc
= pm8xxx_writeb(chip
->dev
, SSBI_REG_ADDR_IRQ_CONFIG
, cp
);
116 pr_err("Failed Configuring IRQ rc=%d\n", rc
);
118 spin_unlock(&chip
->pm_irq_lock
);
122 static int pm8xxx_irq_block_handler(struct pm_irq_chip
*chip
, int block
)
124 int pmirq
, irq
, i
, ret
= 0;
127 ret
= pm8xxx_read_block_irq(chip
, block
, &bits
);
129 pr_err("Failed reading %d block ret=%d", block
, ret
);
133 pr_err("block bit set in master but no irqs: %d", block
);
138 for (i
= 0; i
< 8; i
++) {
139 if (bits
& (1 << i
)) {
140 pmirq
= block
* 8 + i
;
141 irq
= pmirq
+ chip
->irq_base
;
142 generic_handle_irq(irq
);
148 static int pm8xxx_irq_master_handler(struct pm_irq_chip
*chip
, int master
)
151 int block_number
, i
, ret
= 0;
153 ret
= pm8xxx_read_master_irq(chip
, master
, &blockbits
);
155 pr_err("Failed to read master %d ret=%d\n", master
, ret
);
159 pr_err("master bit set in root but no blocks: %d", master
);
163 for (i
= 0; i
< 8; i
++)
164 if (blockbits
& (1 << i
)) {
165 block_number
= master
* 8 + i
; /* block # */
166 ret
|= pm8xxx_irq_block_handler(chip
, block_number
);
171 static void pm8xxx_irq_handler(unsigned int irq
, struct irq_desc
*desc
)
173 struct pm_irq_chip
*chip
= irq_desc_get_handler_data(desc
);
174 struct irq_chip
*irq_chip
= irq_desc_get_chip(desc
);
176 int i
, ret
, masters
= 0;
178 chained_irq_enter(irq_chip
, desc
);
180 ret
= pm8xxx_read_root_irq(chip
, &root
);
182 pr_err("Can't read root status ret=%d\n", ret
);
186 /* on pm8xxx series masters start from bit 1 of the root */
189 /* Read allowed masters for blocks. */
190 for (i
= 0; i
< chip
->num_masters
; i
++)
191 if (masters
& (1 << i
))
192 pm8xxx_irq_master_handler(chip
, i
);
194 chained_irq_exit(irq_chip
, desc
);
197 static void pm8xxx_irq_mask_ack(struct irq_data
*d
)
199 struct pm_irq_chip
*chip
= irq_data_get_irq_chip_data(d
);
200 unsigned int pmirq
= d
->irq
- chip
->irq_base
;
208 config
= chip
->config
[pmirq
] | PM_IRQF_MASK_ALL
| PM_IRQF_CLR
;
209 pm8xxx_config_irq(chip
, block
, config
);
212 static void pm8xxx_irq_unmask(struct irq_data
*d
)
214 struct pm_irq_chip
*chip
= irq_data_get_irq_chip_data(d
);
215 unsigned int pmirq
= d
->irq
- chip
->irq_base
;
223 config
= chip
->config
[pmirq
];
224 pm8xxx_config_irq(chip
, block
, config
);
227 static int pm8xxx_irq_set_type(struct irq_data
*d
, unsigned int flow_type
)
229 struct pm_irq_chip
*chip
= irq_data_get_irq_chip_data(d
);
230 unsigned int pmirq
= d
->irq
- chip
->irq_base
;
238 chip
->config
[pmirq
] = (irq_bit
<< PM_IRQF_BITS_SHIFT
)
240 if (flow_type
& (IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
)) {
241 if (flow_type
& IRQF_TRIGGER_RISING
)
242 chip
->config
[pmirq
] &= ~PM_IRQF_MASK_RE
;
243 if (flow_type
& IRQF_TRIGGER_FALLING
)
244 chip
->config
[pmirq
] &= ~PM_IRQF_MASK_FE
;
246 chip
->config
[pmirq
] |= PM_IRQF_LVL_SEL
;
248 if (flow_type
& IRQF_TRIGGER_HIGH
)
249 chip
->config
[pmirq
] &= ~PM_IRQF_MASK_RE
;
251 chip
->config
[pmirq
] &= ~PM_IRQF_MASK_FE
;
254 config
= chip
->config
[pmirq
] | PM_IRQF_CLR
;
255 return pm8xxx_config_irq(chip
, block
, config
);
258 static int pm8xxx_irq_set_wake(struct irq_data
*d
, unsigned int on
)
263 static struct irq_chip pm8xxx_irq_chip
= {
265 .irq_mask_ack
= pm8xxx_irq_mask_ack
,
266 .irq_unmask
= pm8xxx_irq_unmask
,
267 .irq_set_type
= pm8xxx_irq_set_type
,
268 .irq_set_wake
= pm8xxx_irq_set_wake
,
269 .flags
= IRQCHIP_MASK_ON_SUSPEND
,
273 * pm8xxx_get_irq_stat - get the status of the irq line
274 * @chip: pointer to identify a pmic irq controller
275 * @irq: the irq number
277 * The pm8xxx gpio and mpp rely on the interrupt block to read
278 * the values on their pins. This function is to facilitate reading
279 * the status of a gpio or an mpp line. The caller has to convert the
280 * gpio number to irq number.
283 * an int indicating the value read on that line
285 static int pm8xxx_get_irq_stat(struct pm_irq_chip
*chip
, int irq
)
291 if (chip
== NULL
|| irq
< chip
->irq_base
||
292 irq
>= chip
->irq_base
+ chip
->num_irqs
)
295 pmirq
= irq
- chip
->irq_base
;
300 spin_lock_irqsave(&chip
->pm_irq_lock
, flags
);
302 rc
= pm8xxx_writeb(chip
->dev
, SSBI_REG_ADDR_IRQ_BLK_SEL
, block
);
304 pr_err("Failed Selecting block irq=%d pmirq=%d blk=%d rc=%d\n",
305 irq
, pmirq
, block
, rc
);
309 rc
= pm8xxx_readb(chip
->dev
, SSBI_REG_ADDR_IRQ_RT_STATUS
, &bits
);
311 pr_err("Failed Configuring irq=%d pmirq=%d blk=%d rc=%d\n",
312 irq
, pmirq
, block
, rc
);
316 rc
= (bits
& (1 << bit
)) ? 1 : 0;
319 spin_unlock_irqrestore(&chip
->pm_irq_lock
, flags
);
324 static struct pm_irq_chip
*pm8xxx_irq_init(struct device
*dev
,
325 const struct pm8xxx_irq_platform_data
*pdata
)
327 struct pm_irq_chip
*chip
;
332 pr_err("No platform data\n");
333 return ERR_PTR(-EINVAL
);
336 devirq
= pdata
->devirq
;
338 pr_err("missing devirq\n");
340 return ERR_PTR(-EINVAL
);
343 chip
= kzalloc(sizeof(struct pm_irq_chip
)
344 + sizeof(u8
) * pdata
->irq_cdata
.nirqs
, GFP_KERNEL
);
346 pr_err("Cannot alloc pm_irq_chip struct\n");
347 return ERR_PTR(-EINVAL
);
351 chip
->devirq
= devirq
;
352 chip
->irq_base
= pdata
->irq_base
;
353 chip
->num_irqs
= pdata
->irq_cdata
.nirqs
;
354 chip
->num_blocks
= DIV_ROUND_UP(chip
->num_irqs
, 8);
355 chip
->num_masters
= DIV_ROUND_UP(chip
->num_blocks
, 8);
356 spin_lock_init(&chip
->pm_irq_lock
);
358 for (pmirq
= 0; pmirq
< chip
->num_irqs
; pmirq
++) {
359 irq_set_chip_and_handler(chip
->irq_base
+ pmirq
,
362 irq_set_chip_data(chip
->irq_base
+ pmirq
, chip
);
364 set_irq_flags(chip
->irq_base
+ pmirq
, IRQF_VALID
);
366 irq_set_noprobe(chip
->irq_base
+ pmirq
);
370 irq_set_irq_type(devirq
, pdata
->irq_trigger_flag
);
371 irq_set_handler_data(devirq
, chip
);
372 irq_set_chained_handler(devirq
, pm8xxx_irq_handler
);
373 irq_set_irq_wake(devirq
, 1);
378 static int pm8xxx_irq_exit(struct pm_irq_chip
*chip
)
380 irq_set_chained_handler(chip
->devirq
, NULL
);
385 static int pm8921_readb(const struct device
*dev
, u16 addr
, u8
*val
)
387 const struct pm8xxx_drvdata
*pm8921_drvdata
= dev_get_drvdata(dev
);
388 const struct pm8921
*pmic
= pm8921_drvdata
->pm_chip_data
;
390 return ssbi_read(pmic
->dev
->parent
, addr
, val
, 1);
393 static int pm8921_writeb(const struct device
*dev
, u16 addr
, u8 val
)
395 const struct pm8xxx_drvdata
*pm8921_drvdata
= dev_get_drvdata(dev
);
396 const struct pm8921
*pmic
= pm8921_drvdata
->pm_chip_data
;
398 return ssbi_write(pmic
->dev
->parent
, addr
, &val
, 1);
401 static int pm8921_read_buf(const struct device
*dev
, u16 addr
, u8
*buf
,
404 const struct pm8xxx_drvdata
*pm8921_drvdata
= dev_get_drvdata(dev
);
405 const struct pm8921
*pmic
= pm8921_drvdata
->pm_chip_data
;
407 return ssbi_read(pmic
->dev
->parent
, addr
, buf
, cnt
);
410 static int pm8921_write_buf(const struct device
*dev
, u16 addr
, u8
*buf
,
413 const struct pm8xxx_drvdata
*pm8921_drvdata
= dev_get_drvdata(dev
);
414 const struct pm8921
*pmic
= pm8921_drvdata
->pm_chip_data
;
416 return ssbi_write(pmic
->dev
->parent
, addr
, buf
, cnt
);
419 static int pm8921_read_irq_stat(const struct device
*dev
, int irq
)
421 const struct pm8xxx_drvdata
*pm8921_drvdata
= dev_get_drvdata(dev
);
422 const struct pm8921
*pmic
= pm8921_drvdata
->pm_chip_data
;
424 return pm8xxx_get_irq_stat(pmic
->irq_chip
, irq
);
427 static struct pm8xxx_drvdata pm8921_drvdata
= {
428 .pmic_readb
= pm8921_readb
,
429 .pmic_writeb
= pm8921_writeb
,
430 .pmic_read_buf
= pm8921_read_buf
,
431 .pmic_write_buf
= pm8921_write_buf
,
432 .pmic_read_irq_stat
= pm8921_read_irq_stat
,
435 static int pm8921_add_subdevices(const struct pm8921_platform_data
440 int ret
= 0, irq_base
= 0;
441 struct pm_irq_chip
*irq_chip
;
443 if (pdata
->irq_pdata
) {
444 pdata
->irq_pdata
->irq_cdata
.nirqs
= PM8921_NR_IRQS
;
445 pdata
->irq_pdata
->irq_cdata
.rev
= rev
;
446 irq_base
= pdata
->irq_pdata
->irq_base
;
447 irq_chip
= pm8xxx_irq_init(pmic
->dev
, pdata
->irq_pdata
);
449 if (IS_ERR(irq_chip
)) {
450 pr_err("Failed to init interrupts ret=%ld\n",
452 return PTR_ERR(irq_chip
);
454 pmic
->irq_chip
= irq_chip
;
459 static int pm8921_probe(struct platform_device
*pdev
)
461 const struct pm8921_platform_data
*pdata
= dev_get_platdata(&pdev
->dev
);
468 pr_err("missing platform data\n");
472 pmic
= devm_kzalloc(&pdev
->dev
, sizeof(struct pm8921
), GFP_KERNEL
);
474 pr_err("Cannot alloc pm8921 struct\n");
478 /* Read PMIC chip revision */
479 rc
= ssbi_read(pdev
->dev
.parent
, REG_HWREV
, &val
, sizeof(val
));
481 pr_err("Failed to read hw rev reg %d:rc=%d\n", REG_HWREV
, rc
);
484 pr_info("PMIC revision 1: %02X\n", val
);
487 /* Read PMIC chip revision 2 */
488 rc
= ssbi_read(pdev
->dev
.parent
, REG_HWREV_2
, &val
, sizeof(val
));
490 pr_err("Failed to read hw rev 2 reg %d:rc=%d\n",
494 pr_info("PMIC revision 2: %02X\n", val
);
495 rev
|= val
<< BITS_PER_BYTE
;
497 pmic
->dev
= &pdev
->dev
;
498 pm8921_drvdata
.pm_chip_data
= pmic
;
499 platform_set_drvdata(pdev
, &pm8921_drvdata
);
501 rc
= pm8921_add_subdevices(pdata
, pmic
, rev
);
503 pr_err("Cannot add subdevices rc=%d\n", rc
);
507 /* gpio might not work if no irq device is found */
508 WARN_ON(pmic
->irq_chip
== NULL
);
513 mfd_remove_devices(pmic
->dev
);
517 static int pm8921_remove(struct platform_device
*pdev
)
519 struct pm8xxx_drvdata
*drvdata
;
520 struct pm8921
*pmic
= NULL
;
522 drvdata
= platform_get_drvdata(pdev
);
524 pmic
= drvdata
->pm_chip_data
;
526 mfd_remove_devices(pmic
->dev
);
527 if (pmic
->irq_chip
) {
528 pm8xxx_irq_exit(pmic
->irq_chip
);
529 pmic
->irq_chip
= NULL
;
536 static struct platform_driver pm8921_driver
= {
537 .probe
= pm8921_probe
,
538 .remove
= pm8921_remove
,
540 .name
= "pm8921-core",
541 .owner
= THIS_MODULE
,
545 static int __init
pm8921_init(void)
547 return platform_driver_register(&pm8921_driver
);
549 subsys_initcall(pm8921_init
);
551 static void __exit
pm8921_exit(void)
553 platform_driver_unregister(&pm8921_driver
);
555 module_exit(pm8921_exit
);
557 MODULE_LICENSE("GPL v2");
558 MODULE_DESCRIPTION("PMIC 8921 core driver");
559 MODULE_VERSION("1.0");
560 MODULE_ALIAS("platform:pm8921-core");