1 /*
2 * intel_bxtwc_tmu.c - Intel BXT Whiskey Cove PMIC TMU driver
3 *
4 * Copyright (C) 2016 Intel Corporation. All rights reserved.
5 *
6 * This driver adds TMU (Time Management Unit) support for Intel BXT platform.
7 * It enables the alarm wake-up functionality in the TMU unit of Whiskey Cove
8 * PMIC.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License version
12 * 2 as published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 */
20
21 #include <linux/module.h>
22 #include <linux/interrupt.h>
23 #include <linux/platform_device.h>
24 #include <linux/mfd/intel_soc_pmic.h>
25
26 #define BXTWC_TMUIRQ 0x4fb6
27 #define BXTWC_MIRQLVL1 0x4e0e
28 #define BXTWC_MTMUIRQ_REG 0x4fb7
29 #define BXTWC_MIRQLVL1_MTMU BIT(1)
30 #define BXTWC_TMU_WK_ALRM BIT(1)
31 #define BXTWC_TMU_SYS_ALRM BIT(2)
32 #define BXTWC_TMU_ALRM_MASK (BXTWC_TMU_WK_ALRM | BXTWC_TMU_SYS_ALRM)
33 #define BXTWC_TMU_ALRM_IRQ (BXTWC_TMU_WK_ALRM | BXTWC_TMU_SYS_ALRM)
34
35 struct wcove_tmu {
36 int irq;
37 struct device *dev;
38 struct regmap *regmap;
39 };
40
bxt_wcove_tmu_irq_handler(int irq,void * data)41 static irqreturn_t bxt_wcove_tmu_irq_handler(int irq, void *data)
42 {
43 struct wcove_tmu *wctmu = data;
44 unsigned int tmu_irq;
45
46 /* Read TMU interrupt reg */
47 regmap_read(wctmu->regmap, BXTWC_TMUIRQ, &tmu_irq);
48 if (tmu_irq & BXTWC_TMU_ALRM_IRQ) {
49 /* clear TMU irq */
50 regmap_write(wctmu->regmap, BXTWC_TMUIRQ, tmu_irq);
51 return IRQ_HANDLED;
52 }
53 return IRQ_NONE;
54 }
55
bxt_wcove_tmu_probe(struct platform_device * pdev)56 static int bxt_wcove_tmu_probe(struct platform_device *pdev)
57 {
58 struct intel_soc_pmic *pmic = dev_get_drvdata(pdev->dev.parent);
59 struct regmap_irq_chip_data *regmap_irq_chip;
60 struct wcove_tmu *wctmu;
61 int ret, virq, irq;
62
63 wctmu = devm_kzalloc(&pdev->dev, sizeof(*wctmu), GFP_KERNEL);
64 if (!wctmu)
65 return -ENOMEM;
66
67 wctmu->dev = &pdev->dev;
68 wctmu->regmap = pmic->regmap;
69
70 irq = platform_get_irq(pdev, 0);
71
72 if (irq < 0) {
73 dev_err(&pdev->dev, "invalid irq %d\n", irq);
74 return irq;
75 }
76
77 regmap_irq_chip = pmic->irq_chip_data_tmu;
78 virq = regmap_irq_get_virq(regmap_irq_chip, irq);
79 if (virq < 0) {
80 dev_err(&pdev->dev,
81 "failed to get virtual interrupt=%d\n", irq);
82 return virq;
83 }
84
85 ret = devm_request_threaded_irq(&pdev->dev, virq,
86 NULL, bxt_wcove_tmu_irq_handler,
87 IRQF_ONESHOT, "bxt_wcove_tmu", wctmu);
88 if (ret) {
89 dev_err(&pdev->dev, "request irq failed: %d,virq: %d\n",
90 ret, virq);
91 return ret;
92 }
93 wctmu->irq = virq;
94
95 /* Unmask TMU second level Wake & System alarm */
96 regmap_update_bits(wctmu->regmap, BXTWC_MTMUIRQ_REG,
97 BXTWC_TMU_ALRM_MASK, 0);
98
99 platform_set_drvdata(pdev, wctmu);
100 return 0;
101 }
102
bxt_wcove_tmu_remove(struct platform_device * pdev)103 static int bxt_wcove_tmu_remove(struct platform_device *pdev)
104 {
105 struct wcove_tmu *wctmu = platform_get_drvdata(pdev);
106 unsigned int val;
107
108 /* Mask TMU interrupts */
109 regmap_read(wctmu->regmap, BXTWC_MIRQLVL1, &val);
110 regmap_write(wctmu->regmap, BXTWC_MIRQLVL1,
111 val | BXTWC_MIRQLVL1_MTMU);
112 regmap_read(wctmu->regmap, BXTWC_MTMUIRQ_REG, &val);
113 regmap_write(wctmu->regmap, BXTWC_MTMUIRQ_REG,
114 val | BXTWC_TMU_ALRM_MASK);
115 return 0;
116 }
117
118 #ifdef CONFIG_PM_SLEEP
bxtwc_tmu_suspend(struct device * dev)119 static int bxtwc_tmu_suspend(struct device *dev)
120 {
121 struct wcove_tmu *wctmu = dev_get_drvdata(dev);
122
123 enable_irq_wake(wctmu->irq);
124 return 0;
125 }
126
bxtwc_tmu_resume(struct device * dev)127 static int bxtwc_tmu_resume(struct device *dev)
128 {
129 struct wcove_tmu *wctmu = dev_get_drvdata(dev);
130
131 disable_irq_wake(wctmu->irq);
132 return 0;
133 }
134 #endif
135
136 static SIMPLE_DEV_PM_OPS(bxtwc_tmu_pm_ops, bxtwc_tmu_suspend, bxtwc_tmu_resume);
137
138 static const struct platform_device_id bxt_wcove_tmu_id_table[] = {
139 { .name = "bxt_wcove_tmu" },
140 {},
141 };
142 MODULE_DEVICE_TABLE(platform, bxt_wcove_tmu_id_table);
143
144 static struct platform_driver bxt_wcove_tmu_driver = {
145 .probe = bxt_wcove_tmu_probe,
146 .remove = bxt_wcove_tmu_remove,
147 .driver = {
148 .name = "bxt_wcove_tmu",
149 .pm = &bxtwc_tmu_pm_ops,
150 },
151 .id_table = bxt_wcove_tmu_id_table,
152 };
153
154 module_platform_driver(bxt_wcove_tmu_driver);
155
156 MODULE_LICENSE("GPL v2");
157 MODULE_AUTHOR("Nilesh Bacchewar <nilesh.bacchewar@intel.com>");
158 MODULE_DESCRIPTION("BXT Whiskey Cove TMU Driver");
159