drivers/regulator/mtk-dvfsrc-regulator.c

   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
  39 struct 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  */
  49 struct dvfsrc_regulator_init_data {
  50         u32 size;
  51         struct dvfsrc_regulator *regulator_info;
  52 };
  53
  54 static inline struct device *to_dvfsrc_dev(struct regulator_dev *rdev)
  55 {
  56         return rdev_get_dev(rdev)->parent;
  57 }
  58
  59 static 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
  79 static 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
 102 static 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
 108 static const unsigned int mt8183_voltages[] = {
 109         725000,
 110         800000,
 111 };
 112
 113 static struct dvfsrc_regulator mt8183_regulators[] = {
 114         MT_DVFSRC_REGULAR("dvfsrc-vcore", VCORE,
 115                           mt8183_voltages),
 116 };
 117
 118 static const struct dvfsrc_regulator_init_data regulator_mt8183_data = {
 119         .size = ARRAY_SIZE(mt8183_regulators),
 120         .regulator_info = &mt8183_regulators[0],
 121 };
 122
 123 static const unsigned int mt6873_voltages[] = {
 124         575000,
 125         600000,
 126         650000,
 127         725000,
 128 };
 129
 130 static 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
 137 static const struct dvfsrc_regulator_init_data regulator_mt6873_data = {
 138         .size = ARRAY_SIZE(mt6873_regulators),
 139         .regulator_info = &mt6873_regulators[0],
 140 };
 141
 142 static const struct of_device_id mtk_dvfsrc_regulator_match[] = {
 143         {
 144                 .compatible = "mediatek,mt8183-dvfsrc",
 145                 .data = &regulator_mt8183_data,
 146         }, {
 147                 .compatible = "mediatek,mt8192-dvfsrc",
 148                 .data = &regulator_mt6873_data,
 149         }, {
 150                 .compatible = "mediatek,mt6873-dvfsrc",
 151                 .data = &regulator_mt6873_data,
 152         }, {
 153                 /* sentinel */
 154         },
 155 };
 156 MODULE_DEVICE_TABLE(of, mtk_dvfsrc_regulator_match);
 157
 158 static 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
 193 static 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
 201 static int __init mtk_dvfsrc_regulator_init(void)
 202 {
 203         return platform_driver_register(&mtk_dvfsrc_regulator_driver);
 204 }
 205 subsys_initcall(mtk_dvfsrc_regulator_init);
 206
 207 static void __exit mtk_dvfsrc_regulator_exit(void)
 208 {
 209         platform_driver_unregister(&mtk_dvfsrc_regulator_driver);
 210 }
 211 module_exit(mtk_dvfsrc_regulator_exit);
 212
 213 MODULE_AUTHOR("Arvin wang <arvin.wang@mediatek.com>");
 214 MODULE_LICENSE("GPL v2");