Commit | Line | Data |
---|---|---|
9c92ab61 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
3e9f0b3e CZ |
2 | /* |
3 | * Copyright (C) 2017 MediaTek, Inc. | |
4 | * | |
5 | * Author: Chen Zhong <chen.zhong@mediatek.com> | |
3e9f0b3e CZ |
6 | */ |
7 | ||
3e9f0b3e CZ |
8 | #include <linux/input.h> |
9 | #include <linux/interrupt.h> | |
3e9f0b3e | 10 | #include <linux/kernel.h> |
3e9f0b3e | 11 | #include <linux/mfd/mt6323/registers.h> |
3e9f0b3e | 12 | #include <linux/mfd/mt6397/core.h> |
1eb7ea26 Y |
13 | #include <linux/mfd/mt6397/registers.h> |
14 | #include <linux/module.h> | |
15 | #include <linux/of_device.h> | |
16 | #include <linux/of.h> | |
17 | #include <linux/platform_device.h> | |
18 | #include <linux/regmap.h> | |
3e9f0b3e CZ |
19 | |
20 | #define MTK_PMIC_PWRKEY_RST_EN_MASK 0x1 | |
21 | #define MTK_PMIC_PWRKEY_RST_EN_SHIFT 6 | |
22 | #define MTK_PMIC_HOMEKEY_RST_EN_MASK 0x1 | |
23 | #define MTK_PMIC_HOMEKEY_RST_EN_SHIFT 5 | |
24 | #define MTK_PMIC_RST_DU_MASK 0x3 | |
25 | #define MTK_PMIC_RST_DU_SHIFT 8 | |
26 | ||
27 | #define MTK_PMIC_PWRKEY_RST \ | |
28 | (MTK_PMIC_PWRKEY_RST_EN_MASK << MTK_PMIC_PWRKEY_RST_EN_SHIFT) | |
29 | #define MTK_PMIC_HOMEKEY_RST \ | |
30 | (MTK_PMIC_HOMEKEY_RST_EN_MASK << MTK_PMIC_HOMEKEY_RST_EN_SHIFT) | |
31 | ||
32 | #define MTK_PMIC_PWRKEY_INDEX 0 | |
33 | #define MTK_PMIC_HOMEKEY_INDEX 1 | |
34 | #define MTK_PMIC_MAX_KEY_COUNT 2 | |
35 | ||
36 | struct mtk_pmic_keys_regs { | |
37 | u32 deb_reg; | |
38 | u32 deb_mask; | |
39 | u32 intsel_reg; | |
40 | u32 intsel_mask; | |
41 | }; | |
42 | ||
43 | #define MTK_PMIC_KEYS_REGS(_deb_reg, _deb_mask, \ | |
44 | _intsel_reg, _intsel_mask) \ | |
45 | { \ | |
46 | .deb_reg = _deb_reg, \ | |
47 | .deb_mask = _deb_mask, \ | |
48 | .intsel_reg = _intsel_reg, \ | |
49 | .intsel_mask = _intsel_mask, \ | |
50 | } | |
51 | ||
52 | struct mtk_pmic_regs { | |
53 | const struct mtk_pmic_keys_regs keys_regs[MTK_PMIC_MAX_KEY_COUNT]; | |
54 | u32 pmic_rst_reg; | |
55 | }; | |
56 | ||
57 | static const struct mtk_pmic_regs mt6397_regs = { | |
58 | .keys_regs[MTK_PMIC_PWRKEY_INDEX] = | |
59 | MTK_PMIC_KEYS_REGS(MT6397_CHRSTATUS, | |
60 | 0x8, MT6397_INT_RSV, 0x10), | |
61 | .keys_regs[MTK_PMIC_HOMEKEY_INDEX] = | |
62 | MTK_PMIC_KEYS_REGS(MT6397_OCSTATUS2, | |
63 | 0x10, MT6397_INT_RSV, 0x8), | |
64 | .pmic_rst_reg = MT6397_TOP_RST_MISC, | |
65 | }; | |
66 | ||
67 | static const struct mtk_pmic_regs mt6323_regs = { | |
68 | .keys_regs[MTK_PMIC_PWRKEY_INDEX] = | |
69 | MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS, | |
70 | 0x2, MT6323_INT_MISC_CON, 0x10), | |
71 | .keys_regs[MTK_PMIC_HOMEKEY_INDEX] = | |
72 | MTK_PMIC_KEYS_REGS(MT6323_CHRSTATUS, | |
73 | 0x4, MT6323_INT_MISC_CON, 0x8), | |
74 | .pmic_rst_reg = MT6323_TOP_RST_MISC, | |
75 | }; | |
76 | ||
77 | struct mtk_pmic_keys_info { | |
78 | struct mtk_pmic_keys *keys; | |
79 | const struct mtk_pmic_keys_regs *regs; | |
80 | unsigned int keycode; | |
81 | int irq; | |
82 | bool wakeup:1; | |
83 | }; | |
84 | ||
85 | struct mtk_pmic_keys { | |
86 | struct input_dev *input_dev; | |
87 | struct device *dev; | |
88 | struct regmap *regmap; | |
89 | struct mtk_pmic_keys_info keys[MTK_PMIC_MAX_KEY_COUNT]; | |
90 | }; | |
91 | ||
92 | enum mtk_pmic_keys_lp_mode { | |
93 | LP_DISABLE, | |
94 | LP_ONEKEY, | |
95 | LP_TWOKEY, | |
96 | }; | |
97 | ||
98 | static void mtk_pmic_keys_lp_reset_setup(struct mtk_pmic_keys *keys, | |
99 | u32 pmic_rst_reg) | |
100 | { | |
101 | int ret; | |
102 | u32 long_press_mode, long_press_debounce; | |
103 | ||
104 | ret = of_property_read_u32(keys->dev->of_node, | |
105 | "power-off-time-sec", &long_press_debounce); | |
106 | if (ret) | |
107 | long_press_debounce = 0; | |
108 | ||
109 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
110 | MTK_PMIC_RST_DU_MASK << MTK_PMIC_RST_DU_SHIFT, | |
111 | long_press_debounce << MTK_PMIC_RST_DU_SHIFT); | |
112 | ||
113 | ret = of_property_read_u32(keys->dev->of_node, | |
114 | "mediatek,long-press-mode", &long_press_mode); | |
115 | if (ret) | |
116 | long_press_mode = LP_DISABLE; | |
117 | ||
118 | switch (long_press_mode) { | |
119 | case LP_ONEKEY: | |
120 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
121 | MTK_PMIC_PWRKEY_RST, | |
122 | MTK_PMIC_PWRKEY_RST); | |
123 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
124 | MTK_PMIC_HOMEKEY_RST, | |
125 | 0); | |
126 | break; | |
127 | case LP_TWOKEY: | |
128 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
129 | MTK_PMIC_PWRKEY_RST, | |
130 | MTK_PMIC_PWRKEY_RST); | |
131 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
132 | MTK_PMIC_HOMEKEY_RST, | |
133 | MTK_PMIC_HOMEKEY_RST); | |
134 | break; | |
135 | case LP_DISABLE: | |
136 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
137 | MTK_PMIC_PWRKEY_RST, | |
138 | 0); | |
139 | regmap_update_bits(keys->regmap, pmic_rst_reg, | |
140 | MTK_PMIC_HOMEKEY_RST, | |
141 | 0); | |
142 | break; | |
143 | default: | |
144 | break; | |
145 | } | |
146 | } | |
147 | ||
148 | static irqreturn_t mtk_pmic_keys_irq_handler_thread(int irq, void *data) | |
149 | { | |
150 | struct mtk_pmic_keys_info *info = data; | |
151 | u32 key_deb, pressed; | |
152 | ||
153 | regmap_read(info->keys->regmap, info->regs->deb_reg, &key_deb); | |
154 | ||
155 | key_deb &= info->regs->deb_mask; | |
156 | ||
157 | pressed = !key_deb; | |
158 | ||
159 | input_report_key(info->keys->input_dev, info->keycode, pressed); | |
160 | input_sync(info->keys->input_dev); | |
161 | ||
162 | dev_dbg(info->keys->dev, "(%s) key =%d using PMIC\n", | |
163 | pressed ? "pressed" : "released", info->keycode); | |
164 | ||
165 | return IRQ_HANDLED; | |
166 | } | |
167 | ||
168 | static int mtk_pmic_key_setup(struct mtk_pmic_keys *keys, | |
169 | struct mtk_pmic_keys_info *info) | |
170 | { | |
171 | int ret; | |
172 | ||
173 | info->keys = keys; | |
174 | ||
175 | ret = regmap_update_bits(keys->regmap, info->regs->intsel_reg, | |
176 | info->regs->intsel_mask, | |
177 | info->regs->intsel_mask); | |
178 | if (ret < 0) | |
179 | return ret; | |
180 | ||
181 | ret = devm_request_threaded_irq(keys->dev, info->irq, NULL, | |
182 | mtk_pmic_keys_irq_handler_thread, | |
183 | IRQF_ONESHOT | IRQF_TRIGGER_HIGH, | |
184 | "mtk-pmic-keys", info); | |
185 | if (ret) { | |
186 | dev_err(keys->dev, "Failed to request IRQ: %d: %d\n", | |
187 | info->irq, ret); | |
188 | return ret; | |
189 | } | |
190 | ||
191 | input_set_capability(keys->input_dev, EV_KEY, info->keycode); | |
192 | ||
193 | return 0; | |
194 | } | |
195 | ||
196 | static int __maybe_unused mtk_pmic_keys_suspend(struct device *dev) | |
197 | { | |
198 | struct mtk_pmic_keys *keys = dev_get_drvdata(dev); | |
199 | int index; | |
200 | ||
201 | for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) { | |
202 | if (keys->keys[index].wakeup) | |
203 | enable_irq_wake(keys->keys[index].irq); | |
204 | } | |
205 | ||
206 | return 0; | |
207 | } | |
208 | ||
209 | static int __maybe_unused mtk_pmic_keys_resume(struct device *dev) | |
210 | { | |
211 | struct mtk_pmic_keys *keys = dev_get_drvdata(dev); | |
212 | int index; | |
213 | ||
214 | for (index = 0; index < MTK_PMIC_MAX_KEY_COUNT; index++) { | |
215 | if (keys->keys[index].wakeup) | |
216 | disable_irq_wake(keys->keys[index].irq); | |
217 | } | |
218 | ||
219 | return 0; | |
220 | } | |
221 | ||
222 | static SIMPLE_DEV_PM_OPS(mtk_pmic_keys_pm_ops, mtk_pmic_keys_suspend, | |
223 | mtk_pmic_keys_resume); | |
224 | ||
225 | static const struct of_device_id of_mtk_pmic_keys_match_tbl[] = { | |
226 | { | |
227 | .compatible = "mediatek,mt6397-keys", | |
228 | .data = &mt6397_regs, | |
229 | }, { | |
230 | .compatible = "mediatek,mt6323-keys", | |
231 | .data = &mt6323_regs, | |
232 | }, { | |
233 | /* sentinel */ | |
234 | } | |
235 | }; | |
236 | MODULE_DEVICE_TABLE(of, of_mtk_pmic_keys_match_tbl); | |
237 | ||
238 | static int mtk_pmic_keys_probe(struct platform_device *pdev) | |
239 | { | |
240 | int error, index = 0; | |
241 | unsigned int keycount; | |
242 | struct mt6397_chip *pmic_chip = dev_get_drvdata(pdev->dev.parent); | |
243 | struct device_node *node = pdev->dev.of_node, *child; | |
244 | struct mtk_pmic_keys *keys; | |
245 | const struct mtk_pmic_regs *mtk_pmic_regs; | |
246 | struct input_dev *input_dev; | |
247 | const struct of_device_id *of_id = | |
248 | of_match_device(of_mtk_pmic_keys_match_tbl, &pdev->dev); | |
249 | ||
250 | keys = devm_kzalloc(&pdev->dev, sizeof(*keys), GFP_KERNEL); | |
251 | if (!keys) | |
252 | return -ENOMEM; | |
253 | ||
254 | keys->dev = &pdev->dev; | |
255 | keys->regmap = pmic_chip->regmap; | |
256 | mtk_pmic_regs = of_id->data; | |
257 | ||
258 | keys->input_dev = input_dev = devm_input_allocate_device(keys->dev); | |
259 | if (!input_dev) { | |
260 | dev_err(keys->dev, "input allocate device fail.\n"); | |
261 | return -ENOMEM; | |
262 | } | |
263 | ||
264 | input_dev->name = "mtk-pmic-keys"; | |
265 | input_dev->id.bustype = BUS_HOST; | |
266 | input_dev->id.vendor = 0x0001; | |
267 | input_dev->id.product = 0x0001; | |
268 | input_dev->id.version = 0x0001; | |
269 | ||
270 | keycount = of_get_available_child_count(node); | |
271 | if (keycount > MTK_PMIC_MAX_KEY_COUNT) { | |
272 | dev_err(keys->dev, "too many keys defined (%d)\n", keycount); | |
273 | return -EINVAL; | |
274 | } | |
275 | ||
276 | for_each_child_of_node(node, child) { | |
277 | keys->keys[index].regs = &mtk_pmic_regs->keys_regs[index]; | |
278 | ||
279 | keys->keys[index].irq = platform_get_irq(pdev, index); | |
280 | if (keys->keys[index].irq < 0) | |
281 | return keys->keys[index].irq; | |
282 | ||
283 | error = of_property_read_u32(child, | |
284 | "linux,keycodes", &keys->keys[index].keycode); | |
285 | if (error) { | |
286 | dev_err(keys->dev, | |
287 | "failed to read key:%d linux,keycode property: %d\n", | |
288 | index, error); | |
289 | return error; | |
290 | } | |
291 | ||
292 | if (of_property_read_bool(child, "wakeup-source")) | |
293 | keys->keys[index].wakeup = true; | |
294 | ||
295 | error = mtk_pmic_key_setup(keys, &keys->keys[index]); | |
296 | if (error) | |
297 | return error; | |
298 | ||
299 | index++; | |
300 | } | |
301 | ||
302 | error = input_register_device(input_dev); | |
303 | if (error) { | |
304 | dev_err(&pdev->dev, | |
305 | "register input device failed (%d)\n", error); | |
306 | return error; | |
307 | } | |
308 | ||
309 | mtk_pmic_keys_lp_reset_setup(keys, mtk_pmic_regs->pmic_rst_reg); | |
310 | ||
311 | platform_set_drvdata(pdev, keys); | |
312 | ||
313 | return 0; | |
314 | } | |
315 | ||
316 | static struct platform_driver pmic_keys_pdrv = { | |
317 | .probe = mtk_pmic_keys_probe, | |
318 | .driver = { | |
319 | .name = "mtk-pmic-keys", | |
320 | .of_match_table = of_mtk_pmic_keys_match_tbl, | |
321 | .pm = &mtk_pmic_keys_pm_ops, | |
322 | }, | |
323 | }; | |
324 | ||
325 | module_platform_driver(pmic_keys_pdrv); | |
326 | ||
327 | MODULE_LICENSE("GPL v2"); | |
328 | MODULE_AUTHOR("Chen Zhong <chen.zhong@mediatek.com>"); | |
329 | MODULE_DESCRIPTION("MTK pmic-keys driver v0.1"); |