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