poweroff: mxc_wd_reset isn't needed at all, in fact..
[efikamx:linux-kernel.git] / arch / arm / mach-mx5 / mx51_efikamx_pmic.c
1 /*
2  * mx51_efikamx_pmic.c  --  Efika MX Driver for Atlas MC13892 PMIC
3  */
4  /*
5   * Copyright 2009 Pegatron Corporation. All Rights Reserved.
6   * Copyright 2009-2011 Genesi USA, Inc. All Rights Reserved.
7   */
8
9  /*
10   * The code contained herein is licensed under the GNU General Public
11   * License. You may obtain a copy of the GNU General Public License
12   * Version 2 or later at the following locations:
13   *
14   * http://www.opensource.org/licenses/gpl-license.html
15   * http://www.gnu.org/copyleft/gpl.html
16   */
17
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/delay.h>
21 #include <linux/platform_device.h>
22 #include <linux/spi/spi.h>
23 #include <linux/err.h>
24 #include <linux/pmic_external.h>
25 #include <linux/regulator/machine.h>
26 #include <linux/mfd/mc13892/core.h>
27 #include <mach/irqs.h>
28 #include <asm/mach-types.h>
29
30 #include "devices.h"
31 #include "mx51_pins.h"
32 #include "iomux.h"
33
34 #include "mx51_efikamx.h"
35
36 /*
37  * Convenience conversion.
38  * Here atm, maybe there is somewhere better for this.
39  */
40 #define mV_to_uV(mV) (mV * 1000)
41 #define uV_to_mV(uV) (uV / 1000)
42 #define V_to_uV(V) (mV_to_uV(V * 1000))
43 #define uV_to_V(uV) (uV_to_mV(uV) / 1000)
44
45 /* Coin cell charger enable */
46 #define COINCHEN_LSH    23
47 #define COINCHEN_WID    1
48 /* Coin cell charger voltage setting */
49 #define VCOIN_LSH       20
50 #define VCOIN_WID       3
51
52 /* Coin Charger voltage */
53 #define VCOIN_2_5V      0x0
54 #define VCOIN_2_7V      0x1
55 #define VCOIN_2_8V      0x2
56 #define VCOIN_2_9V      0x3
57 #define VCOIN_3_0V      0x4
58 #define VCOIN_3_1V      0x5
59 #define VCOIN_3_2V      0x6
60 #define VCOIN_3_3V      0x7
61
62 /* Keeps VSRTC and CLK32KMCU on for all states */
63 #define DRM_LSH 4
64 #define DRM_WID 1
65
66 /* regulator standby mask */
67 #define GEN1_STBY_MASK          (1 << 1)
68 #define IOHI_STBY_MASK          (1 << 4)
69 #define DIG_STBY_MASK           (1 << 10)
70 #define GEN2_STBY_MASK          (1 << 13)
71 #define PLL_STBY_MASK           (1 << 16)
72 #define USB2_STBY_MASK          (1 << 19)
73
74 #define GEN3_STBY_MASK          (1 << 1)
75 #define CAM_STBY_MASK           (1 << 7)
76 #define VIDEO_STBY_MASK         (1 << 13)
77 #define AUDIO_STBY_MASK         (1 << 16)
78 #define SD_STBY_MASK            (1 << 19)
79
80 /* 0x92412 */
81 #define REG_MODE_0_ALL_MASK     (GEN1_STBY_MASK |\
82                                 DIG_STBY_MASK | GEN2_STBY_MASK |\
83                                 PLL_STBY_MASK)
84 /* 0x92082 */
85 #define REG_MODE_1_ALL_MASK     (CAM_STBY_MASK | VIDEO_STBY_MASK |\
86                                 AUDIO_STBY_MASK | SD_STBY_MASK)
87
88 /* switch mode setting */
89 #define SW1MODE_LSB     0
90 #define SW2MODE_LSB     10
91 #define SW3MODE_LSB     0
92 #define SW4MODE_LSB     8
93
94 #define SWMODE_MASK     0xF
95 #define SWMODE_AUTO     0x8
96
97 #define PWGT1SPIEN (1 << 15)
98 #define PWGT2SPIEN (1 << 16)
99 #define USEROFFSPI (1 << 3)
100
101
102 /* CPU */
103 static struct regulator_consumer_supply sw1_consumers[] = {
104         {
105                 .supply = "cpu_vcc",
106         }
107 };
108
109 static struct regulator_consumer_supply vdig_consumers[] = {
110         {
111                 /* sgtl5000 */
112                 .supply = "VDDA",
113                 .dev_name = "1-000a",
114         },
115         {
116                 /* sgtl5000 */
117                 .supply = "VDDD",
118                 .dev_name = "1-000a",
119         },
120 };
121
122 static struct regulator_consumer_supply vvideo_consumers[] = {
123         {
124                 /* sgtl5000 */
125                 .supply = "VDDIO",
126                 .dev_name = "1-000a",
127         },
128 };
129
130 struct mc13892;
131
132 static struct regulator_init_data sw1_init = {
133         .constraints = {
134                 .name = "SW1",
135                 .min_uV = mV_to_uV(600),
136                 .max_uV = mV_to_uV(1375),
137                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
138                 .valid_modes_mask = 0,
139                 .always_on = 1,
140                 .boot_on = 1,
141                 .initial_state = PM_SUSPEND_MEM,
142                 .state_mem = {
143                         .uV = 850000,
144                         .mode = REGULATOR_MODE_NORMAL,
145                         .enabled = 1,
146                 },
147         },
148         .num_consumer_supplies = ARRAY_SIZE(sw1_consumers),
149         .consumer_supplies = sw1_consumers,
150 };
151
152 static struct regulator_init_data sw2_init = {
153         .constraints = {
154                 .name = "SW2",
155                 .min_uV = mV_to_uV(900),
156                 .max_uV = mV_to_uV(1850),
157                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
158                 .always_on = 1,
159                 .boot_on = 1,
160                 .initial_state = PM_SUSPEND_MEM,
161                 .state_mem = {
162                         .uV = 950000,
163                         .mode = REGULATOR_MODE_NORMAL,
164                         .enabled = 1,
165                 },
166         }
167 };
168
169 static struct regulator_init_data sw3_init = {
170         .constraints = {
171                 .name = "SW3",
172                 .min_uV = mV_to_uV(1100),
173                 .max_uV = mV_to_uV(1850),
174                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
175                 .always_on = 1,
176                 .boot_on = 1,
177         }
178 };
179
180 static struct regulator_init_data sw4_init = {
181         .constraints = {
182                 .name = "SW4",
183                 .min_uV = mV_to_uV(1100),
184                 .max_uV = mV_to_uV(1850),
185                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
186                 .always_on = 1,
187                 .boot_on = 1,
188         }
189 };
190
191 static struct regulator_init_data viohi_init = {
192         .constraints = {
193                 .name = "VIOHI",
194                 .boot_on = 1,
195                 .always_on = 1,
196         }
197 };
198
199 static struct regulator_init_data vusb_init = {
200         .constraints = {
201                 .name = "VUSB",
202                 .boot_on = 1,
203                 .always_on = 1,
204         }
205 };
206
207 static struct regulator_init_data swbst_init = {
208         .constraints = {
209                 .name = "SWBST",
210         }
211 };
212
213 static struct regulator_init_data vdig_init = {
214         .constraints = {
215                 .name = "VDIG",
216                 .min_uV = mV_to_uV(1650),
217                 .max_uV = mV_to_uV(1650),
218                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
219                 .boot_on = 1,
220         },
221         .num_consumer_supplies = ARRAY_SIZE(vdig_consumers),
222         .consumer_supplies = vdig_consumers,
223 };
224
225 static struct regulator_init_data vpll_init = {
226         .constraints = {
227                 .name = "VPLL",
228                 .min_uV = mV_to_uV(1050),
229                 .max_uV = mV_to_uV(1800),
230                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
231                 .boot_on = 1,
232                 .always_on = 1,
233         }
234 };
235
236 static struct regulator_init_data vusb2_init = {
237         .constraints = {
238                 .name = "VUSB2",
239                 .min_uV = mV_to_uV(2400),
240                 .max_uV = mV_to_uV(2775),
241                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
242                 .boot_on = 1,
243                 .always_on = 1,
244         }
245 };
246
247 static struct regulator_init_data vvideo_init = {
248         .constraints = {
249                 .name = "VVIDEO",
250                 .min_uV = mV_to_uV(2775),
251                 .max_uV = mV_to_uV(2775),
252                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
253                 .always_on = 1,
254                 .apply_uV =1,
255         },
256         .num_consumer_supplies = ARRAY_SIZE(vvideo_consumers),
257         .consumer_supplies = vvideo_consumers,
258 };
259
260 static struct regulator_init_data vaudio_init = {
261         .constraints = {
262                 .name = "VAUDIO",
263                 .min_uV = mV_to_uV(2300),
264                 .max_uV = mV_to_uV(3000),
265                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
266         }
267 };
268
269 static struct regulator_init_data vsd_init = {
270         .constraints = {
271                 .name = "VSD",
272                 .min_uV = mV_to_uV(1800),
273                 .max_uV = mV_to_uV(3150),
274                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
275         }
276 };
277
278 static struct regulator_init_data vcam_init = {
279         .constraints = {
280                 .name = "VCAM",
281                 .min_uV = mV_to_uV(2500),
282                 .max_uV = mV_to_uV(3000),
283                 .valid_ops_mask =
284                         REGULATOR_CHANGE_VOLTAGE | REGULATOR_CHANGE_MODE,
285                 .valid_modes_mask = REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL,
286         }
287 };
288
289 static struct regulator_init_data vgen1_init = {
290         .constraints = {
291                 .name = "VGEN1",
292                 .min_uV = mV_to_uV(1200),
293                 .max_uV = mV_to_uV(3150),
294                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
295         }
296 };
297
298 static struct regulator_init_data vgen2_init = {
299         .constraints = {
300                 .name = "VGEN2",
301                 .min_uV = mV_to_uV(1200),
302                 .max_uV = mV_to_uV(3150),
303                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
304                 .always_on = 1,
305         }
306 };
307
308 static struct regulator_init_data vgen3_init = {
309         .constraints = {
310                 .name = "VGEN3",
311                 .min_uV = mV_to_uV(1800),
312                 .max_uV = mV_to_uV(2900),
313                 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
314                 .always_on = 1,
315         }
316 };
317
318 static struct regulator_init_data gpo1_init = {
319         .constraints = {
320                 .name = "GPO1",
321         }
322 };
323
324 static struct regulator_init_data gpo2_init = {
325         .constraints = {
326                 .name = "GPO2",
327         }
328 };
329
330 static struct regulator_init_data gpo3_init = {
331         .constraints = {
332                 .name = "GPO3",
333         }
334 };
335
336 static struct regulator_init_data gpo4_init = {
337         .constraints = {
338                 .name = "GPO4",
339         }
340 };
341
342 static int mc13892_regulator_init(struct mc13892 *mc13892)
343 {
344         unsigned int value, register_mask;
345
346         printk("Initializing regulators for Efika MX\n");
347         if (mxc_cpu_is_rev(CHIP_REV_2_0) < 0)
348                 sw2_init.constraints.state_mem.uV = 1100000;
349         else if (mxc_cpu_is_rev(CHIP_REV_2_0) == 1) {
350                 sw2_init.constraints.state_mem.uV = 1250000;
351                 sw1_init.constraints.state_mem.uV = 1000000;
352         }
353
354         /* enable standby controll for all regulators */
355         pmic_read_reg(REG_MODE_0, &value, 0xffffff);
356         value |= REG_MODE_0_ALL_MASK;
357         pmic_write_reg(REG_MODE_0, value, 0xffffff);
358
359         pmic_read_reg(REG_MODE_1, &value, 0xffffff);
360         value |= REG_MODE_1_ALL_MASK;
361         pmic_write_reg(REG_MODE_1, value, 0xffffff);
362
363         /* enable switch auto mode (ENGR00120510 ENGR00121057) */
364         pmic_read_reg(REG_IDENTIFICATION, &value, 0xffffff);
365         /* only for mc13892 2.0A */
366         if ((value & 0x0000FFFF) == 0x45d0) {
367                 pmic_read_reg(REG_SW_4, &value, 0xffffff);
368                 register_mask = (SWMODE_MASK << SW1MODE_LSB) |
369                        (SWMODE_MASK << SW2MODE_LSB);
370                 value &= ~register_mask;
371                 value |= (SWMODE_AUTO << SW1MODE_LSB) |
372                         (SWMODE_AUTO << SW2MODE_LSB);
373                 pmic_write_reg(REG_SW_4, value, 0xffffff);
374
375                 pmic_read_reg(REG_SW_5, &value, 0xffffff);
376                 register_mask = (SWMODE_MASK << SW3MODE_LSB) |
377                         (SWMODE_MASK << SW4MODE_LSB);
378                 value &= ~register_mask;
379                 value |= (SWMODE_AUTO << SW3MODE_LSB) |
380                         (SWMODE_AUTO << SW4MODE_LSB);
381                 pmic_write_reg(REG_SW_5, value, 0xffffff);
382         }
383
384         if (machine_is_mx51_efikamx()) {
385                 /* Enable coin cell charger */
386                 value = BITFVAL(COINCHEN, 1) | BITFVAL(VCOIN, VCOIN_3_0V);
387                 register_mask = BITFMASK(COINCHEN) | BITFMASK(VCOIN);
388                 pmic_write_reg(REG_POWER_CTL0, value, register_mask);
389         }
390
391 #if defined(CONFIG_RTC_DRV_MXC_V2) || defined(CONFIG_RTC_DRV_MXC_V2_MODULE)
392         value = BITFVAL(DRM, 1);
393         register_mask = BITFMASK(DRM);
394         pmic_write_reg(REG_POWER_CTL0, value, register_mask);
395 #endif
396
397         mc13892_register_regulator(mc13892, MC13892_SW1, &sw1_init);
398         mc13892_register_regulator(mc13892, MC13892_SW2, &sw2_init);
399         mc13892_register_regulator(mc13892, MC13892_SW3, &sw3_init);
400         mc13892_register_regulator(mc13892, MC13892_SW4, &sw4_init);
401         mc13892_register_regulator(mc13892, MC13892_SWBST, &swbst_init);
402         mc13892_register_regulator(mc13892, MC13892_VIOHI, &viohi_init);
403         mc13892_register_regulator(mc13892, MC13892_VPLL, &vpll_init);
404         mc13892_register_regulator(mc13892, MC13892_VDIG, &vdig_init);
405         mc13892_register_regulator(mc13892, MC13892_VSD, &vsd_init);
406         mc13892_register_regulator(mc13892, MC13892_VUSB2, &vusb2_init);
407         mc13892_register_regulator(mc13892, MC13892_VVIDEO, &vvideo_init);
408         mc13892_register_regulator(mc13892, MC13892_VAUDIO, &vaudio_init);
409         mc13892_register_regulator(mc13892, MC13892_VCAM, &vcam_init);
410         mc13892_register_regulator(mc13892, MC13892_VGEN1, &vgen1_init);
411         mc13892_register_regulator(mc13892, MC13892_VGEN2, &vgen2_init);
412         mc13892_register_regulator(mc13892, MC13892_VGEN3, &vgen3_init);
413         mc13892_register_regulator(mc13892, MC13892_VUSB, &vusb_init);
414         mc13892_register_regulator(mc13892, MC13892_GPO1, &gpo1_init);
415         mc13892_register_regulator(mc13892, MC13892_GPO2, &gpo2_init);
416         mc13892_register_regulator(mc13892, MC13892_GPO3, &gpo3_init);
417         mc13892_register_regulator(mc13892, MC13892_GPO4, &gpo4_init);
418
419 //      regulator_has_full_constraints();
420
421         return 0;
422 }
423
424 static struct mc13892_platform_data mc13892_plat = {
425         .init = mc13892_regulator_init,
426 };
427
428 #define EFIKAMX_PMIC_INTERRUPT  MX51_PIN_GPIO1_6
429
430 static struct spi_board_info __initdata mc13892_spi_device[] = {
431         {
432         .modalias = "pmic_spi",
433         .irq = IOMUX_TO_IRQ(EFIKAMX_PMIC_INTERRUPT),
434         .platform_data = &mc13892_plat,
435         .chip_select = 0,
436 #if defined(CONFIG_SPI_GPIO)
437         .bus_num = 0,
438         .mode = SPI_CS_HIGH,
439         .controller_data = (void *) IOMUX_TO_GPIO(MX51_PIN_CSPI1_SS0),
440 #elif defined(CONFIG_SPI_IMX)
441         .bus_num = 0,
442         .mode = SPI_CS_HIGH,
443 #elif defined(CONFIG_SPI_MXC)
444         .bus_num = 1,
445 #endif
446         .max_speed_hz = 1000000,        /* max spi SCK clock speed in HZ */
447         },
448 };
449
450
451 static struct mxc_iomux_pin_cfg __initdata mx51_efikamx_pmic_iomux_pins[] = {
452         {
453          EFIKAMX_PMIC_INTERRUPT, IOMUX_CONFIG_GPIO | IOMUX_CONFIG_SION,
454           (PAD_CTL_SRE_SLOW | PAD_CTL_DRV_MEDIUM | PAD_CTL_100K_PU |
455           PAD_CTL_HYS_ENABLE | PAD_CTL_DRV_VOT_HIGH),
456          },
457 };
458
459 #define EFIKAMX_WATCHDOG_REBOOT MX51_PIN_DI1_PIN13
460 #define EFIKASB_WATCHDOG_REBOOT MX51_PIN_GPIO1_4
461
462 static struct mxc_iomux_pin_cfg __initdata mx51_efikamx_watchdog_pins[] = {
463         { EFIKAMX_WATCHDOG_REBOOT, IOMUX_CONFIG_GPIO, },
464 };
465
466 static struct mxc_iomux_pin_cfg __initdata mx51_efikasb_watchdog_pins[] = {
467         { EFIKASB_WATCHDOG_REBOOT, IOMUX_CONFIG_GPIO, },
468 };
469
470 #define EFIKASB_POWERGOOD       MX51_PIN_CSI2_PIXCLK
471 static struct mxc_iomux_pin_cfg __initdata mx51_efikasb_power_pins[] = {
472         { EFIKASB_POWERGOOD, IOMUX_CONFIG_GPIO, },
473 };
474
475 int __init mx51_efikamx_init_pmic(void)
476 {
477         CONFIG_IOMUX(mx51_efikamx_pmic_iomux_pins);
478
479         /* disable power gating for some reason */
480         pmic_write_reg(REG_POWER_MISC, ~(PWGT1SPIEN|PWGT2SPIEN), (PWGT1SPIEN|PWGT2SPIEN));
481
482         if (machine_is_mx51_efikamx() && (mx51_efikamx_revision() == 1)) {
483                 CONFIG_IOMUX(mx51_efikamx_watchdog_pins);
484
485                 gpio_free(IOMUX_TO_GPIO(EFIKAMX_WATCHDOG_REBOOT));
486                 gpio_request(IOMUX_TO_GPIO(EFIKAMX_WATCHDOG_REBOOT), "sys:reboot");
487                 gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_WATCHDOG_REBOOT), 1);
488         } else {
489                 CONFIG_IOMUX(mx51_efikasb_watchdog_pins);
490
491                 gpio_free(IOMUX_TO_GPIO(EFIKASB_WATCHDOG_REBOOT));
492                 gpio_request(IOMUX_TO_GPIO(EFIKASB_WATCHDOG_REBOOT), "sys:reboot");
493                 gpio_direction_output(IOMUX_TO_GPIO(EFIKASB_WATCHDOG_REBOOT), 1);
494
495                 if (machine_is_mx51_efikasb()) {
496                         CONFIG_IOMUX(mx51_efikasb_power_pins);
497
498                         gpio_free(IOMUX_TO_GPIO(EFIKASB_POWERGOOD));
499                         gpio_request(IOMUX_TO_GPIO(EFIKASB_POWERGOOD), "sys:powergood");
500                         gpio_direction_input(IOMUX_TO_GPIO(EFIKASB_POWERGOOD));
501                 }
502         }
503
504         return spi_register_board_info(mc13892_spi_device, ARRAY_SIZE(mc13892_spi_device));
505 }
506
507 int mx51_efikamx_reboot(void)
508 {
509         if ( machine_is_mx51_efikamx() && (mx51_efikamx_revision() == 1) ) /* board rev1.1 */
510                 gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_WATCHDOG_REBOOT), 0);
511         else
512                 gpio_direction_output(IOMUX_TO_GPIO(EFIKASB_WATCHDOG_REBOOT), 0);
513
514         return 0;
515 }
516
517 #define EFIKAMX_POWEROFF MX51_PIN_CSI2_VSYNC
518 #define EFIKAMX_USB_PHY_RESET   MX51_PIN_EIM_D27
519
520 void mx51_efikamx_power_off(void)
521 {
522         /* hold USB phy to ransom */
523         /* TODO: put this back into _usb.c */
524         gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_USB_PHY_RESET), 0);
525
526         /* Set the power gate bits to power down */
527         pmic_write_reg(REG_POWER_MISC, (PWGT1SPIEN|PWGT2SPIEN), (PWGT1SPIEN|PWGT2SPIEN));
528
529         mxc_request_iomux(IOMUX_TO_GPIO(EFIKAMX_POWEROFF), IOMUX_CONFIG_GPIO);
530         gpio_request(IOMUX_TO_GPIO(EFIKAMX_POWEROFF), "sys:poweroff");
531         gpio_direction_output(IOMUX_TO_GPIO(EFIKAMX_POWEROFF), 0);
532         msleep(10);
533         gpio_set_value(IOMUX_TO_GPIO(EFIKAMX_POWEROFF), 1);
534 }