ARM: tegra11: use mW values for battery EDP states
[linux-2.6.git] / arch / arm / mach-tegra / board-pluto-sensors.c
1 /*
2  * arch/arm/mach-tegra/board-pluto-sensors.c
3  *
4  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
5
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 #include <linux/i2c.h>
19 #include <linux/delay.h>
20 #include <linux/regulator/consumer.h>
21 #include <linux/gpio.h>
22 #include <linux/mpu.h>
23 #include <linux/max77665-charger.h>
24 #include <linux/mfd/max77665.h>
25 #include <linux/input/max77665-haptic.h>
26 #include <linux/power/max17042_battery.h>
27 #include <linux/nct1008.h>
28 #include <linux/interrupt.h>
29 #include <mach/edp.h>
30 #include <linux/edp.h>
31 #include <mach/gpio-tegra.h>
32 #include <mach/pinmux-t11.h>
33 #include <mach/pinmux.h>
34 #include <media/max77665-flash.h>
35 #include <media/imx091.h>
36 #include <media/imx132.h>
37 #include <media/ad5816.h>
38 #include <media/ov5640.h>
39 #include <asm/mach-types.h>
40
41 #include "gpio-names.h"
42 #include "board.h"
43 #include "board-common.h"
44 #include "board-pluto.h"
45 #include "cpu-tegra.h"
46 #include "devices.h"
47 #include "tegra-board-id.h"
48 #include "dvfs.h"
49
50 #define NTC_10K_TGAIN   0xE6A2
51 #define NTC_10K_TOFF    0x2694
52 #define MAX77665_CHARGER_INT    TEGRA_GPIO_PJ2
53
54 static struct nvc_gpio_pdata imx091_gpio_pdata[] = {
55         {IMX091_GPIO_RESET, CAM_RSTN, true, false},
56         {IMX091_GPIO_PWDN, CAM1_POWER_DWN_GPIO, true, false},
57         {IMX091_GPIO_GP1, CAM_GPIO1, true, false}
58 };
59
60 static struct board_info board_info;
61 static struct max17042_config_data conf_data = {
62         .valrt_thresh = 0xff00,
63         .talrt_thresh = 0xff00,
64         .soc_alrt_thresh = 0xff00,
65         .shdntimer = 0xe000,
66         .design_cap = 0x07d0,
67         .at_rate = 0x0000,
68         .tgain = NTC_10K_TGAIN,
69         .toff = NTC_10K_TOFF,
70         .vempty = 0xACDA,
71         .qrtbl00 = 0x5C80,
72         .qrtbl10 = 0x438C,
73         .qrtbl20 = 0x1198,
74         .qrtbl30 = 0x0E19,
75         .full_soc_thresh = 0x5A00,
76         .rcomp0 = 0x0077,
77         .tcompc0 = 0x1F2A,
78         .ichgt_term = 0x0320,
79         .temp_nom = 0x1400,
80         .temp_lim = 0x2305,
81         .filter_cfg = 0x87A4,
82         .config = 0x2210,
83         .learn_cfg = 0x2606,
84         .misc_cfg = 0x0810,
85         .fullcap =  0x07d0,
86         .fullcapnom = 0x07d0,
87         .lavg_empty = 0x1000,
88         .dqacc = 0x01f4,
89         .dpacc = 0x3200,
90         .fctc = 0x05e0,
91         .kempty0 = 0x0600,
92         .cell_technology = POWER_SUPPLY_TECHNOLOGY_LION,
93         .cell_char_tbl = {
94                 /* Data to be written from 0x80h */
95                 0x9180, 0xA4C0, 0xB6A0, 0xB760, 0xB980, 0xBB30,
96                 0xBBC0, 0xBC50, 0xBD50, 0xBE50, 0xBF80, 0xC290,
97                 0xC470, 0xC7D0, 0xCC40, 0xCFB0,
98                 /* Data to be written from 0x90h */
99                 0x00C0, 0x0200, 0x1C10, 0x0B00, 0x0900, 0x1F00,
100                 0x1F00, 0x23C0, 0x1990, 0x19F0, 0x09A0, 0x0CE0,
101                 0x0BE0, 0x07D0, 0x0990, 0x0990,
102                 /* Data to be written from 0xA0h */
103                 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100,
104                 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100,
105                 0x0100, 0x0100, 0x0100, 0x0100,
106         },
107 };
108
109 static unsigned int bat_depl_states[] = {
110         5400, 4800, 4200, 3600, 3000, 2400, 1800, 1200, 600, 0
111 };
112
113 static struct edp_client bat_depl_client = {
114         .states = bat_depl_states,
115         .num_states = ARRAY_SIZE(bat_depl_states),
116         .e0_index = 0,
117         .priority = EDP_MAX_PRIO
118 };
119
120 static struct max17042_platform_data max17042_pdata = {
121         .config_data = &conf_data,
122         .init_data  = NULL,
123         .num_init_data = 0,
124         .enable_por_init = 1, /* Use POR init from Maxim appnote */
125         .enable_current_sense = 1,
126         .r_sns = 0,
127         .edp_client = &bat_depl_client
128 };
129
130 static struct i2c_board_info max17042_device[] = {
131         {
132                 I2C_BOARD_INFO("max17042", 0x36),
133                 .platform_data = &max17042_pdata,
134         },
135 };
136
137 static struct nvc_torch_lumi_level_v1 pluto_max77665_lumi_tbl[] = {
138         {0, 100000},
139         {1, 201690},
140         {2, 298080},
141         {3, 387700},
142         {4, 479050},
143         {5, 562000},
144         {6, 652560},
145         {7, 732150},
146         {8, 816050},
147         {9, 896710},
148         {10, 976890},
149         {11, 1070160},
150         {12, 1151000},
151         {13, 1227790},
152         {14, 1287690},
153         {15, 1375060},
154 };
155
156 static unsigned max77665_f_estates[] = { 3500, 2375, 560, 456, 0 };
157
158 static struct max77665_f_platform_data pluto_max77665_flash_pdata = {
159         .config         = {
160                 .led_mask               = 3,
161                 /* set to true only when using the torch strobe input
162                  * to trigger the flash.
163                  */
164                 .flash_on_torch         = false,
165                 /* use ONE-SHOOT flash mode - flash triggered at the
166                  * raising edge of strobe or strobe signal.
167                  */
168                 .flash_mode             = 1,
169                 /* .flash_on_torch         = true, */
170                 .max_total_current_mA   = 1000,
171                 .max_peak_current_mA    = 600,
172                 .led_config[0] = {
173                         .flash_torch_ratio = 18100,
174                         .granularity = 1000,
175                         .flash_levels = ARRAY_SIZE(pluto_max77665_lumi_tbl),
176                         .lumi_levels = pluto_max77665_lumi_tbl,
177                         },
178                 .led_config[1] = {
179                         .flash_torch_ratio = 18100,
180                         .granularity = 1000,
181                         .flash_levels = ARRAY_SIZE(pluto_max77665_lumi_tbl),
182                         .lumi_levels = pluto_max77665_lumi_tbl,
183                         },
184                 },
185         .pinstate       = {
186                 .mask   = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0),
187                 .values = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0),
188                 },
189         .dev_name       = "torch",
190         .gpio_strobe    = CAM_FLASH_STROBE,
191         .edpc_config    = {
192                 .states = max77665_f_estates,
193                 .num_states = ARRAY_SIZE(max77665_f_estates),
194                 .e0_index = 3,
195                 .priority = EDP_MAX_PRIO - 2,
196                 },
197 };
198
199 static struct max77665_haptic_platform_data max77665_haptic_pdata = {
200         .pwm_channel_id = 2,
201         .pwm_period = 50,
202         .type = MAX77665_HAPTIC_LRA,
203         .mode = MAX77665_INTERNAL_MODE,
204         .internal_mode_pattern = 0,
205         .pattern_cycle = 10,
206         .pattern_signal_period = 0xD0,
207         .pwm_divisor = MAX77665_PWM_DIVISOR_128,
208         .feedback_duty_cycle = 12,
209         .invert = MAX77665_INVERT_OFF,
210         .cont_mode = MAX77665_CONT_MODE,
211         .motor_startup_val = 0,
212         .scf_val = 2,
213         .edp_states = { 360, 0 },
214 };
215
216 static struct max77665_charger_cable maxim_cable[] = {
217         {
218                 .name           = "USB",
219         },
220         {
221                 .name           = "USB-Host",
222         },
223         {
224                 .name           = "TA",
225         },
226         {
227                 .name           = "Fast-charger",
228         },
229         {
230                 .name           = "Slow-charger",
231         },
232         {
233                 .name           = "Charge-downstream",
234         },
235 };
236
237 static struct max77665_charger_plat_data max77665_charger = {
238         .fast_chg_cc = 1500, /* fast charger current*/
239         .term_volt = 3700, /* charger termination voltage */
240         .curr_lim = 1500, /* input current limit */
241         .num_cables = MAX_CABLES,
242         .cables = maxim_cable,
243         .irq_base = MAX77665_TEGRA_IRQ_BASE,
244         .update_status = max17042_update_status,
245 };
246
247 static struct max77665_muic_platform_data max77665_muic = {
248         .irq_base = 0,
249 };
250
251 static struct max77665_platform_data pluto_max77665_pdata = {
252         .irq_base = MAX77665_TEGRA_IRQ_BASE,
253         .irq_flag = IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
254         .muic_platform_data = {
255                 .pdata = &max77665_muic,
256                 .size = sizeof(max77665_muic),
257                 },
258         .charger_platform_data = {
259                 .pdata = &max77665_charger,
260                 .size = sizeof(max77665_charger),
261                 },
262         .flash_platform_data = {
263                 .pdata = &pluto_max77665_flash_pdata,
264                 .size = sizeof(pluto_max77665_flash_pdata),
265                 },
266         .haptic_platform_data = {
267                 .pdata = &max77665_haptic_pdata,
268                 .size = sizeof(max77665_haptic_pdata),
269                 },
270 };
271
272 static struct i2c_board_info pluto_i2c_board_info_max77665[] = {
273         {
274                 I2C_BOARD_INFO("max77665", 0x66),
275                 .platform_data = &pluto_max77665_pdata,
276         },
277 };
278
279 /* isl29029 support is provided by isl29028*/
280 static struct i2c_board_info pluto_i2c1_isl_board_info[] = {
281         {
282                 I2C_BOARD_INFO("isl29028", 0x44),
283         }
284 };
285
286 static struct throttle_table tj_throttle_table[] = {
287                 /* CPU_THROT_LOW cannot be used by other than CPU */
288                 /* NO_CAP cannot be used by CPU */
289                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
290                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
291                 { { 1428000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
292                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
293                 { { 1224000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
294                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
295                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
296                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
297                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
298                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
299                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
300                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
301                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
302                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
303                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
304                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
305                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
306                 { {  612000,  360000,  360000,  312000,  NO_CAP } },
307                 { {  510000,  360000,  360000,  312000,  480000 } },
308                 { {  468000,  360000,  360000,  312000,  480000 } },
309                 { {  468000,  276000,  276000,  208000,  480000 } },
310                 { {  372000,  276000,  276000,  208000,  204000 } },
311                 { {  288000,  276000,  276000,  208000,  204000 } },
312                 { {  252000,  276000,  228000,  208000,  102000 } },
313                 { {  204000,  276000,  228000,  208000,  102000 } },
314                 { {  102000,  276000,  228000,  208000,  102000 } },
315           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
316 };
317
318 static struct balanced_throttle tj_throttle = {
319         .throt_tab_size = ARRAY_SIZE(tj_throttle_table),
320         .throt_tab = tj_throttle_table,
321 };
322
323 static int __init pluto_throttle_init(void)
324 {
325         if (machine_is_tegra_pluto())
326                 balanced_throttle_register(&tj_throttle, "tegra-balanced");
327         return 0;
328 }
329 module_init(pluto_throttle_init);
330
331 static struct nct1008_platform_data pluto_nct1008_pdata = {
332         .supported_hwrev = true,
333         .ext_range = true,
334         .conv_rate = 0x08,
335         .offset = 0,
336         .shutdown_ext_limit = 105, /* C */
337         .shutdown_local_limit = 120, /* C */
338 };
339
340 static struct i2c_board_info pluto_i2c4_nct1008_board_info[] = {
341         {
342                 I2C_BOARD_INFO("nct1008", 0x4C),
343                 .platform_data = &pluto_nct1008_pdata,
344                 .irq = -1,
345         }
346 };
347
348 #define VI_PINMUX(_pingroup, _mux, _pupd, _tri, _io, _lock, _ioreset) \
349         {                                                       \
350                 .pingroup       = TEGRA_PINGROUP_##_pingroup,   \
351                 .func           = TEGRA_MUX_##_mux,             \
352                 .pupd           = TEGRA_PUPD_##_pupd,           \
353                 .tristate       = TEGRA_TRI_##_tri,             \
354                 .io             = TEGRA_PIN_##_io,              \
355                 .lock           = TEGRA_PIN_LOCK_##_lock,       \
356                 .od             = TEGRA_PIN_OD_DEFAULT,         \
357                 .ioreset        = TEGRA_PIN_IO_RESET_##_ioreset \
358 }
359
360 static int pluto_focuser_power_on(struct ad5816_power_rail *pw)
361 {
362         int err;
363
364         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
365                 return -EFAULT;
366
367         err = regulator_enable(pw->vdd_i2c);
368         if (unlikely(err))
369                 goto ad5816_vdd_i2c_fail;
370
371         err = regulator_enable(pw->vdd);
372         if (unlikely(err))
373                 goto ad5816_vdd_fail;
374
375         return 0;
376
377 ad5816_vdd_fail:
378         regulator_disable(pw->vdd_i2c);
379
380 ad5816_vdd_i2c_fail:
381         pr_err("%s FAILED\n", __func__);
382
383         return -ENODEV;
384 }
385
386 static int pluto_focuser_power_off(struct ad5816_power_rail *pw)
387 {
388         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
389                 return -EFAULT;
390
391         regulator_disable(pw->vdd);
392         regulator_disable(pw->vdd_i2c);
393
394         return 0;
395 }
396
397 static struct tegra_pingroup_config mclk_disable =
398         VI_PINMUX(CAM_MCLK, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
399
400 static struct tegra_pingroup_config mclk_enable =
401         VI_PINMUX(CAM_MCLK, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
402
403 static struct tegra_pingroup_config pbb0_disable =
404         VI_PINMUX(GPIO_PBB0, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
405
406 static struct tegra_pingroup_config pbb0_enable =
407         VI_PINMUX(GPIO_PBB0, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
408
409 /*
410  * more regulators need to be allocated to activate the sensor devices.
411  * pluto_vcmvdd: this is a workaround due to the focuser device(AD5816) will
412  *               hook up the i2c bus if it is not powered up.
413  * pluto_i2cvdd: by default, the power supply on the i2c bus is OFF. So it
414  *               should be turned on every time any sensor device is activated.
415 */
416 static struct regulator *pluto_vcmvdd;
417 static struct regulator *pluto_i2cvdd;
418
419 static int pluto_get_extra_regulators(void)
420 {
421         if (!pluto_vcmvdd) {
422                 pluto_vcmvdd = regulator_get(NULL, "vdd_af_cam1");
423                 if (WARN_ON(IS_ERR(pluto_vcmvdd))) {
424                         pr_err("%s: can't get regulator vdd_af_cam1: %ld\n",
425                                 __func__, PTR_ERR(pluto_vcmvdd));
426                         pluto_vcmvdd = NULL;
427                         return -ENODEV;
428                 }
429         }
430
431         if (!pluto_i2cvdd) {
432                 pluto_i2cvdd = regulator_get(NULL, "vddio_cam_mb");
433                 if (unlikely(WARN_ON(IS_ERR(pluto_i2cvdd)))) {
434                         pr_err("%s: can't get regulator vddio_cam_mb: %ld\n",
435                                 __func__, PTR_ERR(pluto_i2cvdd));
436                         pluto_i2cvdd = NULL;
437                         return -ENODEV;
438                 }
439         }
440
441         return 0;
442 }
443
444 static int pluto_imx091_power_on(struct nvc_regulator *vreg)
445 {
446         int err;
447
448         if (unlikely(WARN_ON(!vreg)))
449                 return -EFAULT;
450
451         if (pluto_get_extra_regulators())
452                 goto imx091_poweron_fail;
453
454         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
455         usleep_range(10, 20);
456
457         err = regulator_enable(vreg[IMX091_VREG_AVDD].vreg);
458         if (unlikely(err))
459                 goto imx091_avdd_fail;
460
461         err = regulator_enable(vreg[IMX091_VREG_DVDD].vreg);
462         if (unlikely(err))
463                 goto imx091_dvdd_fail;
464
465         err = regulator_enable(vreg[IMX091_VREG_IOVDD].vreg);
466         if (unlikely(err))
467                 goto imx091_iovdd_fail;
468
469         usleep_range(1, 2);
470         gpio_set_value(CAM1_POWER_DWN_GPIO, 1);
471
472         tegra_pinmux_config_table(&mclk_enable, 1);
473         err = regulator_enable(pluto_i2cvdd);
474         if (unlikely(err))
475                 goto imx091_i2c_fail;
476
477         err = regulator_enable(pluto_vcmvdd);
478         if (unlikely(err))
479                 goto imx091_vcm_fail;
480         usleep_range(300, 310);
481
482         return 0;
483
484 imx091_vcm_fail:
485         regulator_disable(pluto_i2cvdd);
486
487 imx091_i2c_fail:
488         tegra_pinmux_config_table(&mclk_disable, 1);
489         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
490         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
491
492 imx091_iovdd_fail:
493         regulator_disable(vreg[IMX091_VREG_DVDD].vreg);
494
495 imx091_dvdd_fail:
496         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
497
498 imx091_avdd_fail:
499 imx091_poweron_fail:
500         pr_err("%s FAILED\n", __func__);
501         return -ENODEV;
502 }
503
504 static int pluto_imx091_power_off(struct nvc_regulator *vreg)
505 {
506         if (unlikely(WARN_ON(!vreg)))
507                 return -EFAULT;
508
509         usleep_range(1, 2);
510         tegra_pinmux_config_table(&mclk_disable, 1);
511         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
512         usleep_range(1, 2);
513
514         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
515         regulator_disable(vreg[IMX091_VREG_DVDD].vreg);
516         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
517         regulator_disable(pluto_i2cvdd);
518         regulator_disable(pluto_vcmvdd);
519
520         return 0;
521 }
522
523 static struct nvc_imager_cap imx091_cap = {
524         .identifier             = "IMX091",
525         .sensor_nvc_interface   = 3,
526         .pixel_types[0]         = 0x100,
527         .orientation            = 0,
528         .direction              = 0,
529         .initial_clock_rate_khz = 6000,
530         .clock_profiles[0] = {
531                 .external_clock_khz     = 24000,
532                 .clock_multiplier       = 850000, /* value / 1,000,000 */
533         },
534         .clock_profiles[1] = {
535                 .external_clock_khz     = 0,
536                 .clock_multiplier       = 0,
537         },
538         .h_sync_edge            = 0,
539         .v_sync_edge            = 0,
540         .mclk_on_vgp0           = 0,
541         .csi_port               = 0,
542         .data_lanes             = 4,
543         .virtual_channel_id     = 0,
544         .discontinuous_clk_mode = 1,
545         .cil_threshold_settle   = 0x0,
546         .min_blank_time_width   = 16,
547         .min_blank_time_height  = 16,
548         .preferred_mode_index   = 0,
549         .focuser_guid           = NVC_FOCUS_GUID(0),
550         .torch_guid             = NVC_TORCH_GUID(0),
551         .cap_version            = NVC_IMAGER_CAPABILITIES_VERSION2,
552 };
553
554 static unsigned imx091_estates[] = { 876, 656, 220, 0 };
555
556 static struct imx091_platform_data imx091_pdata = {
557         .num                    = 0,
558         .sync                   = 0,
559         .dev_name               = "camera",
560         .gpio_count             = ARRAY_SIZE(imx091_gpio_pdata),
561         .gpio                   = imx091_gpio_pdata,
562         .flash_cap              = {
563                 .sdo_trigger_enabled = 1,
564                 .adjustable_flash_timing = 1,
565         },
566         .cap                    = &imx091_cap,
567         .edpc_config    = {
568                 .states = imx091_estates,
569                 .num_states = ARRAY_SIZE(imx091_estates),
570                 .e0_index = 0,
571                 .priority = EDP_MAX_PRIO - 1,
572                 },
573         .power_on               = pluto_imx091_power_on,
574         .power_off              = pluto_imx091_power_off,
575 };
576
577 static int pluto_imx132_power_on(struct imx132_power_rail *pw)
578 {
579         int err;
580
581         if (unlikely(WARN_ON(!pw || !pw->avdd || !pw->iovdd || !pw->dvdd)))
582                 return -EFAULT;
583
584         if (pluto_get_extra_regulators())
585                 goto pluto_imx132_poweron_fail;
586
587         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
588
589         tegra_pinmux_config_table(&pbb0_enable, 1);
590
591         err = regulator_enable(pluto_i2cvdd);
592         if (unlikely(err))
593                 goto imx132_i2c_fail;
594
595         err = regulator_enable(pluto_vcmvdd);
596         if (unlikely(err))
597                 goto imx132_vcm_fail;
598
599         err = regulator_enable(pw->avdd);
600         if (unlikely(err))
601                 goto imx132_avdd_fail;
602
603         err = regulator_enable(pw->dvdd);
604         if (unlikely(err))
605                 goto imx132_dvdd_fail;
606
607         err = regulator_enable(pw->iovdd);
608         if (unlikely(err))
609                 goto imx132_iovdd_fail;
610
611         usleep_range(1, 2);
612
613         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
614
615         return 0;
616
617 imx132_iovdd_fail:
618         regulator_disable(pw->dvdd);
619
620 imx132_dvdd_fail:
621         regulator_disable(pw->avdd);
622
623 imx132_avdd_fail:
624         regulator_disable(pluto_vcmvdd);
625
626 imx132_vcm_fail:
627         regulator_disable(pluto_i2cvdd);
628
629 imx132_i2c_fail:
630         tegra_pinmux_config_table(&pbb0_disable, 1);
631
632 pluto_imx132_poweron_fail:
633         pr_err("%s failed.\n", __func__);
634         return -ENODEV;
635 }
636
637 static int pluto_imx132_power_off(struct imx132_power_rail *pw)
638 {
639         if (unlikely(WARN_ON(!pw || !pw->avdd || !pw->iovdd || !pw->dvdd ||
640                         !pluto_i2cvdd || !pluto_vcmvdd)))
641                 return -EFAULT;
642
643         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
644
645         usleep_range(1, 2);
646
647         regulator_disable(pw->iovdd);
648         regulator_disable(pw->dvdd);
649         regulator_disable(pw->avdd);
650
651         tegra_pinmux_config_table(&pbb0_disable, 1);
652
653         regulator_disable(pluto_vcmvdd);
654         regulator_disable(pluto_i2cvdd);
655
656         return 0;
657 }
658
659 struct imx132_platform_data pluto_imx132_data = {
660         .power_on = pluto_imx132_power_on,
661         .power_off = pluto_imx132_power_off,
662 };
663
664 static struct ad5816_platform_data pluto_ad5816_pdata = {
665         .cfg            = 0,
666         .num            = 0,
667         .sync           = 0,
668         .dev_name       = "focuser",
669         .power_on       = pluto_focuser_power_on,
670         .power_off      = pluto_focuser_power_off,
671 };
672
673 static struct regulator *dvdd_1v8;
674 static struct regulator *avdd_cam2;
675 static struct regulator *vdd_af1;
676 static int pluto_ov5640_power_on(struct device *dev)
677 {
678         if (avdd_cam2 == NULL) {
679                 avdd_cam2 = regulator_get(dev, "avdd_cam2");
680                 if (WARN_ON(IS_ERR(avdd_cam2))) {
681                         pr_err("%s: couldn't get regulator avdd_cam2: %ld\n",
682                                 __func__, PTR_ERR(avdd_cam2));
683                         avdd_cam2 = NULL;
684                         goto avdd_cam2_fail;
685                 }
686         }
687         if (dvdd_1v8 == NULL) {
688                 dvdd_1v8 = regulator_get(dev, "vdd_1v8_cam12");
689                 if (WARN_ON(IS_ERR(dvdd_1v8))) {
690                         pr_err("%s: couldn't get regulator vdd_1v8_cam: %ld\n",
691                                 __func__, PTR_ERR(dvdd_1v8));
692                         dvdd_1v8 = NULL;
693                         goto dvdd_1v8_fail;
694                 }
695         }
696
697         if (vdd_af1 == NULL) {
698                 vdd_af1 = regulator_get(dev, "vdd_af_cam1");
699                 if (WARN_ON(IS_ERR(vdd_af1))) {
700                         pr_err("%s: couldn't get regulator vdd_af_cam1: %ld\n",
701                                 __func__, PTR_ERR(vdd_af1));
702                         vdd_af1 = NULL;
703                         goto vdd_af1_fail;
704                 }
705         }
706
707         /* power up sequence */
708         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
709         gpio_set_value(CAM_RSTN, 0);
710         mdelay(1);
711
712         regulator_enable(vdd_af1);
713         regulator_enable(dvdd_1v8);
714         regulator_enable(avdd_cam2);
715
716         tegra_pinmux_config_table(&pbb0_enable, 1);
717
718         mdelay(5);
719         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
720         mdelay(1);
721         gpio_set_value(CAM_RSTN, 1);
722
723         mdelay(20);
724
725         return 0;
726
727 vdd_af1_fail:
728         regulator_disable(dvdd_1v8);
729 dvdd_1v8_fail:
730         regulator_disable(avdd_cam2);
731 avdd_cam2_fail:
732         return -ENODEV;
733 }
734
735 static int pluto_ov5640_power_off(struct device *dev)
736 {
737         gpio_set_value(CAM_RSTN, 0);
738
739         tegra_pinmux_config_table(&pbb0_disable, 1);
740
741         if (avdd_cam2)
742                 regulator_disable(avdd_cam2);
743         if (dvdd_1v8)
744                 regulator_disable(dvdd_1v8);
745         if (vdd_af1)
746                 regulator_disable(vdd_af1);
747         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
748
749         return 0;
750 }
751
752 struct ov5640_platform_data pluto_ov5640_data = {
753         .power_on = pluto_ov5640_power_on,
754         .power_off = pluto_ov5640_power_off,
755 };
756
757 static struct i2c_board_info pluto_board_info_ov5640[] = {
758         {
759                 I2C_BOARD_INFO("ov5640", 0x3c),
760                 .platform_data = &pluto_ov5640_data,
761         }
762 };
763
764 static struct i2c_board_info pluto_i2c_board_info_e1625[] = {
765         {
766                 I2C_BOARD_INFO("imx091", 0x10),
767                 .platform_data = &imx091_pdata,
768         },
769         {
770                 I2C_BOARD_INFO("imx132", 0x36),
771                 .platform_data = &pluto_imx132_data,
772         },
773         {
774                 I2C_BOARD_INFO("ad5816", 0x0E),
775                 .platform_data = &pluto_ad5816_pdata,
776         },
777 };
778
779 /* Detect ov5640 adapter by toggling the CAM_GPIO1 and read it back
780  * from CAM_GPIO2.
781  * On the ov5640 adapter board (E1633) for pluto, pin 5 & 6 of connector J9
782  * should be shorted.
783  */
784 static int ov5640_installed(void)
785 {
786         int val;
787         int ret;
788
789         ret = gpio_request(CAM_GPIO1, "camera_gpio1");
790         if (ret < 0) {
791                 pr_err("%s, gpio_request failed for CAM_GPIO1\n", __func__);
792                 return 0;
793         }
794
795         ret = gpio_request(CAM_GPIO2, "camera_gpio2");
796         if (ret < 0) {
797                 pr_err("%s, gpio_request failed for CAM_GPIO2\n", __func__);
798                 gpio_free(CAM_GPIO1);
799                 return 0;
800         }
801
802         gpio_direction_output(CAM_GPIO1, 1);
803         gpio_direction_input(CAM_GPIO2);
804
805         val = gpio_get_value(CAM_GPIO1);
806         ret = gpio_get_value(CAM_GPIO2);
807         pr_info("%s round 1: %d vs %d\n", __func__, val, ret);
808         if (ret != val) {
809                 gpio_free(CAM_GPIO1);
810                 gpio_free(CAM_GPIO2);
811                 return 0;
812         }
813
814         /* toggle CAM_GPIO1 and read back from detect pin */
815         val ^= 1;
816         gpio_set_value(CAM_GPIO1, val & 1);
817         ret = gpio_get_value(CAM_GPIO2);
818         /* resume CAM_GPIO1 state */
819         gpio_set_value(CAM_GPIO1, (~val) & 1);
820
821         gpio_free(CAM_GPIO2);
822         gpio_free(CAM_GPIO1);
823
824         pr_info("%s round 2: %d vs %d\n", __func__, val, ret);
825         if (ret != val)
826                 return 0;
827
828         return 1;
829 }
830
831 static int pluto_camera_init(void)
832 {
833         pr_debug("%s: ++\n", __func__);
834
835         tegra_pinmux_config_table(&mclk_disable, 1);
836         tegra_pinmux_config_table(&pbb0_disable, 1);
837
838         if (ov5640_installed()) {
839                 pr_info("%s ov5640 installed.\n", __func__);
840                 i2c_register_board_info(2, pluto_board_info_ov5640,
841                         ARRAY_SIZE(pluto_board_info_ov5640));
842         } else
843                 i2c_register_board_info(2, pluto_i2c_board_info_e1625,
844                         ARRAY_SIZE(pluto_i2c_board_info_e1625));
845
846         return 0;
847 }
848
849 /* MPU board file definition */
850 static struct mpu_platform_data mpu_gyro_data = {
851         .int_config     = 0x00,
852         .level_shifter  = 0,
853         .orientation    = MPU_GYRO_ORIENTATION,
854         .sec_slave_type = SECONDARY_SLAVE_TYPE_COMPASS,
855         .sec_slave_id   = COMPASS_ID_AK8963,
856         .secondary_i2c_addr     = MPU_COMPASS_ADDR,
857         .secondary_orientation  = MPU_COMPASS_ORIENTATION,
858         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
859                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
860 };
861
862 static struct i2c_board_info __initdata inv_mpu_i2c0_board_info[] = {
863         {
864                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
865                 .platform_data = &mpu_gyro_data,
866         },
867 };
868
869 static void mpuirq_init(void)
870 {
871         int ret = 0;
872         int i = 0;
873
874         pr_info("*** MPU START *** mpuirq_init...\n");
875
876         /* MPU-IRQ assignment */
877         ret = gpio_request(MPU_GYRO_IRQ_GPIO, MPU_GYRO_NAME);
878         if (ret < 0) {
879                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
880                 return;
881         }
882
883         ret = gpio_direction_input(MPU_GYRO_IRQ_GPIO);
884         if (ret < 0) {
885                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
886                 gpio_free(MPU_GYRO_IRQ_GPIO);
887                 return;
888         }
889         pr_info("*** MPU END *** mpuirq_init...\n");
890
891         inv_mpu_i2c0_board_info[i++].irq = gpio_to_irq(MPU_GYRO_IRQ_GPIO);
892 #if MPU_COMPASS_IRQ_GPIO
893         inv_mpu_i2c0_board_info[i++].irq = gpio_to_irq(MPU_COMPASS_IRQ_GPIO);
894 #endif
895         i2c_register_board_info(MPU_GYRO_BUS_NUM, inv_mpu_i2c0_board_info,
896                 ARRAY_SIZE(inv_mpu_i2c0_board_info));
897 }
898
899 static int pluto_nct1008_init(void)
900 {
901         int nct1008_port;
902         int ret = 0;
903
904         if (board_info.board_id == BOARD_E1580 ||
905             board_info.board_id == BOARD_E1575 ||
906             board_info.board_id == BOARD_E1577) {
907                 nct1008_port = TEGRA_GPIO_PX6;
908         } else {
909                 nct1008_port = TEGRA_GPIO_PX6;
910                 pr_err("Warning: nct alert port assumed TEGRA_GPIO_PX6 for unknown pluto board id E%d\n",
911                         board_info.board_id);
912         }
913
914         tegra_add_cdev_trips(pluto_nct1008_pdata.trips,
915                                 &pluto_nct1008_pdata.num_trips);
916
917         pluto_i2c4_nct1008_board_info[0].irq =
918                 gpio_to_irq(nct1008_port);
919         pr_info("%s: pluto nct1008 irq %d",
920                         __func__, pluto_i2c4_nct1008_board_info[0].irq);
921
922         ret = gpio_request(nct1008_port, "temp_alert");
923         if (ret < 0)
924                 return ret;
925
926         ret = gpio_direction_input(nct1008_port);
927         if (ret < 0) {
928                 pr_info("%s: calling gpio_free(nct1008_port)", __func__);
929                 gpio_free(nct1008_port);
930         }
931
932         /* pluto has thermal sensor on GEN1-I2C i.e. instance 0 */
933         i2c_register_board_info(0, pluto_i2c4_nct1008_board_info,
934                 ARRAY_SIZE(pluto_i2c4_nct1008_board_info));
935
936         return ret;
937 }
938
939 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
940 static int tegra_skin_match(struct thermal_zone_device *thz, void *data)
941 {
942         return strcmp((char *)data, thz->type) == 0;
943 }
944
945 static int tegra_skin_get_temp(void *data, long *temp)
946 {
947         struct thermal_zone_device *thz;
948
949         thz = thermal_zone_device_find(data, tegra_skin_match);
950
951         if (!thz || thz->ops->get_temp(thz, temp))
952                 *temp = 25000;
953
954         return 0;
955 }
956
957 static struct therm_est_data skin_data = {
958         .cdev_type = "skin-balanced",
959         .toffset = 9793,
960         .polling_period = 1100,
961         .ndevs = 2,
962         .tc1 = 5,
963         .tc2 = 1,
964         .devs = {
965                         {
966                                 .dev_data = "nct_ext",
967                                 .get_temp = tegra_skin_get_temp,
968                                 .coeffs = {
969                                         2, 1, 1, 1,
970                                         1, 1, 1, 1,
971                                         1, 1, 1, 0,
972                                         1, 1, 0, 0,
973                                         0, 0, -1, -7
974                                 },
975                         },
976                         {
977                                 .dev_data = "nct_int",
978                                 .get_temp = tegra_skin_get_temp,
979                                 .coeffs = {
980                                         -11, -7, -5, -3,
981                                         -3, -2, -1, 0,
982                                         0, 0, 1, 1,
983                                         1, 2, 2, 3,
984                                         4, 6, 11, 18
985                                 },
986                         },
987         },
988         .trip_temp = 43000,
989         .passive_delay = 5000,
990 };
991
992 static struct throttle_table skin_throttle_table[] = {
993                 /* CPU_THROT_LOW cannot be used by other than CPU */
994                 /* NO_CAP cannot be used by CPU */
995                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
996                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
997                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
998                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
999                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1000                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1001                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1002                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1003                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1004                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1005                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1006                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1007                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1008                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1009                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1010                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1011                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1012                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1013                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1014                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1015                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1016                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1017                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1018                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1019                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1020                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1021                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1022                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1023                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1024                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1025                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1026                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1027                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1028                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1029                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1030                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1031                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1032                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1033                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1034                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1035                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1036                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1037                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1038                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
1039                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
1040                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
1041                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
1042                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
1043                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
1044                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
1045                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
1046                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
1047                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
1048                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
1049                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
1050                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
1051                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
1052                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
1053                 { {  510000,  360000,  360000,  312000,  480000 } },
1054                 { {  510000,  360000,  360000,  312000,  480000 } },
1055                 { {  510000,  360000,  360000,  312000,  480000 } },
1056                 { {  510000,  360000,  360000,  312000,  480000 } },
1057                 { {  510000,  360000,  360000,  312000,  480000 } },
1058                 { {  510000,  360000,  360000,  312000,  480000 } },
1059                 { {  468000,  360000,  360000,  312000,  480000 } },
1060                 { {  468000,  360000,  360000,  312000,  480000 } },
1061                 { {  468000,  276000,  276000,  208000,  480000 } },
1062                 { {  468000,  276000,  276000,  208000,  480000 } },
1063                 { {  372000,  276000,  276000,  208000,  204000 } },
1064                 { {  372000,  276000,  276000,  208000,  204000 } },
1065                 { {  288000,  276000,  276000,  208000,  204000 } },
1066                 { {  288000,  276000,  276000,  208000,  204000 } },
1067                 { {  252000,  276000,  228000,  208000,  102000 } },
1068                 { {  252000,  276000,  228000,  208000,  102000 } },
1069                 { {  204000,  276000,  228000,  208000,  102000 } },
1070                 { {  204000,  276000,  228000,  208000,  102000 } },
1071                 { {  102000,  276000,  228000,  208000,  102000 } },
1072           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
1073 };
1074
1075 static struct balanced_throttle skin_throttle = {
1076         .throt_tab_size = ARRAY_SIZE(skin_throttle_table),
1077         .throt_tab = skin_throttle_table,
1078 };
1079
1080 static int __init pluto_skin_init(void)
1081 {
1082         if (machine_is_tegra_pluto()) {
1083                 balanced_throttle_register(&skin_throttle, "skin-balanced");
1084                 tegra_skin_therm_est_device.dev.platform_data = &skin_data;
1085                 platform_device_register(&tegra_skin_therm_est_device);
1086         }
1087
1088         return 0;
1089 }
1090 late_initcall(pluto_skin_init);
1091 #endif
1092
1093 void __init max77665_init(void)
1094 {
1095         int err;
1096
1097         err = gpio_request(MAX77665_CHARGER_INT, "CHARGER_INT");
1098         if (err < 0) {
1099                 pr_err("%s: gpio_request failed %d\n", __func__, err);
1100                 goto fail_init_irq;
1101         }
1102
1103         err = gpio_direction_input(MAX77665_CHARGER_INT);
1104         if (err < 0) {
1105                 pr_err("%s: gpio_direction_input failed %d\n", __func__, err);
1106                 goto fail_init_irq;
1107         }
1108
1109         pluto_i2c_board_info_max77665[0].irq =
1110                                 gpio_to_irq(MAX77665_CHARGER_INT);
1111 fail_init_irq:
1112         err = i2c_register_board_info(4, pluto_i2c_board_info_max77665,
1113                 ARRAY_SIZE(pluto_i2c_board_info_max77665));
1114         if (err)
1115                 pr_err("%s: max77665 device register failed.\n", __func__);
1116
1117         return;
1118 }
1119
1120 int __init pluto_sensors_init(void)
1121 {
1122         int err;
1123
1124         tegra_get_board_info(&board_info);
1125
1126         pr_debug("%s: ++\n", __func__);
1127         pluto_camera_init();
1128
1129         err = pluto_nct1008_init();
1130         if (err)
1131                 return err;
1132
1133         err = i2c_register_board_info(0, pluto_i2c1_isl_board_info,
1134                                 ARRAY_SIZE(pluto_i2c1_isl_board_info));
1135         if (err)
1136                 pr_err("%s: isl board register failed.\n", __func__);
1137
1138         mpuirq_init();
1139         max77665_init();
1140         pluto_i2c_board_info_max77665[0].irq = gpio_to_irq(TEGRA_GPIO_PJ0);
1141
1142         err = i2c_register_board_info(0, max17042_device,
1143                                 ARRAY_SIZE(max17042_device));
1144         if (err)
1145                 pr_err("%s: max17042 device register failed.\n", __func__);
1146
1147
1148         return 0;
1149 }