1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
6 #define pr_fmt(fmt) "%s: " fmt, __func__
8 #include <linux/kernel.h>
9 #include <linux/interrupt.h>
10 #include <linux/irqchip/chained_irq.h>
11 #include <linux/irq.h>
12 #include <linux/irqdomain.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/slab.h>
16 #include <linux/err.h>
17 #include <linux/ssbi.h>
18 #include <linux/regmap.h>
19 #include <linux/of_platform.h>
20 #include <linux/mfd/core.h>
22 #define SSBI_REG_ADDR_IRQ_BASE 0x1BB
24 #define SSBI_REG_ADDR_IRQ_ROOT (SSBI_REG_ADDR_IRQ_BASE + 0)
25 #define SSBI_REG_ADDR_IRQ_M_STATUS1 (SSBI_REG_ADDR_IRQ_BASE + 1)
26 #define SSBI_REG_ADDR_IRQ_M_STATUS2 (SSBI_REG_ADDR_IRQ_BASE + 2)
27 #define SSBI_REG_ADDR_IRQ_M_STATUS3 (SSBI_REG_ADDR_IRQ_BASE + 3)
28 #define SSBI_REG_ADDR_IRQ_M_STATUS4 (SSBI_REG_ADDR_IRQ_BASE + 4)
29 #define SSBI_REG_ADDR_IRQ_BLK_SEL (SSBI_REG_ADDR_IRQ_BASE + 5)
30 #define SSBI_REG_ADDR_IRQ_IT_STATUS (SSBI_REG_ADDR_IRQ_BASE + 6)
31 #define SSBI_REG_ADDR_IRQ_CONFIG (SSBI_REG_ADDR_IRQ_BASE + 7)
32 #define SSBI_REG_ADDR_IRQ_RT_STATUS (SSBI_REG_ADDR_IRQ_BASE + 8)
34 #define PM8821_SSBI_REG_ADDR_IRQ_BASE 0x100
35 #define PM8821_SSBI_REG_ADDR_IRQ_MASTER0 (PM8821_SSBI_REG_ADDR_IRQ_BASE + 0x30)
36 #define PM8821_SSBI_REG_ADDR_IRQ_MASTER1 (PM8821_SSBI_REG_ADDR_IRQ_BASE + 0xb0)
37 #define PM8821_SSBI_REG(m, b, offset) \
39 (PM8821_SSBI_REG_ADDR_IRQ_MASTER0 + b + offset) : \
40 (PM8821_SSBI_REG_ADDR_IRQ_MASTER1 + b + offset))
41 #define PM8821_SSBI_ADDR_IRQ_ROOT(m, b) PM8821_SSBI_REG(m, b, 0x0)
42 #define PM8821_SSBI_ADDR_IRQ_CLEAR(m, b) PM8821_SSBI_REG(m, b, 0x01)
43 #define PM8821_SSBI_ADDR_IRQ_MASK(m, b) PM8821_SSBI_REG(m, b, 0x08)
44 #define PM8821_SSBI_ADDR_IRQ_RT_STATUS(m, b) PM8821_SSBI_REG(m, b, 0x0f)
46 #define PM8821_BLOCKS_PER_MASTER 7
48 #define PM_IRQF_LVL_SEL 0x01 /* level select */
49 #define PM_IRQF_MASK_FE 0x02 /* mask falling edge */
50 #define PM_IRQF_MASK_RE 0x04 /* mask rising edge */
51 #define PM_IRQF_CLR 0x08 /* clear interrupt */
52 #define PM_IRQF_BITS_MASK 0x70
53 #define PM_IRQF_BITS_SHIFT 4
54 #define PM_IRQF_WRITE 0x80
56 #define PM_IRQF_MASK_ALL (PM_IRQF_MASK_FE | \
59 #define REG_HWREV 0x002 /* PMIC4 revision */
60 #define REG_HWREV_2 0x0E8 /* PMIC4 revision 2 */
62 #define PM8XXX_NR_IRQS 256
63 #define PM8821_NR_IRQS 112
67 struct irq_chip *irq_chip;
68 void (*irq_handler)(struct irq_desc *desc);
72 struct regmap *regmap;
73 spinlock_t pm_irq_lock;
74 struct irq_domain *irqdomain;
75 unsigned int num_blocks;
76 unsigned int num_masters;
77 const struct pm_irq_data *pm_irq_data;
78 /* MUST BE AT THE END OF THIS STRUCT */
82 static int pm8xxx_read_block_irq(struct pm_irq_chip *chip, unsigned int bp,
87 spin_lock(&chip->pm_irq_lock);
88 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_BLK_SEL, bp);
90 pr_err("Failed Selecting Block %d rc=%d\n", bp, rc);
94 rc = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_IT_STATUS, ip);
96 pr_err("Failed Reading Status rc=%d\n", rc);
98 spin_unlock(&chip->pm_irq_lock);
103 pm8xxx_config_irq(struct pm_irq_chip *chip, unsigned int bp, unsigned int cp)
107 spin_lock(&chip->pm_irq_lock);
108 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_BLK_SEL, bp);
110 pr_err("Failed Selecting Block %d rc=%d\n", bp, rc);
115 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_CONFIG, cp);
117 pr_err("Failed Configuring IRQ rc=%d\n", rc);
119 spin_unlock(&chip->pm_irq_lock);
123 static int pm8xxx_irq_block_handler(struct pm_irq_chip *chip, int block)
125 int pmirq, i, ret = 0;
128 ret = pm8xxx_read_block_irq(chip, block, &bits);
130 pr_err("Failed reading %d block ret=%d", block, ret);
134 pr_err("block bit set in master but no irqs: %d", block);
139 for (i = 0; i < 8; i++) {
140 if (bits & (1 << i)) {
141 pmirq = block * 8 + i;
142 generic_handle_domain_irq(chip->irqdomain, pmirq);
148 static int pm8xxx_irq_master_handler(struct pm_irq_chip *chip, int master)
150 unsigned int blockbits;
151 int block_number, i, ret = 0;
153 ret = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_M_STATUS1 + master,
156 pr_err("Failed to read master %d ret=%d\n", master, ret);
160 pr_err("master bit set in root but no blocks: %d", master);
164 for (i = 0; i < 8; i++)
165 if (blockbits & (1 << i)) {
166 block_number = master * 8 + i; /* block # */
167 ret |= pm8xxx_irq_block_handler(chip, block_number);
172 static void pm8xxx_irq_handler(struct irq_desc *desc)
174 struct pm_irq_chip *chip = irq_desc_get_handler_data(desc);
175 struct irq_chip *irq_chip = irq_desc_get_chip(desc);
177 int i, ret, masters = 0;
179 chained_irq_enter(irq_chip, desc);
181 ret = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_ROOT, &root);
183 pr_err("Can't read root status ret=%d\n", ret);
187 /* on pm8xxx series masters start from bit 1 of the root */
190 /* Read allowed masters for blocks. */
191 for (i = 0; i < chip->num_masters; i++)
192 if (masters & (1 << i))
193 pm8xxx_irq_master_handler(chip, i);
195 chained_irq_exit(irq_chip, desc);
198 static void pm8821_irq_block_handler(struct pm_irq_chip *chip,
199 int master, int block)
204 ret = regmap_read(chip->regmap,
205 PM8821_SSBI_ADDR_IRQ_ROOT(master, block), &bits);
207 pr_err("Reading block %d failed ret=%d", block, ret);
211 /* Convert block offset to global block number */
212 block += (master * PM8821_BLOCKS_PER_MASTER) - 1;
215 for (i = 0; i < 8; i++) {
217 pmirq = block * 8 + i;
218 generic_handle_domain_irq(chip->irqdomain, pmirq);
223 static inline void pm8821_irq_master_handler(struct pm_irq_chip *chip,
224 int master, u8 master_val)
228 for (block = 1; block < 8; block++)
229 if (master_val & BIT(block))
230 pm8821_irq_block_handler(chip, master, block);
233 static void pm8821_irq_handler(struct irq_desc *desc)
235 struct pm_irq_chip *chip = irq_desc_get_handler_data(desc);
236 struct irq_chip *irq_chip = irq_desc_get_chip(desc);
240 chained_irq_enter(irq_chip, desc);
241 ret = regmap_read(chip->regmap,
242 PM8821_SSBI_REG_ADDR_IRQ_MASTER0, &master);
244 pr_err("Failed to read master 0 ret=%d\n", ret);
248 /* bits 1 through 7 marks the first 7 blocks in master 0 */
249 if (master & GENMASK(7, 1))
250 pm8821_irq_master_handler(chip, 0, master);
252 /* bit 0 marks if master 1 contains any bits */
253 if (!(master & BIT(0)))
256 ret = regmap_read(chip->regmap,
257 PM8821_SSBI_REG_ADDR_IRQ_MASTER1, &master);
259 pr_err("Failed to read master 1 ret=%d\n", ret);
263 pm8821_irq_master_handler(chip, 1, master);
266 chained_irq_exit(irq_chip, desc);
269 static void pm8xxx_irq_mask_ack(struct irq_data *d)
271 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
272 unsigned int pmirq = irqd_to_hwirq(d);
277 config = chip->config[pmirq] | PM_IRQF_MASK_ALL | PM_IRQF_CLR;
278 pm8xxx_config_irq(chip, block, config);
281 static void pm8xxx_irq_unmask(struct irq_data *d)
283 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
284 unsigned int pmirq = irqd_to_hwirq(d);
289 config = chip->config[pmirq];
290 pm8xxx_config_irq(chip, block, config);
293 static int pm8xxx_irq_set_type(struct irq_data *d, unsigned int flow_type)
295 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
296 unsigned int pmirq = irqd_to_hwirq(d);
303 chip->config[pmirq] = (irq_bit << PM_IRQF_BITS_SHIFT)
305 if (flow_type & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)) {
306 if (flow_type & IRQF_TRIGGER_RISING)
307 chip->config[pmirq] &= ~PM_IRQF_MASK_RE;
308 if (flow_type & IRQF_TRIGGER_FALLING)
309 chip->config[pmirq] &= ~PM_IRQF_MASK_FE;
311 chip->config[pmirq] |= PM_IRQF_LVL_SEL;
313 if (flow_type & IRQF_TRIGGER_HIGH)
314 chip->config[pmirq] &= ~PM_IRQF_MASK_RE;
316 chip->config[pmirq] &= ~PM_IRQF_MASK_FE;
319 config = chip->config[pmirq] | PM_IRQF_CLR;
320 return pm8xxx_config_irq(chip, block, config);
323 static int pm8xxx_irq_get_irqchip_state(struct irq_data *d,
324 enum irqchip_irq_state which,
327 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
328 unsigned int pmirq = irqd_to_hwirq(d);
334 if (which != IRQCHIP_STATE_LINE_LEVEL)
340 spin_lock(&chip->pm_irq_lock);
341 rc = regmap_write(chip->regmap, SSBI_REG_ADDR_IRQ_BLK_SEL, block);
343 pr_err("Failed Selecting Block %d rc=%d\n", block, rc);
347 rc = regmap_read(chip->regmap, SSBI_REG_ADDR_IRQ_RT_STATUS, &bits);
349 pr_err("Failed Reading Status rc=%d\n", rc);
353 *state = !!(bits & BIT(irq_bit));
355 spin_unlock(&chip->pm_irq_lock);
360 static struct irq_chip pm8xxx_irq_chip = {
362 .irq_mask_ack = pm8xxx_irq_mask_ack,
363 .irq_unmask = pm8xxx_irq_unmask,
364 .irq_set_type = pm8xxx_irq_set_type,
365 .irq_get_irqchip_state = pm8xxx_irq_get_irqchip_state,
366 .flags = IRQCHIP_MASK_ON_SUSPEND | IRQCHIP_SKIP_SET_WAKE,
369 static void pm8xxx_irq_domain_map(struct pm_irq_chip *chip,
370 struct irq_domain *domain, unsigned int irq,
371 irq_hw_number_t hwirq, unsigned int type)
373 irq_domain_set_info(domain, irq, hwirq, chip->pm_irq_data->irq_chip,
374 chip, handle_level_irq, NULL, NULL);
375 irq_set_noprobe(irq);
378 static int pm8xxx_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
379 unsigned int nr_irqs, void *data)
381 struct pm_irq_chip *chip = domain->host_data;
382 struct irq_fwspec *fwspec = data;
383 irq_hw_number_t hwirq;
387 ret = irq_domain_translate_twocell(domain, fwspec, &hwirq, &type);
391 for (i = 0; i < nr_irqs; i++)
392 pm8xxx_irq_domain_map(chip, domain, virq + i, hwirq + i, type);
397 static const struct irq_domain_ops pm8xxx_irq_domain_ops = {
398 .alloc = pm8xxx_irq_domain_alloc,
399 .free = irq_domain_free_irqs_common,
400 .translate = irq_domain_translate_twocell,
403 static void pm8821_irq_mask_ack(struct irq_data *d)
405 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
406 unsigned int pmirq = irqd_to_hwirq(d);
411 master = block / PM8821_BLOCKS_PER_MASTER;
413 block %= PM8821_BLOCKS_PER_MASTER;
415 rc = regmap_update_bits(chip->regmap,
416 PM8821_SSBI_ADDR_IRQ_MASK(master, block),
417 BIT(irq_bit), BIT(irq_bit));
419 pr_err("Failed to mask IRQ:%d rc=%d\n", pmirq, rc);
423 rc = regmap_update_bits(chip->regmap,
424 PM8821_SSBI_ADDR_IRQ_CLEAR(master, block),
425 BIT(irq_bit), BIT(irq_bit));
427 pr_err("Failed to CLEAR IRQ:%d rc=%d\n", pmirq, rc);
430 static void pm8821_irq_unmask(struct irq_data *d)
432 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
433 unsigned int pmirq = irqd_to_hwirq(d);
438 master = block / PM8821_BLOCKS_PER_MASTER;
440 block %= PM8821_BLOCKS_PER_MASTER;
442 rc = regmap_update_bits(chip->regmap,
443 PM8821_SSBI_ADDR_IRQ_MASK(master, block),
444 BIT(irq_bit), ~BIT(irq_bit));
446 pr_err("Failed to read/write unmask IRQ:%d rc=%d\n", pmirq, rc);
450 static int pm8821_irq_get_irqchip_state(struct irq_data *d,
451 enum irqchip_irq_state which,
454 struct pm_irq_chip *chip = irq_data_get_irq_chip_data(d);
455 int rc, pmirq = irqd_to_hwirq(d);
456 u8 block, irq_bit, master;
460 master = block / PM8821_BLOCKS_PER_MASTER;
462 block %= PM8821_BLOCKS_PER_MASTER;
464 rc = regmap_read(chip->regmap,
465 PM8821_SSBI_ADDR_IRQ_RT_STATUS(master, block), &bits);
467 pr_err("Reading Status of IRQ %d failed rc=%d\n", pmirq, rc);
471 *state = !!(bits & BIT(irq_bit));
476 static struct irq_chip pm8821_irq_chip = {
478 .irq_mask_ack = pm8821_irq_mask_ack,
479 .irq_unmask = pm8821_irq_unmask,
480 .irq_get_irqchip_state = pm8821_irq_get_irqchip_state,
481 .flags = IRQCHIP_MASK_ON_SUSPEND | IRQCHIP_SKIP_SET_WAKE,
484 static const struct regmap_config ssbi_regmap_config = {
487 .max_register = 0x3ff,
489 .reg_read = ssbi_reg_read,
490 .reg_write = ssbi_reg_write
493 static const struct pm_irq_data pm8xxx_data = {
494 .num_irqs = PM8XXX_NR_IRQS,
495 .irq_chip = &pm8xxx_irq_chip,
496 .irq_handler = pm8xxx_irq_handler,
499 static const struct pm_irq_data pm8821_data = {
500 .num_irqs = PM8821_NR_IRQS,
501 .irq_chip = &pm8821_irq_chip,
502 .irq_handler = pm8821_irq_handler,
505 static const struct of_device_id pm8xxx_id_table[] = {
506 { .compatible = "qcom,pm8018", .data = &pm8xxx_data},
507 { .compatible = "qcom,pm8058", .data = &pm8xxx_data},
508 { .compatible = "qcom,pm8821", .data = &pm8821_data},
509 { .compatible = "qcom,pm8921", .data = &pm8xxx_data},
512 MODULE_DEVICE_TABLE(of, pm8xxx_id_table);
514 static int pm8xxx_probe(struct platform_device *pdev)
516 const struct pm_irq_data *data;
517 struct regmap *regmap;
521 struct pm_irq_chip *chip;
523 data = of_device_get_match_data(&pdev->dev);
525 dev_err(&pdev->dev, "No matching driver data found\n");
529 irq = platform_get_irq(pdev, 0);
533 regmap = devm_regmap_init(&pdev->dev, NULL, pdev->dev.parent,
534 &ssbi_regmap_config);
536 return PTR_ERR(regmap);
538 /* Read PMIC chip revision */
539 rc = regmap_read(regmap, REG_HWREV, &val);
541 pr_err("Failed to read hw rev reg %d:rc=%d\n", REG_HWREV, rc);
544 pr_info("PMIC revision 1: %02X\n", val);
547 /* Read PMIC chip revision 2 */
548 rc = regmap_read(regmap, REG_HWREV_2, &val);
550 pr_err("Failed to read hw rev 2 reg %d:rc=%d\n",
554 pr_info("PMIC revision 2: %02X\n", val);
555 rev |= val << BITS_PER_BYTE;
557 chip = devm_kzalloc(&pdev->dev,
558 struct_size(chip, config, data->num_irqs),
563 platform_set_drvdata(pdev, chip);
564 chip->regmap = regmap;
565 chip->num_blocks = DIV_ROUND_UP(data->num_irqs, 8);
566 chip->num_masters = DIV_ROUND_UP(chip->num_blocks, 8);
567 chip->pm_irq_data = data;
568 spin_lock_init(&chip->pm_irq_lock);
570 chip->irqdomain = irq_domain_add_linear(pdev->dev.of_node,
572 &pm8xxx_irq_domain_ops,
574 if (!chip->irqdomain)
577 irq_set_chained_handler_and_data(irq, data->irq_handler, chip);
578 irq_set_irq_wake(irq, 1);
580 rc = of_platform_populate(pdev->dev.of_node, NULL, NULL, &pdev->dev);
582 irq_set_chained_handler_and_data(irq, NULL, NULL);
583 irq_domain_remove(chip->irqdomain);
589 static int pm8xxx_remove_child(struct device *dev, void *unused)
591 platform_device_unregister(to_platform_device(dev));
595 static int pm8xxx_remove(struct platform_device *pdev)
597 int irq = platform_get_irq(pdev, 0);
598 struct pm_irq_chip *chip = platform_get_drvdata(pdev);
600 device_for_each_child(&pdev->dev, NULL, pm8xxx_remove_child);
601 irq_set_chained_handler_and_data(irq, NULL, NULL);
602 irq_domain_remove(chip->irqdomain);
607 static struct platform_driver pm8xxx_driver = {
608 .probe = pm8xxx_probe,
609 .remove = pm8xxx_remove,
611 .name = "pm8xxx-core",
612 .of_match_table = pm8xxx_id_table,
616 static int __init pm8xxx_init(void)
618 return platform_driver_register(&pm8xxx_driver);
620 subsys_initcall(pm8xxx_init);
622 static void __exit pm8xxx_exit(void)
624 platform_driver_unregister(&pm8xxx_driver);
626 module_exit(pm8xxx_exit);
628 MODULE_LICENSE("GPL v2");
629 MODULE_DESCRIPTION("PMIC 8xxx core driver");
630 MODULE_VERSION("1.0");
631 MODULE_ALIAS("platform:pm8xxx-core");