arm: tegra: sd: enable sd dpd
[linux-2.6.git] / arch / arm / mach-tegra / board-enterprise-sensors.c
1 /*
2  * arch/arm/mach-tegra/board-enterprise-sensors.c
3  *
4  * Copyright (c) 2011-2012, NVIDIA CORPORATION, All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions are
8  * met:
9  *
10  * Redistributions of source code must retain the above copyright notice,
11  * this list of conditions and the following disclaimer.
12  *
13  * Redistributions in binary form must reproduce the above copyright
14  * notice, this list of conditions and the following disclaimer in the
15  * documentation and/or other materials provided with the distribution.
16  *
17  * Neither the name of NVIDIA CORPORATION nor the names of its contributors
18  * may be used to endorse or promote products derived from this software
19  * without specific prior written permission.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
22  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
24  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33
34 #include <linux/i2c.h>
35 #include <linux/delay.h>
36 #include <linux/i2c/pca954x.h>
37 #include <linux/nct1008.h>
38 #include <linux/err.h>
39 #include <linux/mpu.h>
40 #include <linux/platform_data/ina230.h>
41 #include <linux/regulator/consumer.h>
42 #include <linux/slab.h>
43 #include <mach/gpio.h>
44 #include <media/ar0832_main.h>
45 #include <media/tps61050.h>
46 #include <media/ov9726.h>
47 #include <mach/edp.h>
48 #include <mach/thermal.h>
49 #include "cpu-tegra.h"
50 #include "gpio-names.h"
51 #include "board-enterprise.h"
52 #include "board.h"
53
54 static int nct_get_temp(void *_data, long *temp)
55 {
56         struct nct1008_data *data = _data;
57         return nct1008_thermal_get_temp(data, temp);
58 }
59
60 static int nct_get_temp_low(void *_data, long *temp)
61 {
62         struct nct1008_data *data = _data;
63         return nct1008_thermal_get_temp_low(data, temp);
64 }
65
66 static int nct_set_limits(void *_data,
67                         long lo_limit_milli,
68                         long hi_limit_milli)
69 {
70         struct nct1008_data *data = _data;
71         return nct1008_thermal_set_limits(data,
72                                         lo_limit_milli,
73                                         hi_limit_milli);
74 }
75
76 static int nct_set_alert(void *_data,
77                                 void (*alert_func)(void *),
78                                 void *alert_data)
79 {
80         struct nct1008_data *data = _data;
81         return nct1008_thermal_set_alert(data, alert_func, alert_data);
82 }
83
84 static int nct_set_shutdown_temp(void *_data, long shutdown_temp)
85 {
86         struct nct1008_data *data = _data;
87         return nct1008_thermal_set_shutdown_temp(data,
88                                                 shutdown_temp);
89 }
90
91 static void nct1008_probe_callback(struct nct1008_data *data)
92 {
93         struct tegra_thermal_device *thermal_device;
94
95         thermal_device = kzalloc(sizeof(struct tegra_thermal_device),
96                                         GFP_KERNEL);
97         if (!thermal_device) {
98                 pr_err("unable to allocate thermal device\n");
99                 return;
100         }
101
102         thermal_device->name = "nct1008";
103         thermal_device->data = data;
104         thermal_device->id = THERMAL_DEVICE_ID_NCT_EXT;
105         thermal_device->offset = TDIODE_OFFSET;
106         thermal_device->get_temp = nct_get_temp;
107         thermal_device->get_temp_low = nct_get_temp_low;
108         thermal_device->set_limits = nct_set_limits;
109         thermal_device->set_alert = nct_set_alert;
110         thermal_device->set_shutdown_temp = nct_set_shutdown_temp;
111
112         tegra_thermal_device_register(thermal_device);
113 }
114
115 static struct nct1008_platform_data enterprise_nct1008_pdata = {
116         .supported_hwrev = true,
117         .ext_range = true,
118         .conv_rate = 0x08,
119         .offset = 8, /* 4 * 2C. Bug 844025 - 1C for device accuracies */
120         .probe_callback = nct1008_probe_callback,
121 };
122
123 static struct i2c_board_info enterprise_i2c4_nct1008_board_info[] = {
124         {
125                 I2C_BOARD_INFO("nct1008", 0x4C),
126                 .irq = TEGRA_GPIO_TO_IRQ(TEGRA_GPIO_PH7),
127                 .platform_data = &enterprise_nct1008_pdata,
128         }
129 };
130
131 static void enterprise_nct1008_init(void)
132 {
133         int ret;
134
135         ret = gpio_request(TEGRA_GPIO_PH7, "temp_alert");
136         if (ret < 0) {
137                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
138                 return;
139         }
140
141         ret = gpio_direction_input(TEGRA_GPIO_PH7);
142         if (ret < 0) {
143                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
144                 gpio_free(TEGRA_GPIO_PH7);
145                 return;
146         }
147
148         i2c_register_board_info(4, enterprise_i2c4_nct1008_board_info,
149                                 ARRAY_SIZE(enterprise_i2c4_nct1008_board_info));
150 }
151
152 /* MPU board file definition    */
153 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
154 #define MPU_GYRO_NAME           "mpu3050"
155 #endif
156 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU6050)
157 #define MPU_GYRO_NAME           "mpu6050"
158 #endif
159 static struct mpu_platform_data mpu_gyro_data = {
160         .int_config     = 0x10,
161         .level_shifter  = 0,
162         .orientation    = MPU_GYRO_ORIENTATION, /* Located in board_[platformname].h    */
163 };
164
165 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
166 static struct ext_slave_platform_data mpu_accel_data = {
167         .address        = MPU_ACCEL_ADDR,
168         .irq            = 0,
169         .adapt_num      = MPU_ACCEL_BUS_NUM,
170         .bus            = EXT_SLAVE_BUS_SECONDARY,
171         .orientation    = MPU_ACCEL_ORIENTATION,        /* Located in board_[platformname].h    */
172 };
173 #endif
174
175 static struct ext_slave_platform_data mpu_compass_data = {
176         .address        = MPU_COMPASS_ADDR,
177         .irq            = 0,
178         .adapt_num      = MPU_COMPASS_BUS_NUM,
179         .bus            = EXT_SLAVE_BUS_PRIMARY,
180         .orientation    = MPU_COMPASS_ORIENTATION,      /* Located in board_[platformname].h    */
181 };
182
183 static struct i2c_board_info __initdata inv_mpu_i2c2_board_info[] = {
184         {
185                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
186                 .irq = TEGRA_GPIO_TO_IRQ(MPU_GYRO_IRQ_GPIO),
187                 .platform_data = &mpu_gyro_data,
188         },
189 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
190         {
191                 I2C_BOARD_INFO(MPU_ACCEL_NAME, MPU_ACCEL_ADDR),
192 #if     MPU_ACCEL_IRQ_GPIO
193                 .irq = TEGRA_GPIO_TO_IRQ(MPU_ACCEL_IRQ_GPIO),
194 #endif
195                 .platform_data = &mpu_accel_data,
196         },
197 #endif
198         {
199                 I2C_BOARD_INFO(MPU_COMPASS_NAME, MPU_COMPASS_ADDR),
200 #if     MPU_COMPASS_IRQ_GPIO
201                 .irq = TEGRA_GPIO_TO_IRQ(MPU_COMPASS_IRQ_GPIO),
202 #endif
203                 .platform_data = &mpu_compass_data,
204         },
205 };
206
207 static void mpuirq_init(void)
208 {
209         int ret = 0;
210
211         pr_info("*** MPU START *** mpuirq_init...\n");
212
213 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
214 #if     MPU_ACCEL_IRQ_GPIO
215         /* ACCEL-IRQ assignment */
216         ret = gpio_request(MPU_ACCEL_IRQ_GPIO, MPU_ACCEL_NAME);
217         if (ret < 0) {
218                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
219                 return;
220         }
221
222         ret = gpio_direction_input(MPU_ACCEL_IRQ_GPIO);
223         if (ret < 0) {
224                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
225                 gpio_free(MPU_ACCEL_IRQ_GPIO);
226                 return;
227         }
228 #endif
229 #endif
230
231         /* MPU-IRQ assignment */
232         ret = gpio_request(MPU_GYRO_IRQ_GPIO, MPU_GYRO_NAME);
233         if (ret < 0) {
234                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
235                 return;
236         }
237
238         ret = gpio_direction_input(MPU_GYRO_IRQ_GPIO);
239         if (ret < 0) {
240                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
241                 gpio_free(MPU_GYRO_IRQ_GPIO);
242                 return;
243         }
244         pr_info("*** MPU END *** mpuirq_init...\n");
245
246         i2c_register_board_info(MPU_GYRO_BUS_NUM, inv_mpu_i2c2_board_info,
247                 ARRAY_SIZE(inv_mpu_i2c2_board_info));
248 }
249
250 static inline void enterprise_msleep(u32 t)
251 {
252         /*
253         If timer value is between ( 10us - 20ms),
254         usleep_range() is recommended.
255         Please read Documentation/timers/timers-howto.txt.
256         */
257         usleep_range(t*1000, t*1000 + 500);
258 }
259
260 static struct i2c_board_info enterprise_i2c0_isl_board_info[] = {
261         {
262                 I2C_BOARD_INFO("isl29028", 0x44),
263         }
264 };
265
266 static void enterprise_isl_init(void)
267 {
268         i2c_register_board_info(0, enterprise_i2c0_isl_board_info,
269                                 ARRAY_SIZE(enterprise_i2c0_isl_board_info));
270 }
271
272 enum CAMERA_INDEX {
273         CAM_REAR_LEFT,
274         CAM_REAR_RIGHT,
275         CAM_FRONT,
276         NUM_OF_CAM
277 };
278
279 struct enterprise_power_rail {
280         struct regulator *cam_reg;
281         struct regulator *csi_reg;
282 };
283
284 static struct enterprise_power_rail ent_vicsi_pwr[NUM_OF_CAM];
285
286 static int enterprise_cam_pwr(enum CAMERA_INDEX cam, bool pwr_on)
287 {
288         struct enterprise_power_rail *reg_cam = &ent_vicsi_pwr[cam];
289         int ret = 0;
290
291         /*
292         * SW must turn on 1.8V first then 2.8V
293         * SW must turn off 2.8V first then 1.8V
294         */
295         if (pwr_on) {
296                 if (reg_cam->csi_reg == NULL) {
297                         reg_cam->csi_reg = regulator_get(NULL,
298                                                 "avdd_dsi_csi");
299                         if (IS_ERR_OR_NULL(reg_cam->csi_reg)) {
300                                 pr_err("%s: csi pwr err\n", __func__);
301                                 ret = PTR_ERR(reg_cam->csi_reg);
302                                 goto enterprise_cam_pwr_fail;
303                         }
304                 }
305
306                 ret = regulator_enable(reg_cam->csi_reg);
307                 if (ret) {
308                         pr_err("%s: enable csi pwr err\n", __func__);
309                         goto enterprise_cam_pwr_fail;
310                 }
311
312                 if (reg_cam->cam_reg == NULL) {
313                         reg_cam->cam_reg = regulator_get(NULL,
314                                                 "vddio_cam");
315                         if (IS_ERR_OR_NULL(reg_cam->cam_reg)) {
316                                 pr_err("%s: vddio pwr err\n", __func__);
317                                 ret = PTR_ERR(reg_cam->cam_reg);
318                                 regulator_disable(reg_cam->csi_reg);
319                                 goto enterprise_cam_pwr_fail;
320                         }
321                 }
322
323                 ret = regulator_enable(reg_cam->cam_reg);
324                 if (ret) {
325                         pr_err("%s: enable vddio pwr err\n", __func__);
326                         regulator_disable(reg_cam->csi_reg);
327                         goto enterprise_cam_pwr_fail;
328                 }
329         } else {
330                 if (reg_cam->cam_reg)
331                         regulator_disable(reg_cam->cam_reg);
332
333                 if (reg_cam->csi_reg)
334                         regulator_disable(reg_cam->csi_reg);
335         }
336         return 0;
337
338 enterprise_cam_pwr_fail:
339         if (!IS_ERR_OR_NULL(reg_cam->cam_reg))
340                 regulator_put(reg_cam->cam_reg);
341         reg_cam->cam_reg = NULL;
342
343         if (!IS_ERR_OR_NULL(reg_cam->csi_reg))
344                 regulator_put(reg_cam->csi_reg);
345         reg_cam->csi_reg = NULL;
346
347         return ret;
348 }
349
350 static int enterprise_ar0832_ri_power_on(int is_stereo)
351 {
352         int ret = 0;
353
354         pr_info("%s: ++\n", __func__);
355         ret = enterprise_cam_pwr(CAM_REAR_RIGHT, true);
356
357         /* Release Reset */
358         if (is_stereo) {
359                 gpio_set_value(CAM1_RST_L_GPIO, 1);
360                 gpio_set_value(CAM2_RST_L_GPIO, 1);
361         } else
362                 gpio_set_value(CAM1_RST_L_GPIO, 1);
363         /*
364         It takes 2400 EXTCLK for ar0832 to be ready for I2c.
365         EXTCLK is 10 ~ 24MHz. 1 ms should be enough to cover
366         at least 2400 EXTCLK within frequency range.
367         */
368         enterprise_msleep(1);
369
370         return ret;
371 }
372
373 static int enterprise_ar0832_le_power_on(int is_stereo)
374 {
375         int ret = 0;
376
377         pr_info("%s: ++\n", __func__);
378         ret = enterprise_cam_pwr(CAM_REAR_LEFT, true);
379
380         /* Release Reset */
381         gpio_set_value(CAM2_RST_L_GPIO, 1);
382
383         /*
384         It takes 2400 EXTCLK for ar0832 to be ready for I2c.
385         EXTCLK is 10 ~ 24MHz. 1 ms should be enough to cover
386         at least 2400 EXTCLK within frequency range.
387         */
388         enterprise_msleep(1);
389
390         /* CSI B is shared between Front camera and Rear Left camera */
391         gpio_set_value(CAM_CSI_MUX_SEL_GPIO, 1);
392
393         return ret;
394 }
395
396 static int enterprise_ar0832_ri_power_off(int is_stereo)
397 {
398         int ret;
399
400         pr_info("%s: ++\n", __func__);
401         ret = enterprise_cam_pwr(CAM_REAR_RIGHT, false);
402
403         /* Assert Reset */
404         if (is_stereo) {
405                 gpio_set_value(CAM1_RST_L_GPIO, 0);
406                 gpio_set_value(CAM2_RST_L_GPIO, 0);
407         } else
408                 gpio_set_value(CAM1_RST_L_GPIO, 0);
409
410         return ret;
411 }
412
413 static int enterprise_ar0832_le_power_off(int is_stereo)
414 {
415         int ret;
416
417         pr_info("%s: ++\n", __func__);
418         ret = enterprise_cam_pwr(CAM_REAR_LEFT, false);
419
420         /* Assert Reset */
421         gpio_set_value(CAM2_RST_L_GPIO, 0);
422
423         return ret;
424 }
425
426 static int enterprise_ov9726_power_on(void)
427 {
428         pr_info("ov9726 power on\n");
429
430         /* switch mipi mux to front camera */
431         gpio_set_value(CAM_CSI_MUX_SEL_GPIO, CAM_CSI_MUX_SEL_FRONT);
432         enterprise_cam_pwr(CAM_FRONT, true);
433
434         return 0;
435 }
436
437 static int enterprise_ov9726_power_off(void)
438 {
439         pr_info("ov9726 power off\n");
440
441         enterprise_cam_pwr(CAM_FRONT, false);
442
443         return 0;
444 }
445
446 struct ov9726_platform_data enterprise_ov9726_data = {
447         .power_on = enterprise_ov9726_power_on,
448         .power_off = enterprise_ov9726_power_off,
449         .gpio_rst = CAM3_RST_L_GPIO,
450         .rst_low_active = true,
451         .gpio_pwdn = CAM3_PWDN_GPIO,
452         .pwdn_low_active = false,
453 };
454
455 static struct nvc_torch_pin_state enterprise_tps61050_pinstate = {
456         .mask           = 0x0008, /*VGP3*/
457         .values         = 0x0008,
458 };
459
460 static struct tps61050_platform_data enterprise_tps61050_pdata = {
461         .dev_name       = "torch",
462         .pinstate       = &enterprise_tps61050_pinstate,
463 };
464
465
466 struct enterprise_cam_gpio {
467         int gpio;
468         const char *label;
469         int value;
470 };
471
472 #define TEGRA_CAMERA_GPIO(_gpio, _label, _value)        \
473         {                                               \
474                 .gpio = _gpio,                          \
475                 .label = _label,                        \
476                 .value = _value,                        \
477         }
478
479 static struct enterprise_cam_gpio enterprise_cam_gpio_data[] = {
480         [0] = TEGRA_CAMERA_GPIO(CAM_CSI_MUX_SEL_GPIO, "cam_csi_sel", 1),
481         [1] = TEGRA_CAMERA_GPIO(CAM1_RST_L_GPIO, "cam1_rst_lo", 0),
482         [2] = TEGRA_CAMERA_GPIO(CAM2_RST_L_GPIO, "cam2_rst_lo", 0),
483         [3] = TEGRA_CAMERA_GPIO(CAM3_RST_L_GPIO, "cam3_rst_lo", 0),
484         [4] = TEGRA_CAMERA_GPIO(CAM3_PWDN_GPIO, "cam3_pwdn", 1),
485         [5] = TEGRA_CAMERA_GPIO(CAM_FLASH_EN_GPIO, "flash_en", 1),
486         [6] = TEGRA_CAMERA_GPIO(CAM_I2C_MUX_RST_EXP, "cam_i2c_mux_rst", 1),
487 };
488
489 static struct pca954x_platform_mode enterprise_pca954x_modes[] = {
490         { .adap_id = PCA954x_I2C_BUS0, .deselect_on_exit = true, },
491         { .adap_id = PCA954x_I2C_BUS1, .deselect_on_exit = true, },
492         { .adap_id = PCA954x_I2C_BUS2, .deselect_on_exit = true, },
493         { .adap_id = PCA954x_I2C_BUS3, .deselect_on_exit = true, },
494 };
495
496 static struct pca954x_platform_data enterprise_pca954x_data = {
497         .modes    = enterprise_pca954x_modes,
498         .num_modes      = ARRAY_SIZE(enterprise_pca954x_modes),
499 };
500
501 static struct ar0832_platform_data enterprise_ar0832_ri_data = {
502         .power_on = enterprise_ar0832_ri_power_on,
503         .power_off = enterprise_ar0832_ri_power_off,
504         .id = "right",
505 };
506
507 static struct ar0832_platform_data enterprise_ar0832_le_data = {
508         .power_on = enterprise_ar0832_le_power_on,
509         .power_off = enterprise_ar0832_le_power_off,
510         .id = "left",
511 };
512
513 static const struct i2c_board_info enterprise_i2c2_boardinfo[] = {
514         {
515                 I2C_BOARD_INFO("pca9546", 0x70),
516                 .platform_data = &enterprise_pca954x_data,
517         },
518         {
519                 I2C_BOARD_INFO("tps61050", 0x33),
520                 .platform_data = &enterprise_tps61050_pdata,
521         },
522         {
523                 I2C_BOARD_INFO("ov9726", OV9726_I2C_ADDR >> 1),
524                 .platform_data = &enterprise_ov9726_data,
525         },
526 };
527
528 /*
529  * Since ar0832 driver should support multiple devices, slave
530  * address should be changed after it is open. Default slave
531  * address of ar0832 is 0x36. It will be changed to alternate
532  * address defined below when device is open.
533  */
534 static struct i2c_board_info ar0832_i2c2_boardinfo[] = {
535         {
536                 /* 0x36: alternative slave address */
537                 I2C_BOARD_INFO("ar0832", 0x36),
538                 .platform_data = &enterprise_ar0832_ri_data,
539         },
540         {
541                 /* 0x32: alternative slave address */
542                 I2C_BOARD_INFO("ar0832", 0x32),
543                 .platform_data = &enterprise_ar0832_le_data,
544         },
545         {
546                 I2C_BOARD_INFO("tps61050", 0x33),
547                 .platform_data = &enterprise_tps61050_pdata,
548         },
549         {
550                 I2C_BOARD_INFO("ov9726", OV9726_I2C_ADDR >> 1),
551                 .platform_data = &enterprise_ov9726_data,
552         },
553 };
554
555 static struct i2c_board_info enterprise_i2c6_boardinfo[] = {
556         {
557                 I2C_BOARD_INFO("ar0832", 0x36),
558                 .platform_data = &enterprise_ar0832_le_data,
559         },
560 };
561
562 static struct i2c_board_info enterprise_i2c7_boardinfo[] = {
563         {
564                 I2C_BOARD_INFO("ar0832", 0x36),
565                 .platform_data = &enterprise_ar0832_ri_data,
566         },
567 };
568
569 static int enterprise_cam_init(void)
570 {
571         int ret;
572         int i;
573         struct board_info bi;
574         struct board_info cam_bi;
575         bool i2c_mux = false;
576
577         pr_info("%s:++\n", __func__);
578         memset(ent_vicsi_pwr, 0, sizeof(ent_vicsi_pwr));
579         for (i = 0; i < ARRAY_SIZE(enterprise_cam_gpio_data); i++) {
580                 ret = gpio_request(enterprise_cam_gpio_data[i].gpio,
581                                    enterprise_cam_gpio_data[i].label);
582                 if (ret < 0) {
583                         pr_err("%s: gpio_request failed for gpio #%d\n",
584                                 __func__, i);
585                         goto fail_free_gpio;
586                 }
587                 gpio_direction_output(enterprise_cam_gpio_data[i].gpio,
588                                       enterprise_cam_gpio_data[i].value);
589                 gpio_export(enterprise_cam_gpio_data[i].gpio, false);
590         }
591
592         tegra_get_board_info(&bi);
593         tegra_get_camera_board_info(&cam_bi);
594
595         if (bi.board_id == BOARD_E1205) {
596                 if (bi.fab == BOARD_FAB_A00 || bi.fab == BOARD_FAB_A01)
597                         i2c_mux = false;
598                 else if (bi.fab == BOARD_FAB_A02)
599                         i2c_mux = true;
600         } else if (bi.board_id == BOARD_E1197) {
601                 if (cam_bi.fab == BOARD_FAB_A00)
602                         i2c_mux = false;
603                 else if (cam_bi.fab == BOARD_FAB_A01)
604                         i2c_mux = true;
605         }
606
607         if (!i2c_mux)
608                 i2c_register_board_info(2, ar0832_i2c2_boardinfo,
609                         ARRAY_SIZE(ar0832_i2c2_boardinfo));
610         else {
611                 i2c_register_board_info(2, enterprise_i2c2_boardinfo,
612                         ARRAY_SIZE(enterprise_i2c2_boardinfo));
613                 /*
614                  * Right  camera is on PCA954x's I2C BUS1,
615                  * Left camera is on BUS0
616                  */
617                 i2c_register_board_info(PCA954x_I2C_BUS0, enterprise_i2c6_boardinfo,
618                         ARRAY_SIZE(enterprise_i2c6_boardinfo));
619                 i2c_register_board_info(PCA954x_I2C_BUS1, enterprise_i2c7_boardinfo,
620                         ARRAY_SIZE(enterprise_i2c7_boardinfo));
621         }
622         return 0;
623
624 fail_free_gpio:
625         pr_err("%s enterprise_cam_init failed!\n", __func__);
626         while (i--)
627                 gpio_free(enterprise_cam_gpio_data[i].gpio);
628         return ret;
629 }
630
631 #define ENTERPRISE_INA230_ENABLED 0
632
633 #if ENTERPRISE_INA230_ENABLED
634 static struct ina230_platform_data ina230_platform = {
635         .rail_name = "VDD_AC_BAT",
636         .current_threshold = TEGRA_CUR_MON_THRESHOLD,
637         .resistor = TEGRA_CUR_MON_RESISTOR,
638         .min_cores_online = TEGRA_CUR_MON_MIN_CORES,
639 };
640
641 static struct i2c_board_info enterprise_i2c0_ina230_info[] = {
642         {
643                 I2C_BOARD_INFO("ina230", 0x42),
644                 .platform_data = &ina230_platform,
645                 .irq = -1,
646         },
647 };
648
649 static int __init enterprise_ina230_init(void)
650 {
651         return i2c_register_board_info(0, enterprise_i2c0_ina230_info,
652                                        ARRAY_SIZE(enterprise_i2c0_ina230_info));
653 }
654 #endif
655
656 int __init enterprise_sensors_init(void)
657 {
658         int ret;
659
660         enterprise_isl_init();
661         enterprise_nct1008_init();
662         mpuirq_init();
663 #if ENTERPRISE_INA230_ENABLED
664         enterprise_ina230_init();
665 #endif
666         ret = enterprise_cam_init();
667
668         return ret;
669 }
670