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