Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2020 MediaTek Inc.
4 * Copyright (c) 2024 Collabora Ltd.
5 * AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>
6 */
7
8#include <linux/module.h>
9#include <linux/platform_device.h>
10#include <linux/of.h>
11#include <linux/regulator/driver.h>
12#include <linux/regulator/of_regulator.h>
13#include <linux/soc/mediatek/dvfsrc.h>
14
15enum dvfsrc_regulator_id {
16 DVFSRC_ID_VCORE,
17 DVFSRC_ID_VSCP,
18 DVFSRC_ID_MAX
19};
20
21struct dvfsrc_regulator_pdata {
22 const struct regulator_desc *descs;
23 u32 size;
24};
25
26#define MTK_DVFSRC_VREG(match, _name, _volt_table) \
27{ \
28 .name = match, \
29 .of_match = match, \
30 .ops = &dvfsrc_vcore_ops, \
31 .type = REGULATOR_VOLTAGE, \
32 .id = DVFSRC_ID_##_name, \
33 .owner = THIS_MODULE, \
34 .n_voltages = ARRAY_SIZE(_volt_table), \
35 .volt_table = _volt_table, \
36}
37
38static inline struct device *to_dvfs_regulator_dev(struct regulator_dev *rdev)
39{
40 return rdev_get_dev(rdev)->parent;
41}
42
43static inline struct device *to_dvfsrc_dev(struct regulator_dev *rdev)
44{
45 return to_dvfs_regulator_dev(rdev)->parent;
46}
47
48static int dvfsrc_get_cmd(int rdev_id, enum mtk_dvfsrc_cmd *cmd)
49{
50 switch (rdev_id) {
51 case DVFSRC_ID_VCORE:
52 *cmd = MTK_DVFSRC_CMD_VCORE_LEVEL;
53 break;
54 case DVFSRC_ID_VSCP:
55 *cmd = MTK_DVFSRC_CMD_VSCP_LEVEL;
56 break;
57 default:
58 return -EINVAL;
59 }
60
61 return 0;
62}
63
64static int dvfsrc_set_voltage_sel(struct regulator_dev *rdev,
65 unsigned int selector)
66{
67 struct device *dvfsrc_dev = to_dvfsrc_dev(rdev);
68 enum mtk_dvfsrc_cmd req_cmd;
69 int id = rdev_get_id(rdev);
70 int ret;
71
72 ret = dvfsrc_get_cmd(id, &req_cmd);
73 if (ret)
74 return ret;
75
76 return mtk_dvfsrc_send_request(dvfsrc_dev, req_cmd, selector);
77}
78
79static int dvfsrc_get_voltage_sel(struct regulator_dev *rdev)
80{
81 struct device *dvfsrc_dev = to_dvfsrc_dev(rdev);
82 enum mtk_dvfsrc_cmd query_cmd;
83 int id = rdev_get_id(rdev);
84 int val, ret;
85
86 ret = dvfsrc_get_cmd(id, &query_cmd);
87 if (ret)
88 return ret;
89
90 ret = mtk_dvfsrc_query_info(dvfsrc_dev, query_cmd, &val);
91 if (ret)
92 return ret;
93
94 return val;
95}
96
97static const struct regulator_ops dvfsrc_vcore_ops = {
98 .list_voltage = regulator_list_voltage_table,
99 .get_voltage_sel = dvfsrc_get_voltage_sel,
100 .set_voltage_sel = dvfsrc_set_voltage_sel,
101};
102
103static const unsigned int mt6873_voltages[] = {
104 575000,
105 600000,
106 650000,
107 725000,
108};
109
110static const struct regulator_desc mt6873_regulators[] = {
111 MTK_DVFSRC_VREG("dvfsrc-vcore", VCORE, mt6873_voltages),
112 MTK_DVFSRC_VREG("dvfsrc-vscp", VSCP, mt6873_voltages),
113};
114
115static const struct dvfsrc_regulator_pdata mt6873_data = {
116 .descs = mt6873_regulators,
117 .size = ARRAY_SIZE(mt6873_regulators),
118};
119
120static const unsigned int mt8183_voltages[] = {
121 725000,
122 800000,
123};
124
125static const struct regulator_desc mt8183_regulators[] = {
126 MTK_DVFSRC_VREG("dvfsrc-vcore", VCORE, mt8183_voltages),
127};
128
129static const struct dvfsrc_regulator_pdata mt8183_data = {
130 .descs = mt8183_regulators,
131 .size = ARRAY_SIZE(mt8183_regulators),
132};
133
134static const unsigned int mt8195_voltages[] = {
135 550000,
136 600000,
137 650000,
138 750000,
139};
140
141static const struct regulator_desc mt8195_regulators[] = {
142 MTK_DVFSRC_VREG("dvfsrc-vcore", VCORE, mt8195_voltages),
143 MTK_DVFSRC_VREG("dvfsrc-vscp", VSCP, mt8195_voltages),
144};
145
146static const struct dvfsrc_regulator_pdata mt8195_data = {
147 .descs = mt8195_regulators,
148 .size = ARRAY_SIZE(mt8195_regulators),
149};
150
151static int dvfsrc_vcore_regulator_probe(struct platform_device *pdev)
152{
153 struct regulator_config config = { .dev = &pdev->dev };
154 const struct dvfsrc_regulator_pdata *pdata;
155 int i;
156
157 pdata = device_get_match_data(&pdev->dev);
158 if (!pdata)
159 return -EINVAL;
160
161 for (i = 0; i < pdata->size; i++) {
162 const struct regulator_desc *vrdesc = &pdata->descs[i];
163 struct regulator_dev *rdev;
164
165 rdev = devm_regulator_register(&pdev->dev, vrdesc, &config);
166 if (IS_ERR(rdev))
167 return dev_err_probe(&pdev->dev, PTR_ERR(rdev),
168 "failed to register %s\n", vrdesc->name);
169 }
170
171 return 0;
172}
173
174static const struct of_device_id mtk_dvfsrc_regulator_match[] = {
175 { .compatible = "mediatek,mt6873-dvfsrc-regulator", .data = &mt6873_data },
176 { .compatible = "mediatek,mt8183-dvfsrc-regulator", .data = &mt8183_data },
177 { .compatible = "mediatek,mt8192-dvfsrc-regulator", .data = &mt6873_data },
178 { .compatible = "mediatek,mt8195-dvfsrc-regulator", .data = &mt8195_data },
179 { /* sentinel */ }
180};
181MODULE_DEVICE_TABLE(of, mtk_dvfsrc_regulator_match);
182
183static struct platform_driver mtk_dvfsrc_regulator_driver = {
184 .driver = {
185 .name = "mtk-dvfsrc-regulator",
186 .of_match_table = mtk_dvfsrc_regulator_match,
187 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
188 },
189 .probe = dvfsrc_vcore_regulator_probe,
190};
191module_platform_driver(mtk_dvfsrc_regulator_driver);
192
193MODULE_AUTHOR("AngeloGioacchino Del Regno <angelogioacchino.delregno@collabora.com>");
194MODULE_AUTHOR("Arvin wang <arvin.wang@mediatek.com>");
195MODULE_DESCRIPTION("MediaTek DVFS Resource Collector Regulator driver");
196MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0
2//
3// Copyright (c) 2020 MediaTek Inc.
4
5#include <linux/err.h>
6#include <linux/init.h>
7#include <linux/module.h>
8#include <linux/platform_device.h>
9#include <linux/of_.h>
10#include <linux/regulator/driver.h>
11#include <linux/regulator/of_regulator.h>
12#include <linux/soc/mediatek/mtk_dvfsrc.h>
13
14#define DVFSRC_ID_VCORE 0
15#define DVFSRC_ID_VSCP 1
16
17#define MT_DVFSRC_REGULAR(match, _name, _volt_table) \
18[DVFSRC_ID_##_name] = { \
19 .desc = { \
20 .name = match, \
21 .of_match = of_match_ptr(match), \
22 .ops = &dvfsrc_vcore_ops, \
23 .type = REGULATOR_VOLTAGE, \
24 .id = DVFSRC_ID_##_name, \
25 .owner = THIS_MODULE, \
26 .n_voltages = ARRAY_SIZE(_volt_table), \
27 .volt_table = _volt_table, \
28 }, \
29}
30
31/*
32 * DVFSRC regulators' information
33 *
34 * @desc: standard fields of regulator description.
35 * @voltage_selector: Selector used for get_voltage_sel() and
36 * set_voltage_sel() callbacks
37 */
38
39struct dvfsrc_regulator {
40 struct regulator_desc desc;
41};
42
43/*
44 * MTK DVFSRC regulators' init data
45 *
46 * @size: num of regulators
47 * @regulator_info: regulator info.
48 */
49struct dvfsrc_regulator_init_data {
50 u32 size;
51 struct dvfsrc_regulator *regulator_info;
52};
53
54static inline struct device *to_dvfsrc_dev(struct regulator_dev *rdev)
55{
56 return rdev_get_dev(rdev)->parent;
57}
58
59static int dvfsrc_set_voltage_sel(struct regulator_dev *rdev,
60 unsigned int selector)
61{
62 struct device *dvfsrc_dev = to_dvfsrc_dev(rdev);
63 int id = rdev_get_id(rdev);
64
65 if (id == DVFSRC_ID_VCORE)
66 mtk_dvfsrc_send_request(dvfsrc_dev,
67 MTK_DVFSRC_CMD_VCORE_REQUEST,
68 selector);
69 else if (id == DVFSRC_ID_VSCP)
70 mtk_dvfsrc_send_request(dvfsrc_dev,
71 MTK_DVFSRC_CMD_VSCP_REQUEST,
72 selector);
73 else
74 return -EINVAL;
75
76 return 0;
77}
78
79static int dvfsrc_get_voltage_sel(struct regulator_dev *rdev)
80{
81 struct device *dvfsrc_dev = to_dvfsrc_dev(rdev);
82 int id = rdev_get_id(rdev);
83 int val, ret;
84
85 if (id == DVFSRC_ID_VCORE)
86 ret = mtk_dvfsrc_query_info(dvfsrc_dev,
87 MTK_DVFSRC_CMD_VCORE_LEVEL_QUERY,
88 &val);
89 else if (id == DVFSRC_ID_VSCP)
90 ret = mtk_dvfsrc_query_info(dvfsrc_dev,
91 MTK_DVFSRC_CMD_VSCP_LEVEL_QUERY,
92 &val);
93 else
94 return -EINVAL;
95
96 if (ret != 0)
97 return ret;
98
99 return val;
100}
101
102static const struct regulator_ops dvfsrc_vcore_ops = {
103 .list_voltage = regulator_list_voltage_table,
104 .get_voltage_sel = dvfsrc_get_voltage_sel,
105 .set_voltage_sel = dvfsrc_set_voltage_sel,
106};
107
108static const unsigned int mt8183_voltages[] = {
109 725000,
110 800000,
111};
112
113static struct dvfsrc_regulator mt8183_regulators[] = {
114 MT_DVFSRC_REGULAR("dvfsrc-vcore", VCORE,
115 mt8183_voltages),
116};
117
118static const struct dvfsrc_regulator_init_data regulator_mt8183_data = {
119 .size = ARRAY_SIZE(mt8183_regulators),
120 .regulator_info = &mt8183_regulators[0],
121};
122
123static const unsigned int mt6873_voltages[] = {
124 575000,
125 600000,
126 650000,
127 725000,
128};
129
130static struct dvfsrc_regulator mt6873_regulators[] = {
131 MT_DVFSRC_REGULAR("dvfsrc-vcore", VCORE,
132 mt6873_voltages),
133 MT_DVFSRC_REGULAR("dvfsrc-vscp", VSCP,
134 mt6873_voltages),
135};
136
137static const struct dvfsrc_regulator_init_data regulator_mt6873_data = {
138 .size = ARRAY_SIZE(mt6873_regulators),
139 .regulator_info = &mt6873_regulators[0],
140};
141
142static const struct of_device_id mtk_dvfsrc_regulator_match[] = {
143 {
144 .compatible = "mediatek,mt8183-dvfsrc",
145 .data = ®ulator_mt8183_data,
146 }, {
147 .compatible = "mediatek,mt8192-dvfsrc",
148 .data = ®ulator_mt6873_data,
149 }, {
150 .compatible = "mediatek,mt6873-dvfsrc",
151 .data = ®ulator_mt6873_data,
152 }, {
153 /* sentinel */
154 },
155};
156MODULE_DEVICE_TABLE(of, mtk_dvfsrc_regulator_match);
157
158static int dvfsrc_vcore_regulator_probe(struct platform_device *pdev)
159{
160 const struct of_device_id *match;
161 struct device *dev = &pdev->dev;
162 struct regulator_config config = { };
163 struct regulator_dev *rdev;
164 const struct dvfsrc_regulator_init_data *regulator_init_data;
165 struct dvfsrc_regulator *mt_regulators;
166 int i;
167
168 match = of_match_node(mtk_dvfsrc_regulator_match, dev->parent->of_node);
169
170 if (!match) {
171 dev_err(dev, "invalid compatible string\n");
172 return -ENODEV;
173 }
174
175 regulator_init_data = match->data;
176
177 mt_regulators = regulator_init_data->regulator_info;
178 for (i = 0; i < regulator_init_data->size; i++) {
179 config.dev = dev->parent;
180 config.driver_data = (mt_regulators + i);
181 rdev = devm_regulator_register(dev, &(mt_regulators + i)->desc,
182 &config);
183 if (IS_ERR(rdev)) {
184 dev_err(dev, "failed to register %s\n",
185 (mt_regulators + i)->desc.name);
186 return PTR_ERR(rdev);
187 }
188 }
189
190 return 0;
191}
192
193static struct platform_driver mtk_dvfsrc_regulator_driver = {
194 .driver = {
195 .name = "mtk-dvfsrc-regulator",
196 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
197 },
198 .probe = dvfsrc_vcore_regulator_probe,
199};
200
201static int __init mtk_dvfsrc_regulator_init(void)
202{
203 return platform_driver_register(&mtk_dvfsrc_regulator_driver);
204}
205subsys_initcall(mtk_dvfsrc_regulator_init);
206
207static void __exit mtk_dvfsrc_regulator_exit(void)
208{
209 platform_driver_unregister(&mtk_dvfsrc_regulator_driver);
210}
211module_exit(mtk_dvfsrc_regulator_exit);
212
213MODULE_AUTHOR("Arvin wang <arvin.wang@mediatek.com>");
214MODULE_LICENSE("GPL v2");