Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18

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_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                 table = tps658623_regulator;
346                 num = ARRAY_SIZE(tps658623_regulator);
347                 break;
348         case TPS658640:
349         case TPS658640v2:
350                 table = tps658640_regulator;
351                 num = ARRAY_SIZE(tps658640_regulator);
352                 break;
353         case TPS658643:
354                 table = tps658643_regulator;
355                 num = ARRAY_SIZE(tps658643_regulator);
356                 break;
357         }
358 
359         /* Search version specific table first */
360         if (table) {
361                 for (i = 0; i < num; i++) {
362                         ri = &table[i];
363                         if (ri->desc.id == id)
364                                 return ri;
365                 }
366         }
367 
368         for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) {
369                 ri = &tps6586x_regulator[i];
370                 if (ri->desc.id == id)
371                         return ri;
372         }
373         return NULL;
374 }
375 
376 #ifdef CONFIG_OF
377 static struct of_regulator_match tps6586x_matches[] = {
378         { .name = "sys",     .driver_data = (void *)TPS6586X_ID_SYS     },
379         { .name = "sm0",     .driver_data = (void *)TPS6586X_ID_SM_0    },
380         { .name = "sm1",     .driver_data = (void *)TPS6586X_ID_SM_1    },
381         { .name = "sm2",     .driver_data = (void *)TPS6586X_ID_SM_2    },
382         { .name = "ldo0",    .driver_data = (void *)TPS6586X_ID_LDO_0   },
383         { .name = "ldo1",    .driver_data = (void *)TPS6586X_ID_LDO_1   },
384         { .name = "ldo2",    .driver_data = (void *)TPS6586X_ID_LDO_2   },
385         { .name = "ldo3",    .driver_data = (void *)TPS6586X_ID_LDO_3   },
386         { .name = "ldo4",    .driver_data = (void *)TPS6586X_ID_LDO_4   },
387         { .name = "ldo5",    .driver_data = (void *)TPS6586X_ID_LDO_5   },
388         { .name = "ldo6",    .driver_data = (void *)TPS6586X_ID_LDO_6   },
389         { .name = "ldo7",    .driver_data = (void *)TPS6586X_ID_LDO_7   },
390         { .name = "ldo8",    .driver_data = (void *)TPS6586X_ID_LDO_8   },
391         { .name = "ldo9",    .driver_data = (void *)TPS6586X_ID_LDO_9   },
392         { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC },
393 };
394 
395 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
396                 struct platform_device *pdev,
397                 struct of_regulator_match **tps6586x_reg_matches)
398 {
399         const unsigned int num = ARRAY_SIZE(tps6586x_matches);
400         struct device_node *np = pdev->dev.parent->of_node;
401         struct device_node *regs;
402         const char *sys_rail = NULL;
403         unsigned int i;
404         struct tps6586x_platform_data *pdata;
405         int err;
406 
407         regs = of_get_child_by_name(np, "regulators");
408         if (!regs) {
409                 dev_err(&pdev->dev, "regulator node not found\n");
410                 return NULL;
411         }
412 
413         err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num);
414         of_node_put(regs);
415         if (err < 0) {
416                 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err);
417                 return NULL;
418         }
419 
420         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
421         if (!pdata)
422                 return NULL;
423 
424         for (i = 0; i < num; i++) {
425                 int id;
426                 if (!tps6586x_matches[i].init_data)
427                         continue;
428 
429                 pdata->reg_init_data[i] = tps6586x_matches[i].init_data;
430                 id = (int)tps6586x_matches[i].driver_data;
431                 if (id == TPS6586X_ID_SYS)
432                         sys_rail = pdata->reg_init_data[i]->constraints.name;
433 
434                 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC))
435                         pdata->reg_init_data[i]->supply_regulator = sys_rail;
436         }
437         *tps6586x_reg_matches = tps6586x_matches;
438         return pdata;
439 }
440 #else
441 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt(
442                 struct platform_device *pdev,
443                 struct of_regulator_match **tps6586x_reg_matches)
444 {
445         *tps6586x_reg_matches = NULL;
446         return NULL;
447 }
448 #endif
449 
450 static int tps6586x_regulator_probe(struct platform_device *pdev)
451 {
452         struct tps6586x_regulator *ri = NULL;
453         struct regulator_config config = { };
454         struct regulator_dev *rdev;
455         struct regulator_init_data *reg_data;
456         struct tps6586x_platform_data *pdata;
457         struct of_regulator_match *tps6586x_reg_matches = NULL;
458         int version;
459         int id;
460         int err;
461 
462         dev_dbg(&pdev->dev, "Probing regulator\n");
463 
464         pdata = dev_get_platdata(pdev->dev.parent);
465         if ((!pdata) && (pdev->dev.parent->of_node))
466                 pdata = tps6586x_parse_regulator_dt(pdev,
467                                         &tps6586x_reg_matches);
468 
469         if (!pdata) {
470                 dev_err(&pdev->dev, "Platform data not available, exiting\n");
471                 return -ENODEV;
472         }
473 
474         version = tps6586x_get_version(pdev->dev.parent);
475 
476         for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) {
477                 reg_data = pdata->reg_init_data[id];
478 
479                 ri = find_regulator_info(id, version);
480 
481                 if (!ri) {
482                         dev_err(&pdev->dev, "invalid regulator ID specified\n");
483                         return -EINVAL;
484                 }
485 
486                 err = tps6586x_regulator_preinit(pdev->dev.parent, ri);
487                 if (err) {
488                         dev_err(&pdev->dev,
489                                 "regulator %d preinit failed, e %d\n", id, err);
490                         return err;
491                 }
492 
493                 config.dev = pdev->dev.parent;
494                 config.init_data = reg_data;
495                 config.driver_data = ri;
496 
497                 if (tps6586x_reg_matches)
498                         config.of_node = tps6586x_reg_matches[id].of_node;
499 
500                 rdev = devm_regulator_register(&pdev->dev, &ri->desc, &config);
501                 if (IS_ERR(rdev)) {
502                         dev_err(&pdev->dev, "failed to register regulator %s\n",
503                                         ri->desc.name);
504                         return PTR_ERR(rdev);
505                 }
506 
507                 if (reg_data) {
508                         err = tps6586x_regulator_set_slew_rate(pdev, id,
509                                         reg_data);
510                         if (err < 0) {
511                                 dev_err(&pdev->dev,
512                                         "Slew rate config failed, e %d\n", err);
513                                 return err;
514                         }
515                 }
516         }
517 
518         platform_set_drvdata(pdev, rdev);
519         return 0;
520 }
521 
522 static struct platform_driver tps6586x_regulator_driver = {
523         .driver = {
524                 .name   = "tps6586x-regulator",
525                 .owner  = THIS_MODULE,
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");
546 

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