Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/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_ro_regulator_ops = {
 78         .list_voltage = regulator_list_voltage_table,
 79         .map_voltage = regulator_map_voltage_ascend,
 80         .get_voltage_sel = regulator_get_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_sys_regulator_ops = {
 88 };
 89 
 90 static const unsigned int tps6586x_ldo0_voltages[] = {
 91         1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 92 };
 93 
 94 static const unsigned int tps6586x_ldo4_voltages[] = {
 95         1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
 96         1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
 97         2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
 98         2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
 99 };
100 
101 #define tps658623_sm2_voltages tps6586x_ldo4_voltages
102 
103 static const unsigned int tps6586x_ldo_voltages[] = {
104         1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
105 };
106 
107 static const unsigned int tps6586x_sm2_voltages[] = {
108         3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
109         3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
110         3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
111         4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
112 };
113 
114 static int tps658640_sm2_voltages[] = {
115         2150000, 2200000, 2250000, 2300000, 2350000, 2400000, 2450000, 2500000,
116         2550000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000, 2900000,
117         2950000, 3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000,
118         3350000, 3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000,
119 };
120 
121 static const unsigned int tps658643_sm2_voltages[] = {
122         1025000, 1050000, 1075000, 1100000, 1125000, 1150000, 1175000, 1200000,
123         1225000, 1250000, 1275000, 1300000, 1325000, 1350000, 1375000, 1400000,
124         1425000, 1450000, 1475000, 1500000, 1525000, 1550000, 1575000, 1600000,
125         1625000, 1650000, 1675000, 1700000, 1725000, 1750000, 1775000, 1800000,
126 };
127 
128 static const unsigned int tps6586x_dvm_voltages[] = {
129          725000,  750000,  775000,  800000,  825000,  850000,  875000,  900000,
130          925000,  950000,  975000, 1000000, 1025000, 1050000, 1075000, 1100000,
131         1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000,
132         1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000,
133 };
134 
135 static int tps658640_rtc_voltages[] = {
136         2500000, 2850000, 3100000, 3300000,
137 };
138 
139 #define TPS6586X_REGULATOR(_id, _ops, _pin_name, vdata, vreg, shift, nbits, \
140                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
141         .desc   = {                                                     \
142                 .supply_name = _pin_name,                               \
143                 .name   = "REG-" #_id,                                  \
144                 .ops    = &tps6586x_## _ops ## _regulator_ops,          \
145                 .type   = REGULATOR_VOLTAGE,                            \
146                 .id     = TPS6586X_ID_##_id,                            \
147                 .n_voltages = ARRAY_SIZE(vdata##_voltages),             \
148                 .volt_table = vdata##_voltages,                         \
149                 .owner  = THIS_MODULE,                                  \
150                 .enable_reg = TPS6586X_SUPPLY##ereg0,                   \
151                 .enable_mask = 1 << (ebit0),                            \
152                 .vsel_reg = TPS6586X_##vreg,                            \
153                 .vsel_mask = ((1 << (nbits)) - 1) << (shift),           \
154                 .apply_reg = (goreg),                           \
155                 .apply_bit = (gobit),                           \
156         },                                                              \
157         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
158         .enable_bit[0]  = (ebit0),                                      \
159         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
160         .enable_bit[1]  = (ebit1),
161 
162 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
163                      ereg0, ebit0, ereg1, ebit1)                        \
164 {                                                                       \
165         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
166                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
167 }
168 
169 #define TPS6586X_FIXED_LDO(_id, _pname, vdata, vreg, shift, nbits,      \
170                           ereg0, ebit0, ereg1, ebit1)                   \
171 {                                                                       \
172         TPS6586X_REGULATOR(_id, ro, _pname, vdata, vreg, shift, nbits,  \
173                            ereg0, ebit0, ereg1, ebit1, 0, 0)            \
174 }
175 
176 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
177                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
178 {                                                                       \
179         TPS6586X_REGULATOR(_id, rw, _pname, vdata, vreg, shift, nbits,  \
180                            ereg0, ebit0, ereg1, ebit1, goreg, gobit)    \
181 }
182 
183 #define TPS6586X_SYS_REGULATOR()                                        \
184 {                                                                       \
185         .desc   = {                                                     \
186                 .supply_name = "sys",                                   \
187                 .name   = "REG-SYS",                                    \
188                 .ops    = &tps6586x_sys_regulator_ops,                  \
189                 .type   = REGULATOR_VOLTAGE,                            \
190                 .id     = TPS6586X_ID_SYS,                              \
191                 .owner  = THIS_MODULE,                                  \
192         },                                                              \
193 }
194 
195 static struct tps6586x_regulator tps6586x_regulator[] = {
196         TPS6586X_SYS_REGULATOR(),
197         TPS6586X_LDO(LDO_0, "vinldo01", tps6586x_ldo0, SUPPLYV1, 5, 3, ENC, 0,
198                                         END, 0),
199         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo, SUPPLYV4, 0, 3, ENC, 2,
200                                         END, 2),
201         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo, SUPPLYV6, 0, 3, ENE, 6,
202                                         ENE, 6),
203         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo, SUPPLYV3, 0, 3, ENC, 4,
204                                         END, 4),
205         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo, SUPPLYV3, 3, 3, ENC, 5,
206                                         END, 5),
207         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo, SUPPLYV2, 5, 3, ENC, 6,
208                                         END, 6),
209         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo, SUPPLYV6, 3, 3, ENE, 7,
210                                         ENE, 7),
211         TPS6586X_LDO(LDO_RTC, "REG-SYS", tps6586x_ldo, SUPPLYV4, 3, 3, V4, 7,
212                                         V4, 7),
213         TPS6586X_LDO(LDO_1, "vinldo01", tps6586x_dvm, SUPPLYV1, 0, 5, ENC, 1,
214                                         END, 1),
215         TPS6586X_LDO(SM_2, "vin-sm2", tps6586x_sm2, SUPPLYV2, 0, 5, ENC, 7,
216                                         END, 7),
217 
218         TPS6586X_DVM(LDO_2, "vinldo23", tps6586x_dvm, LDO2BV1, 0, 5, ENA, 3,
219                                         ENB, 3, TPS6586X_VCC2, BIT(6)),
220         TPS6586X_DVM(LDO_4, "vinldo4", tps6586x_ldo4, LDO4V1, 0, 5, ENC, 3,
221                                         END, 3, TPS6586X_VCC1, BIT(6)),
222         TPS6586X_DVM(SM_0, "vin-sm0", tps6586x_dvm, SM0V1, 0, 5, ENA, 1,
223                                         ENB, 1, TPS6586X_VCC1, BIT(2)),
224         TPS6586X_DVM(SM_1, "vin-sm1", tps6586x_dvm, SM1V1, 0, 5, ENA, 0,
225                                         ENB, 0, TPS6586X_VCC1, BIT(0)),
226 };
227 
228 static struct tps6586x_regulator tps658623_regulator[] = {
229         TPS6586X_LDO(SM_2, "vin-sm2", tps658623_sm2, SUPPLYV2, 0, 5, ENC, 7,
230                                         END, 7),
231 };
232 
233 static struct tps6586x_regulator tps658640_regulator[] = {
234         TPS6586X_LDO(LDO_3, "vinldo23", tps6586x_ldo0, SUPPLYV4, 0, 3,
235                                         ENC, 2, END, 2),
236         TPS6586X_LDO(LDO_5, "REG-SYS", tps6586x_ldo0, SUPPLYV6, 0, 3,
237                                         ENE, 6, ENE, 6),
238         TPS6586X_LDO(LDO_6, "vinldo678", tps6586x_ldo0, SUPPLYV3, 0, 3,
239                                         ENC, 4, END, 4),
240         TPS6586X_LDO(LDO_7, "vinldo678", tps6586x_ldo0, SUPPLYV3, 3, 3,
241                                         ENC, 5, END, 5),
242         TPS6586X_LDO(LDO_8, "vinldo678", tps6586x_ldo0, SUPPLYV2, 5, 3,
243                                         ENC, 6, END, 6),
244         TPS6586X_LDO(LDO_9, "vinldo9", tps6586x_ldo0, SUPPLYV6, 3, 3,
245                                         ENE, 7, ENE, 7),
246         TPS6586X_LDO(SM_2, "vin-sm2", tps658640_sm2, SUPPLYV2, 0, 5,
247                                         ENC, 7, END, 7),
248 
249         TPS6586X_FIXED_LDO(LDO_RTC, "REG-SYS", tps658640_rtc, SUPPLYV4, 3, 2,
250                                         V4, 7, V4, 7),
251 };
252 
253 static struct tps6586x_regulator tps658643_regulator[] = {
254         TPS6586X_LDO(SM_2, "vin-sm2", tps658643_sm2, SUPPLYV2, 0, 5, ENC, 7,
255                                         END, 7),
256 };
257 
258 /*
259  * TPS6586X has 2 enable bits that are OR'ed to determine the actual
260  * regulator state. Clearing one of this bits allows switching
261  * regulator on and of with single register write.
262  */
263 static inline int tps6586x_regulator_preinit(struct device *parent,
264                                              struct tps6586x_regulator *ri)
265 {
266         uint8_t val1, val2;
267         int ret;
268 
269         if (ri->enable_reg[0] == ri->enable_reg[1] &&
270             ri->enable_bit[0] == ri->enable_bit[1])
271                         return 0;
272 
273         ret = tps6586x_read(parent, ri->enable_reg[0], &val1);
274         if (ret)
275                 return ret;
276 
277         ret = tps6586x_read(parent, ri->enable_reg[1], &val2);
278         if (ret)
279                 return ret;
280 
281         if (!(val2 & (1 << ri->enable_bit[1])))
282                 return 0;
283 
284         /*
285          * The regulator is on, but it's enabled with the bit we don't
286          * want to use, so we switch the enable bits
287          */
288         if (!(val1 & (1 << ri->enable_bit[0]))) {
289                 ret = tps6586x_set_bits(parent, ri->enable_reg[0],
290                                         1 << ri->enable_bit[0]);
291                 if (ret)
292                         return ret;
293         }
294 
295         return tps6586x_clr_bits(parent, ri->enable_reg[1],
296                                  1 << ri->enable_bit[1]);
297 }
298 
299 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev,
300                         int id, struct regulator_init_data *p)
301 {
302         struct device *parent = pdev->dev.parent;
303         struct tps6586x_settings *setting = p->driver_data;
304         uint8_t reg;
305 
306         if (setting == NULL)
307                 return 0;
308 
309         if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET))
310                 return 0;
311 
312         /* only SM0 and SM1 can have the slew rate settings */
313         switch (id) {
314         case TPS6586X_ID_SM_0:
315                 reg = TPS6586X_SM0SL;
316                 break;
317         case TPS6586X_ID_SM_1:
318                 reg = TPS6586X_SM1SL;
319                 break;
320         default:
321                 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n");
322                 return -EINVAL;
323         }
324 
325         return tps6586x_write(parent, reg,
326                         setting->slew_rate & TPS6586X_SLEW_RATE_MASK);
327 }
328 
329 static struct tps6586x_regulator *find_regulator_info(int id, int version)
330 {
331         struct tps6586x_regulator *ri;
332         struct tps6586x_regulator *table = NULL;
333         int num;
334         int i;
335 
336         switch (version) {
337         case TPS658623:
338                 table = tps658623_regulator;
339                 num = ARRAY_SIZE(tps658623_regulator);
340                 break;
341         case TPS658640:
342         case TPS658640v2:
343                 table = tps658640_regulator;
344                 num = ARRAY_SIZE(tps658640_regulator);
345                 break;
346         case TPS658643:
347                 table = tps658643_regulator;
348                 num = ARRAY_SIZE(tps658643_regulator);
349                 break;
350         }
351 
352         /* Search version specific table first */
353         if (table) {
354                 for (i = 0; i < num; i++) {
355                         ri = &table[i];
356                         if (ri->desc.id == id)
357                                 return ri;
358                 }
359         }
360 
361         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
362                 ri = &tps6586x_regulator[i];
363                 if (ri->desc.id == id)
364                         return ri;
365         }
366         return NULL;
367 }
368 
369 #ifdef CONFIG_OF
370 static struct of_regulator_match tps6586x_matches[] = {
371         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
372         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
373         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
374         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
375         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
376         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
377         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
378         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
379         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
380         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
381         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
382         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
383         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
384         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
385         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
386 };
387 
388 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
389                 struct platform_device *pdev,
390                 struct of_regulator_match **tps6586x_reg_matches)
391 {
392         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
393         struct device_node *np = pdev->dev.parent->of_node;
394         struct device_node *regs;
395         const char *sys_rail = NULL;
396         unsigned int i;
397         struct tps6586x_platform_data *pdata;
398         int err;
399 
400         regs = of_get_child_by_name(np, "regulators");
401         if (!regs) {
402                 dev_err(&pdev->dev, "regulator node not found\n");
403                 return NULL;
404         }
405 
406         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
407         of_node_put(regs);
408         if (err < 0) {
409                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
410                 return NULL;
411         }
412 
413         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
414         if (!pdata)
415                 return NULL;
416 
417         for (i = 0; i < num; i++) {
418                 int id;
419                 if (!tps6586x_matches[i].init_data)
420                         continue;
421 
422                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
423                 id = (int)tps6586x_matches[i].driver_data;
424                 if (id == TPS6586X_ID_SYS)
425                         sys_rail = pdata->reg_init_data[i]->constraints.name;
426 
427                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
428                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
429         }
430         *tps6586x_reg_matches = tps6586x_matches;
431         return pdata;
432 }
433 #else
434 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
435                 struct platform_device *pdev,
436                 struct of_regulator_match **tps6586x_reg_matches)
437 {
438         *tps6586x_reg_matches = NULL;
439         return NULL;
440 }
441 #endif
442 
443 static int tps6586x_regulator_probe(struct platform_device *pdev)
444 {
445         struct tps6586x_regulator *ri = NULL;
446         struct regulator_config config = { };
447         struct regulator_dev *rdev;
448         struct regulator_init_data *reg_data;
449         struct tps6586x_platform_data *pdata;
450         struct of_regulator_match *tps6586x_reg_matches = NULL;
451         int version;
452         int id;
453         int err;
454 
455         dev_dbg(&pdev->dev, "Probing regulator\n");
456 
457         pdata = dev_get_platdata(pdev->dev.parent);
458         if ((!pdata) && (pdev->dev.parent->of_node))
459                 pdata = tps6586x_parse_regulator_dt(pdev,
460                                         &tps6586x_reg_matches);
461 
462         if (!pdata) {
463                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
464                 return -ENODEV;
465         }
466 
467         version = tps6586x_get_version(pdev->dev.parent);
468 
469         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
470                 reg_data = pdata->reg_init_data[id];
471 
472                 ri = find_regulator_info(id, version);
473 
474                 if (!ri) {
475                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
476                         return -EINVAL;
477                 }
478 
479                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
480                 if (err) {
481                         dev_err(&pdev->dev,
482                                 "regulator %d preinit failed, e %d\n", id, err);
483                         return err;
484                 }
485 
486                 config.dev = pdev->dev.parent;
487                 config.init_data = reg_data;
488                 config.driver_data = ri;
489 
490                 if (tps6586x_reg_matches)
491                         config.of_node = tps6586x_reg_matches[id].of_node;
492 
493                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
494                 if (IS_ERR(rdev)) {
495                         dev_err(&pdev->dev, "failed to register regulator %s\n",
496                                         ri->desc.name);
497                         return PTR_ERR(rdev);
498                 }
499 
500                 if (reg_data) {
501                         err = tps6586x_regulator_set_slew_rate(pdev, id,
502                                         reg_data);
503                         if (err < 0) {
504                                 dev_err(&pdev->dev,
505                                         "Slew rate config failed, e %d\n", err);
506                                 return err;
507                         }
508                 }
509         }
510 
511         platform_set_drvdata(pdev, rdev);
512         return 0;
513 }
514 
515 static struct platform_driver tps6586x_regulator_driver = {
516         .driver = {
517                 .name   = "tps6586x-regulator",
518                 .owner  = THIS_MODULE,
519         },
520         .probe          = tps6586x_regulator_probe,
521 };
522 
523 static int __init tps6586x_regulator_init(void)
524 {
525         return platform_driver_register(&tps6586x_regulator_driver);
526 }
527 subsys_initcall(tps6586x_regulator_init);
528 
529 static void __exit tps6586x_regulator_exit(void)
530 {
531         platform_driver_unregister(&tps6586x_regulator_driver);
532 }
533 module_exit(tps6586x_regulator_exit);
534 
535 MODULE_LICENSE("GPL");
536 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>");
537 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC");
538 MODULE_ALIAS("platform:tps6586x-regulator");
539 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us