Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Regulators driver for Marvell 88PM800 |
| 3 | * |
| 4 | * Copyright (C) 2012 Marvell International Ltd. |
| 5 | * Joseph(Yossi) Hanin <yhanin@marvell.com> |
| 6 | * Yi Zhang <yizhang@marvell.com> |
| 7 | * |
| 8 | * This program is free software; you can redistribute it and/or modify |
| 9 | * it under the terms of the GNU General Public License version 2 as |
| 10 | * published by the Free Software Foundation. |
| 11 | */ |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/moduleparam.h> |
| 14 | #include <linux/init.h> |
| 15 | #include <linux/err.h> |
| 16 | #include <linux/regmap.h> |
| 17 | #include <linux/regulator/driver.h> |
| 18 | #include <linux/regulator/machine.h> |
| 19 | #include <linux/mfd/88pm80x.h> |
| 20 | #include <linux/delay.h> |
| 21 | #include <linux/io.h> |
| 22 | #include <linux/of.h> |
| 23 | #include <linux/regulator/of_regulator.h> |
| 24 | |
| 25 | /* LDO1 with DVC[0..3] */ |
| 26 | #define PM800_LDO1_VOUT (0x08) /* VOUT1 */ |
| 27 | #define PM800_LDO1_VOUT_2 (0x09) |
| 28 | #define PM800_LDO1_VOUT_3 (0x0A) |
| 29 | #define PM800_LDO2_VOUT (0x0B) |
| 30 | #define PM800_LDO3_VOUT (0x0C) |
| 31 | #define PM800_LDO4_VOUT (0x0D) |
| 32 | #define PM800_LDO5_VOUT (0x0E) |
| 33 | #define PM800_LDO6_VOUT (0x0F) |
| 34 | #define PM800_LDO7_VOUT (0x10) |
| 35 | #define PM800_LDO8_VOUT (0x11) |
| 36 | #define PM800_LDO9_VOUT (0x12) |
| 37 | #define PM800_LDO10_VOUT (0x13) |
| 38 | #define PM800_LDO11_VOUT (0x14) |
| 39 | #define PM800_LDO12_VOUT (0x15) |
| 40 | #define PM800_LDO13_VOUT (0x16) |
| 41 | #define PM800_LDO14_VOUT (0x17) |
| 42 | #define PM800_LDO15_VOUT (0x18) |
| 43 | #define PM800_LDO16_VOUT (0x19) |
| 44 | #define PM800_LDO17_VOUT (0x1A) |
| 45 | #define PM800_LDO18_VOUT (0x1B) |
| 46 | #define PM800_LDO19_VOUT (0x1C) |
| 47 | |
| 48 | /* BUCK1 with DVC[0..3] */ |
| 49 | #define PM800_BUCK1 (0x3C) |
| 50 | #define PM800_BUCK1_1 (0x3D) |
| 51 | #define PM800_BUCK1_2 (0x3E) |
| 52 | #define PM800_BUCK1_3 (0x3F) |
| 53 | #define PM800_BUCK2 (0x40) |
| 54 | #define PM800_BUCK3 (0x41) |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 55 | #define PM800_BUCK4 (0x42) |
| 56 | #define PM800_BUCK4_1 (0x43) |
| 57 | #define PM800_BUCK4_2 (0x44) |
| 58 | #define PM800_BUCK4_3 (0x45) |
| 59 | #define PM800_BUCK5 (0x46) |
| 60 | |
| 61 | #define PM800_BUCK_ENA (0x50) |
| 62 | #define PM800_LDO_ENA1_1 (0x51) |
| 63 | #define PM800_LDO_ENA1_2 (0x52) |
| 64 | #define PM800_LDO_ENA1_3 (0x53) |
| 65 | |
| 66 | #define PM800_LDO_ENA2_1 (0x56) |
| 67 | #define PM800_LDO_ENA2_2 (0x57) |
| 68 | #define PM800_LDO_ENA2_3 (0x58) |
| 69 | |
| 70 | #define PM800_BUCK1_MISC1 (0x78) |
| 71 | #define PM800_BUCK3_MISC1 (0x7E) |
| 72 | #define PM800_BUCK4_MISC1 (0x81) |
| 73 | #define PM800_BUCK5_MISC1 (0x84) |
| 74 | |
| 75 | struct pm800_regulator_info { |
| 76 | struct regulator_desc desc; |
| 77 | int max_ua; |
| 78 | }; |
| 79 | |
| 80 | struct pm800_regulators { |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 81 | struct pm80x_chip *chip; |
| 82 | struct regmap *map; |
| 83 | }; |
| 84 | |
| 85 | /* |
| 86 | * vreg - the buck regs string. |
| 87 | * ereg - the string for the enable register. |
| 88 | * ebit - the bit number in the enable register. |
| 89 | * amax - the current |
| 90 | * Buck has 2 kinds of voltage steps. It is easy to find voltage by ranges, |
| 91 | * not the constant voltage table. |
Axel Lin | 6625d9d | 2013-07-19 13:06:22 +0800 | [diff] [blame] | 92 | * n_volt - Number of available selectors |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 93 | */ |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 94 | #define PM800_BUCK(match, vreg, ereg, ebit, amax, volt_ranges, n_volt) \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 95 | { \ |
| 96 | .desc = { \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 97 | .name = #vreg, \ |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 98 | .of_match = of_match_ptr(#match), \ |
| 99 | .regulators_node = of_match_ptr("regulators"), \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 100 | .ops = &pm800_volt_range_ops, \ |
| 101 | .type = REGULATOR_VOLTAGE, \ |
| 102 | .id = PM800_ID_##vreg, \ |
| 103 | .owner = THIS_MODULE, \ |
Axel Lin | 6625d9d | 2013-07-19 13:06:22 +0800 | [diff] [blame] | 104 | .n_voltages = n_volt, \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 105 | .linear_ranges = volt_ranges, \ |
| 106 | .n_linear_ranges = ARRAY_SIZE(volt_ranges), \ |
| 107 | .vsel_reg = PM800_##vreg, \ |
| 108 | .vsel_mask = 0x7f, \ |
| 109 | .enable_reg = PM800_##ereg, \ |
| 110 | .enable_mask = 1 << (ebit), \ |
| 111 | }, \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 112 | .max_ua = (amax), \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 113 | } |
| 114 | |
| 115 | /* |
| 116 | * vreg - the LDO regs string |
| 117 | * ereg - the string for the enable register. |
| 118 | * ebit - the bit number in the enable register. |
| 119 | * amax - the current |
| 120 | * volt_table - the LDO voltage table |
| 121 | * For all the LDOes, there are too many ranges. Using volt_table will be |
| 122 | * simpler and faster. |
| 123 | */ |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 124 | #define PM800_LDO(match, vreg, ereg, ebit, amax, ldo_volt_table) \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 125 | { \ |
| 126 | .desc = { \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 127 | .name = #vreg, \ |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 128 | .of_match = of_match_ptr(#match), \ |
| 129 | .regulators_node = of_match_ptr("regulators"), \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 130 | .ops = &pm800_volt_table_ops, \ |
| 131 | .type = REGULATOR_VOLTAGE, \ |
| 132 | .id = PM800_ID_##vreg, \ |
| 133 | .owner = THIS_MODULE, \ |
| 134 | .n_voltages = ARRAY_SIZE(ldo_volt_table), \ |
| 135 | .vsel_reg = PM800_##vreg##_VOUT, \ |
Mark Brown | bf1fc23 | 2015-07-17 12:42:48 +0100 | [diff] [blame] | 136 | .vsel_mask = 0xf, \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 137 | .enable_reg = PM800_##ereg, \ |
| 138 | .enable_mask = 1 << (ebit), \ |
| 139 | .volt_table = ldo_volt_table, \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 140 | }, \ |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 141 | .max_ua = (amax), \ |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 142 | } |
| 143 | |
| 144 | /* Ranges are sorted in ascending order. */ |
| 145 | static const struct regulator_linear_range buck1_volt_range[] = { |
Axel Lin | 8828bae | 2013-10-11 09:32:18 +0800 | [diff] [blame] | 146 | REGULATOR_LINEAR_RANGE(600000, 0, 0x4f, 12500), |
| 147 | REGULATOR_LINEAR_RANGE(1600000, 0x50, 0x54, 50000), |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 148 | }; |
| 149 | |
| 150 | /* BUCK 2~5 have same ranges. */ |
| 151 | static const struct regulator_linear_range buck2_5_volt_range[] = { |
Axel Lin | 8828bae | 2013-10-11 09:32:18 +0800 | [diff] [blame] | 152 | REGULATOR_LINEAR_RANGE(600000, 0, 0x4f, 12500), |
| 153 | REGULATOR_LINEAR_RANGE(1600000, 0x50, 0x72, 50000), |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 154 | }; |
| 155 | |
| 156 | static const unsigned int ldo1_volt_table[] = { |
| 157 | 600000, 650000, 700000, 750000, 800000, 850000, 900000, 950000, |
| 158 | 1000000, 1050000, 1100000, 1150000, 1200000, 1300000, 1400000, 1500000, |
| 159 | }; |
| 160 | |
| 161 | static const unsigned int ldo2_volt_table[] = { |
| 162 | 1700000, 1800000, 1900000, 2000000, 2100000, 2500000, 2700000, 2800000, |
| 163 | }; |
| 164 | |
| 165 | /* LDO 3~17 have same voltage table. */ |
| 166 | static const unsigned int ldo3_17_volt_table[] = { |
| 167 | 1200000, 1250000, 1700000, 1800000, 1850000, 1900000, 2500000, 2600000, |
| 168 | 2700000, 2750000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000, |
| 169 | }; |
| 170 | |
| 171 | /* LDO 18~19 have same voltage table. */ |
| 172 | static const unsigned int ldo18_19_volt_table[] = { |
| 173 | 1700000, 1800000, 1900000, 2500000, 2800000, 2900000, 3100000, 3300000, |
| 174 | }; |
| 175 | |
| 176 | static int pm800_get_current_limit(struct regulator_dev *rdev) |
| 177 | { |
| 178 | struct pm800_regulator_info *info = rdev_get_drvdata(rdev); |
| 179 | |
| 180 | return info->max_ua; |
| 181 | } |
| 182 | |
Bhumika Goyal | b9f1932 | 2017-01-28 18:53:18 +0530 | [diff] [blame] | 183 | static const struct regulator_ops pm800_volt_range_ops = { |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 184 | .list_voltage = regulator_list_voltage_linear_range, |
| 185 | .map_voltage = regulator_map_voltage_linear_range, |
| 186 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| 187 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| 188 | .enable = regulator_enable_regmap, |
| 189 | .disable = regulator_disable_regmap, |
| 190 | .is_enabled = regulator_is_enabled_regmap, |
| 191 | .get_current_limit = pm800_get_current_limit, |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 192 | }; |
| 193 | |
Bhumika Goyal | b9f1932 | 2017-01-28 18:53:18 +0530 | [diff] [blame] | 194 | static const struct regulator_ops pm800_volt_table_ops = { |
Vaibhav Hiremath | 4d45c70 | 2015-07-16 23:46:54 +0530 | [diff] [blame] | 195 | .list_voltage = regulator_list_voltage_table, |
| 196 | .map_voltage = regulator_map_voltage_iterate, |
| 197 | .set_voltage_sel = regulator_set_voltage_sel_regmap, |
| 198 | .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| 199 | .enable = regulator_enable_regmap, |
| 200 | .disable = regulator_disable_regmap, |
| 201 | .is_enabled = regulator_is_enabled_regmap, |
| 202 | .get_current_limit = pm800_get_current_limit, |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 203 | }; |
| 204 | |
| 205 | /* The array is indexed by id(PM800_ID_XXX) */ |
| 206 | static struct pm800_regulator_info pm800_regulator_info[] = { |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 207 | PM800_BUCK(buck1, BUCK1, BUCK_ENA, 0, 3000000, buck1_volt_range, 0x55), |
| 208 | PM800_BUCK(buck2, BUCK2, BUCK_ENA, 1, 1200000, buck2_5_volt_range, 0x73), |
| 209 | PM800_BUCK(buck3, BUCK3, BUCK_ENA, 2, 1200000, buck2_5_volt_range, 0x73), |
| 210 | PM800_BUCK(buck4, BUCK4, BUCK_ENA, 3, 1200000, buck2_5_volt_range, 0x73), |
| 211 | PM800_BUCK(buck5, BUCK5, BUCK_ENA, 4, 1200000, buck2_5_volt_range, 0x73), |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 212 | |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 213 | PM800_LDO(ldo1, LDO1, LDO_ENA1_1, 0, 200000, ldo1_volt_table), |
| 214 | PM800_LDO(ldo2, LDO2, LDO_ENA1_1, 1, 10000, ldo2_volt_table), |
| 215 | PM800_LDO(ldo3, LDO3, LDO_ENA1_1, 2, 300000, ldo3_17_volt_table), |
| 216 | PM800_LDO(ldo4, LDO4, LDO_ENA1_1, 3, 300000, ldo3_17_volt_table), |
| 217 | PM800_LDO(ldo5, LDO5, LDO_ENA1_1, 4, 300000, ldo3_17_volt_table), |
| 218 | PM800_LDO(ldo6, LDO6, LDO_ENA1_1, 5, 300000, ldo3_17_volt_table), |
| 219 | PM800_LDO(ldo7, LDO7, LDO_ENA1_1, 6, 300000, ldo3_17_volt_table), |
| 220 | PM800_LDO(ldo8, LDO8, LDO_ENA1_1, 7, 300000, ldo3_17_volt_table), |
| 221 | PM800_LDO(ldo9, LDO9, LDO_ENA1_2, 0, 300000, ldo3_17_volt_table), |
| 222 | PM800_LDO(ldo10, LDO10, LDO_ENA1_2, 1, 300000, ldo3_17_volt_table), |
| 223 | PM800_LDO(ldo11, LDO11, LDO_ENA1_2, 2, 300000, ldo3_17_volt_table), |
| 224 | PM800_LDO(ldo12, LDO12, LDO_ENA1_2, 3, 300000, ldo3_17_volt_table), |
| 225 | PM800_LDO(ldo13, LDO13, LDO_ENA1_2, 4, 300000, ldo3_17_volt_table), |
| 226 | PM800_LDO(ldo14, LDO14, LDO_ENA1_2, 5, 300000, ldo3_17_volt_table), |
| 227 | PM800_LDO(ldo15, LDO15, LDO_ENA1_2, 6, 300000, ldo3_17_volt_table), |
| 228 | PM800_LDO(ldo16, LDO16, LDO_ENA1_2, 7, 300000, ldo3_17_volt_table), |
| 229 | PM800_LDO(ldo17, LDO17, LDO_ENA1_3, 0, 300000, ldo3_17_volt_table), |
| 230 | PM800_LDO(ldo18, LDO18, LDO_ENA1_3, 1, 200000, ldo18_19_volt_table), |
| 231 | PM800_LDO(ldo19, LDO19, LDO_ENA1_3, 2, 200000, ldo18_19_volt_table), |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 232 | }; |
| 233 | |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 234 | static int pm800_regulator_probe(struct platform_device *pdev) |
| 235 | { |
| 236 | struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent); |
Jingoo Han | dff91d0 | 2013-07-30 17:20:47 +0900 | [diff] [blame] | 237 | struct pm80x_platform_data *pdata = dev_get_platdata(pdev->dev.parent); |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 238 | struct pm800_regulators *pm800_data; |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 239 | struct regulator_config config = { }; |
| 240 | struct regulator_init_data *init_data; |
| 241 | int i, ret; |
| 242 | |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 243 | if (pdata && pdata->num_regulators) { |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 244 | unsigned int count = 0; |
Axel Lin | 19c6b54 | 2013-08-04 09:23:28 +0800 | [diff] [blame] | 245 | |
| 246 | /* Check whether num_regulator is valid. */ |
Dan Carpenter | 720c027 | 2013-08-14 19:14:03 +0300 | [diff] [blame] | 247 | for (i = 0; i < ARRAY_SIZE(pdata->regulators); i++) { |
Axel Lin | 19c6b54 | 2013-08-04 09:23:28 +0800 | [diff] [blame] | 248 | if (pdata->regulators[i]) |
| 249 | count++; |
| 250 | } |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 251 | if (count != pdata->num_regulators) |
| 252 | return -EINVAL; |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 253 | } |
| 254 | |
| 255 | pm800_data = devm_kzalloc(&pdev->dev, sizeof(*pm800_data), |
| 256 | GFP_KERNEL); |
Sachin Kamat | 001f004 | 2014-02-18 16:11:07 +0530 | [diff] [blame] | 257 | if (!pm800_data) |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 258 | return -ENOMEM; |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 259 | |
| 260 | pm800_data->map = chip->subchip->regmap_power; |
| 261 | pm800_data->chip = chip; |
| 262 | |
| 263 | platform_set_drvdata(pdev, pm800_data); |
| 264 | |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 265 | config.dev = chip->dev; |
| 266 | config.regmap = pm800_data->map; |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 267 | for (i = 0; i < PM800_ID_RG_MAX; i++) { |
Vaibhav Hiremath | a07d94a | 2015-07-16 23:46:55 +0530 | [diff] [blame] | 268 | struct regulator_dev *regulator; |
| 269 | |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 270 | if (pdata && pdata->num_regulators) { |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 271 | init_data = pdata->regulators[i]; |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 272 | if (!init_data) |
| 273 | continue; |
| 274 | |
| 275 | config.init_data = init_data; |
| 276 | } |
| 277 | |
| 278 | config.driver_data = &pm800_regulator_info[i]; |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 279 | |
Vaibhav Hiremath | a07d94a | 2015-07-16 23:46:55 +0530 | [diff] [blame] | 280 | regulator = devm_regulator_register(&pdev->dev, |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 281 | &pm800_regulator_info[i].desc, &config); |
Vaibhav Hiremath | a07d94a | 2015-07-16 23:46:55 +0530 | [diff] [blame] | 282 | if (IS_ERR(regulator)) { |
| 283 | ret = PTR_ERR(regulator); |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 284 | dev_err(&pdev->dev, "Failed to register %s\n", |
Vaibhav Hiremath | fa26e4d | 2015-07-16 23:46:56 +0530 | [diff] [blame] | 285 | pm800_regulator_info[i].desc.name); |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 286 | return ret; |
| 287 | } |
| 288 | } |
| 289 | |
| 290 | return 0; |
| 291 | } |
| 292 | |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 293 | static struct platform_driver pm800_regulator_driver = { |
| 294 | .driver = { |
| 295 | .name = "88pm80x-regulator", |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 296 | }, |
| 297 | .probe = pm800_regulator_probe, |
Chao Xie | 95f1dc0 | 2013-07-17 23:07:03 -0400 | [diff] [blame] | 298 | }; |
| 299 | |
| 300 | module_platform_driver(pm800_regulator_driver); |
| 301 | |
| 302 | MODULE_LICENSE("GPL"); |
| 303 | MODULE_AUTHOR("Joseph(Yossi) Hanin <yhanin@marvell.com>"); |
| 304 | MODULE_DESCRIPTION("Regulator Driver for Marvell 88PM800 PMIC"); |
| 305 | MODULE_ALIAS("platform:88pm800-regulator"); |