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