ARM: tegra: thermal: Update due to struct_est_data modification
[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         9900, 9600, 9300, 9000, 8700, 8400, 8100, 7800,
111         7500, 7200, 6900, 6600, 6300, 6000, 5800, 5600,
112         5400, 5200, 5000, 4800, 4600, 4400, 4200, 4000,
113         3800, 3600, 3400, 3200, 3000, 2800, 2600, 2400,
114         2200, 2000, 1900, 1800, 1700, 1600, 1500, 1400,
115         1300, 1200, 1100, 1000,  900,  800,  700,  600,
116          500,  400,  300,  200,  100,    0
117 };
118
119 static struct edp_client bat_depl_client = {
120         .states = bat_depl_states,
121         .num_states = ARRAY_SIZE(bat_depl_states),
122         .e0_index = 16,
123         .priority = EDP_MAX_PRIO
124 };
125
126 static struct max17042_platform_data max17042_pdata = {
127         .config_data = &conf_data,
128         .init_data  = NULL,
129         .num_init_data = 0,
130         .enable_por_init = 1, /* Use POR init from Maxim appnote */
131         .enable_current_sense = 1,
132         .r_sns = 0,
133         .edp_client = &bat_depl_client
134 };
135
136 static struct i2c_board_info max17042_device[] = {
137         {
138                 I2C_BOARD_INFO("max17042", 0x36),
139                 .platform_data = &max17042_pdata,
140         },
141 };
142
143 static struct nvc_torch_lumi_level_v1 pluto_max77665_lumi_tbl[] = {
144         {0, 100000},
145         {1, 201690},
146         {2, 298080},
147         {3, 387700},
148         {4, 479050},
149         {5, 562000},
150         {6, 652560},
151         {7, 732150},
152         {8, 816050},
153         {9, 896710},
154         {10, 976890},
155         {11, 1070160},
156         {12, 1151000},
157         {13, 1227790},
158         {14, 1287690},
159         {15, 1375060},
160 };
161
162 static unsigned max77665_f_estates[] = { 3500, 2375, 560, 456, 0 };
163
164 static struct max77665_f_platform_data pluto_max77665_flash_pdata = {
165         .config         = {
166                 .led_mask               = 3,
167                 /* set to true only when using the torch strobe input
168                  * to trigger the flash.
169                  */
170                 .flash_on_torch         = false,
171                 /* use ONE-SHOOT flash mode - flash triggered at the
172                  * raising edge of strobe or strobe signal.
173                  */
174                 .flash_mode             = 1,
175                 /* .flash_on_torch         = true, */
176                 .max_total_current_mA   = 1000,
177                 .max_peak_current_mA    = 600,
178                 .max_flash_threshold_mV = 3400,
179                 .max_flash_hysteresis_mV = 200,
180                 .max_flash_lbdly_f_uS   = 256,
181                 .max_flash_lbdly_r_uS   = 256,
182                 .led_config[0] = {
183                         .flash_torch_ratio = 18100,
184                         .granularity = 1000,
185                         .flash_levels = ARRAY_SIZE(pluto_max77665_lumi_tbl),
186                         .lumi_levels = pluto_max77665_lumi_tbl,
187                         },
188                 .led_config[1] = {
189                         .flash_torch_ratio = 18100,
190                         .granularity = 1000,
191                         .flash_levels = ARRAY_SIZE(pluto_max77665_lumi_tbl),
192                         .lumi_levels = pluto_max77665_lumi_tbl,
193                         },
194                 },
195         .pinstate       = {
196                 .mask   = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0),
197                 .values = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0),
198                 },
199         .dev_name       = "torch",
200         .gpio_strobe    = CAM_FLASH_STROBE,
201         .edpc_config    = {
202                 .states = max77665_f_estates,
203                 .num_states = ARRAY_SIZE(max77665_f_estates),
204                 .e0_index = ARRAY_SIZE(max77665_f_estates) - 1,
205                 .priority = EDP_MAX_PRIO + 2,
206                 },
207 };
208
209 static struct max77665_haptic_platform_data max77665_haptic_pdata = {
210         .pwm_channel_id = 2,
211         .pwm_period = 50,
212         .type = MAX77665_HAPTIC_LRA,
213         .mode = MAX77665_INTERNAL_MODE,
214         .internal_mode_pattern = 0,
215         .pattern_cycle = 10,
216         .pattern_signal_period = 0xD0,
217         .pwm_divisor = MAX77665_PWM_DIVISOR_128,
218         .feedback_duty_cycle = 12,
219         .invert = MAX77665_INVERT_OFF,
220         .cont_mode = MAX77665_CONT_MODE,
221         .motor_startup_val = 0,
222         .scf_val = 2,
223         .edp_states = { 360, 0 },
224 };
225
226 static struct max77665_charger_cable maxim_cable[] = {
227         {
228                 .name           = "USB",
229         },
230         {
231                 .name           = "USB-Host",
232         },
233         {
234                 .name           = "TA",
235         },
236         {
237                 .name           = "Fast-charger",
238         },
239         {
240                 .name           = "Slow-charger",
241         },
242         {
243                 .name           = "Charge-downstream",
244         },
245 };
246
247 static struct max77665_charger_plat_data max77665_charger = {
248         .fast_chg_cc = 1500, /* fast charger current*/
249         .term_volt = 3700, /* charger termination voltage */
250         .curr_lim = 1500, /* input current limit */
251         .num_cables = MAX_CABLES,
252         .cables = maxim_cable,
253         .irq_base = MAX77665_TEGRA_IRQ_BASE,
254         .update_status = max17042_update_status,
255 };
256
257 static struct max77665_muic_platform_data max77665_muic = {
258         .irq_base = 0,
259 };
260
261 static struct max77665_platform_data pluto_max77665_pdata = {
262         .irq_base = MAX77665_TEGRA_IRQ_BASE,
263         .irq_flag = IRQF_ONESHOT | IRQF_TRIGGER_FALLING,
264         .muic_platform_data = {
265                 .pdata = &max77665_muic,
266                 .size = sizeof(max77665_muic),
267                 },
268         .charger_platform_data = {
269                 .pdata = &max77665_charger,
270                 .size = sizeof(max77665_charger),
271                 },
272         .flash_platform_data = {
273                 .pdata = &pluto_max77665_flash_pdata,
274                 .size = sizeof(pluto_max77665_flash_pdata),
275                 },
276         .haptic_platform_data = {
277                 .pdata = &max77665_haptic_pdata,
278                 .size = sizeof(max77665_haptic_pdata),
279                 },
280 };
281
282 static struct i2c_board_info pluto_i2c_board_info_max77665[] = {
283         {
284                 I2C_BOARD_INFO("max77665", 0x66),
285                 .platform_data = &pluto_max77665_pdata,
286         },
287 };
288
289 /* isl29029 support is provided by isl29028*/
290 static struct i2c_board_info pluto_i2c1_isl_board_info[] = {
291         {
292                 I2C_BOARD_INFO("isl29028", 0x44),
293         }
294 };
295
296 static struct throttle_table tj_throttle_table[] = {
297         /* CPU_THROT_LOW cannot be used by other than CPU */
298         /*      CPU,  C2BUS,  C3BUS,   SCLK,    EMC   */
299         { { 1810500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
300         { { 1785000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
301         { { 1759500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
302         { { 1734000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
303         { { 1708500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
304         { { 1683000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
305         { { 1657500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
306         { { 1632000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
307         { { 1606500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
308         { { 1581000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
309         { { 1555500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
310         { { 1530000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
311         { { 1504500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
312         { { 1479000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
313         { { 1453500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
314         { { 1428000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
315         { { 1402500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
316         { { 1377000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
317         { { 1351500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
318         { { 1326000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
319         { { 1300500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
320         { { 1275000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
321         { { 1249500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
322         { { 1224000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
323         { { 1198500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
324         { { 1173000, 636000, NO_CAP, NO_CAP, NO_CAP } },
325         { { 1147500, 636000, NO_CAP, NO_CAP, NO_CAP } },
326         { { 1122000, 636000, NO_CAP, NO_CAP, NO_CAP } },
327         { { 1096500, 636000, NO_CAP, NO_CAP, NO_CAP } },
328         { { 1071000, 636000, NO_CAP, NO_CAP, NO_CAP } },
329         { { 1045500, 636000, NO_CAP, NO_CAP, NO_CAP } },
330         { { 1020000, 636000, NO_CAP, NO_CAP, NO_CAP } },
331         { {  994500, 636000, NO_CAP, NO_CAP, NO_CAP } },
332         { {  969000, 600000, NO_CAP, NO_CAP, NO_CAP } },
333         { {  943500, 600000, NO_CAP, NO_CAP, NO_CAP } },
334         { {  918000, 600000, NO_CAP, NO_CAP, NO_CAP } },
335         { {  892500, 600000, NO_CAP, NO_CAP, NO_CAP } },
336         { {  867000, 600000, NO_CAP, NO_CAP, NO_CAP } },
337         { {  841500, 564000, NO_CAP, NO_CAP, NO_CAP } },
338         { {  816000, 564000, NO_CAP, NO_CAP, 792000 } },
339         { {  790500, 564000, NO_CAP, 372000, 792000 } },
340         { {  765000, 564000, 468000, 372000, 792000 } },
341         { {  739500, 528000, 468000, 372000, 792000 } },
342         { {  714000, 528000, 468000, 336000, 792000 } },
343         { {  688500, 528000, 420000, 336000, 792000 } },
344         { {  663000, 492000, 420000, 336000, 792000 } },
345         { {  637500, 492000, 420000, 336000, 408000 } },
346         { {  612000, 492000, 420000, 300000, 408000 } },
347         { {  586500, 492000, 360000, 336000, 408000 } },
348         { {  561000, 420000, 420000, 300000, 408000 } },
349         { {  535500, 420000, 360000, 228000, 408000 } },
350         { {  510000, 420000, 288000, 228000, 408000 } },
351         { {  484500, 324000, 288000, 228000, 408000 } },
352         { {  459000, 324000, 288000, 228000, 408000 } },
353         { {  433500, 324000, 288000, 228000, 408000 } },
354         { {  408000, 324000, 288000, 228000, 408000 } },
355 };
356
357 static struct balanced_throttle tj_throttle = {
358         .throt_tab_size = ARRAY_SIZE(tj_throttle_table),
359         .throt_tab = tj_throttle_table,
360 };
361
362 static int __init pluto_throttle_init(void)
363 {
364         if (machine_is_tegra_pluto())
365                 balanced_throttle_register(&tj_throttle, "tegra-balanced");
366         return 0;
367 }
368 module_init(pluto_throttle_init);
369
370 static struct nct1008_platform_data pluto_nct1008_pdata = {
371         .supported_hwrev = true,
372         .ext_range = true,
373         .conv_rate = 0x08,
374         .offset = 0,
375         .shutdown_ext_limit = 105, /* C */
376         .shutdown_local_limit = 120, /* C */
377
378         .num_trips = 1,
379         .trips = {
380                 {
381                         .cdev_type = "suspend_soctherm",
382                         .trip_temp = 50000,
383                         .trip_type = THERMAL_TRIP_ACTIVE,
384                         .upper = 1,
385                         .lower = 1,
386                         .hysteresis = 5000,
387                 },
388         },
389 };
390
391 static struct i2c_board_info pluto_i2c4_nct1008_board_info[] = {
392         {
393                 I2C_BOARD_INFO("nct1008", 0x4C),
394                 .platform_data = &pluto_nct1008_pdata,
395                 .irq = -1,
396         }
397 };
398
399 #define VI_PINMUX(_pingroup, _mux, _pupd, _tri, _io, _lock, _ioreset) \
400         {                                                       \
401                 .pingroup       = TEGRA_PINGROUP_##_pingroup,   \
402                 .func           = TEGRA_MUX_##_mux,             \
403                 .pupd           = TEGRA_PUPD_##_pupd,           \
404                 .tristate       = TEGRA_TRI_##_tri,             \
405                 .io             = TEGRA_PIN_##_io,              \
406                 .lock           = TEGRA_PIN_LOCK_##_lock,       \
407                 .od             = TEGRA_PIN_OD_DEFAULT,         \
408                 .ioreset        = TEGRA_PIN_IO_RESET_##_ioreset \
409 }
410
411 static int pluto_focuser_power_on(struct ad5816_power_rail *pw)
412 {
413         int err;
414
415         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
416                 return -EFAULT;
417
418         err = regulator_enable(pw->vdd_i2c);
419         if (unlikely(err))
420                 goto ad5816_vdd_i2c_fail;
421
422         err = regulator_enable(pw->vdd);
423         if (unlikely(err))
424                 goto ad5816_vdd_fail;
425
426         return 0;
427
428 ad5816_vdd_fail:
429         regulator_disable(pw->vdd_i2c);
430
431 ad5816_vdd_i2c_fail:
432         pr_err("%s FAILED\n", __func__);
433
434         return -ENODEV;
435 }
436
437 static int pluto_focuser_power_off(struct ad5816_power_rail *pw)
438 {
439         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
440                 return -EFAULT;
441
442         regulator_disable(pw->vdd);
443         regulator_disable(pw->vdd_i2c);
444
445         return 0;
446 }
447
448 static struct tegra_pingroup_config mclk_disable =
449         VI_PINMUX(CAM_MCLK, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
450
451 static struct tegra_pingroup_config mclk_enable =
452         VI_PINMUX(CAM_MCLK, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
453
454 static struct tegra_pingroup_config pbb0_disable =
455         VI_PINMUX(GPIO_PBB0, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
456
457 static struct tegra_pingroup_config pbb0_enable =
458         VI_PINMUX(GPIO_PBB0, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
459
460 /*
461  * more regulators need to be allocated to activate the sensor devices.
462  * pluto_vcmvdd: this is a workaround due to the focuser device(AD5816) will
463  *               hook up the i2c bus if it is not powered up.
464  * pluto_i2cvdd: by default, the power supply on the i2c bus is OFF. So it
465  *               should be turned on every time any sensor device is activated.
466 */
467 static struct regulator *pluto_vcmvdd;
468 static struct regulator *pluto_i2cvdd;
469
470 static int pluto_get_extra_regulators(void)
471 {
472         if (!pluto_vcmvdd) {
473                 pluto_vcmvdd = regulator_get(NULL, "vdd_af_cam1");
474                 if (WARN_ON(IS_ERR(pluto_vcmvdd))) {
475                         pr_err("%s: can't get regulator vdd_af_cam1: %ld\n",
476                                 __func__, PTR_ERR(pluto_vcmvdd));
477                         pluto_vcmvdd = NULL;
478                         return -ENODEV;
479                 }
480         }
481
482         if (!pluto_i2cvdd) {
483                 pluto_i2cvdd = regulator_get(NULL, "vddio_cam_mb");
484                 if (unlikely(WARN_ON(IS_ERR(pluto_i2cvdd)))) {
485                         pr_err("%s: can't get regulator vddio_cam_mb: %ld\n",
486                                 __func__, PTR_ERR(pluto_i2cvdd));
487                         pluto_i2cvdd = NULL;
488                         return -ENODEV;
489                 }
490         }
491
492         return 0;
493 }
494
495 static int pluto_imx091_power_on(struct nvc_regulator *vreg)
496 {
497         int err;
498
499         if (unlikely(WARN_ON(!vreg)))
500                 return -EFAULT;
501
502         if (pluto_get_extra_regulators())
503                 goto imx091_poweron_fail;
504
505         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
506         usleep_range(10, 20);
507
508         err = regulator_enable(vreg[IMX091_VREG_AVDD].vreg);
509         if (unlikely(err))
510                 goto imx091_avdd_fail;
511
512         err = regulator_enable(vreg[IMX091_VREG_DVDD].vreg);
513         if (unlikely(err))
514                 goto imx091_dvdd_fail;
515
516         err = regulator_enable(vreg[IMX091_VREG_IOVDD].vreg);
517         if (unlikely(err))
518                 goto imx091_iovdd_fail;
519
520         usleep_range(1, 2);
521         gpio_set_value(CAM1_POWER_DWN_GPIO, 1);
522
523         tegra_pinmux_config_table(&mclk_enable, 1);
524         err = regulator_enable(pluto_i2cvdd);
525         if (unlikely(err))
526                 goto imx091_i2c_fail;
527
528         err = regulator_enable(pluto_vcmvdd);
529         if (unlikely(err))
530                 goto imx091_vcm_fail;
531         usleep_range(300, 310);
532
533         return 1;
534
535 imx091_vcm_fail:
536         regulator_disable(pluto_i2cvdd);
537
538 imx091_i2c_fail:
539         tegra_pinmux_config_table(&mclk_disable, 1);
540         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
541         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
542
543 imx091_iovdd_fail:
544         regulator_disable(vreg[IMX091_VREG_DVDD].vreg);
545
546 imx091_dvdd_fail:
547         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
548
549 imx091_avdd_fail:
550 imx091_poweron_fail:
551         pr_err("%s FAILED\n", __func__);
552         return -ENODEV;
553 }
554
555 static int pluto_imx091_power_off(struct nvc_regulator *vreg)
556 {
557         if (unlikely(WARN_ON(!vreg)))
558                 return -EFAULT;
559
560         usleep_range(1, 2);
561         tegra_pinmux_config_table(&mclk_disable, 1);
562         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
563         usleep_range(1, 2);
564
565         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
566         regulator_disable(vreg[IMX091_VREG_DVDD].vreg);
567         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
568         if (pluto_i2cvdd)
569                 regulator_disable(pluto_i2cvdd);
570         if (pluto_vcmvdd)
571                 regulator_disable(pluto_vcmvdd);
572
573         return 0;
574 }
575
576 static struct nvc_imager_cap imx091_cap = {
577         .identifier             = "IMX091",
578         .sensor_nvc_interface   = 3,
579         .pixel_types[0]         = 0x100,
580         .orientation            = 0,
581         .direction              = 0,
582         .initial_clock_rate_khz = 6000,
583         .clock_profiles[0] = {
584                 .external_clock_khz     = 24000,
585                 .clock_multiplier       = 850000, /* value / 1,000,000 */
586         },
587         .clock_profiles[1] = {
588                 .external_clock_khz     = 0,
589                 .clock_multiplier       = 0,
590         },
591         .h_sync_edge            = 0,
592         .v_sync_edge            = 0,
593         .mclk_on_vgp0           = 0,
594         .csi_port               = 0,
595         .data_lanes             = 4,
596         .virtual_channel_id     = 0,
597         .discontinuous_clk_mode = 1,
598         .cil_threshold_settle   = 0x0,
599         .min_blank_time_width   = 16,
600         .min_blank_time_height  = 16,
601         .preferred_mode_index   = 0,
602         .focuser_guid           = NVC_FOCUS_GUID(0),
603         .torch_guid             = NVC_TORCH_GUID(0),
604         .cap_version            = NVC_IMAGER_CAPABILITIES_VERSION2,
605 };
606
607 static unsigned imx091_estates[] = { 876, 656, 220, 0 };
608
609 static struct imx091_platform_data imx091_pdata = {
610         .num                    = 0,
611         .sync                   = 0,
612         .dev_name               = "camera",
613         .gpio_count             = ARRAY_SIZE(imx091_gpio_pdata),
614         .gpio                   = imx091_gpio_pdata,
615         .flash_cap              = {
616                 .sdo_trigger_enabled = 1,
617                 .adjustable_flash_timing = 1,
618         },
619         .cap                    = &imx091_cap,
620         .edpc_config    = {
621                 .states = imx091_estates,
622                 .num_states = ARRAY_SIZE(imx091_estates),
623                 .e0_index = ARRAY_SIZE(imx091_estates) - 1,
624                 .priority = EDP_MAX_PRIO + 1,
625                 },
626         .power_on               = pluto_imx091_power_on,
627         .power_off              = pluto_imx091_power_off,
628 };
629
630 static int pluto_imx132_power_on(struct imx132_power_rail *pw)
631 {
632         int err;
633
634         if (unlikely(WARN_ON(!pw || !pw->avdd || !pw->iovdd || !pw->dvdd)))
635                 return -EFAULT;
636
637         if (pluto_get_extra_regulators())
638                 goto pluto_imx132_poweron_fail;
639
640         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
641
642         tegra_pinmux_config_table(&pbb0_enable, 1);
643
644         err = regulator_enable(pluto_i2cvdd);
645         if (unlikely(err))
646                 goto imx132_i2c_fail;
647
648         err = regulator_enable(pluto_vcmvdd);
649         if (unlikely(err))
650                 goto imx132_vcm_fail;
651
652         err = regulator_enable(pw->avdd);
653         if (unlikely(err))
654                 goto imx132_avdd_fail;
655
656         err = regulator_enable(pw->dvdd);
657         if (unlikely(err))
658                 goto imx132_dvdd_fail;
659
660         err = regulator_enable(pw->iovdd);
661         if (unlikely(err))
662                 goto imx132_iovdd_fail;
663
664         usleep_range(1, 2);
665
666         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
667
668         return 0;
669
670 imx132_iovdd_fail:
671         regulator_disable(pw->dvdd);
672
673 imx132_dvdd_fail:
674         regulator_disable(pw->avdd);
675
676 imx132_avdd_fail:
677         regulator_disable(pluto_vcmvdd);
678
679 imx132_vcm_fail:
680         regulator_disable(pluto_i2cvdd);
681
682 imx132_i2c_fail:
683         tegra_pinmux_config_table(&pbb0_disable, 1);
684
685 pluto_imx132_poweron_fail:
686         pr_err("%s failed.\n", __func__);
687         return -ENODEV;
688 }
689
690 static int pluto_imx132_power_off(struct imx132_power_rail *pw)
691 {
692         if (unlikely(WARN_ON(!pw || !pw->avdd || !pw->iovdd || !pw->dvdd ||
693                         !pluto_i2cvdd || !pluto_vcmvdd)))
694                 return -EFAULT;
695
696         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
697
698         usleep_range(1, 2);
699
700         regulator_disable(pw->iovdd);
701         regulator_disable(pw->dvdd);
702         regulator_disable(pw->avdd);
703
704         tegra_pinmux_config_table(&pbb0_disable, 1);
705
706         regulator_disable(pluto_vcmvdd);
707         regulator_disable(pluto_i2cvdd);
708
709         return 0;
710 }
711
712 struct imx132_platform_data pluto_imx132_data = {
713         .power_on = pluto_imx132_power_on,
714         .power_off = pluto_imx132_power_off,
715 };
716
717 static struct ad5816_platform_data pluto_ad5816_pdata = {
718         .cfg            = 0,
719         .num            = 0,
720         .sync           = 0,
721         .dev_name       = "focuser",
722         .power_on       = pluto_focuser_power_on,
723         .power_off      = pluto_focuser_power_off,
724 };
725
726 static struct regulator *dvdd_1v8;
727 static struct regulator *avdd_cam2;
728 static struct regulator *vdd_af1;
729 static int pluto_ov5640_power_on(struct device *dev)
730 {
731         if (avdd_cam2 == NULL) {
732                 avdd_cam2 = regulator_get(dev, "avdd_cam2");
733                 if (WARN_ON(IS_ERR(avdd_cam2))) {
734                         pr_err("%s: couldn't get regulator avdd_cam2: %ld\n",
735                                 __func__, PTR_ERR(avdd_cam2));
736                         avdd_cam2 = NULL;
737                         goto avdd_cam2_fail;
738                 }
739         }
740         if (dvdd_1v8 == NULL) {
741                 dvdd_1v8 = regulator_get(dev, "vdd_1v8_cam12");
742                 if (WARN_ON(IS_ERR(dvdd_1v8))) {
743                         pr_err("%s: couldn't get regulator vdd_1v8_cam: %ld\n",
744                                 __func__, PTR_ERR(dvdd_1v8));
745                         dvdd_1v8 = NULL;
746                         goto dvdd_1v8_fail;
747                 }
748         }
749
750         if (vdd_af1 == NULL) {
751                 vdd_af1 = regulator_get(dev, "vdd_af_cam1");
752                 if (WARN_ON(IS_ERR(vdd_af1))) {
753                         pr_err("%s: couldn't get regulator vdd_af_cam1: %ld\n",
754                                 __func__, PTR_ERR(vdd_af1));
755                         vdd_af1 = NULL;
756                         goto vdd_af1_fail;
757                 }
758         }
759
760         /* power up sequence */
761         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
762         gpio_set_value(CAM_RSTN, 0);
763         mdelay(1);
764
765         regulator_enable(vdd_af1);
766         regulator_enable(dvdd_1v8);
767         regulator_enable(avdd_cam2);
768
769         tegra_pinmux_config_table(&pbb0_enable, 1);
770
771         mdelay(5);
772         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
773         mdelay(1);
774         gpio_set_value(CAM_RSTN, 1);
775
776         mdelay(20);
777
778         return 0;
779
780 vdd_af1_fail:
781         regulator_disable(dvdd_1v8);
782 dvdd_1v8_fail:
783         regulator_disable(avdd_cam2);
784 avdd_cam2_fail:
785         return -ENODEV;
786 }
787
788 static int pluto_ov5640_power_off(struct device *dev)
789 {
790         gpio_set_value(CAM_RSTN, 0);
791
792         tegra_pinmux_config_table(&pbb0_disable, 1);
793
794         if (avdd_cam2)
795                 regulator_disable(avdd_cam2);
796         if (dvdd_1v8)
797                 regulator_disable(dvdd_1v8);
798         if (vdd_af1)
799                 regulator_disable(vdd_af1);
800         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
801
802         return 0;
803 }
804
805 struct ov5640_platform_data pluto_ov5640_data = {
806         .power_on = pluto_ov5640_power_on,
807         .power_off = pluto_ov5640_power_off,
808 };
809
810 static struct i2c_board_info pluto_board_info_ov5640[] = {
811         {
812                 I2C_BOARD_INFO("ov5640", 0x3c),
813                 .platform_data = &pluto_ov5640_data,
814         }
815 };
816
817 static struct i2c_board_info pluto_i2c_board_info_e1625[] = {
818         {
819                 I2C_BOARD_INFO("imx091", 0x10),
820                 .platform_data = &imx091_pdata,
821         },
822         {
823                 I2C_BOARD_INFO("imx132", 0x36),
824                 .platform_data = &pluto_imx132_data,
825         },
826         {
827                 I2C_BOARD_INFO("ad5816", 0x0E),
828                 .platform_data = &pluto_ad5816_pdata,
829         },
830 };
831
832 /* Detect ov5640 adapter by toggling the CAM_GPIO1 and read it back
833  * from CAM_GPIO2.
834  * On the ov5640 adapter board (E1633) for pluto, pin 5 & 6 of connector J9
835  * should be shorted.
836  */
837 static int ov5640_installed(void)
838 {
839         int val;
840         int ret;
841
842         ret = gpio_request(CAM_GPIO1, "camera_gpio1");
843         if (ret < 0) {
844                 pr_err("%s, gpio_request failed for CAM_GPIO1\n", __func__);
845                 return 0;
846         }
847
848         ret = gpio_request(CAM_GPIO2, "camera_gpio2");
849         if (ret < 0) {
850                 pr_err("%s, gpio_request failed for CAM_GPIO2\n", __func__);
851                 gpio_free(CAM_GPIO1);
852                 return 0;
853         }
854
855         gpio_direction_output(CAM_GPIO1, 1);
856         gpio_direction_input(CAM_GPIO2);
857
858         val = gpio_get_value(CAM_GPIO1);
859         ret = gpio_get_value(CAM_GPIO2);
860         pr_info("%s round 1: %d vs %d\n", __func__, val, ret);
861         if (ret != val) {
862                 gpio_free(CAM_GPIO1);
863                 gpio_free(CAM_GPIO2);
864                 return 0;
865         }
866
867         /* toggle CAM_GPIO1 and read back from detect pin */
868         val ^= 1;
869         gpio_set_value(CAM_GPIO1, val & 1);
870         ret = gpio_get_value(CAM_GPIO2);
871         /* resume CAM_GPIO1 state */
872         gpio_set_value(CAM_GPIO1, (~val) & 1);
873
874         gpio_free(CAM_GPIO2);
875         gpio_free(CAM_GPIO1);
876
877         pr_info("%s round 2: %d vs %d\n", __func__, val, ret);
878         if (ret != val)
879                 return 0;
880
881         return 1;
882 }
883
884 static int pluto_camera_init(void)
885 {
886         pr_debug("%s: ++\n", __func__);
887
888         tegra_pinmux_config_table(&mclk_disable, 1);
889         tegra_pinmux_config_table(&pbb0_disable, 1);
890
891         if (ov5640_installed()) {
892                 pr_info("%s ov5640 installed.\n", __func__);
893                 i2c_register_board_info(2, pluto_board_info_ov5640,
894                         ARRAY_SIZE(pluto_board_info_ov5640));
895         } else
896                 i2c_register_board_info(2, pluto_i2c_board_info_e1625,
897                         ARRAY_SIZE(pluto_i2c_board_info_e1625));
898
899         return 0;
900 }
901
902 /* MPU board file definition */
903 static struct mpu_platform_data mpu_gyro_data = {
904         .int_config     = 0x00,
905         .level_shifter  = 0,
906         .orientation    = MPU_GYRO_ORIENTATION,
907         .sec_slave_type = SECONDARY_SLAVE_TYPE_NONE,
908         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
909                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
910 };
911
912 static struct mpu_platform_data mpu_compass_data = {
913         .orientation    = MPU_COMPASS_ORIENTATION,
914         .config         = NVI_CONFIG_BOOT_MPU,
915 };
916
917 static struct mpu_platform_data bmp180_pdata = {
918         .config         = NVI_CONFIG_BOOT_MPU,
919 };
920
921 static struct i2c_board_info __initdata inv_mpu_i2c0_board_info[] = {
922         {
923                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
924                 .platform_data = &mpu_gyro_data,
925         },
926         {
927                 /* The actual BMP180 address is 0x77 but because this conflicts
928                  * with another device, this address is hacked so Linux will
929                  * call the driver.  The conflict is technically okay since the
930                  * BMP180 is behind the MPU.  Also, the BMP180 driver uses a
931                  * hard-coded address of 0x77 since it can't be changed anyway.
932                  */
933                 I2C_BOARD_INFO("bmp180", 0x78),
934                 .platform_data = &bmp180_pdata,
935         },
936         {
937                 I2C_BOARD_INFO(MPU_COMPASS_NAME, MPU_COMPASS_ADDR),
938                 .platform_data = &mpu_compass_data,
939         },
940 };
941
942 static void mpuirq_init(void)
943 {
944         int ret = 0;
945         int i = 0;
946
947         pr_info("*** MPU START *** mpuirq_init...\n");
948
949         /* MPU-IRQ assignment */
950         ret = gpio_request(MPU_GYRO_IRQ_GPIO, MPU_GYRO_NAME);
951         if (ret < 0) {
952                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
953                 return;
954         }
955
956         ret = gpio_direction_input(MPU_GYRO_IRQ_GPIO);
957         if (ret < 0) {
958                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
959                 gpio_free(MPU_GYRO_IRQ_GPIO);
960                 return;
961         }
962         pr_info("*** MPU END *** mpuirq_init...\n");
963
964         inv_mpu_i2c0_board_info[i++].irq = gpio_to_irq(MPU_GYRO_IRQ_GPIO);
965 #if MPU_COMPASS_IRQ_GPIO
966         inv_mpu_i2c0_board_info[i++].irq = gpio_to_irq(MPU_COMPASS_IRQ_GPIO);
967 #endif
968         i2c_register_board_info(MPU_GYRO_BUS_NUM, inv_mpu_i2c0_board_info,
969                 ARRAY_SIZE(inv_mpu_i2c0_board_info));
970 }
971
972 static int pluto_nct1008_init(void)
973 {
974         int nct1008_port;
975         int ret = 0;
976
977         if (board_info.board_id == BOARD_E1580 ||
978             board_info.board_id == BOARD_E1575 ||
979             board_info.board_id == BOARD_E1577) {
980                 nct1008_port = TEGRA_GPIO_PX6;
981         } else {
982                 nct1008_port = TEGRA_GPIO_PX6;
983                 pr_err("Warning: nct alert port assumed TEGRA_GPIO_PX6 for unknown pluto board id E%d\n",
984                         board_info.board_id);
985         }
986
987         tegra_add_cdev_trips(pluto_nct1008_pdata.trips,
988                                 &pluto_nct1008_pdata.num_trips);
989
990         pluto_i2c4_nct1008_board_info[0].irq =
991                 gpio_to_irq(nct1008_port);
992         pr_info("%s: pluto nct1008 irq %d",
993                         __func__, pluto_i2c4_nct1008_board_info[0].irq);
994
995         ret = gpio_request(nct1008_port, "temp_alert");
996         if (ret < 0)
997                 return ret;
998
999         ret = gpio_direction_input(nct1008_port);
1000         if (ret < 0) {
1001                 pr_info("%s: calling gpio_free(nct1008_port)", __func__);
1002                 gpio_free(nct1008_port);
1003         }
1004
1005         /* pluto has thermal sensor on GEN1-I2C i.e. instance 0 */
1006         i2c_register_board_info(0, pluto_i2c4_nct1008_board_info,
1007                 ARRAY_SIZE(pluto_i2c4_nct1008_board_info));
1008
1009         return ret;
1010 }
1011
1012 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
1013 static struct thermal_trip_info skin_trips[] = {
1014         {
1015                 .cdev_type = "skin-balanced",
1016                 .trip_temp = 45000,
1017                 .trip_type = THERMAL_TRIP_PASSIVE,
1018                 .upper = THERMAL_NO_LIMIT,
1019                 .lower = THERMAL_NO_LIMIT,
1020                 .hysteresis = 0,
1021         },
1022 };
1023
1024 static struct therm_est_subdevice skin_devs[] = {
1025         {
1026                 .dev_data = "nct_ext",
1027                 .coeffs = {
1028                         2, 1, 1, 1,
1029                         1, 1, 1, 1,
1030                         1, 1, 1, 0,
1031                         1, 1, 0, 0,
1032                         0, 0, -1, -7
1033                 },
1034         },
1035         {
1036                 .dev_data = "nct_int",
1037                 .coeffs = {
1038                         -11, -7, -5, -3,
1039                         -3, -2, -1, 0,
1040                         0, 0, 1, 1,
1041                         1, 2, 2, 3,
1042                         4, 6, 11, 18
1043                 },
1044         },
1045 };
1046
1047 static struct therm_est_data skin_data = {
1048         .num_trips = ARRAY_SIZE(skin_trips),
1049         .trips = skin_trips,
1050         .toffset = 9793,
1051         .polling_period = 1100,
1052         .passive_delay = 15000,
1053         .tc1 = 10,
1054         .tc2 = 1,
1055         .ndevs = ARRAY_SIZE(skin_devs),
1056         .devs = skin_devs,
1057 };
1058
1059 static struct throttle_table skin_throttle_table[] = {
1060         /* CPU_THROT_LOW cannot be used by other than CPU */
1061         /*      CPU,  C2BUS,  C3BUS,   SCLK,    EMC   */
1062         { { 1810500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1063         { { 1785000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1064         { { 1759500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1065         { { 1734000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1066         { { 1708500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1067         { { 1683000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1068         { { 1657500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1069         { { 1632000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1070         { { 1606500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1071         { { 1581000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1072         { { 1555500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1073         { { 1530000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1074         { { 1504500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1075         { { 1479000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1076         { { 1453500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1077         { { 1428000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1078         { { 1402500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1079         { { 1377000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1080         { { 1351500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1081         { { 1326000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1082         { { 1300500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1083         { { 1275000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1084         { { 1249500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1085         { { 1224000, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1086         { { 1198500, NO_CAP, NO_CAP, NO_CAP, NO_CAP } },
1087         { { 1173000, 636000, NO_CAP, NO_CAP, NO_CAP } },
1088         { { 1147500, 636000, NO_CAP, NO_CAP, NO_CAP } },
1089         { { 1122000, 636000, NO_CAP, NO_CAP, NO_CAP } },
1090         { { 1096500, 636000, NO_CAP, NO_CAP, NO_CAP } },
1091         { { 1071000, 636000, NO_CAP, NO_CAP, NO_CAP } },
1092         { { 1045500, 636000, NO_CAP, NO_CAP, NO_CAP } },
1093         { { 1020000, 636000, NO_CAP, NO_CAP, NO_CAP } },
1094         { {  994500, 636000, NO_CAP, NO_CAP, NO_CAP } },
1095         { {  969000, 600000, NO_CAP, NO_CAP, NO_CAP } },
1096         { {  943500, 600000, NO_CAP, NO_CAP, NO_CAP } },
1097         { {  918000, 600000, NO_CAP, NO_CAP, NO_CAP } },
1098         { {  892500, 600000, NO_CAP, NO_CAP, NO_CAP } },
1099         { {  867000, 600000, NO_CAP, NO_CAP, NO_CAP } },
1100         { {  841500, 564000, NO_CAP, NO_CAP, NO_CAP } },
1101         { {  816000, 564000, NO_CAP, NO_CAP, 792000 } },
1102         { {  790500, 564000, NO_CAP, 372000, 792000 } },
1103         { {  765000, 564000, 468000, 372000, 792000 } },
1104         { {  739500, 528000, 468000, 372000, 792000 } },
1105         { {  714000, 528000, 468000, 336000, 792000 } },
1106         { {  688500, 528000, 420000, 336000, 792000 } },
1107         { {  663000, 492000, 420000, 336000, 792000 } },
1108         { {  637500, 492000, 420000, 336000, 408000 } },
1109         { {  612000, 492000, 420000, 300000, 408000 } },
1110         { {  586500, 492000, 360000, 336000, 408000 } },
1111         { {  561000, 420000, 420000, 300000, 408000 } },
1112         { {  535500, 420000, 360000, 228000, 408000 } },
1113         { {  510000, 420000, 288000, 228000, 408000 } },
1114         { {  484500, 324000, 288000, 228000, 408000 } },
1115         { {  459000, 324000, 288000, 228000, 408000 } },
1116         { {  433500, 324000, 288000, 228000, 408000 } },
1117         { {  408000, 324000, 288000, 228000, 408000 } },
1118 };
1119
1120 static struct balanced_throttle skin_throttle = {
1121         .throt_tab_size = ARRAY_SIZE(skin_throttle_table),
1122         .throt_tab = skin_throttle_table,
1123 };
1124
1125 static int __init pluto_skin_init(void)
1126 {
1127         if (machine_is_tegra_pluto()) {
1128                 balanced_throttle_register(&skin_throttle, "skin-balanced");
1129                 tegra_skin_therm_est_device.dev.platform_data = &skin_data;
1130                 platform_device_register(&tegra_skin_therm_est_device);
1131         }
1132
1133         return 0;
1134 }
1135 late_initcall(pluto_skin_init);
1136 #endif
1137
1138 void __init max77665_init(void)
1139 {
1140         int err;
1141
1142         err = gpio_request(MAX77665_CHARGER_INT, "CHARGER_INT");
1143         if (err < 0) {
1144                 pr_err("%s: gpio_request failed %d\n", __func__, err);
1145                 goto fail_init_irq;
1146         }
1147
1148         err = gpio_direction_input(MAX77665_CHARGER_INT);
1149         if (err < 0) {
1150                 pr_err("%s: gpio_direction_input failed %d\n", __func__, err);
1151                 goto fail_init_irq;
1152         }
1153
1154         pluto_i2c_board_info_max77665[0].irq =
1155                                 gpio_to_irq(MAX77665_CHARGER_INT);
1156 fail_init_irq:
1157         err = i2c_register_board_info(4, pluto_i2c_board_info_max77665,
1158                 ARRAY_SIZE(pluto_i2c_board_info_max77665));
1159         if (err)
1160                 pr_err("%s: max77665 device register failed.\n", __func__);
1161
1162         return;
1163 }
1164
1165 int __init pluto_sensors_init(void)
1166 {
1167         int err;
1168
1169         tegra_get_board_info(&board_info);
1170
1171         pr_debug("%s: ++\n", __func__);
1172         pluto_camera_init();
1173
1174         err = pluto_nct1008_init();
1175         if (err)
1176                 return err;
1177
1178         err = i2c_register_board_info(0, pluto_i2c1_isl_board_info,
1179                                 ARRAY_SIZE(pluto_i2c1_isl_board_info));
1180         if (err)
1181                 pr_err("%s: isl board register failed.\n", __func__);
1182
1183         mpuirq_init();
1184         max77665_init();
1185         pluto_i2c_board_info_max77665[0].irq = gpio_to_irq(TEGRA_GPIO_PJ0);
1186
1187         err = i2c_register_board_info(0, max17042_device,
1188                                 ARRAY_SIZE(max17042_device));
1189         if (err)
1190                 pr_err("%s: max17042 device register failed.\n", __func__);
1191
1192
1193         return 0;
1194 }