arm: tegra: sh532u focuser board support
[linux-2.6.git] / arch / arm / mach-tegra / board-cardhu-sensors.c
1 /*
2  * arch/arm/mach-tegra/board-cardhu-sensors.c
3  *
4  * Copyright (c) 2010-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/regulator/consumer.h>
37 #include <linux/i2c/pca954x.h>
38 #include <linux/i2c/pca953x.h>
39 #include <linux/nct1008.h>
40 #include <linux/gpio.h>
41
42 #include <mach/gpio-tegra.h>
43 #include <mach/fb.h>
44 #include <media/ov5650.h>
45 #include <media/ov14810.h>
46 #include <media/ov2710.h>
47 #include <media/tps61050.h>
48 #include <generated/mach-types.h>
49 #include "board.h"
50 #include <linux/mpu.h>
51 #include <media/sh532u.h>
52 #include <linux/bq27x00.h>
53 #include <mach/edp.h>
54 #include <mach/thermal.h>
55
56 #include "gpio-names.h"
57 #include "board-cardhu.h"
58 #include "cpu-tegra.h"
59
60 static struct regulator *cardhu_1v8_cam1 = NULL;
61 static struct regulator *cardhu_1v8_cam2 = NULL;
62 static struct regulator *cardhu_1v8_cam3 = NULL;
63 static struct regulator *cardhu_vdd_2v8_cam1 = NULL;
64 static struct regulator *cardhu_vdd_2v8_cam2 = NULL;
65 static struct regulator *cardhu_vdd_cam3 = NULL;
66
67 static struct board_info board_info;
68
69 static struct pca954x_platform_mode cardhu_pca954x_modes[] = {
70         { .adap_id = PCA954x_I2C_BUS0, .deselect_on_exit = true, },
71         { .adap_id = PCA954x_I2C_BUS1, .deselect_on_exit = true, },
72         { .adap_id = PCA954x_I2C_BUS2, .deselect_on_exit = true, },
73         { .adap_id = PCA954x_I2C_BUS3, .deselect_on_exit = true, },
74 };
75
76 static struct pca954x_platform_data cardhu_pca954x_data = {
77         .modes    = cardhu_pca954x_modes,
78         .num_modes      = ARRAY_SIZE(cardhu_pca954x_modes),
79 };
80
81 static int cardhu_camera_init(void)
82 {
83         int ret;
84
85         /* Boards E1198 and E1291 are of Cardhu personality
86          * and donot have TCA6416 exp for camera */
87         if ((board_info.board_id == BOARD_E1198) ||
88                 (board_info.board_id == BOARD_E1291)) {
89                 tegra_gpio_enable(CAM1_POWER_DWN_GPIO);
90                 ret = gpio_request(CAM1_POWER_DWN_GPIO, "camera_power_en");
91                 if (ret < 0)
92                         pr_err("%s: gpio_request failed for gpio %s\n",
93                                 __func__, "CAM1_POWER_DWN_GPIO");
94                                 tegra_gpio_enable(CAM3_POWER_DWN_GPIO);
95                 ret = gpio_request(CAM3_POWER_DWN_GPIO, "cam3_power_en");
96                 if (ret < 0)
97                         pr_err("%s: gpio_request failed for gpio %s\n",
98                                 __func__, "CAM3_POWER_DWN_GPIO");
99
100                 tegra_gpio_enable(CAM2_POWER_DWN_GPIO);
101                 ret = gpio_request(CAM2_POWER_DWN_GPIO, "camera2_power_en");
102                 if (ret < 0)
103                         pr_err("%s: gpio_request failed for gpio %s\n",
104                                 __func__, "CAM2_POWER_DWN_GPIO");
105
106                 tegra_gpio_enable(OV5650_RESETN_GPIO);
107                 ret = gpio_request(OV5650_RESETN_GPIO, "camera_reset");
108                 if (ret < 0)
109                         pr_err("%s: gpio_request failed for gpio %s\n",
110                                 __func__, "OV5650_RESETN_GPIO");
111
112                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
113                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
114                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
115                 mdelay(10);
116
117                 gpio_direction_output(OV5650_RESETN_GPIO, 1);
118                 mdelay(5);
119                 gpio_direction_output(OV5650_RESETN_GPIO, 0);
120                 mdelay(5);
121                 gpio_direction_output(OV5650_RESETN_GPIO, 1);
122                 mdelay(5);
123         }
124
125         /* To select the CSIB MUX either for cam2 or cam3 */
126         tegra_gpio_enable(CAMERA_CSI_MUX_SEL_GPIO);
127         ret = gpio_request(CAMERA_CSI_MUX_SEL_GPIO, "camera_csi_sel");
128         if (ret < 0)
129                 pr_err("%s: gpio_request failed for gpio %s\n",
130                         __func__, "CAMERA_CSI_MUX_SEL_GPIO");
131         gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 0);
132         gpio_export(CAMERA_CSI_MUX_SEL_GPIO, false);
133
134         return 0;
135 }
136
137 static int cardhu_left_ov5650_power_on(void)
138 {
139         /* Boards E1198 and E1291 are of Cardhu personality
140          * and donot have TCA6416 exp for camera */
141         if ((board_info.board_id == BOARD_E1198) ||
142                 (board_info.board_id == BOARD_E1291)) {
143
144                 if (cardhu_vdd_2v8_cam1 == NULL) {
145                         cardhu_vdd_2v8_cam1 = regulator_get(NULL, "vdd_2v8_cam1");
146                         if (WARN_ON(IS_ERR(cardhu_vdd_2v8_cam1))) {
147                                 pr_err("%s: couldn't get regulator vdd_2v8_cam1: %ld\n",
148                                         __func__, PTR_ERR(cardhu_vdd_2v8_cam1));
149                                 goto reg_alloc_fail;
150                         }
151                 }
152                 regulator_enable(cardhu_vdd_2v8_cam1);
153                 mdelay(5);
154         }
155
156         /* Enable VDD_1V8_Cam1 */
157         if (cardhu_1v8_cam1 == NULL) {
158                 cardhu_1v8_cam1 = regulator_get(NULL, "vdd_1v8_cam1");
159                 if (WARN_ON(IS_ERR(cardhu_1v8_cam1))) {
160                         pr_err("%s: couldn't get regulator vdd_1v8_cam1: %ld\n",
161                                 __func__, PTR_ERR(cardhu_1v8_cam1));
162                         goto reg_alloc_fail;
163                 }
164         }
165         regulator_enable(cardhu_1v8_cam1);
166
167         mdelay(5);
168         if ((board_info.board_id == BOARD_E1198) ||
169                 (board_info.board_id == BOARD_E1291)) {
170                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
171                 mdelay(20);
172                 gpio_direction_output(OV5650_RESETN_GPIO, 0);
173                 mdelay(100);
174                 gpio_direction_output(OV5650_RESETN_GPIO, 1);
175         }
176
177         if (board_info.board_id == BOARD_PM269) {
178                 gpio_direction_output(CAM1_RST_L_GPIO, 0);
179                 mdelay(100);
180                 gpio_direction_output(CAM1_RST_L_GPIO, 1);
181         }
182
183         return 0;
184
185 reg_alloc_fail:
186         if (cardhu_1v8_cam1) {
187                 regulator_put(cardhu_1v8_cam1);
188                 cardhu_1v8_cam1 = NULL;
189         }
190         if (cardhu_vdd_2v8_cam1) {
191                 regulator_put(cardhu_vdd_2v8_cam1);
192                 cardhu_vdd_2v8_cam1 = NULL;
193         }
194
195         return -ENODEV;
196
197 }
198
199 static int cardhu_left_ov5650_power_off(void)
200 {
201         /* Boards E1198 and E1291 are of Cardhu personality
202          * and donot have TCA6416 exp for camera */
203         if ((board_info.board_id == BOARD_E1198) ||
204                 (board_info.board_id == BOARD_E1291)) {
205                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
206                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
207                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
208         }
209         if (cardhu_1v8_cam1)
210                 regulator_disable(cardhu_1v8_cam1);
211         if (cardhu_vdd_2v8_cam1)
212                 regulator_disable(cardhu_vdd_2v8_cam1);
213
214         return 0;
215 }
216
217 struct ov5650_platform_data cardhu_left_ov5650_data = {
218         .power_on = cardhu_left_ov5650_power_on,
219         .power_off = cardhu_left_ov5650_power_off,
220 };
221
222 #ifdef CONFIG_VIDEO_OV14810
223 static int cardhu_ov14810_power_on(void)
224 {
225         if (board_info.board_id == BOARD_E1198) {
226                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
227                 mdelay(20);
228                 gpio_direction_output(OV14810_RESETN_GPIO, 0);
229                 mdelay(100);
230                 gpio_direction_output(OV14810_RESETN_GPIO, 1);
231         }
232
233         return 0;
234 }
235
236 static int cardhu_ov14810_power_off(void)
237 {
238         if (board_info.board_id == BOARD_E1198) {
239                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
240                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
241                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
242         }
243
244         return 0;
245 }
246
247 struct ov14810_platform_data cardhu_ov14810_data = {
248         .power_on = cardhu_ov14810_power_on,
249         .power_off = cardhu_ov14810_power_off,
250 };
251
252 struct ov14810_platform_data cardhu_ov14810uC_data = {
253         .power_on = NULL,
254         .power_off = NULL,
255 };
256
257 struct ov14810_platform_data cardhu_ov14810SlaveDev_data = {
258         .power_on = NULL,
259         .power_off = NULL,
260 };
261
262 static struct i2c_board_info cardhu_i2c_board_info_e1214[] = {
263         {
264                 I2C_BOARD_INFO("ov14810", 0x36),
265                 .platform_data = &cardhu_ov14810_data,
266         },
267         {
268                 I2C_BOARD_INFO("ov14810uC", 0x67),
269                 .platform_data = &cardhu_ov14810uC_data,
270         },
271         {
272                 I2C_BOARD_INFO("ov14810SlaveDev", 0x69),
273                 .platform_data = &cardhu_ov14810SlaveDev_data,
274         }
275 };
276 #endif
277
278 static int cardhu_right_ov5650_power_on(void)
279 {
280         /* CSI-B and front sensor are muxed on cardhu */
281         gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 0);
282
283         /* Boards E1198 and E1291 are of Cardhu personality
284          * and donot have TCA6416 exp for camera */
285         if ((board_info.board_id == BOARD_E1198) ||
286                 (board_info.board_id == BOARD_E1291)) {
287
288                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
289                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
290                 mdelay(10);
291
292                 if (cardhu_vdd_2v8_cam2 == NULL) {
293                         cardhu_vdd_2v8_cam2 = regulator_get(NULL, "vdd_2v8_cam2");
294                         if (WARN_ON(IS_ERR(cardhu_vdd_2v8_cam2))) {
295                                 pr_err("%s: couldn't get regulator vdd_2v8_cam2: %ld\n",
296                                         __func__, PTR_ERR(cardhu_vdd_2v8_cam2));
297                                 goto reg_alloc_fail;
298                         }
299                 }
300                 regulator_enable(cardhu_vdd_2v8_cam2);
301                 mdelay(5);
302         }
303
304         /* Enable VDD_1V8_Cam2 */
305         if (cardhu_1v8_cam2 == NULL) {
306                 cardhu_1v8_cam2 = regulator_get(NULL, "vdd_1v8_cam2");
307                 if (WARN_ON(IS_ERR(cardhu_1v8_cam2))) {
308                         pr_err("%s: couldn't get regulator vdd_1v8_cam2: %ld\n",
309                                 __func__, PTR_ERR(cardhu_1v8_cam2));
310                         goto reg_alloc_fail;
311                 }
312         }
313         regulator_enable(cardhu_1v8_cam2);
314
315         mdelay(5);
316
317         if (board_info.board_id == BOARD_PM269) {
318                 gpio_direction_output(CAM2_RST_L_GPIO, 0);
319                 mdelay(100);
320                 gpio_direction_output(CAM2_RST_L_GPIO, 1);
321         }
322
323         return 0;
324
325 reg_alloc_fail:
326         if (cardhu_1v8_cam2) {
327                 regulator_put(cardhu_1v8_cam2);
328                 cardhu_1v8_cam2 = NULL;
329         }
330         if (cardhu_vdd_2v8_cam2) {
331                 regulator_put(cardhu_vdd_2v8_cam2);
332                 cardhu_vdd_2v8_cam2 = NULL;
333         }
334
335         return -ENODEV;
336
337 }
338
339 static int cardhu_right_ov5650_power_off(void)
340 {
341         /* CSI-B and front sensor are muxed on cardhu */
342         gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 0);
343
344         /* Boards E1198 and E1291 are of Cardhu personality
345          * and donot have TCA6416 exp for camera */
346         if ((board_info.board_id == BOARD_E1198) ||
347                 (board_info.board_id == BOARD_E1291)) {
348                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
349                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
350                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
351         }
352
353         if (cardhu_1v8_cam2)
354                 regulator_disable(cardhu_1v8_cam2);
355         if (cardhu_vdd_2v8_cam2)
356                 regulator_disable(cardhu_vdd_2v8_cam2);
357
358         return 0;
359 }
360
361 static void cardhu_ov5650_synchronize_sensors(void)
362 {
363         if (board_info.board_id == BOARD_E1198) {
364                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
365                 mdelay(50);
366                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
367                 mdelay(50);
368         }
369         else if (board_info.board_id == BOARD_E1291) {
370                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
371                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
372                 mdelay(50);
373                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
374                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
375                 mdelay(50);
376         }
377         else
378                 pr_err("%s: UnSupported BoardId\n", __func__);
379 }
380
381 struct ov5650_platform_data cardhu_right_ov5650_data = {
382         .power_on = cardhu_right_ov5650_power_on,
383         .power_off = cardhu_right_ov5650_power_off,
384         .synchronize_sensors = cardhu_ov5650_synchronize_sensors,
385 };
386
387 static int cardhu_ov2710_power_on(void)
388 {
389         /* CSI-B and front sensor are muxed on cardhu */
390         gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
391
392         /* Boards E1198 and E1291 are of Cardhu personality
393          * and donot have TCA6416 exp for camera */
394         if ((board_info.board_id == BOARD_E1198) ||
395                 (board_info.board_id == BOARD_E1291)) {
396
397                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 0);
398                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 0);
399                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 0);
400                 mdelay(10);
401
402                 if (cardhu_vdd_cam3 == NULL) {
403                         cardhu_vdd_cam3 = regulator_get(NULL, "vdd_cam3");
404                         if (WARN_ON(IS_ERR(cardhu_vdd_cam3))) {
405                                 pr_err("%s: couldn't get regulator vdd_cam3: %ld\n",
406                                         __func__, PTR_ERR(cardhu_vdd_cam3));
407                                 goto reg_alloc_fail;
408                         }
409                 }
410                 regulator_enable(cardhu_vdd_cam3);
411         }
412
413         /* Enable VDD_1V8_Cam3 */
414         if (cardhu_1v8_cam3 == NULL) {
415                 cardhu_1v8_cam3 = regulator_get(NULL, "vdd_1v8_cam3");
416                 if (WARN_ON(IS_ERR(cardhu_1v8_cam3))) {
417                         pr_err("%s: couldn't get regulator vdd_1v8_cam3: %ld\n",
418                                 __func__, PTR_ERR(cardhu_1v8_cam3));
419                         goto reg_alloc_fail;
420                 }
421         }
422         regulator_enable(cardhu_1v8_cam3);
423         mdelay(5);
424
425         return 0;
426
427 reg_alloc_fail:
428         if (cardhu_1v8_cam3) {
429                 regulator_put(cardhu_1v8_cam3);
430                 cardhu_1v8_cam3 = NULL;
431         }
432         if (cardhu_vdd_cam3) {
433                 regulator_put(cardhu_vdd_cam3);
434                 cardhu_vdd_cam3 = NULL;
435         }
436
437         return -ENODEV;
438 }
439
440 static int cardhu_ov2710_power_off(void)
441 {
442         /* CSI-B and front sensor are muxed on cardhu */
443         gpio_direction_output(CAMERA_CSI_MUX_SEL_GPIO, 1);
444
445         /* Boards E1198 and E1291 are of Cardhu personality
446          * and donot have TCA6416 exp for camera */
447         if ((board_info.board_id == BOARD_E1198) ||
448                 (board_info.board_id == BOARD_E1291)) {
449                 gpio_direction_output(CAM1_POWER_DWN_GPIO, 1);
450                 gpio_direction_output(CAM2_POWER_DWN_GPIO, 1);
451                 gpio_direction_output(CAM3_POWER_DWN_GPIO, 1);
452         }
453
454         if (cardhu_1v8_cam3)
455                 regulator_disable(cardhu_1v8_cam3);
456         if (cardhu_vdd_cam3)
457                 regulator_disable(cardhu_vdd_cam3);
458
459         return 0;
460 }
461
462 struct ov2710_platform_data cardhu_ov2710_data = {
463         .power_on = cardhu_ov2710_power_on,
464         .power_off = cardhu_ov2710_power_off,
465 };
466
467 static const struct i2c_board_info cardhu_i2c3_board_info[] = {
468         {
469                 I2C_BOARD_INFO("pca9546", 0x70),
470                 .platform_data = &cardhu_pca954x_data,
471         },
472 };
473
474
475 static struct nvc_gpio_pdata sh532u_gpio_pdata[] = {
476         { SH532U_GPIO_RESET, TEGRA_GPIO_PBB0, false, 0, },
477 };
478
479 static struct sh532u_platform_data sh532u_left_pdata = {
480         .cfg            = NVC_CFG_NODEV,
481         .num            = 1,
482         .sync           = 2,
483         .dev_name       = "focuser",
484         .gpio_count     = ARRAY_SIZE(sh532u_gpio_pdata),
485         .gpio           = sh532u_gpio_pdata,
486 };
487
488 static struct sh532u_platform_data sh532u_right_pdata = {
489         .cfg            = NVC_CFG_NODEV,
490         .num            = 2,
491         .sync           = 1,
492         .dev_name       = "focuser",
493         .gpio_count     = ARRAY_SIZE(sh532u_gpio_pdata),
494         .gpio           = sh532u_gpio_pdata,
495 };
496
497 static struct nvc_gpio_pdata pm269_sh532u_left_gpio_pdata[] = {
498         { SH532U_GPIO_RESET, CAM1_RST_L_GPIO, false, 0, },
499 };
500
501 static struct sh532u_platform_data pm269_sh532u_left_pdata = {
502         .cfg            = NVC_CFG_NODEV,
503         .num            = 1,
504         .sync           = 2,
505         .dev_name       = "focuser",
506         .gpio_count     = ARRAY_SIZE(pm269_sh532u_left_gpio_pdata),
507         .gpio           = pm269_sh532u_left_gpio_pdata,
508 };
509
510 static struct nvc_gpio_pdata pm269_sh532u_right_gpio_pdata[] = {
511         { SH532U_GPIO_RESET, CAM2_RST_L_GPIO, false, 0, },
512 };
513
514 static struct sh532u_platform_data pm269_sh532u_right_pdata = {
515         .cfg            = NVC_CFG_NODEV,
516         .num            = 2,
517         .sync           = 1,
518         .dev_name       = "focuser",
519         .gpio_count     = ARRAY_SIZE(pm269_sh532u_right_gpio_pdata),
520         .gpio           = pm269_sh532u_right_gpio_pdata,
521 };
522
523
524 static struct nvc_torch_pin_state cardhu_tps61050_pinstate = {
525         .mask           = 0x0008, /*VGP3*/
526         .values         = 0x0008,
527 };
528
529 static struct tps61050_platform_data cardhu_tps61050_pdata = {
530         .dev_name       = "torch",
531         .pinstate       = &cardhu_tps61050_pinstate,
532 };
533
534 static const struct i2c_board_info cardhu_i2c_board_info_tps61050[] = {
535         {
536                 I2C_BOARD_INFO("tps61050", 0x33),
537                 .platform_data = &cardhu_tps61050_pdata,
538         },
539 };
540
541 static struct i2c_board_info cardhu_i2c6_board_info[] = {
542         {
543                 I2C_BOARD_INFO("ov5650L", 0x36),
544                 .platform_data = &cardhu_left_ov5650_data,
545         },
546         {
547                 I2C_BOARD_INFO("sh532u", 0x72),
548                 .platform_data = &sh532u_left_pdata,
549         },
550 };
551
552 static struct i2c_board_info cardhu_i2c7_board_info[] = {
553         {
554                 I2C_BOARD_INFO("ov5650R", 0x36),
555                 .platform_data = &cardhu_right_ov5650_data,
556         },
557         {
558                 I2C_BOARD_INFO("sh532u", 0x72),
559                 .platform_data = &sh532u_right_pdata,
560         },
561 };
562
563 static struct i2c_board_info pm269_i2c6_board_info[] = {
564         {
565                 I2C_BOARD_INFO("ov5650L", 0x36),
566                 .platform_data = &cardhu_left_ov5650_data,
567         },
568         {
569                 I2C_BOARD_INFO("sh532u", 0x72),
570                 .platform_data = &pm269_sh532u_left_pdata,
571         },
572 };
573
574 static struct i2c_board_info pm269_i2c7_board_info[] = {
575         {
576                 I2C_BOARD_INFO("ov5650R", 0x36),
577                 .platform_data = &cardhu_right_ov5650_data,
578         },
579         {
580                 I2C_BOARD_INFO("sh532u", 0x72),
581                 .platform_data = &pm269_sh532u_right_pdata,
582         },
583 };
584
585 static struct i2c_board_info cardhu_i2c8_board_info[] = {
586         {
587                 I2C_BOARD_INFO("ov2710", 0x36),
588                 .platform_data = &cardhu_ov2710_data,
589         },
590 };
591
592 static int nct_get_temp(void *_data, long *temp)
593 {
594         struct nct1008_data *data = _data;
595         return nct1008_thermal_get_temp(data, temp);
596 }
597
598 static int nct_get_temp_low(void *_data, long *temp)
599 {
600         struct nct1008_data *data = _data;
601         return nct1008_thermal_get_temp_low(data, temp);
602 }
603
604 static int nct_set_limits(void *_data,
605                         long lo_limit_milli,
606                         long hi_limit_milli)
607 {
608         struct nct1008_data *data = _data;
609         return nct1008_thermal_set_limits(data,
610                                         lo_limit_milli,
611                                         hi_limit_milli);
612 }
613
614 static int nct_set_alert(void *_data,
615                                 void (*alert_func)(void *),
616                                 void *alert_data)
617 {
618         struct nct1008_data *data = _data;
619         return nct1008_thermal_set_alert(data, alert_func, alert_data);
620 }
621
622 static int nct_set_shutdown_temp(void *_data, long shutdown_temp)
623 {
624         struct nct1008_data *data = _data;
625         return nct1008_thermal_set_shutdown_temp(data, shutdown_temp);
626 }
627
628 static void nct1008_probe_callback(struct nct1008_data *data)
629 {
630         struct tegra_thermal_device *thermal_device;
631
632         thermal_device = kzalloc(sizeof(struct tegra_thermal_device),
633                                         GFP_KERNEL);
634         if (!thermal_device) {
635                 pr_err("unable to allocate thermal device\n");
636                 return;
637         }
638
639         thermal_device->name = "nct1008";
640         thermal_device->data = data;
641         thermal_device->offset = TDIODE_OFFSET;
642         thermal_device->get_temp = nct_get_temp;
643         thermal_device->get_temp_low = nct_get_temp_low;
644         thermal_device->set_limits = nct_set_limits;
645         thermal_device->set_alert = nct_set_alert;
646         thermal_device->set_shutdown_temp = nct_set_shutdown_temp;
647
648         tegra_thermal_set_device(thermal_device);
649 }
650
651 static struct nct1008_platform_data cardhu_nct1008_pdata = {
652         .supported_hwrev = true,
653         .ext_range = true,
654         .conv_rate = 0x08,
655         .offset = 8, /* 4 * 2C. Bug 844025 - 1C for device accuracies */
656         .probe_callback = nct1008_probe_callback,
657 };
658
659 static struct i2c_board_info cardhu_i2c4_bq27510_board_info[] = {
660         {
661                 I2C_BOARD_INFO("bq27510", 0x55),
662         },
663 };
664
665 static struct i2c_board_info cardhu_i2c4_nct1008_board_info[] = {
666         {
667                 I2C_BOARD_INFO("nct1008", 0x4C),
668                 .platform_data = &cardhu_nct1008_pdata,
669                 .irq = -1,
670         }
671 };
672
673 static int cardhu_nct1008_init(void)
674 {
675         int nct1008_port = -1;
676         int ret = 0;
677
678         if ((board_info.board_id == BOARD_E1198) ||
679                 (board_info.board_id == BOARD_E1291) ||
680                 (board_info.board_id == BOARD_E1257) ||
681                 (board_info.board_id == BOARD_PM269) ||
682                 (board_info.board_id == BOARD_PM305) ||
683                 (board_info.board_id == BOARD_PM311)) {
684                 nct1008_port = TEGRA_GPIO_PCC2;
685         } else if ((board_info.board_id == BOARD_E1186) ||
686                 (board_info.board_id == BOARD_E1187) ||
687                 (board_info.board_id == BOARD_E1256)) {
688                 /* FIXME: seems to be conflicting with usb3 vbus on E1186 */
689                 /* nct1008_port = TEGRA_GPIO_PH7; */
690         }
691
692         if (nct1008_port >= 0) {
693                 /* FIXME: enable irq when throttling is supported */
694                 cardhu_i2c4_nct1008_board_info[0].irq = TEGRA_GPIO_TO_IRQ(nct1008_port);
695
696                 ret = gpio_request(nct1008_port, "temp_alert");
697                 if (ret < 0)
698                         return ret;
699
700                 ret = gpio_direction_input(nct1008_port);
701                 if (ret < 0)
702                         gpio_free(nct1008_port);
703                 else
704                         tegra_gpio_enable(nct1008_port);
705         }
706
707         return ret;
708 }
709
710 #if defined(CONFIG_GPIO_PCA953X)
711 static struct pca953x_platform_data cardhu_pmu_tca6416_data = {
712         .gpio_base      = PMU_TCA6416_GPIO_BASE,
713 };
714
715 static const struct i2c_board_info cardhu_i2c4_board_info_tca6416[] = {
716         {
717                 I2C_BOARD_INFO("tca6416", 0x20),
718                 .platform_data = &cardhu_pmu_tca6416_data,
719         },
720 };
721
722 static struct pca953x_platform_data cardhu_cam_tca6416_data = {
723         .gpio_base      = CAM_TCA6416_GPIO_BASE,
724 };
725
726 static const struct i2c_board_info cardhu_i2c2_board_info_tca6416[] = {
727         {
728                 I2C_BOARD_INFO("tca6416", 0x20),
729                 .platform_data = &cardhu_cam_tca6416_data,
730         },
731 };
732
733 static int __init pmu_tca6416_init(void)
734 {
735         if ((board_info.board_id == BOARD_E1198) ||
736                 (board_info.board_id == BOARD_E1291))
737                         return 0;
738
739         pr_info("Registering pmu pca6416\n");
740         i2c_register_board_info(4, cardhu_i2c4_board_info_tca6416,
741                 ARRAY_SIZE(cardhu_i2c4_board_info_tca6416));
742         return 0;
743 }
744
745 static int __init cam_tca6416_init(void)
746 {
747         /* Boards E1198 and E1291 are of Cardhu personality
748          * and donot have TCA6416 exp for camera */
749         if ((board_info.board_id == BOARD_E1198) ||
750                 (board_info.board_id == BOARD_E1291))
751                 return 0;
752
753         pr_info("Registering cam pca6416\n");
754         i2c_register_board_info(2, cardhu_i2c2_board_info_tca6416,
755                 ARRAY_SIZE(cardhu_i2c2_board_info_tca6416));
756         return 0;
757 }
758 #else
759 static int __init pmu_tca6416_init(void)
760 {
761         return 0;
762 }
763
764 static int __init cam_tca6416_init(void)
765 {
766         return 0;
767 }
768 #endif
769
770 /* MPU board file definition    */
771 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
772 #define MPU_GYRO_NAME           "mpu3050"
773 #endif
774 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU6050)
775 #define MPU_GYRO_NAME           "mpu6050"
776 #endif
777 static struct mpu_platform_data mpu_gyro_data = {
778         .int_config     = 0x10,
779         .level_shifter  = 0,
780         .orientation    = MPU_GYRO_ORIENTATION, /* Located in board_[platformname].h    */
781 };
782
783 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
784 static struct ext_slave_platform_data mpu_accel_data = {
785         .address        = MPU_ACCEL_ADDR,
786         .irq            = 0,
787         .adapt_num      = MPU_ACCEL_BUS_NUM,
788         .bus            = EXT_SLAVE_BUS_SECONDARY,
789         .orientation    = MPU_ACCEL_ORIENTATION,        /* Located in board_[platformname].h    */
790 };
791 #endif
792
793 static struct ext_slave_platform_data mpu_compass_data = {
794         .address        = MPU_COMPASS_ADDR,
795         .irq            = 0,
796         .adapt_num      = MPU_COMPASS_BUS_NUM,
797         .bus            = EXT_SLAVE_BUS_PRIMARY,
798         .orientation    = MPU_COMPASS_ORIENTATION,      /* Located in board_[platformname].h    */
799 };
800
801 static struct i2c_board_info __initdata inv_mpu_i2c2_board_info[] = {
802         {
803                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
804                 .irq = TEGRA_GPIO_TO_IRQ(MPU_GYRO_IRQ_GPIO),
805                 .platform_data = &mpu_gyro_data,
806         },
807 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
808         {
809                 I2C_BOARD_INFO(MPU_ACCEL_NAME, MPU_ACCEL_ADDR),
810 #if     MPU_ACCEL_IRQ_GPIO
811                 .irq = TEGRA_GPIO_TO_IRQ(MPU_ACCEL_IRQ_GPIO),
812 #endif
813                 .platform_data = &mpu_accel_data,
814         },
815 #endif
816         {
817                 I2C_BOARD_INFO(MPU_COMPASS_NAME, MPU_COMPASS_ADDR),
818 #if     MPU_COMPASS_IRQ_GPIO
819                 .irq = TEGRA_GPIO_TO_IRQ(MPU_COMPASS_IRQ_GPIO),
820 #endif
821                 .platform_data = &mpu_compass_data,
822         },
823 };
824
825 static void mpuirq_init(void)
826 {
827         int ret = 0;
828
829         pr_info("*** MPU START *** mpuirq_init...\n");
830
831 #if (MPU_GYRO_TYPE == MPU_TYPE_MPU3050)
832 #if     MPU_ACCEL_IRQ_GPIO
833         /* ACCEL-IRQ assignment */
834         tegra_gpio_enable(MPU_ACCEL_IRQ_GPIO);
835         ret = gpio_request(MPU_ACCEL_IRQ_GPIO, MPU_ACCEL_NAME);
836         if (ret < 0) {
837                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
838                 return;
839         }
840
841         ret = gpio_direction_input(MPU_ACCEL_IRQ_GPIO);
842         if (ret < 0) {
843                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
844                 gpio_free(MPU_ACCEL_IRQ_GPIO);
845                 return;
846         }
847 #endif
848 #endif
849
850         /* MPU-IRQ assignment */
851         tegra_gpio_enable(MPU_GYRO_IRQ_GPIO);
852         ret = gpio_request(MPU_GYRO_IRQ_GPIO, MPU_GYRO_NAME);
853         if (ret < 0) {
854                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
855                 return;
856         }
857
858         ret = gpio_direction_input(MPU_GYRO_IRQ_GPIO);
859         if (ret < 0) {
860                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
861                 gpio_free(MPU_GYRO_IRQ_GPIO);
862                 return;
863         }
864         pr_info("*** MPU END *** mpuirq_init...\n");
865
866         i2c_register_board_info(MPU_GYRO_BUS_NUM, inv_mpu_i2c2_board_info,
867                 ARRAY_SIZE(inv_mpu_i2c2_board_info));
868 }
869
870 static struct i2c_board_info cardhu_i2c2_isl_board_info[] = {
871         {
872                 I2C_BOARD_INFO("isl29028", 0x44),
873         }
874 };
875
876 static struct i2c_board_info cardhu_i2c2_ltr_board_info[] = {
877         {
878                 I2C_BOARD_INFO("LTR_558ALS", 0x23),
879         }
880 };
881
882 int __init cardhu_sensors_init(void)
883 {
884         int err;
885
886         tegra_get_board_info(&board_info);
887
888         cardhu_camera_init();
889         cam_tca6416_init();
890
891         i2c_register_board_info(2, cardhu_i2c3_board_info,
892                 ARRAY_SIZE(cardhu_i2c3_board_info));
893
894         i2c_register_board_info(2, cardhu_i2c_board_info_tps61050,
895                 ARRAY_SIZE(cardhu_i2c_board_info_tps61050));
896
897 #ifdef CONFIG_VIDEO_OV14810
898         /* This is disabled by default; To enable this change Kconfig;
899          * there should be some way to detect dynamically which board
900          * is connected (E1211/E1214), till that time sensor selection
901          * logic is static;
902          * e1214 corresponds to ov14810 sensor */
903         i2c_register_board_info(2, cardhu_i2c_board_info_e1214,
904                 ARRAY_SIZE(cardhu_i2c_board_info_e1214));
905 #else
906         /* Left  camera is on PCA954x's I2C BUS0, Right camera is on BUS1 &
907          * Front camera is on BUS2 */
908         if (board_info.board_id != BOARD_PM269) {
909                 i2c_register_board_info(PCA954x_I2C_BUS0,
910                                         cardhu_i2c6_board_info,
911                                         ARRAY_SIZE(cardhu_i2c6_board_info));
912
913                 i2c_register_board_info(PCA954x_I2C_BUS1,
914                                         cardhu_i2c7_board_info,
915                                         ARRAY_SIZE(cardhu_i2c7_board_info));
916         } else {
917                 i2c_register_board_info(PCA954x_I2C_BUS0,
918                                         pm269_i2c6_board_info,
919                                         ARRAY_SIZE(pm269_i2c6_board_info));
920
921                 i2c_register_board_info(PCA954x_I2C_BUS1,
922                                         pm269_i2c7_board_info,
923                                         ARRAY_SIZE(pm269_i2c7_board_info));
924         }
925         i2c_register_board_info(PCA954x_I2C_BUS2, cardhu_i2c8_board_info,
926                 ARRAY_SIZE(cardhu_i2c8_board_info));
927
928 #endif
929         pmu_tca6416_init();
930
931         if (board_info.board_id == BOARD_E1291)
932                 i2c_register_board_info(4, cardhu_i2c4_bq27510_board_info,
933                         ARRAY_SIZE(cardhu_i2c4_bq27510_board_info));
934
935         if (board_info.sku == BOARD_SKU_B11)
936                 i2c_register_board_info(2, cardhu_i2c2_ltr_board_info,
937                         ARRAY_SIZE(cardhu_i2c2_ltr_board_info));
938         else
939                 i2c_register_board_info(2, cardhu_i2c2_isl_board_info,
940                         ARRAY_SIZE(cardhu_i2c2_isl_board_info));
941
942         err = cardhu_nct1008_init();
943         if (err)
944                 return err;
945
946         i2c_register_board_info(4, cardhu_i2c4_nct1008_board_info,
947                 ARRAY_SIZE(cardhu_i2c4_nct1008_board_info));
948
949         mpuirq_init();
950         return 0;
951 }
952
953 #if defined(CONFIG_GPIO_PCA953X)
954 struct ov5650_gpios {
955         const char *name;
956         int gpio;
957         int enabled;
958 };
959
960 #define OV5650_GPIO(_name, _gpio, _enabled)             \
961         {                                               \
962                 .name = _name,                          \
963                 .gpio = _gpio,                          \
964                 .enabled = _enabled,                    \
965         }
966
967 static struct ov5650_gpios ov5650_gpio_keys[] = {
968         [0] = OV5650_GPIO("cam1_pwdn", CAM1_PWR_DN_GPIO, 0),
969         [1] = OV5650_GPIO("cam1_rst_lo", CAM1_RST_L_GPIO, 1),
970         [2] = OV5650_GPIO("cam1_af_pwdn_lo", CAM1_AF_PWR_DN_L_GPIO, 0),
971         [3] = OV5650_GPIO("cam1_ldo_shdn_lo", CAM1_LDO_SHUTDN_L_GPIO, 1),
972         [4] = OV5650_GPIO("cam2_pwdn", CAM2_PWR_DN_GPIO, 0),
973         [5] = OV5650_GPIO("cam2_rst_lo", CAM2_RST_L_GPIO, 1),
974         [6] = OV5650_GPIO("cam2_af_pwdn_lo", CAM2_AF_PWR_DN_L_GPIO, 0),
975         [7] = OV5650_GPIO("cam2_ldo_shdn_lo", CAM2_LDO_SHUTDN_L_GPIO, 1),
976         [8] = OV5650_GPIO("cam3_pwdn", CAM_FRONT_PWR_DN_GPIO, 0),
977         [9] = OV5650_GPIO("cam3_rst_lo", CAM_FRONT_RST_L_GPIO, 1),
978         [10] = OV5650_GPIO("cam3_af_pwdn_lo", CAM_FRONT_AF_PWR_DN_L_GPIO, 0),
979         [11] = OV5650_GPIO("cam3_ldo_shdn_lo", CAM_FRONT_LDO_SHUTDN_L_GPIO, 1),
980         [12] = OV5650_GPIO("cam_led_exp", CAM_FRONT_LED_EXP, 1),
981         [13] = OV5650_GPIO("cam_led_rear_exp", CAM_SNN_LED_REAR_EXP, 1),
982         [14] = OV5650_GPIO("cam_i2c_mux_rst", CAM_I2C_MUX_RST_EXP, 1),
983 };
984
985 int __init cardhu_ov5650_late_init(void)
986 {
987         int ret;
988         int i;
989
990         if (!machine_is_cardhu())
991                 return 0;
992
993         if ((board_info.board_id == BOARD_E1198) ||
994                 (board_info.board_id == BOARD_E1291))
995                 return 0;
996
997         printk("%s: \n", __func__);
998         for (i = 0; i < ARRAY_SIZE(ov5650_gpio_keys); i++) {
999                 ret = gpio_request(ov5650_gpio_keys[i].gpio,
1000                         ov5650_gpio_keys[i].name);
1001                 if (ret < 0) {
1002                         printk("%s: gpio_request failed for gpio #%d\n",
1003                                 __func__, i);
1004                         goto fail;
1005                 }
1006                 printk("%s: enable - %d\n", __func__, i);
1007                 gpio_direction_output(ov5650_gpio_keys[i].gpio,
1008                         ov5650_gpio_keys[i].enabled);
1009                 gpio_export(ov5650_gpio_keys[i].gpio, false);
1010         }
1011
1012         return 0;
1013
1014 fail:
1015         while (i--)
1016                 gpio_free(ov5650_gpio_keys[i].gpio);
1017         return ret;
1018 }
1019
1020 late_initcall(cardhu_ov5650_late_init);
1021 #endif