1 /*
2 * twl-common.c
3 *
4 * Copyright (C) 2011 Texas Instruments, Inc..
5 * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * version 2 as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
19 * 02110-1301 USA
20 *
21 */
22
23 #include <linux/i2c.h>
24 #include <linux/i2c/twl.h>
25 #include <linux/gpio.h>
26 #include <linux/string.h>
27 #include <linux/regulator/machine.h>
28 #include <linux/regulator/fixed.h>
29
30 #include "soc.h"
31 #include "twl-common.h"
32 #include "pm.h"
33 #include "voltage.h"
34 #include "mux.h"
35
36 static struct i2c_board_info __initdata pmic_i2c_board_info = {
37 .addr = 0x48,
38 .flags = I2C_CLIENT_WAKE,
39 };
40
41 #if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
twl_set_voltage(void * data,int target_uV)42 static int twl_set_voltage(void *data, int target_uV)
43 {
44 struct voltagedomain *voltdm = (struct voltagedomain *)data;
45 return voltdm_scale(voltdm, target_uV);
46 }
47
twl_get_voltage(void * data)48 static int twl_get_voltage(void *data)
49 {
50 struct voltagedomain *voltdm = (struct voltagedomain *)data;
51 return voltdm_get_voltage(voltdm);
52 }
53 #endif
54
omap_pmic_init(int bus,u32 clkrate,const char * pmic_type,int pmic_irq,struct twl4030_platform_data * pmic_data)55 void __init omap_pmic_init(int bus, u32 clkrate,
56 const char *pmic_type, int pmic_irq,
57 struct twl4030_platform_data *pmic_data)
58 {
59 omap_mux_init_signal("sys_nirq", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
60 strlcpy(pmic_i2c_board_info.type, pmic_type,
61 sizeof(pmic_i2c_board_info.type));
62 pmic_i2c_board_info.irq = pmic_irq;
63 pmic_i2c_board_info.platform_data = pmic_data;
64
65 omap_register_i2c_bus(bus, clkrate, &pmic_i2c_board_info, 1);
66 }
67
omap4_pmic_init(const char * pmic_type,struct twl4030_platform_data * pmic_data,struct i2c_board_info * devices,int nr_devices)68 void __init omap4_pmic_init(const char *pmic_type,
69 struct twl4030_platform_data *pmic_data,
70 struct i2c_board_info *devices, int nr_devices)
71 {
72 /* PMIC part*/
73 omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
74 omap_mux_init_signal("fref_clk0_out.sys_drm_msecure", OMAP_PIN_OUTPUT);
75 omap_pmic_init(1, 400, pmic_type, 7 + OMAP44XX_IRQ_GIC_START, pmic_data);
76
77 /* Register additional devices on i2c1 bus if needed */
78 if (devices)
79 i2c_register_board_info(1, devices, nr_devices);
80 }
81
omap_pmic_late_init(void)82 void __init omap_pmic_late_init(void)
83 {
84 /* Init the OMAP TWL parameters (if PMIC has been registerd) */
85 if (!pmic_i2c_board_info.irq)
86 return;
87
88 omap3_twl_init();
89 omap4_twl_init();
90 }
91
92 #if defined(CONFIG_ARCH_OMAP3)
93 static struct twl4030_usb_data omap3_usb_pdata = {
94 .usb_mode = T2_USB_MODE_ULPI,
95 };
96
97 static int omap3_batt_table[] = {
98 /* 0 C */
99 30800, 29500, 28300, 27100,
100 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
101 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
102 11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
103 8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
104 5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
105 4040, 3910, 3790, 3670, 3550
106 };
107
108 static struct twl4030_bci_platform_data omap3_bci_pdata = {
109 .battery_tmp_tbl = omap3_batt_table,
110 .tblsize = ARRAY_SIZE(omap3_batt_table),
111 };
112
113 static struct twl4030_madc_platform_data omap3_madc_pdata = {
114 .irq_line = 1,
115 };
116
117 static struct twl4030_codec_data omap3_codec;
118
119 static struct twl4030_audio_data omap3_audio_pdata = {
120 .audio_mclk = 26000000,
121 .codec = &omap3_codec,
122 };
123
124 static struct regulator_consumer_supply omap3_vdda_dac_supplies[] = {
125 REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
126 };
127
128 static struct regulator_init_data omap3_vdac_idata = {
129 .constraints = {
130 .min_uV = 1800000,
131 .max_uV = 1800000,
132 .valid_modes_mask = REGULATOR_MODE_NORMAL
133 | REGULATOR_MODE_STANDBY,
134 .valid_ops_mask = REGULATOR_CHANGE_MODE
135 | REGULATOR_CHANGE_STATUS,
136 },
137 .num_consumer_supplies = ARRAY_SIZE(omap3_vdda_dac_supplies),
138 .consumer_supplies = omap3_vdda_dac_supplies,
139 };
140
141 static struct regulator_consumer_supply omap3_vpll2_supplies[] = {
142 REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
143 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
144 };
145
146 static struct regulator_init_data omap3_vpll2_idata = {
147 .constraints = {
148 .min_uV = 1800000,
149 .max_uV = 1800000,
150 .valid_modes_mask = REGULATOR_MODE_NORMAL
151 | REGULATOR_MODE_STANDBY,
152 .valid_ops_mask = REGULATOR_CHANGE_MODE
153 | REGULATOR_CHANGE_STATUS,
154 },
155 .num_consumer_supplies = ARRAY_SIZE(omap3_vpll2_supplies),
156 .consumer_supplies = omap3_vpll2_supplies,
157 };
158
159 static struct regulator_consumer_supply omap3_vdd1_supply[] = {
160 REGULATOR_SUPPLY("vcc", "cpu0"),
161 };
162
163 static struct regulator_consumer_supply omap3_vdd2_supply[] = {
164 REGULATOR_SUPPLY("vcc", "l3_main.0"),
165 };
166
167 static struct regulator_init_data omap3_vdd1 = {
168 .constraints = {
169 .name = "vdd_mpu_iva",
170 .min_uV = 600000,
171 .max_uV = 1450000,
172 .valid_modes_mask = REGULATOR_MODE_NORMAL,
173 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
174 },
175 .num_consumer_supplies = ARRAY_SIZE(omap3_vdd1_supply),
176 .consumer_supplies = omap3_vdd1_supply,
177 };
178
179 static struct regulator_init_data omap3_vdd2 = {
180 .constraints = {
181 .name = "vdd_core",
182 .min_uV = 600000,
183 .max_uV = 1450000,
184 .valid_modes_mask = REGULATOR_MODE_NORMAL,
185 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
186 },
187 .num_consumer_supplies = ARRAY_SIZE(omap3_vdd2_supply),
188 .consumer_supplies = omap3_vdd2_supply,
189 };
190
191 static struct twl_regulator_driver_data omap3_vdd1_drvdata = {
192 .get_voltage = twl_get_voltage,
193 .set_voltage = twl_set_voltage,
194 };
195
196 static struct twl_regulator_driver_data omap3_vdd2_drvdata = {
197 .get_voltage = twl_get_voltage,
198 .set_voltage = twl_set_voltage,
199 };
200
omap3_pmic_get_config(struct twl4030_platform_data * pmic_data,u32 pdata_flags,u32 regulators_flags)201 void __init omap3_pmic_get_config(struct twl4030_platform_data *pmic_data,
202 u32 pdata_flags, u32 regulators_flags)
203 {
204 if (!pmic_data->vdd1) {
205 omap3_vdd1.driver_data = &omap3_vdd1_drvdata;
206 omap3_vdd1_drvdata.data = voltdm_lookup("mpu_iva");
207 pmic_data->vdd1 = &omap3_vdd1;
208 }
209 if (!pmic_data->vdd2) {
210 omap3_vdd2.driver_data = &omap3_vdd2_drvdata;
211 omap3_vdd2_drvdata.data = voltdm_lookup("core");
212 pmic_data->vdd2 = &omap3_vdd2;
213 }
214
215 /* Common platform data configurations */
216 if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
217 pmic_data->usb = &omap3_usb_pdata;
218
219 if (pdata_flags & TWL_COMMON_PDATA_BCI && !pmic_data->bci)
220 pmic_data->bci = &omap3_bci_pdata;
221
222 if (pdata_flags & TWL_COMMON_PDATA_MADC && !pmic_data->madc)
223 pmic_data->madc = &omap3_madc_pdata;
224
225 if (pdata_flags & TWL_COMMON_PDATA_AUDIO && !pmic_data->audio)
226 pmic_data->audio = &omap3_audio_pdata;
227
228 /* Common regulator configurations */
229 if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
230 pmic_data->vdac = &omap3_vdac_idata;
231
232 if (regulators_flags & TWL_COMMON_REGULATOR_VPLL2 && !pmic_data->vpll2)
233 pmic_data->vpll2 = &omap3_vpll2_idata;
234 }
235 #endif /* CONFIG_ARCH_OMAP3 */
236
237 #if defined(CONFIG_ARCH_OMAP4)
238 static struct twl4030_usb_data omap4_usb_pdata = {
239 };
240
241 static struct regulator_consumer_supply omap4_vdda_hdmi_dac_supplies[] = {
242 REGULATOR_SUPPLY("vdda_hdmi_dac", "omapdss_hdmi"),
243 };
244
245 static struct regulator_init_data omap4_vdac_idata = {
246 .constraints = {
247 .min_uV = 1800000,
248 .max_uV = 1800000,
249 .valid_modes_mask = REGULATOR_MODE_NORMAL
250 | REGULATOR_MODE_STANDBY,
251 .valid_ops_mask = REGULATOR_CHANGE_MODE
252 | REGULATOR_CHANGE_STATUS,
253 },
254 .num_consumer_supplies = ARRAY_SIZE(omap4_vdda_hdmi_dac_supplies),
255 .consumer_supplies = omap4_vdda_hdmi_dac_supplies,
256 .supply_regulator = "V2V1",
257 };
258
259 static struct regulator_init_data omap4_vaux2_idata = {
260 .constraints = {
261 .min_uV = 1200000,
262 .max_uV = 2800000,
263 .apply_uV = true,
264 .valid_modes_mask = REGULATOR_MODE_NORMAL
265 | REGULATOR_MODE_STANDBY,
266 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
267 | REGULATOR_CHANGE_MODE
268 | REGULATOR_CHANGE_STATUS,
269 },
270 };
271
272 static struct regulator_init_data omap4_vaux3_idata = {
273 .constraints = {
274 .min_uV = 1000000,
275 .max_uV = 3000000,
276 .apply_uV = true,
277 .valid_modes_mask = REGULATOR_MODE_NORMAL
278 | REGULATOR_MODE_STANDBY,
279 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
280 | REGULATOR_CHANGE_MODE
281 | REGULATOR_CHANGE_STATUS,
282 },
283 };
284
285 static struct regulator_consumer_supply omap4_vmmc_supply[] = {
286 REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
287 };
288
289 /* VMMC1 for MMC1 card */
290 static struct regulator_init_data omap4_vmmc_idata = {
291 .constraints = {
292 .min_uV = 1200000,
293 .max_uV = 3000000,
294 .apply_uV = true,
295 .valid_modes_mask = REGULATOR_MODE_NORMAL
296 | REGULATOR_MODE_STANDBY,
297 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
298 | REGULATOR_CHANGE_MODE
299 | REGULATOR_CHANGE_STATUS,
300 },
301 .num_consumer_supplies = ARRAY_SIZE(omap4_vmmc_supply),
302 .consumer_supplies = omap4_vmmc_supply,
303 };
304
305 static struct regulator_init_data omap4_vpp_idata = {
306 .constraints = {
307 .min_uV = 1800000,
308 .max_uV = 2500000,
309 .apply_uV = true,
310 .valid_modes_mask = REGULATOR_MODE_NORMAL
311 | REGULATOR_MODE_STANDBY,
312 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
313 | REGULATOR_CHANGE_MODE
314 | REGULATOR_CHANGE_STATUS,
315 },
316 };
317
318 static struct regulator_init_data omap4_vana_idata = {
319 .constraints = {
320 .min_uV = 2100000,
321 .max_uV = 2100000,
322 .valid_modes_mask = REGULATOR_MODE_NORMAL
323 | REGULATOR_MODE_STANDBY,
324 .valid_ops_mask = REGULATOR_CHANGE_MODE
325 | REGULATOR_CHANGE_STATUS,
326 },
327 };
328
329 static struct regulator_consumer_supply omap4_vcxio_supply[] = {
330 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dss"),
331 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
332 REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.1"),
333 };
334
335 static struct regulator_init_data omap4_vcxio_idata = {
336 .constraints = {
337 .min_uV = 1800000,
338 .max_uV = 1800000,
339 .valid_modes_mask = REGULATOR_MODE_NORMAL
340 | REGULATOR_MODE_STANDBY,
341 .valid_ops_mask = REGULATOR_CHANGE_MODE
342 | REGULATOR_CHANGE_STATUS,
343 .always_on = true,
344 },
345 .num_consumer_supplies = ARRAY_SIZE(omap4_vcxio_supply),
346 .consumer_supplies = omap4_vcxio_supply,
347 .supply_regulator = "V2V1",
348 };
349
350 static struct regulator_init_data omap4_vusb_idata = {
351 .constraints = {
352 .min_uV = 3300000,
353 .max_uV = 3300000,
354 .valid_modes_mask = REGULATOR_MODE_NORMAL
355 | REGULATOR_MODE_STANDBY,
356 .valid_ops_mask = REGULATOR_CHANGE_MODE
357 | REGULATOR_CHANGE_STATUS,
358 },
359 };
360
361 static struct regulator_init_data omap4_clk32kg_idata = {
362 .constraints = {
363 .valid_ops_mask = REGULATOR_CHANGE_STATUS,
364 },
365 };
366
367 static struct regulator_consumer_supply omap4_vdd1_supply[] = {
368 REGULATOR_SUPPLY("vcc", "cpu0"),
369 };
370
371 static struct regulator_consumer_supply omap4_vdd2_supply[] = {
372 REGULATOR_SUPPLY("vcc", "iva.0"),
373 };
374
375 static struct regulator_consumer_supply omap4_vdd3_supply[] = {
376 REGULATOR_SUPPLY("vcc", "l3_main.0"),
377 };
378
379 static struct regulator_init_data omap4_vdd1 = {
380 .constraints = {
381 .name = "vdd_mpu",
382 .min_uV = 500000,
383 .max_uV = 1500000,
384 .valid_modes_mask = REGULATOR_MODE_NORMAL,
385 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
386 },
387 .num_consumer_supplies = ARRAY_SIZE(omap4_vdd1_supply),
388 .consumer_supplies = omap4_vdd1_supply,
389 };
390
391 static struct regulator_init_data omap4_vdd2 = {
392 .constraints = {
393 .name = "vdd_iva",
394 .min_uV = 500000,
395 .max_uV = 1500000,
396 .valid_modes_mask = REGULATOR_MODE_NORMAL,
397 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
398 },
399 .num_consumer_supplies = ARRAY_SIZE(omap4_vdd2_supply),
400 .consumer_supplies = omap4_vdd2_supply,
401 };
402
403 static struct regulator_init_data omap4_vdd3 = {
404 .constraints = {
405 .name = "vdd_core",
406 .min_uV = 500000,
407 .max_uV = 1500000,
408 .valid_modes_mask = REGULATOR_MODE_NORMAL,
409 .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
410 },
411 .num_consumer_supplies = ARRAY_SIZE(omap4_vdd3_supply),
412 .consumer_supplies = omap4_vdd3_supply,
413 };
414
415
416 static struct twl_regulator_driver_data omap4_vdd1_drvdata = {
417 .get_voltage = twl_get_voltage,
418 .set_voltage = twl_set_voltage,
419 };
420
421 static struct twl_regulator_driver_data omap4_vdd2_drvdata = {
422 .get_voltage = twl_get_voltage,
423 .set_voltage = twl_set_voltage,
424 };
425
426 static struct twl_regulator_driver_data omap4_vdd3_drvdata = {
427 .get_voltage = twl_get_voltage,
428 .set_voltage = twl_set_voltage,
429 };
430
431 static struct regulator_consumer_supply omap4_v1v8_supply[] = {
432 REGULATOR_SUPPLY("vio", "1-004b"),
433 };
434
435 static struct regulator_init_data omap4_v1v8_idata = {
436 .constraints = {
437 .min_uV = 1800000,
438 .max_uV = 1800000,
439 .valid_modes_mask = REGULATOR_MODE_NORMAL
440 | REGULATOR_MODE_STANDBY,
441 .valid_ops_mask = REGULATOR_CHANGE_MODE
442 | REGULATOR_CHANGE_STATUS,
443 .always_on = true,
444 },
445 .num_consumer_supplies = ARRAY_SIZE(omap4_v1v8_supply),
446 .consumer_supplies = omap4_v1v8_supply,
447 };
448
449 static struct regulator_consumer_supply omap4_v2v1_supply[] = {
450 REGULATOR_SUPPLY("v2v1", "1-004b"),
451 };
452
453 static struct regulator_init_data omap4_v2v1_idata = {
454 .constraints = {
455 .min_uV = 2100000,
456 .max_uV = 2100000,
457 .valid_modes_mask = REGULATOR_MODE_NORMAL
458 | REGULATOR_MODE_STANDBY,
459 .valid_ops_mask = REGULATOR_CHANGE_MODE
460 | REGULATOR_CHANGE_STATUS,
461 },
462 .num_consumer_supplies = ARRAY_SIZE(omap4_v2v1_supply),
463 .consumer_supplies = omap4_v2v1_supply,
464 };
465
omap4_pmic_get_config(struct twl4030_platform_data * pmic_data,u32 pdata_flags,u32 regulators_flags)466 void __init omap4_pmic_get_config(struct twl4030_platform_data *pmic_data,
467 u32 pdata_flags, u32 regulators_flags)
468 {
469 if (!pmic_data->vdd1) {
470 omap4_vdd1.driver_data = &omap4_vdd1_drvdata;
471 omap4_vdd1_drvdata.data = voltdm_lookup("mpu");
472 pmic_data->vdd1 = &omap4_vdd1;
473 }
474
475 if (!pmic_data->vdd2) {
476 omap4_vdd2.driver_data = &omap4_vdd2_drvdata;
477 omap4_vdd2_drvdata.data = voltdm_lookup("iva");
478 pmic_data->vdd2 = &omap4_vdd2;
479 }
480
481 if (!pmic_data->vdd3) {
482 omap4_vdd3.driver_data = &omap4_vdd3_drvdata;
483 omap4_vdd3_drvdata.data = voltdm_lookup("core");
484 pmic_data->vdd3 = &omap4_vdd3;
485 }
486
487 /* Common platform data configurations */
488 if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
489 pmic_data->usb = &omap4_usb_pdata;
490
491 /* Common regulator configurations */
492 if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
493 pmic_data->vdac = &omap4_vdac_idata;
494
495 if (regulators_flags & TWL_COMMON_REGULATOR_VAUX2 && !pmic_data->vaux2)
496 pmic_data->vaux2 = &omap4_vaux2_idata;
497
498 if (regulators_flags & TWL_COMMON_REGULATOR_VAUX3 && !pmic_data->vaux3)
499 pmic_data->vaux3 = &omap4_vaux3_idata;
500
501 if (regulators_flags & TWL_COMMON_REGULATOR_VMMC && !pmic_data->vmmc)
502 pmic_data->vmmc = &omap4_vmmc_idata;
503
504 if (regulators_flags & TWL_COMMON_REGULATOR_VPP && !pmic_data->vpp)
505 pmic_data->vpp = &omap4_vpp_idata;
506
507 if (regulators_flags & TWL_COMMON_REGULATOR_VANA && !pmic_data->vana)
508 pmic_data->vana = &omap4_vana_idata;
509
510 if (regulators_flags & TWL_COMMON_REGULATOR_VCXIO && !pmic_data->vcxio)
511 pmic_data->vcxio = &omap4_vcxio_idata;
512
513 if (regulators_flags & TWL_COMMON_REGULATOR_VUSB && !pmic_data->vusb)
514 pmic_data->vusb = &omap4_vusb_idata;
515
516 if (regulators_flags & TWL_COMMON_REGULATOR_CLK32KG &&
517 !pmic_data->clk32kg)
518 pmic_data->clk32kg = &omap4_clk32kg_idata;
519
520 if (regulators_flags & TWL_COMMON_REGULATOR_V1V8 && !pmic_data->v1v8)
521 pmic_data->v1v8 = &omap4_v1v8_idata;
522
523 if (regulators_flags & TWL_COMMON_REGULATOR_V2V1 && !pmic_data->v2v1)
524 pmic_data->v2v1 = &omap4_v2v1_idata;
525 }
526 #endif /* CONFIG_ARCH_OMAP4 */
527
528 #if defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030) || \
529 defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030_MODULE)
530 #include <linux/platform_data/omap-twl4030.h>
531
532 /* Commonly used configuration */
533 static struct omap_tw4030_pdata omap_twl4030_audio_data;
534
535 static struct platform_device audio_device = {
536 .name = "omap-twl4030",
537 .id = -1,
538 };
539
omap_twl4030_audio_init(char * card_name,struct omap_tw4030_pdata * pdata)540 void omap_twl4030_audio_init(char *card_name,
541 struct omap_tw4030_pdata *pdata)
542 {
543 if (!pdata)
544 pdata = &omap_twl4030_audio_data;
545
546 pdata->card_name = card_name;
547
548 audio_device.dev.platform_data = pdata;
549 platform_device_register(&audio_device);
550 }
551
552 #else /* SOC_OMAP_TWL4030 */
omap_twl4030_audio_init(char * card_name,struct omap_tw4030_pdata * pdata)553 void omap_twl4030_audio_init(char *card_name,
554 struct omap_tw4030_pdata *pdata)
555 {
556 return;
557 }
558 #endif /* SOC_OMAP_TWL4030 */
559