1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Regulator controller driver for UniPhier SoC 4 // Copyright 2018 Socionext Inc. 5 // Author: Kunihiko Hayashi <hayashi.kunihiko@socionext.com> 6 7 #include <linux/clk.h> 8 #include <linux/io.h> 9 #include <linux/module.h> 10 #include <linux/of_device.h> 11 #include <linux/platform_device.h> 12 #include <linux/regmap.h> 13 #include <linux/regulator/driver.h> 14 #include <linux/regulator/of_regulator.h> 15 #include <linux/reset.h> 16 17 #define MAX_CLKS 2 18 #define MAX_RSTS 2 19 20 struct uniphier_regulator_soc_data { 21 int nclks; 22 const char * const *clock_names; 23 int nrsts; 24 const char * const *reset_names; 25 const struct regulator_desc *desc; 26 const struct regmap_config *regconf; 27 }; 28 29 struct uniphier_regulator_priv { 30 struct clk_bulk_data clk[MAX_CLKS]; 31 struct reset_control *rst[MAX_RSTS]; 32 const struct uniphier_regulator_soc_data *data; 33 }; 34 35 static struct regulator_ops uniphier_regulator_ops = { 36 .enable = regulator_enable_regmap, 37 .disable = regulator_disable_regmap, 38 .is_enabled = regulator_is_enabled_regmap, 39 }; 40 41 static int uniphier_regulator_probe(struct platform_device *pdev) 42 { 43 struct device *dev = &pdev->dev; 44 struct uniphier_regulator_priv *priv; 45 struct regulator_config config = { }; 46 struct regulator_dev *rdev; 47 struct regmap *regmap; 48 struct resource *res; 49 void __iomem *base; 50 const char *name; 51 int i, ret, nr; 52 53 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 54 if (!priv) 55 return -ENOMEM; 56 57 priv->data = of_device_get_match_data(dev); 58 if (WARN_ON(!priv->data)) 59 return -EINVAL; 60 61 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 62 base = devm_ioremap_resource(dev, res); 63 if (IS_ERR(base)) 64 return PTR_ERR(base); 65 66 for (i = 0; i < priv->data->nclks; i++) 67 priv->clk[i].id = priv->data->clock_names[i]; 68 ret = devm_clk_bulk_get(dev, priv->data->nclks, priv->clk); 69 if (ret) 70 return ret; 71 72 for (i = 0; i < priv->data->nrsts; i++) { 73 name = priv->data->reset_names[i]; 74 priv->rst[i] = devm_reset_control_get_shared(dev, name); 75 if (IS_ERR(priv->rst[i])) 76 return PTR_ERR(priv->rst[i]); 77 } 78 79 ret = clk_bulk_prepare_enable(priv->data->nclks, priv->clk); 80 if (ret) 81 return ret; 82 83 for (nr = 0; nr < priv->data->nrsts; nr++) { 84 ret = reset_control_deassert(priv->rst[nr]); 85 if (ret) 86 goto out_rst_assert; 87 } 88 89 regmap = devm_regmap_init_mmio(dev, base, priv->data->regconf); 90 if (IS_ERR(regmap)) 91 return PTR_ERR(regmap); 92 93 config.dev = dev; 94 config.driver_data = priv; 95 config.of_node = dev->of_node; 96 config.regmap = regmap; 97 config.init_data = of_get_regulator_init_data(dev, dev->of_node, 98 priv->data->desc); 99 rdev = devm_regulator_register(dev, priv->data->desc, &config); 100 if (IS_ERR(rdev)) { 101 ret = PTR_ERR(rdev); 102 goto out_rst_assert; 103 } 104 105 platform_set_drvdata(pdev, priv); 106 107 return 0; 108 109 out_rst_assert: 110 while (nr--) 111 reset_control_assert(priv->rst[nr]); 112 113 clk_bulk_disable_unprepare(priv->data->nclks, priv->clk); 114 115 return ret; 116 } 117 118 static int uniphier_regulator_remove(struct platform_device *pdev) 119 { 120 struct uniphier_regulator_priv *priv = platform_get_drvdata(pdev); 121 int i; 122 123 for (i = 0; i < priv->data->nrsts; i++) 124 reset_control_assert(priv->rst[i]); 125 126 clk_bulk_disable_unprepare(priv->data->nclks, priv->clk); 127 128 return 0; 129 } 130 131 /* USB3 controller data */ 132 #define USB3VBUS_OFFSET 0x0 133 #define USB3VBUS_REG BIT(4) 134 #define USB3VBUS_REG_EN BIT(3) 135 static const struct regulator_desc uniphier_usb3_regulator_desc = { 136 .name = "vbus", 137 .of_match = of_match_ptr("vbus"), 138 .ops = &uniphier_regulator_ops, 139 .type = REGULATOR_VOLTAGE, 140 .owner = THIS_MODULE, 141 .enable_reg = USB3VBUS_OFFSET, 142 .enable_mask = USB3VBUS_REG_EN | USB3VBUS_REG, 143 .enable_val = USB3VBUS_REG_EN | USB3VBUS_REG, 144 .disable_val = USB3VBUS_REG_EN, 145 }; 146 147 static const struct regmap_config uniphier_usb3_regulator_regconf = { 148 .reg_bits = 32, 149 .val_bits = 32, 150 .reg_stride = 4, 151 .max_register = 1, 152 }; 153 154 static const char * const uniphier_pro4_clock_reset_names[] = { 155 "gio", "link", 156 }; 157 158 static const struct uniphier_regulator_soc_data uniphier_pro4_usb3_data = { 159 .nclks = ARRAY_SIZE(uniphier_pro4_clock_reset_names), 160 .clock_names = uniphier_pro4_clock_reset_names, 161 .nrsts = ARRAY_SIZE(uniphier_pro4_clock_reset_names), 162 .reset_names = uniphier_pro4_clock_reset_names, 163 .desc = &uniphier_usb3_regulator_desc, 164 .regconf = &uniphier_usb3_regulator_regconf, 165 }; 166 167 static const char * const uniphier_pxs2_clock_reset_names[] = { 168 "link", 169 }; 170 171 static const struct uniphier_regulator_soc_data uniphier_pxs2_usb3_data = { 172 .nclks = ARRAY_SIZE(uniphier_pxs2_clock_reset_names), 173 .clock_names = uniphier_pxs2_clock_reset_names, 174 .nrsts = ARRAY_SIZE(uniphier_pxs2_clock_reset_names), 175 .reset_names = uniphier_pxs2_clock_reset_names, 176 .desc = &uniphier_usb3_regulator_desc, 177 .regconf = &uniphier_usb3_regulator_regconf, 178 }; 179 180 static const struct of_device_id uniphier_regulator_match[] = { 181 /* USB VBUS */ 182 { 183 .compatible = "socionext,uniphier-pro4-usb3-regulator", 184 .data = &uniphier_pro4_usb3_data, 185 }, 186 { 187 .compatible = "socionext,uniphier-pxs2-usb3-regulator", 188 .data = &uniphier_pxs2_usb3_data, 189 }, 190 { 191 .compatible = "socionext,uniphier-ld20-usb3-regulator", 192 .data = &uniphier_pxs2_usb3_data, 193 }, 194 { 195 .compatible = "socionext,uniphier-pxs3-usb3-regulator", 196 .data = &uniphier_pxs2_usb3_data, 197 }, 198 { /* Sentinel */ }, 199 }; 200 201 static struct platform_driver uniphier_regulator_driver = { 202 .probe = uniphier_regulator_probe, 203 .remove = uniphier_regulator_remove, 204 .driver = { 205 .name = "uniphier-regulator", 206 .of_match_table = uniphier_regulator_match, 207 }, 208 }; 209 module_platform_driver(uniphier_regulator_driver); 210 211 MODULE_AUTHOR("Kunihiko Hayashi <hayashi.kunihiko@socionext.com>"); 212 MODULE_DESCRIPTION("UniPhier Regulator Controller Driver"); 213 MODULE_LICENSE("GPL"); 214