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