1 /*
2 * Regulator driver for TPS6524x PMIC
3 *
4 * Copyright (C) 2010 Texas Instruments
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation version 2.
9 *
10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
11 * whether express or implied; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
14 */
15
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/err.h>
19 #include <linux/errno.h>
20 #include <linux/slab.h>
21 #include <linux/spi/spi.h>
22 #include <linux/regulator/driver.h>
23 #include <linux/regulator/machine.h>
24
25 #define REG_LDO_SET 0x0
26 #define LDO_ILIM_MASK 1 /* 0 = 400-800, 1 = 900-1500 */
27 #define LDO_VSEL_MASK 0x0f
28 #define LDO2_ILIM_SHIFT 12
29 #define LDO2_VSEL_SHIFT 4
30 #define LDO1_ILIM_SHIFT 8
31 #define LDO1_VSEL_SHIFT 0
32
33 #define REG_BLOCK_EN 0x1
34 #define BLOCK_MASK 1
35 #define BLOCK_LDO1_SHIFT 0
36 #define BLOCK_LDO2_SHIFT 1
37 #define BLOCK_LCD_SHIFT 2
38 #define BLOCK_USB_SHIFT 3
39
40 #define REG_DCDC_SET 0x2
41 #define DCDC_VDCDC_MASK 0x1f
42 #define DCDC_VDCDC1_SHIFT 0
43 #define DCDC_VDCDC2_SHIFT 5
44 #define DCDC_VDCDC3_SHIFT 10
45
46 #define REG_DCDC_EN 0x3
47 #define DCDCDCDC_EN_MASK 0x1
48 #define DCDCDCDC1_EN_SHIFT 0
49 #define DCDCDCDC1_PG_MSK BIT(1)
50 #define DCDCDCDC2_EN_SHIFT 2
51 #define DCDCDCDC2_PG_MSK BIT(3)
52 #define DCDCDCDC3_EN_SHIFT 4
53 #define DCDCDCDC3_PG_MSK BIT(5)
54
55 #define REG_USB 0x4
56 #define USB_ILIM_SHIFT 0
57 #define USB_ILIM_MASK 0x3
58 #define USB_TSD_SHIFT 2
59 #define USB_TSD_MASK 0x3
60 #define USB_TWARN_SHIFT 4
61 #define USB_TWARN_MASK 0x3
62 #define USB_IWARN_SD BIT(6)
63 #define USB_FAST_LOOP BIT(7)
64
65 #define REG_ALARM 0x5
66 #define ALARM_LDO1 BIT(0)
67 #define ALARM_DCDC1 BIT(1)
68 #define ALARM_DCDC2 BIT(2)
69 #define ALARM_DCDC3 BIT(3)
70 #define ALARM_LDO2 BIT(4)
71 #define ALARM_USB_WARN BIT(5)
72 #define ALARM_USB_ALARM BIT(6)
73 #define ALARM_LCD BIT(9)
74 #define ALARM_TEMP_WARM BIT(10)
75 #define ALARM_TEMP_HOT BIT(11)
76 #define ALARM_NRST BIT(14)
77 #define ALARM_POWERUP BIT(15)
78
79 #define REG_INT_ENABLE 0x6
80 #define INT_LDO1 BIT(0)
81 #define INT_DCDC1 BIT(1)
82 #define INT_DCDC2 BIT(2)
83 #define INT_DCDC3 BIT(3)
84 #define INT_LDO2 BIT(4)
85 #define INT_USB_WARN BIT(5)
86 #define INT_USB_ALARM BIT(6)
87 #define INT_LCD BIT(9)
88 #define INT_TEMP_WARM BIT(10)
89 #define INT_TEMP_HOT BIT(11)
90 #define INT_GLOBAL_EN BIT(15)
91
92 #define REG_INT_STATUS 0x7
93 #define STATUS_LDO1 BIT(0)
94 #define STATUS_DCDC1 BIT(1)
95 #define STATUS_DCDC2 BIT(2)
96 #define STATUS_DCDC3 BIT(3)
97 #define STATUS_LDO2 BIT(4)
98 #define STATUS_USB_WARN BIT(5)
99 #define STATUS_USB_ALARM BIT(6)
100 #define STATUS_LCD BIT(9)
101 #define STATUS_TEMP_WARM BIT(10)
102 #define STATUS_TEMP_HOT BIT(11)
103
104 #define REG_SOFTWARE_RESET 0xb
105 #define REG_WRITE_ENABLE 0xd
106 #define REG_REV_ID 0xf
107
108 #define N_DCDC 3
109 #define N_LDO 2
110 #define N_SWITCH 2
111 #define N_REGULATORS (N_DCDC + N_LDO + N_SWITCH)
112
113 #define FIXED_ILIMSEL BIT(0)
114 #define FIXED_VOLTAGE BIT(1)
115
116 #define CMD_READ(reg) ((reg) << 6)
117 #define CMD_WRITE(reg) (BIT(5) | (reg) << 6)
118 #define STAT_CLK BIT(3)
119 #define STAT_WRITE BIT(2)
120 #define STAT_INVALID BIT(1)
121 #define STAT_WP BIT(0)
122
123 struct field {
124 int reg;
125 int shift;
126 int mask;
127 };
128
129 struct supply_info {
130 const char *name;
131 int n_voltages;
132 const int *voltages;
133 int fixed_voltage;
134 int n_ilimsels;
135 const int *ilimsels;
136 int fixed_ilimsel;
137 int flags;
138 struct field enable, voltage, ilimsel;
139 };
140
141 struct tps6524x {
142 struct device *dev;
143 struct spi_device *spi;
144 struct mutex lock;
145 struct regulator_desc desc[N_REGULATORS];
146 struct regulator_dev *rdev[N_REGULATORS];
147 };
148
__read_reg(struct tps6524x * hw,int reg)149 static int __read_reg(struct tps6524x *hw, int reg)
150 {
151 int error = 0;
152 u16 cmd = CMD_READ(reg), in;
153 u8 status;
154 struct spi_message m;
155 struct spi_transfer t[3];
156
157 spi_message_init(&m);
158 memset(t, 0, sizeof(t));
159
160 t[0].tx_buf = &cmd;
161 t[0].len = 2;
162 t[0].bits_per_word = 12;
163 spi_message_add_tail(&t[0], &m);
164
165 t[1].rx_buf = ∈
166 t[1].len = 2;
167 t[1].bits_per_word = 16;
168 spi_message_add_tail(&t[1], &m);
169
170 t[2].rx_buf = &status;
171 t[2].len = 1;
172 t[2].bits_per_word = 4;
173 spi_message_add_tail(&t[2], &m);
174
175 error = spi_sync(hw->spi, &m);
176 if (error < 0)
177 return error;
178
179 dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
180 reg, in, status);
181
182 if (!(status & STAT_CLK) || (status & STAT_WRITE))
183 return -EIO;
184
185 if (status & STAT_INVALID)
186 return -EINVAL;
187
188 return in;
189 }
190
read_reg(struct tps6524x * hw,int reg)191 static int read_reg(struct tps6524x *hw, int reg)
192 {
193 int ret;
194
195 mutex_lock(&hw->lock);
196 ret = __read_reg(hw, reg);
197 mutex_unlock(&hw->lock);
198
199 return ret;
200 }
201
__write_reg(struct tps6524x * hw,int reg,int val)202 static int __write_reg(struct tps6524x *hw, int reg, int val)
203 {
204 int error = 0;
205 u16 cmd = CMD_WRITE(reg), out = val;
206 u8 status;
207 struct spi_message m;
208 struct spi_transfer t[3];
209
210 spi_message_init(&m);
211 memset(t, 0, sizeof(t));
212
213 t[0].tx_buf = &cmd;
214 t[0].len = 2;
215 t[0].bits_per_word = 12;
216 spi_message_add_tail(&t[0], &m);
217
218 t[1].tx_buf = &out;
219 t[1].len = 2;
220 t[1].bits_per_word = 16;
221 spi_message_add_tail(&t[1], &m);
222
223 t[2].rx_buf = &status;
224 t[2].len = 1;
225 t[2].bits_per_word = 4;
226 spi_message_add_tail(&t[2], &m);
227
228 error = spi_sync(hw->spi, &m);
229 if (error < 0)
230 return error;
231
232 dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
233 reg, out, status);
234
235 if (!(status & STAT_CLK) || !(status & STAT_WRITE))
236 return -EIO;
237
238 if (status & (STAT_INVALID | STAT_WP))
239 return -EINVAL;
240
241 return error;
242 }
243
__rmw_reg(struct tps6524x * hw,int reg,int mask,int val)244 static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
245 {
246 int ret;
247
248 ret = __read_reg(hw, reg);
249 if (ret < 0)
250 return ret;
251
252 ret &= ~mask;
253 ret |= val;
254
255 ret = __write_reg(hw, reg, ret);
256
257 return (ret < 0) ? ret : 0;
258 }
259
rmw_protect(struct tps6524x * hw,int reg,int mask,int val)260 static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
261 {
262 int ret;
263
264 mutex_lock(&hw->lock);
265
266 ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
267 if (ret) {
268 dev_err(hw->dev, "failed to set write enable\n");
269 goto error;
270 }
271
272 ret = __rmw_reg(hw, reg, mask, val);
273 if (ret)
274 dev_err(hw->dev, "failed to rmw register %d\n", reg);
275
276 ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
277 if (ret) {
278 dev_err(hw->dev, "failed to clear write enable\n");
279 goto error;
280 }
281
282 error:
283 mutex_unlock(&hw->lock);
284
285 return ret;
286 }
287
read_field(struct tps6524x * hw,const struct field * field)288 static int read_field(struct tps6524x *hw, const struct field *field)
289 {
290 int tmp;
291
292 tmp = read_reg(hw, field->reg);
293 if (tmp < 0)
294 return tmp;
295
296 return (tmp >> field->shift) & field->mask;
297 }
298
write_field(struct tps6524x * hw,const struct field * field,int val)299 static int write_field(struct tps6524x *hw, const struct field *field,
300 int val)
301 {
302 if (val & ~field->mask)
303 return -EOVERFLOW;
304
305 return rmw_protect(hw, field->reg,
306 field->mask << field->shift,
307 val << field->shift);
308 }
309
310 static const int dcdc1_voltages[] = {
311 800000, 825000, 850000, 875000,
312 900000, 925000, 950000, 975000,
313 1000000, 1025000, 1050000, 1075000,
314 1100000, 1125000, 1150000, 1175000,
315 1200000, 1225000, 1250000, 1275000,
316 1300000, 1325000, 1350000, 1375000,
317 1400000, 1425000, 1450000, 1475000,
318 1500000, 1525000, 1550000, 1575000,
319 };
320
321 static const int dcdc2_voltages[] = {
322 1400000, 1450000, 1500000, 1550000,
323 1600000, 1650000, 1700000, 1750000,
324 1800000, 1850000, 1900000, 1950000,
325 2000000, 2050000, 2100000, 2150000,
326 2200000, 2250000, 2300000, 2350000,
327 2400000, 2450000, 2500000, 2550000,
328 2600000, 2650000, 2700000, 2750000,
329 2800000, 2850000, 2900000, 2950000,
330 };
331
332 static const int dcdc3_voltages[] = {
333 2400000, 2450000, 2500000, 2550000, 2600000,
334 2650000, 2700000, 2750000, 2800000, 2850000,
335 2900000, 2950000, 3000000, 3050000, 3100000,
336 3150000, 3200000, 3250000, 3300000, 3350000,
337 3400000, 3450000, 3500000, 3550000, 3600000,
338 };
339
340 static const int ldo1_voltages[] = {
341 4300000, 4350000, 4400000, 4450000,
342 4500000, 4550000, 4600000, 4650000,
343 4700000, 4750000, 4800000, 4850000,
344 4900000, 4950000, 5000000, 5050000,
345 };
346
347 static const int ldo2_voltages[] = {
348 1100000, 1150000, 1200000, 1250000,
349 1300000, 1700000, 1750000, 1800000,
350 1850000, 1900000, 3150000, 3200000,
351 3250000, 3300000, 3350000, 3400000,
352 };
353
354 static const int ldo_ilimsel[] = {
355 400000, 1500000
356 };
357
358 static const int usb_ilimsel[] = {
359 200000, 400000, 800000, 1000000
360 };
361
362 #define __MK_FIELD(_reg, _mask, _shift) \
363 { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
364
365 static const struct supply_info supply_info[N_REGULATORS] = {
366 {
367 .name = "DCDC1",
368 .flags = FIXED_ILIMSEL,
369 .n_voltages = ARRAY_SIZE(dcdc1_voltages),
370 .voltages = dcdc1_voltages,
371 .fixed_ilimsel = 2400000,
372 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
373 DCDCDCDC1_EN_SHIFT),
374 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
375 DCDC_VDCDC1_SHIFT),
376 },
377 {
378 .name = "DCDC2",
379 .flags = FIXED_ILIMSEL,
380 .n_voltages = ARRAY_SIZE(dcdc2_voltages),
381 .voltages = dcdc2_voltages,
382 .fixed_ilimsel = 1200000,
383 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
384 DCDCDCDC2_EN_SHIFT),
385 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
386 DCDC_VDCDC2_SHIFT),
387 },
388 {
389 .name = "DCDC3",
390 .flags = FIXED_ILIMSEL,
391 .n_voltages = ARRAY_SIZE(dcdc3_voltages),
392 .voltages = dcdc3_voltages,
393 .fixed_ilimsel = 1200000,
394 .enable = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
395 DCDCDCDC3_EN_SHIFT),
396 .voltage = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
397 DCDC_VDCDC3_SHIFT),
398 },
399 {
400 .name = "LDO1",
401 .n_voltages = ARRAY_SIZE(ldo1_voltages),
402 .voltages = ldo1_voltages,
403 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel),
404 .ilimsels = ldo_ilimsel,
405 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
406 BLOCK_LDO1_SHIFT),
407 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
408 LDO1_VSEL_SHIFT),
409 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
410 LDO1_ILIM_SHIFT),
411 },
412 {
413 .name = "LDO2",
414 .n_voltages = ARRAY_SIZE(ldo2_voltages),
415 .voltages = ldo2_voltages,
416 .n_ilimsels = ARRAY_SIZE(ldo_ilimsel),
417 .ilimsels = ldo_ilimsel,
418 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
419 BLOCK_LDO2_SHIFT),
420 .voltage = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
421 LDO2_VSEL_SHIFT),
422 .ilimsel = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
423 LDO2_ILIM_SHIFT),
424 },
425 {
426 .name = "USB",
427 .flags = FIXED_VOLTAGE,
428 .fixed_voltage = 5000000,
429 .n_ilimsels = ARRAY_SIZE(usb_ilimsel),
430 .ilimsels = usb_ilimsel,
431 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
432 BLOCK_USB_SHIFT),
433 .ilimsel = __MK_FIELD(REG_USB, USB_ILIM_MASK,
434 USB_ILIM_SHIFT),
435 },
436 {
437 .name = "LCD",
438 .flags = FIXED_VOLTAGE | FIXED_ILIMSEL,
439 .fixed_voltage = 5000000,
440 .fixed_ilimsel = 400000,
441 .enable = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
442 BLOCK_LCD_SHIFT),
443 },
444 };
445
list_voltage(struct regulator_dev * rdev,unsigned selector)446 static int list_voltage(struct regulator_dev *rdev, unsigned selector)
447 {
448 const struct supply_info *info;
449 struct tps6524x *hw;
450
451 hw = rdev_get_drvdata(rdev);
452 info = &supply_info[rdev_get_id(rdev)];
453
454 if (info->flags & FIXED_VOLTAGE)
455 return selector ? -EINVAL : info->fixed_voltage;
456
457 return ((selector < info->n_voltages) ?
458 info->voltages[selector] : -EINVAL);
459 }
460
set_voltage(struct regulator_dev * rdev,int min_uV,int max_uV,unsigned * selector)461 static int set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
462 unsigned *selector)
463 {
464 const struct supply_info *info;
465 struct tps6524x *hw;
466 unsigned i;
467
468 hw = rdev_get_drvdata(rdev);
469 info = &supply_info[rdev_get_id(rdev)];
470
471 if (info->flags & FIXED_VOLTAGE)
472 return -EINVAL;
473
474 for (i = 0; i < info->n_voltages; i++)
475 if (min_uV <= info->voltages[i] &&
476 max_uV >= info->voltages[i])
477 break;
478
479 if (i >= info->n_voltages)
480 i = info->n_voltages - 1;
481
482 *selector = i;
483
484 return write_field(hw, &info->voltage, i);
485 }
486
get_voltage(struct regulator_dev * rdev)487 static int get_voltage(struct regulator_dev *rdev)
488 {
489 const struct supply_info *info;
490 struct tps6524x *hw;
491 int ret;
492
493 hw = rdev_get_drvdata(rdev);
494 info = &supply_info[rdev_get_id(rdev)];
495
496 if (info->flags & FIXED_VOLTAGE)
497 return info->fixed_voltage;
498
499 ret = read_field(hw, &info->voltage);
500 if (ret < 0)
501 return ret;
502 if (WARN_ON(ret >= info->n_voltages))
503 return -EIO;
504
505 return info->voltages[ret];
506 }
507
set_current_limit(struct regulator_dev * rdev,int min_uA,int max_uA)508 static int set_current_limit(struct regulator_dev *rdev, int min_uA,
509 int max_uA)
510 {
511 const struct supply_info *info;
512 struct tps6524x *hw;
513 int i;
514
515 hw = rdev_get_drvdata(rdev);
516 info = &supply_info[rdev_get_id(rdev)];
517
518 if (info->flags & FIXED_ILIMSEL)
519 return -EINVAL;
520
521 for (i = 0; i < info->n_ilimsels; i++)
522 if (min_uA <= info->ilimsels[i] &&
523 max_uA >= info->ilimsels[i])
524 break;
525
526 if (i >= info->n_ilimsels)
527 return -EINVAL;
528
529 return write_field(hw, &info->ilimsel, i);
530 }
531
get_current_limit(struct regulator_dev * rdev)532 static int get_current_limit(struct regulator_dev *rdev)
533 {
534 const struct supply_info *info;
535 struct tps6524x *hw;
536 int ret;
537
538 hw = rdev_get_drvdata(rdev);
539 info = &supply_info[rdev_get_id(rdev)];
540
541 if (info->flags & FIXED_ILIMSEL)
542 return info->fixed_ilimsel;
543
544 ret = read_field(hw, &info->ilimsel);
545 if (ret < 0)
546 return ret;
547 if (WARN_ON(ret >= info->n_ilimsels))
548 return -EIO;
549
550 return info->ilimsels[ret];
551 }
552
enable_supply(struct regulator_dev * rdev)553 static int enable_supply(struct regulator_dev *rdev)
554 {
555 const struct supply_info *info;
556 struct tps6524x *hw;
557
558 hw = rdev_get_drvdata(rdev);
559 info = &supply_info[rdev_get_id(rdev)];
560
561 return write_field(hw, &info->enable, 1);
562 }
563
disable_supply(struct regulator_dev * rdev)564 static int disable_supply(struct regulator_dev *rdev)
565 {
566 const struct supply_info *info;
567 struct tps6524x *hw;
568
569 hw = rdev_get_drvdata(rdev);
570 info = &supply_info[rdev_get_id(rdev)];
571
572 return write_field(hw, &info->enable, 0);
573 }
574
is_supply_enabled(struct regulator_dev * rdev)575 static int is_supply_enabled(struct regulator_dev *rdev)
576 {
577 const struct supply_info *info;
578 struct tps6524x *hw;
579
580 hw = rdev_get_drvdata(rdev);
581 info = &supply_info[rdev_get_id(rdev)];
582
583 return read_field(hw, &info->enable);
584 }
585
586 static struct regulator_ops regulator_ops = {
587 .is_enabled = is_supply_enabled,
588 .enable = enable_supply,
589 .disable = disable_supply,
590 .get_voltage = get_voltage,
591 .set_voltage = set_voltage,
592 .list_voltage = list_voltage,
593 .set_current_limit = set_current_limit,
594 .get_current_limit = get_current_limit,
595 };
596
pmic_remove(struct spi_device * spi)597 static int pmic_remove(struct spi_device *spi)
598 {
599 struct tps6524x *hw = spi_get_drvdata(spi);
600 int i;
601
602 if (!hw)
603 return 0;
604 for (i = 0; i < N_REGULATORS; i++) {
605 if (hw->rdev[i])
606 regulator_unregister(hw->rdev[i]);
607 hw->rdev[i] = NULL;
608 }
609 spi_set_drvdata(spi, NULL);
610 kfree(hw);
611 return 0;
612 }
613
pmic_probe(struct spi_device * spi)614 static int __devinit pmic_probe(struct spi_device *spi)
615 {
616 struct tps6524x *hw;
617 struct device *dev = &spi->dev;
618 const struct supply_info *info = supply_info;
619 struct regulator_init_data *init_data;
620 int ret = 0, i;
621
622 init_data = dev->platform_data;
623 if (!init_data) {
624 dev_err(dev, "could not find regulator platform data\n");
625 return -EINVAL;
626 }
627
628 hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL);
629 if (!hw) {
630 dev_err(dev, "cannot allocate regulator private data\n");
631 return -ENOMEM;
632 }
633 spi_set_drvdata(spi, hw);
634
635 memset(hw, 0, sizeof(struct tps6524x));
636 hw->dev = dev;
637 hw->spi = spi_dev_get(spi);
638 mutex_init(&hw->lock);
639
640 for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
641 hw->desc[i].name = info->name;
642 hw->desc[i].id = i;
643 hw->desc[i].n_voltages = info->n_voltages;
644 hw->desc[i].ops = ®ulator_ops;
645 hw->desc[i].type = REGULATOR_VOLTAGE;
646 hw->desc[i].owner = THIS_MODULE;
647
648 if (info->flags & FIXED_VOLTAGE)
649 hw->desc[i].n_voltages = 1;
650
651 hw->rdev[i] = regulator_register(&hw->desc[i], dev,
652 init_data, hw, NULL);
653 if (IS_ERR(hw->rdev[i])) {
654 ret = PTR_ERR(hw->rdev[i]);
655 hw->rdev[i] = NULL;
656 goto fail;
657 }
658 }
659
660 return 0;
661
662 fail:
663 pmic_remove(spi);
664 return ret;
665 }
666
667 static struct spi_driver pmic_driver = {
668 .probe = pmic_probe,
669 .remove = __devexit_p(pmic_remove),
670 .driver = {
671 .name = "tps6524x",
672 .owner = THIS_MODULE,
673 },
674 };
675
pmic_driver_init(void)676 static int __init pmic_driver_init(void)
677 {
678 return spi_register_driver(&pmic_driver);
679 }
680 module_init(pmic_driver_init);
681
pmic_driver_exit(void)682 static void __exit pmic_driver_exit(void)
683 {
684 spi_unregister_driver(&pmic_driver);
685 }
686 module_exit(pmic_driver_exit);
687
688 MODULE_DESCRIPTION("TPS6524X PMIC Driver");
689 MODULE_AUTHOR("Cyril Chemparathy");
690 MODULE_LICENSE("GPL");
691 MODULE_ALIAS("spi:tps6524x");
692