~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm/mach-omap2/twl-common.c

Version: ~ [ linux-5.9-rc5 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp