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