Merge tag 'drm-intel-next-2018-06-20' of git://anongit.freedesktop.org/drm/drm-intel...
[linux-2.6-microblaze.git] / drivers / regulator / tps6586x-regulator.c
1 /*
2  * Regulator driver for TI TPS6586x
3  *
4  * Copyright (C) 2010 Compulab Ltd.
5  * Author: Mike Rapoport <mike@compulab.co.il>
6  *
7  * Based on da903x
8  * Copyright (C) 2006-2008 Marvell International Ltd.
9  * Copyright (C) 2008 Compulab Ltd.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License version 2 as
13  * published by the Free Software Foundation.
14  */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/err.h>
20 #include <linux/of.h>
21 #include <linux/slab.h>
22 #include <linux/platform_device.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/of_regulator.h>
26 #include <linux/mfd/tps6586x.h>
27
28 /* supply control and voltage setting  */
29 #define TPS6586X_SUPPLYENA      0x10
30 #define TPS6586X_SUPPLYENB      0x11
31 #define TPS6586X_SUPPLYENC      0x12
32 #define TPS6586X_SUPPLYEND      0x13
33 #define TPS6586X_SUPPLYENE      0x14
34 #define TPS6586X_VCC1           0x20
35 #define TPS6586X_VCC2           0x21
36 #define TPS6586X_SM1V1          0x23
37 #define TPS6586X_SM1V2          0x24
38 #define TPS6586X_SM1SL          0x25
39 #define TPS6586X_SM0V1          0x26
40 #define TPS6586X_SM0V2          0x27
41 #define TPS6586X_SM0SL          0x28
42 #define TPS6586X_LDO2AV1        0x29
43 #define TPS6586X_LDO2AV2        0x2A
44 #define TPS6586X_LDO2BV1        0x2F
45 #define TPS6586X_LDO2BV2        0x30
46 #define TPS6586X_LDO4V1         0x32
47 #define TPS6586X_LDO4V2         0x33
48
49 /* converter settings  */
50 #define TPS6586X_SUPPLYV1       0x41
51 #define TPS6586X_SUPPLYV2       0x42
52 #define TPS6586X_SUPPLYV3       0x43
53 #define TPS6586X_SUPPLYV4       0x44
54 #define TPS6586X_SUPPLYV5       0x45
55 #define TPS6586X_SUPPLYV6       0x46
56 #define TPS6586X_SMODE1         0x47
57 #define TPS6586X_SMODE2         0x48
58
59 struct tps6586x_regulator {
60         struct regulator_desc desc;
61
62         int enable_bit[2];
63         int enable_reg[2];
64 };
65
66 static struct regulator_ops tps6586x_rw_regulator_ops = {
67         .list_voltage = regulator_list_voltage_table,
68         .map_voltage = regulator_map_voltage_ascend,
69         .get_voltage_sel = regulator_get_voltage_sel_regmap,
70         .set_voltage_sel = regulator_set_voltage_sel_regmap,
71
72         .is_enabled = regulator_is_enabled_regmap,
73         .enable = regulator_enable_regmap,
74         .disable = regulator_disable_regmap,
75 };
76
77 static struct regulator_ops tps6586x_rw_linear_regulator_ops = {
78         .list_voltage = regulator_list_voltage_linear,
79         .get_voltage_sel = regulator_get_voltage_sel_regmap,
80         .set_voltage_sel = regulator_set_voltage_sel_regmap,
81
82         .is_enabled = regulator_is_enabled_regmap,
83         .enable = regulator_enable_regmap,
84         .disable = regulator_disable_regmap,
85 };
86
87 static struct regulator_ops tps6586x_ro_regulator_ops = {
88         .list_voltage = regulator_list_voltage_table,
89         .map_voltage = regulator_map_voltage_ascend,
90         .get_voltage_sel = regulator_get_voltage_sel_regmap,
91
92         .is_enabled = regulator_is_enabled_regmap,
93         .enable = regulator_enable_regmap,
94         .disable = regulator_disable_regmap,
95 };
96
97 static struct regulator_ops tps6586x_sys_regulator_ops = {
98 };
99
100 static const unsigned int tps6586x_ldo0_voltages[] = {
101         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
102 };
103
104 static const unsigned int tps6586x_ldo_voltages[] = {
105         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
106 };
107
108 static const unsigned int tps658640_rtc_voltages[] = {
109         2500000, 2850000, 3100000, 3300000,
110 };
111
112 #define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
113                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
114         .desc   = {                                                     \
115                 .supply_name = _pin_name,                               \
116                 .name   = "REG-" #_id,                                  \
117                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
118                 .type   = REGULATOR_VOLTAGE,                            \
119                 .id     = TPS6586X_ID_##_id,                            \
120                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
121                 .volt_table = vdata##_voltages,                         \
122                 .owner  = THIS_MODULE,                                  \
123                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
124                 .enable_mask = 1 << (ebit0),                            \
125                 .vsel_reg = TPS6586X_##vreg,                            \
126                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
127                 .apply_reg = (goreg),                           \
128                 .apply_bit = (gobit),                           \
129         },                                                              \
130         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
131         .enable_bit[0]  = (ebit0),                                      \
132         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
133         .enable_bit[1]  = (ebit1),
134
135 #define TPS6586X_REGULATOR_LINEAR(_id, _ops, _pin_name, n_volt, min_uv, \
136                                   uv_step, vreg, shift, nbits, ereg0,   \
137                                   ebit0, ereg1, ebit1, goreg, gobit)    \
138         .desc   = {                                                     \
139                 .supply_name = _pin_name,                               \
140                 .name   = "REG-" #_id,                                  \
141                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
142                 .type   = REGULATOR_VOLTAGE,                            \
143                 .id     = TPS6586X_ID_##_id,                            \
144                 .n_voltages = n_volt,                                   \
145                 .min_uV = min_uv,                                       \
146                 .uV_step = uv_step,                                     \
147                 .owner  = THIS_MODULE,                                  \
148                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
149                 .enable_mask = 1 << (ebit0),                            \
150                 .vsel_reg = TPS6586X_##vreg,                            \
151                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
152                 .apply_reg = (goreg),                           \
153                 .apply_bit = (gobit),                           \
154         },                                                              \
155         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
156         .enable_bit[0]  = (ebit0),                                      \
157         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
158         .enable_bit[1]  = (ebit1),
159
160 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
161                      ereg0, ebit0, ereg1, ebit1)                        \
162 {                                                                       \
163         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
164                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
165 }
166
167 #define TPS6586X_LDO_LINEAR(_id, _pname, n_volt, min_uv, uv_step, vreg, \
168                             shift, nbits, ereg0, ebit0, ereg1, ebit1)   \
169 {                                                                       \
170         TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,       \
171                                   min_uv, uv_step, vreg, shift, nbits,  \
172                                   ereg0, ebit0, ereg1, ebit1, 0, 0)     \
173 }
174
175 #define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,      \
176                           ereg0, ebit0, ereg1, ebit1)                   \
177 {                                                                       \
178         TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits,  \
179                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
180 }
181
182 #define TPS6586X_DVM(_id, _pname, n_volt, min_uv, uv_step, vreg, shift, \
183                      nbits, ereg0, ebit0, ereg1, ebit1, goreg, gobit)   \
184 {                                                                       \
185         TPS6586X_REGULATOR_LINEAR(_id, rw_linear, _pname, n_volt,       \
186                                   min_uv, uv_step, vreg, shift, nbits,  \
187                                   ereg0, ebit0, ereg1, ebit1, goreg,    \
188                                   gobit)                                \
189 }
190
191 #define TPS6586X_SYS_REGULATOR()                                        \
192 {                                                                       \
193         .desc   = {                                                     \
194                 .supply_name = "sys",                                   \
195                 .name   = "REG-SYS",                                    \
196                 .ops    = &tps6586x_sys_regulator_ops,                  \
197                 .type   = REGULATOR_VOLTAGE,                            \
198                 .id     = TPS6586X_ID_SYS,                              \
199                 .owner  = THIS_MODULE,                                  \
200         },                                                              \
201 }
202
203 static struct tps6586x_regulator tps6586x_regulator[] = {
204         TPS6586X_SYS_REGULATOR(),
205         TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
206                                         END, 0),
207         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
208                                         END, 2),
209         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
210                                         ENE, 6),
211         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
212                                         END, 4),
213         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
214                                         END, 5),
215         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
216                                         END, 6),
217         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
218                                         ENE, 7),
219         TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
220                                         V4, 7),
221         TPS6586X_LDO_LINEAR(LDO_1, "vinldo01", 32, 725000, 25000, SUPPLYV1,
222                             0, 5, ENC, 1, END, 1),
223         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 3000000, 50000, SUPPLYV2,
224                             0, 5, ENC, 7, END, 7),
225         TPS6586X_DVM(LDO_2, "vinldo23", 32, 725000, 25000, LDO2BV1, 0, 5,
226                      ENA, 3, ENB, 3, TPS6586X_VCC2, BIT(6)),
227         TPS6586X_DVM(LDO_4, "vinldo4", 32, 1700000, 25000, LDO4V1, 0, 5,
228                      ENC, 3, END, 3, TPS6586X_VCC1, BIT(6)),
229         TPS6586X_DVM(SM_0, "vin-sm0", 32, 725000, 25000, SM0V1, 0, 5,
230                      ENA, 1, ENB, 1, TPS6586X_VCC1, BIT(2)),
231         TPS6586X_DVM(SM_1, "vin-sm1", 32, 725000, 25000, SM1V1, 0, 5,
232                      ENA, 0, ENB, 0, TPS6586X_VCC1, BIT(0)),
233 };
234
235 static struct tps6586x_regulator tps658623_regulator[] = {
236         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1700000, 25000, SUPPLYV2,
237                             0, 5, ENC, 7, END, 7),
238 };
239
240 static struct tps6586x_regulator tps658640_regulator[] = {
241         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
242                                         ENC, 2, END, 2),
243         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
244                                         ENE, 6, ENE, 6),
245         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
246                                         ENC, 4, END, 4),
247         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
248                                         ENC, 5, END, 5),
249         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
250                                         ENC, 6, END, 6),
251         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
252                                         ENE, 7, ENE, 7),
253         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 2150000, 50000, SUPPLYV2,
254                             0, 5, ENC, 7, END, 7),
255
256         TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
257                                         V4, 7, V4, 7),
258 };
259
260 static struct tps6586x_regulator tps658643_regulator[] = {
261         TPS6586X_LDO_LINEAR(SM_2, "vin-sm2", 32, 1025000, 25000, SUPPLYV2,
262                             0, 5, ENC, 7, END, 7),
263 };
264
265 /*
266  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
267  * regulator state. Clearing one of this bits allows switching
268  * regulator on and of with single register write.
269  */
270 static inline int tps6586x_regulator_preinit(struct device *parent,
271                                              struct tps6586x_regulator *ri)
272 {
273         uint8_t val1, val2;
274         int ret;
275
276         if (ri->enable_reg[0] == ri->enable_reg[1] &&
277             ri->enable_bit[0] == ri->enable_bit[1])
278                         return 0;
279
280         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
281         if (ret)
282                 return ret;
283
284         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
285         if (ret)
286                 return ret;
287
288         if (!(val2 & (1 << ri->enable_bit[1])))
289                 return 0;
290
291         /*
292          * The regulator is on, but it's enabled with the bit we don't
293          * want to use, so we switch the enable bits
294          */
295         if (!(val1 & (1 << ri->enable_bit[0]))) {
296                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
297                                         1 << ri->enable_bit[0]);
298                 if (ret)
299                         return ret;
300         }
301
302         return tps6586x_clr_bits(parent, ri->enable_reg[1],
303                                  1 << ri->enable_bit[1]);
304 }
305
306 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
307                         int id, struct regulator_init_data *p)
308 {
309         struct device *parent = pdev->dev.parent;
310         struct tps6586x_settings *setting = p->driver_data;
311         uint8_t reg;
312
313         if (setting == NULL)
314                 return 0;
315
316         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
317                 return 0;
318
319         /* only SM0 and SM1 can have the slew rate settings */
320         switch (id) {
321         case TPS6586X_ID_SM_0:
322                 reg = TPS6586X_SM0SL;
323                 break;
324         case TPS6586X_ID_SM_1:
325                 reg = TPS6586X_SM1SL;
326                 break;
327         default:
328                 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
329                 return -EINVAL;
330         }
331
332         return tps6586x_write(parent, reg,
333                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
334 }
335
336 static struct tps6586x_regulator *find_regulator_info(int id, int version)
337 {
338         struct tps6586x_regulator *ri;
339         struct tps6586x_regulator *table = NULL;
340         int num;
341         int i;
342
343         switch (version) {
344         case TPS658623:
345         case TPS658624:
346                 table = tps658623_regulator;
347                 num = ARRAY_SIZE(tps658623_regulator);
348                 break;
349         case TPS658640:
350         case TPS658640v2:
351                 table = tps658640_regulator;
352                 num = ARRAY_SIZE(tps658640_regulator);
353                 break;
354         case TPS658643:
355                 table = tps658643_regulator;
356                 num = ARRAY_SIZE(tps658643_regulator);
357                 break;
358         }
359
360         /* Search version specific table first */
361         if (table) {
362                 for (i = 0; i < num; i++) {
363                         ri = &table[i];
364                         if (ri->desc.id == id)
365                                 return ri;
366                 }
367         }
368
369         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
370                 ri = &tps6586x_regulator[i];
371                 if (ri->desc.id == id)
372                         return ri;
373         }
374         return NULL;
375 }
376
377 #ifdef CONFIG_OF
378 static struct of_regulator_match tps6586x_matches[] = {
379         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
380         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
381         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
382         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
383         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
384         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
385         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
386         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
387         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
388         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
389         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
390         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
391         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
392         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
393         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
394 };
395
396 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
397                 struct platform_device *pdev,
398                 struct of_regulator_match **tps6586x_reg_matches)
399 {
400         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
401         struct device_node *np = pdev->dev.parent->of_node;
402         struct device_node *regs;
403         const char *sys_rail = NULL;
404         unsigned int i;
405         struct tps6586x_platform_data *pdata;
406         int err;
407
408         regs = of_get_child_by_name(np, "regulators");
409         if (!regs) {
410                 dev_err(&pdev->dev, "regulator node not found\n");
411                 return NULL;
412         }
413
414         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
415         of_node_put(regs);
416         if (err < 0) {
417                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
418                 return NULL;
419         }
420
421         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
422         if (!pdata)
423                 return NULL;
424
425         for (i = 0; i < num; i++) {
426                 uintptr_t id;
427                 if (!tps6586x_matches[i].init_data)
428                         continue;
429
430                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
431                 id = (uintptr_t)tps6586x_matches[i].driver_data;
432                 if (id == TPS6586X_ID_SYS)
433                         sys_rail = pdata->reg_init_data[i]->constraints.name;
434
435                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
436                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
437         }
438         *tps6586x_reg_matches = tps6586x_matches;
439         return pdata;
440 }
441 #else
442 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
443                 struct platform_device *pdev,
444                 struct of_regulator_match **tps6586x_reg_matches)
445 {
446         *tps6586x_reg_matches = NULL;
447         return NULL;
448 }
449 #endif
450
451 static int tps6586x_regulator_probe(struct platform_device *pdev)
452 {
453         struct tps6586x_regulator *ri = NULL;
454         struct regulator_config config = { };
455         struct regulator_dev *rdev;
456         struct regulator_init_data *reg_data;
457         struct tps6586x_platform_data *pdata;
458         struct of_regulator_match *tps6586x_reg_matches = NULL;
459         int version;
460         int id;
461         int err;
462
463         dev_dbg(&pdev->dev, "Probing regulator\n");
464
465         pdata = dev_get_platdata(pdev->dev.parent);
466         if ((!pdata) && (pdev->dev.parent->of_node))
467                 pdata = tps6586x_parse_regulator_dt(pdev,
468                                         &tps6586x_reg_matches);
469
470         if (!pdata) {
471                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
472                 return -ENODEV;
473         }
474
475         version = tps6586x_get_version(pdev->dev.parent);
476
477         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
478                 reg_data = pdata->reg_init_data[id];
479
480                 ri = find_regulator_info(id, version);
481
482                 if (!ri) {
483                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
484                         return -EINVAL;
485                 }
486
487                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
488                 if (err) {
489                         dev_err(&pdev->dev,
490                                 "regulator %d preinit failed, e %d\n", id, err);
491                         return err;
492                 }
493
494                 config.dev = pdev->dev.parent;
495                 config.init_data = reg_data;
496                 config.driver_data = ri;
497
498                 if (tps6586x_reg_matches)
499                         config.of_node = tps6586x_reg_matches[id].of_node;
500
501                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
502                 if (IS_ERR(rdev)) {
503                         dev_err(&pdev->dev, "failed to register regulator %s\n",
504                                         ri->desc.name);
505                         return PTR_ERR(rdev);
506                 }
507
508                 if (reg_data) {
509                         err = tps6586x_regulator_set_slew_rate(pdev, id,
510                                         reg_data);
511                         if (err < 0) {
512                                 dev_err(&pdev->dev,
513                                         "Slew rate config failed, e %d\n", err);
514                                 return err;
515                         }
516                 }
517         }
518
519         platform_set_drvdata(pdev, rdev);
520         return 0;
521 }
522
523 static struct platform_driver tps6586x_regulator_driver = {
524         .driver = {
525                 .name   = "tps6586x-regulator",
526         },
527         .probe          = tps6586x_regulator_probe,
528 };
529
530 static int __init tps6586x_regulator_init(void)
531 {
532         return platform_driver_register(&tps6586x_regulator_driver);
533 }
534 subsys_initcall(tps6586x_regulator_init);
535
536 static void __exit tps6586x_regulator_exit(void)
537 {
538         platform_driver_unregister(&tps6586x_regulator_driver);
539 }
540 module_exit(tps6586x_regulator_exit);
541
542 MODULE_LICENSE("GPL");
543 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
544 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
545 MODULE_ALIAS("platform:tps6586x-regulator");