c5caead71d909483a9cf90bb401c4e731e6df0c7
[linux-2.6.git] / arch / arm / mach-tegra / board-tegratab-sensors.c
1 /*
2  * arch/arm/mach-tegra/board-tegratab-sensors.c
3  *
4  * Copyright (c) 2012-2013 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 licensed under the terms of the GNU General Public
22  * License version 2, as published by the Free Software Foundation, and
23  * may be copied, distributed, and modified under those terms.
24  *
25  * This program is distributed in the hope that it will be useful,
26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28  * GNU General Public License for more details.
29  */
30
31 #include <linux/i2c.h>
32 #include <linux/delay.h>
33 #include <linux/mpu.h>
34 #include <linux/regulator/consumer.h>
35 #include <linux/gpio.h>
36 #include <linux/therm_est.h>
37 #include <linux/nct1008.h>
38 #include <linux/cm3217.h>
39 #include <mach/edp.h>
40 #include <linux/edp.h>
41 #include <mach/gpio-tegra.h>
42 #include <mach/pinmux-t11.h>
43 #include <mach/pinmux.h>
44 #ifndef CONFIG_USE_OF
45 #include <media/ov5693.h>
46 #include <media/ad5823.h>
47 #endif
48 #include <media/mt9m114.h>
49 #include <media/ov7695.h>
50 #include <generated/mach-types.h>
51 #include <linux/power/sbs-battery.h>
52 #include <linux/generic_adc_thermal.h>
53
54 #include "gpio-names.h"
55 #include "board.h"
56 #include "board-common.h"
57 #include "board-tegratab.h"
58 #include "cpu-tegra.h"
59 #include "devices.h"
60 #include "tegra-board-id.h"
61 #include "dvfs.h"
62
63 static struct board_info board_info;
64
65 static struct throttle_table tj_throttle_table[] = {
66                 /* CPU_THROT_LOW cannot be used by other than CPU */
67                 /* NO_CAP cannot be used by CPU */
68                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
69                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
70                 { { 1428000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
71                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
72                 { { 1224000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
73                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
74                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
75                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
76                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
77                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
78                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
79                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
80                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
81                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
82                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
83                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
84                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
85                 { {  612000,  360000,  360000,  312000,  NO_CAP } },
86                 { {  510000,  360000,  360000,  312000,  480000 } },
87                 { {  468000,  360000,  360000,  312000,  480000 } },
88                 { {  468000,  276000,  276000,  208000,  480000 } },
89                 { {  372000,  276000,  276000,  208000,  204000 } },
90                 { {  288000,  276000,  276000,  208000,  204000 } },
91                 { {  252000,  276000,  228000,  208000,  102000 } },
92                 { {  204000,  276000,  228000,  208000,  102000 } },
93                 { {  102000,  276000,  228000,  208000,  102000 } },
94           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
95 };
96
97 static struct balanced_throttle tj_throttle = {
98         .throt_tab_size = ARRAY_SIZE(tj_throttle_table),
99         .throt_tab = tj_throttle_table,
100 };
101
102 static int __init tegratab_throttle_init(void)
103 {
104         if (machine_is_tegratab())
105                 balanced_throttle_register(&tj_throttle, "tegra-balanced");
106         return 0;
107 }
108 module_init(tegratab_throttle_init);
109
110 static struct nct1008_platform_data tegratab_nct1008_pdata = {
111         .supported_hwrev = true,
112         .ext_range = true,
113         .conv_rate = 0x08,
114         .shutdown_ext_limit = 105, /* C */
115         .shutdown_local_limit = 120, /* C */
116 };
117
118 static struct i2c_board_info tegratab_i2c4_nct1008_board_info[] = {
119         {
120                 I2C_BOARD_INFO("nct1008", 0x4C),
121                 .platform_data = &tegratab_nct1008_pdata,
122                 .irq = -1,
123         }
124 };
125
126 #define VI_PINMUX(_pingroup, _mux, _pupd, _tri, _io, _lock, _ioreset) \
127         {                                                       \
128                 .pingroup       = TEGRA_PINGROUP_##_pingroup,   \
129                 .func           = TEGRA_MUX_##_mux,             \
130                 .pupd           = TEGRA_PUPD_##_pupd,           \
131                 .tristate       = TEGRA_TRI_##_tri,             \
132                 .io             = TEGRA_PIN_##_io,              \
133                 .lock           = TEGRA_PIN_LOCK_##_lock,       \
134                 .od             = TEGRA_PIN_OD_DEFAULT,         \
135                 .ioreset        = TEGRA_PIN_IO_RESET_##_ioreset \
136 }
137
138 #ifndef CONFIG_USE_OF
139 static struct tegra_pingroup_config mclk_disable =
140         VI_PINMUX(CAM_MCLK, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
141
142 static struct tegra_pingroup_config mclk_enable =
143         VI_PINMUX(CAM_MCLK, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
144 #endif
145
146 static struct tegra_pingroup_config pbb0_disable =
147         VI_PINMUX(GPIO_PBB0, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
148
149 static struct tegra_pingroup_config pbb0_enable =
150         VI_PINMUX(GPIO_PBB0, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
151
152 #ifndef CONFIG_USE_OF
153 /*
154  * As a workaround, tegratab_vcmvdd need to be allocated to activate the
155  * sensor devices. This is due to the focuser device(AD5823) will hook up
156  * the i2c bus if it is not powered up.
157 */
158 static struct regulator *tegratab_vcmvdd;
159
160 static int tegratab_get_vcmvdd(void)
161 {
162         if (!tegratab_vcmvdd) {
163                 tegratab_vcmvdd = regulator_get(NULL, "vdd_af_cam1");
164                 if (unlikely(WARN_ON(IS_ERR(tegratab_vcmvdd)))) {
165                         pr_err("%s: can't get regulator vcmvdd: %ld\n",
166                                 __func__, PTR_ERR(tegratab_vcmvdd));
167                         tegratab_vcmvdd = NULL;
168                         return -ENODEV;
169                 }
170         }
171         return 0;
172 }
173
174 static int tegratab_ov5693_power_on(struct ov5693_power_rail *pw)
175 {
176         int err;
177
178         if (unlikely(!pw || !pw->avdd || !pw->dovdd))
179                 return -EFAULT;
180
181         if (tegratab_get_vcmvdd())
182                 goto ov5693_poweron_fail;
183
184         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
185         usleep_range(10, 20);
186
187         err = regulator_enable(pw->avdd);
188         if (err)
189                 goto ov5693_avdd_fail;
190
191         err = regulator_enable(pw->dovdd);
192         if (err)
193                 goto ov5693_iovdd_fail;
194
195         usleep_range(1, 2);
196         gpio_set_value(CAM1_POWER_DWN_GPIO, 1);
197
198         err = regulator_enable(tegratab_vcmvdd);
199         if (unlikely(err))
200                 goto ov5693_vcmvdd_fail;
201
202         tegra_pinmux_config_table(&mclk_enable, 1);
203         usleep_range(300, 310);
204
205         return 0;
206
207 ov5693_vcmvdd_fail:
208         regulator_disable(pw->dovdd);
209
210 ov5693_iovdd_fail:
211         regulator_disable(pw->avdd);
212
213 ov5693_avdd_fail:
214         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
215
216 ov5693_poweron_fail:
217         pr_err("%s FAILED\n", __func__);
218         return -ENODEV;
219 }
220
221 static int tegratab_ov5693_power_off(struct ov5693_power_rail *pw)
222 {
223         if (unlikely(!pw || !tegratab_vcmvdd || !pw->avdd || !pw->dovdd))
224                 return -EFAULT;
225
226         usleep_range(21, 25);
227         tegra_pinmux_config_table(&mclk_disable, 1);
228         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
229         usleep_range(1, 2);
230
231         regulator_disable(tegratab_vcmvdd);
232         regulator_disable(pw->dovdd);
233         regulator_disable(pw->avdd);
234
235         return 0;
236 }
237
238 static struct nvc_gpio_pdata ov5693_gpio_pdata[] = {
239         { OV5693_GPIO_TYPE_PWRDN, CAM1_POWER_DWN_GPIO, true, 0, },
240 };
241 static struct ov5693_platform_data tegratab_ov5693_pdata = {
242         .num            = 5693,
243         .dev_name       = "camera",
244         .gpio_count     = ARRAY_SIZE(ov5693_gpio_pdata),
245         .gpio           = ov5693_gpio_pdata,
246         .power_on       = tegratab_ov5693_power_on,
247         .power_off      = tegratab_ov5693_power_off,
248 };
249
250 static int tegratab_ad5823_power_on(struct ad5823_platform_data *pdata)
251 {
252         int err = 0;
253
254         pr_info("%s\n", __func__);
255
256         gpio_set_value_cansleep(pdata->gpio, 1);
257
258         return err;
259 }
260
261 static int tegratab_ad5823_power_off(struct ad5823_platform_data *pdata)
262 {
263         pr_info("%s\n", __func__);
264         gpio_set_value_cansleep(pdata->gpio, 0);
265         return 0;
266 }
267
268 static struct ad5823_platform_data tegratab_ad5823_pdata = {
269         .gpio = CAM_AF_PWDN,
270         .power_on       = tegratab_ad5823_power_on,
271         .power_off      = tegratab_ad5823_power_off,
272 };
273 #endif
274
275 static int tegratab_mt9m114_power_on(struct mt9m114_power_rail *pw)
276 {
277         int err;
278
279         if (unlikely(!pw || !pw->avdd || !pw->iovdd))
280                 return -EFAULT;
281
282         gpio_set_value(CAM_RSTN, 0);
283         usleep_range(1000, 1020);
284
285         err = regulator_enable(pw->iovdd);
286         if (unlikely(err))
287                 goto mt9m114_iovdd_fail;
288         usleep_range(300, 320);
289
290         err = regulator_enable(pw->avdd);
291         if (unlikely(err))
292                 goto mt9m114_avdd_fail;
293
294         usleep_range(1000, 1020);
295         gpio_set_value(CAM_RSTN, 1);
296
297         usleep_range(1000, 1020);
298         tegra_pinmux_config_table(&pbb0_enable, 1);
299         usleep_range(200, 220);
300
301         /* return 1 to skip the in-driver power_on swquence */
302         return 1;
303
304 mt9m114_avdd_fail:
305         regulator_disable(pw->iovdd);
306
307 mt9m114_iovdd_fail:
308         gpio_set_value(CAM_RSTN, 0);
309         return -ENODEV;
310 }
311
312 static int tegratab_mt9m114_power_off(struct mt9m114_power_rail *pw)
313 {
314         if (unlikely(!pw || !pw->avdd || !pw->iovdd))
315                 return -EFAULT;
316
317         usleep_range(100, 120);
318         tegra_pinmux_config_table(&pbb0_disable, 1);
319         usleep_range(100, 120);
320         gpio_set_value(CAM_RSTN, 0);
321         usleep_range(100, 120);
322         regulator_disable(pw->avdd);
323         usleep_range(100, 120);
324         regulator_disable(pw->iovdd);
325
326         return 1;
327 }
328
329 struct mt9m114_platform_data tegratab_mt9m114_pdata = {
330         .power_on = tegratab_mt9m114_power_on,
331         .power_off = tegratab_mt9m114_power_off,
332 };
333
334 static int tegratab_ov7695_power_on(struct ov7695_power_rail *pw)
335 {
336         int err;
337
338         if (unlikely(!pw || !pw->avdd || !pw->iovdd))
339                 return -EFAULT;
340
341         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
342         usleep_range(1000, 1020);
343
344         err = regulator_enable(pw->iovdd);
345         if (unlikely(err))
346                 goto ov7695_iovdd_fail;
347         usleep_range(300, 320);
348
349         err = regulator_enable(pw->avdd);
350         if (unlikely(err))
351                 goto ov7695_avdd_fail;
352         usleep_range(1000, 1020);
353
354         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
355         usleep_range(1000, 1020);
356
357         tegra_pinmux_config_table(&pbb0_enable, 1);
358         usleep_range(200, 220);
359
360         return 0;
361
362 ov7695_avdd_fail:
363         regulator_disable(pw->iovdd);
364
365 ov7695_iovdd_fail:
366         gpio_set_value(CAM_RSTN, 0);
367         return -ENODEV;
368 }
369
370 static int tegratab_ov7695_power_off(struct ov7695_power_rail *pw)
371 {
372         if (unlikely(!pw || !pw->avdd || !pw->iovdd))
373                 return -EFAULT;
374         usleep_range(100, 120);
375
376         tegra_pinmux_config_table(&pbb0_disable, 1);
377         usleep_range(100, 120);
378
379         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
380         usleep_range(100, 120);
381
382         regulator_disable(pw->avdd);
383         usleep_range(100, 120);
384
385         regulator_disable(pw->iovdd);
386
387         return 0;
388 }
389
390 struct ov7695_platform_data tegratab_ov7695_pdata = {
391         .power_on = tegratab_ov7695_power_on,
392         .power_off = tegratab_ov7695_power_off,
393 };
394
395 static struct i2c_board_info tegratab_i2c_board_info_e1599[] = {
396 #ifndef CONFIG_USE_OF
397         {
398                 I2C_BOARD_INFO("ov5693", 0x10),
399                 .platform_data = &tegratab_ov5693_pdata,
400         },
401         {
402                 I2C_BOARD_INFO("ad5823", 0x0c),
403                 .platform_data = &tegratab_ad5823_pdata,
404         },
405 #endif
406         {
407                 I2C_BOARD_INFO("mt9m114", 0x48),
408                 .platform_data = &tegratab_mt9m114_pdata,
409         },
410         {
411                 I2C_BOARD_INFO("ov7695", 0x21),
412                 .platform_data = &tegratab_ov7695_pdata,
413         },
414 };
415
416 static int tegratab_camera_init(void)
417 {
418 #ifndef CONFIG_USE_OF
419         tegra_pinmux_config_table(&mclk_disable, 1);
420 #endif
421         tegra_pinmux_config_table(&pbb0_disable, 1);
422
423         i2c_register_board_info(2, tegratab_i2c_board_info_e1599,
424                 ARRAY_SIZE(tegratab_i2c_board_info_e1599));
425         return 0;
426 }
427
428 /* MPU board file definition    */
429 static struct mpu_platform_data mpu6050_gyro_data_e1569 = {
430         .int_config     = 0x10,
431         .level_shifter  = 0,
432         /* Located in board_[platformname].h */
433         .orientation    = MPU_GYRO_ORIENTATION_E1569,
434         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
435                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
436 };
437
438 static struct mpu_platform_data mpu6050_gyro_data_p1640_a01 = {
439         .int_config     = 0x10,
440         .level_shifter  = 0,
441         /* Located in board_[platformname].h */
442         .orientation    = MPU_GYRO_ORIENTATION_P1640_A01,
443         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
444                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
445 };
446
447 static struct mpu_platform_data mpu6050_gyro_data = {
448         .int_config     = 0x10,
449         .level_shifter  = 0,
450         /* Located in board_[platformname].h */
451         .orientation    = MPU_GYRO_ORIENTATION,
452         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
453                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
454 };
455
456 #define TEGRA_CAMERA_GPIO(_gpio, _label, _value)                \
457         {                                                       \
458                 .gpio = _gpio,                                  \
459                 .label = _label,                                \
460                 .value = _value,                                \
461         }
462
463 static struct i2c_board_info __initdata inv_mpu6050_i2c2_board_info[] = {
464         {
465                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
466                 .platform_data = &mpu6050_gyro_data,
467         },
468 };
469
470 static void mpuirq_init(void)
471 {
472         int ret = 0;
473         unsigned gyro_irq_gpio = MPU_GYRO_IRQ_GPIO;
474         unsigned gyro_bus_num = MPU_GYRO_BUS_NUM;
475         char *gyro_name = MPU_GYRO_NAME;
476         struct board_info board_info;
477
478         pr_info("*** MPU START *** mpuirq_init...\n");
479
480         ret = gpio_request(gyro_irq_gpio, gyro_name);
481
482         if (ret < 0) {
483                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
484                 return;
485         }
486
487         ret = gpio_direction_input(gyro_irq_gpio);
488         if (ret < 0) {
489                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
490                 gpio_free(gyro_irq_gpio);
491                 return;
492         }
493         pr_info("*** MPU END *** mpuirq_init...\n");
494
495         inv_mpu6050_i2c2_board_info[0].irq = gpio_to_irq(MPU_GYRO_IRQ_GPIO);
496
497         tegra_get_board_info(&board_info);
498         if (board_info.board_id == BOARD_E1569)
499                 inv_mpu6050_i2c2_board_info[0].platform_data =
500                         &mpu6050_gyro_data_e1569;
501         else if ((board_info.board_id == BOARD_P1640) &&
502                         (board_info.fab <= BOARD_FAB_A01))
503                 inv_mpu6050_i2c2_board_info[0].platform_data =
504                         &mpu6050_gyro_data_p1640_a01;
505
506         i2c_register_board_info(gyro_bus_num, inv_mpu6050_i2c2_board_info,
507                 ARRAY_SIZE(inv_mpu6050_i2c2_board_info));
508 }
509
510 static int tegratab_nct1008_init(void)
511 {
512         int nct1008_port;
513         int ret = 0;
514
515         nct1008_port = TEGRA_GPIO_PO4;
516
517         tegra_add_cdev_trips(tegratab_nct1008_pdata.trips,
518                                 &tegratab_nct1008_pdata.num_trips);
519
520         tegratab_i2c4_nct1008_board_info[0].irq = gpio_to_irq(nct1008_port);
521         pr_info("%s: tegratab nct1008 irq %d", __func__, \
522                                 tegratab_i2c4_nct1008_board_info[0].irq);
523
524         ret = gpio_request(nct1008_port, "temp_alert");
525         if (ret < 0)
526                 return ret;
527
528         ret = gpio_direction_input(nct1008_port);
529         if (ret < 0) {
530                 pr_info("%s: calling gpio_free(nct1008_port)", __func__);
531                 gpio_free(nct1008_port);
532         }
533
534         /* tegratab has thermal sensor on GEN1-I2C i.e. instance 0 */
535         i2c_register_board_info(0, tegratab_i2c4_nct1008_board_info,
536                 ARRAY_SIZE(tegratab_i2c4_nct1008_board_info));
537
538         return ret;
539 }
540
541 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
542 static struct thermal_trip_info skin_trips[] = {
543         {
544                 .cdev_type = "skin-balanced",
545                 .trip_temp = 45000,
546                 .trip_type = THERMAL_TRIP_PASSIVE,
547                 .upper = THERMAL_NO_LIMIT,
548                 .lower = THERMAL_NO_LIMIT,
549                 .hysteresis = 0,
550         },
551 };
552
553 static struct therm_est_subdevice skin_devs[] = {
554         {
555                 .dev_data = "Tdiode",
556                 .coeffs = {
557                         3, 0, -2, -2,
558                         -2, -2, -4, -2,
559                         -2, -3, -4, -3,
560                         -5, -2, -4, -3,
561                         0, -3, -2, -22
562                 },
563         },
564         {
565                 .dev_data = "Tboard",
566                 .coeffs = {
567                         46, 11, 8, 10,
568                         10, 12, 10, 13,
569                         9, 8, 8, 9,
570                         6, 6, 3, 5,
571                         1, 3, -2, -27
572                 },
573         },
574 };
575
576 static struct therm_est_subdevice skin_devs_a02[] = {
577         {
578                 .dev_data = "Tdiode",
579                 .coeffs = {
580                         -1, -2, -4, -5,
581                         -5, -4, -3, -3,
582                         -2, -2, -2, -2,
583                         -2, -2, -3, -4,
584                         -5, -5, -7, -10
585                 },
586         },
587         {
588                 .dev_data = "Tboard",
589                 .coeffs = {
590                         144, 30, -11, -21,
591                         -24, -10, 0, 10,
592                         9, -3, -1, 14,
593                         23, 22, 35, 33,
594                         23, -17, -53, -40
595                 },
596         },
597 };
598
599 static struct therm_est_data skin_data = {
600         .num_trips = ARRAY_SIZE(skin_trips),
601         .trips = skin_trips,
602         .toffset = 5588,
603         .polling_period = 1100,
604         .passive_delay = 15000,
605         .tc1 = 10,
606         .tc2 = 1,
607         .ndevs = ARRAY_SIZE(skin_devs),
608         .devs = skin_devs,
609 };
610
611 static struct throttle_table skin_throttle_table[] = {
612                 /* CPU_THROT_LOW cannot be used by other than CPU */
613                 /* NO_CAP cannot be used by CPU */
614                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
615                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
616                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
617                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
618                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
619                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
620                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
621                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
622                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
623                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
624                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
625                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
626                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
627                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
628                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
629                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
630                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
631                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
632                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
633                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
634                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
635                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
636                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
637                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
638                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
639                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
640                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
641                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
642                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
643                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
644                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
645                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
646                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
647                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
648                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
649                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
650                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
651                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
652                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
653                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
654                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
655                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
656                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
657                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
658                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
659                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
660                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
661                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
662                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
663                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
664                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
665                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
666                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
667                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
668                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
669                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
670                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
671                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
672                 { {  510000,  360000,  360000,  312000,  480000 } },
673                 { {  510000,  360000,  360000,  312000,  480000 } },
674                 { {  510000,  360000,  360000,  312000,  480000 } },
675                 { {  510000,  360000,  360000,  312000,  480000 } },
676                 { {  510000,  360000,  360000,  312000,  480000 } },
677                 { {  510000,  360000,  360000,  312000,  480000 } },
678                 { {  468000,  360000,  360000,  312000,  480000 } },
679                 { {  468000,  360000,  360000,  312000,  480000 } },
680                 { {  468000,  276000,  276000,  208000,  480000 } },
681                 { {  468000,  276000,  276000,  208000,  480000 } },
682                 { {  372000,  276000,  276000,  208000,  204000 } },
683                 { {  372000,  276000,  276000,  208000,  204000 } },
684                 { {  288000,  276000,  276000,  208000,  204000 } },
685                 { {  288000,  276000,  276000,  208000,  204000 } },
686                 { {  252000,  276000,  228000,  208000,  102000 } },
687                 { {  252000,  276000,  228000,  208000,  102000 } },
688                 { {  204000,  276000,  228000,  208000,  102000 } },
689                 { {  204000,  276000,  228000,  208000,  102000 } },
690                 { {  102000,  276000,  228000,  208000,  102000 } },
691           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
692 };
693
694 static struct balanced_throttle skin_throttle = {
695         .throt_tab_size = ARRAY_SIZE(skin_throttle_table),
696         .throt_tab = skin_throttle_table,
697 };
698
699 static int __init tegratab_skin_init(void)
700 {
701         if (machine_is_tegratab()) {
702                 tegra_get_board_info(&board_info);
703                 if (board_info.board_id == BOARD_P1640 &&
704                         board_info.fab == BOARD_FAB_A02) {
705                         skin_data.toffset = -1727;
706                         skin_data.ndevs = ARRAY_SIZE(skin_devs_a02);
707                         skin_data.devs = skin_devs_a02;
708                 }
709
710                 balanced_throttle_register(&skin_throttle, "skin-balanced");
711                 tegra_skin_therm_est_device.dev.platform_data = &skin_data;
712                 platform_device_register(&tegra_skin_therm_est_device);
713         }
714
715         return 0;
716 }
717 late_initcall(tegratab_skin_init);
718 #endif
719
720 struct ntc_thermistor_adc_table {
721         int temp; /* degree C */
722         int adc;
723 };
724
725 /* This values are only for TegraTab platform. */
726 static struct ntc_thermistor_adc_table thermistor_table[] = {
727         { -40, 3250 }, { -39, 3245 }, { -38, 3240 }, { -37, 3235 },
728         { -36, 3230 }, { -35, 3224 }, { -34, 3217 }, { -33, 3211 },
729         { -32, 3204 }, { -31, 3196 }, { -30, 3188 }, { -29, 3180 },
730         { -28, 3171 }, { -27, 3161 }, { -26, 3151 }, { -25, 3141 },
731         { -24, 3129 }, { -23, 3118 }, { -22, 3105 }, { -21, 3092 },
732         { -20, 3078 }, { -19, 3064 }, { -18, 3049 }, { -17, 3033 },
733         { -16, 3016 }, { -15, 2999 }, { -14, 2981 }, { -13, 2961 },
734         { -12, 2942 }, { -11, 2921 }, { -10, 2899 }, {  -9, 2877 },
735         {  -8, 2853 }, {  -7, 2829 }, {  -6, 2804 }, {  -5, 2778 },
736         {  -4, 2751 }, {  -3, 2723 }, {  -2, 2694 }, {  -1, 2664 },
737         {   0, 2634 }, {   1, 2602 }, {   2, 2570 }, {   3, 2537 },
738         {   4, 2503 }, {   5, 2468 }, {   6, 2433 }, {   7, 2397 },
739         {   8, 2360 }, {   9, 2322 }, {  10, 2284 }, {  11, 2245 },
740         {  12, 2206 }, {  13, 2166 }, {  14, 2126 }, {  15, 2086 },
741         {  16, 2045 }, {  17, 2004 }, {  18, 1962 }, {  19, 1921 },
742         {  20, 1879 }, {  21, 1837 }, {  22, 1796 }, {  23, 1754 },
743         {  24, 1713 }, {  25, 1671 }, {  26, 1630 }, {  27, 1589 },
744         {  28, 1549 }, {  29, 1508 }, {  30, 1468 }, {  31, 1429 },
745         {  32, 1390 }, {  33, 1351 }, {  34, 1313 }, {  35, 1276 },
746         {  36, 1239 }, {  37, 1203 }, {  38, 1168 }, {  39, 1133 },
747         {  40, 1099 }, {  41, 1065 }, {  42, 1033 }, {  43, 1001 },
748         {  44,  969 }, {  45,  939 }, {  46,  909 }, {  47,  880 },
749         {  48,  852 }, {  49,  824 }, {  50,  797 }, {  51,  771 },
750         {  52,  746 }, {  53,  721 }, {  54,  697 }, {  55,  674 },
751         {  56,  651 }, {  57,  629 }, {  58,  608 }, {  59,  588 },
752         {  60,  568 }, {  61,  548 }, {  62,  530 }, {  63,  512 },
753         {  64,  494 }, {  65,  478 }, {  66,  461 }, {  67,  445 },
754         {  68,  430 }, {  69,  415 }, {  70,  401 }, {  71,  387 },
755         {  72,  374 }, {  73,  361 }, {  74,  349 }, {  75,  337 },
756         {  76,  326 }, {  77,  314 }, {  78,  304 }, {  79,  293 },
757         {  80,  283 }, {  81,  274 }, {  82,  265 }, {  83,  256 },
758         {  84,  247 }, {  85,  239 }, {  86,  231 }, {  87,  223 },
759         {  88,  215 }, {  89,  208 }, {  90,  201 }, {  91,  194 },
760         {  92,  188 }, {  93,  182 }, {  94,  176 }, {  95,  170 },
761         {  96,  164 }, {  97,  159 }, {  98,  154 }, {  99,  149 },
762         { 100,  144 }, { 101,  139 }, { 102,  135 }, { 103,  130 },
763         { 104,  126 }, { 105,  122 }, { 106,  118 }, { 107,  115 },
764         { 108,  111 }, { 109,  107 }, { 110,  104 }, { 111,  101 },
765         { 112,   98 }, { 113,   95 }, { 114,   92 }, { 115,   89 },
766         { 116,   86 }, { 117,   83 }, { 118,   81 }, { 119,   78 },
767         { 120,   76 }, { 121,   74 }, { 122,   71 }, { 123,   69 },
768         { 124,   67 }, { 125,   65 },
769 };
770
771 static int gadc_thermal_thermistor_adc_to_temp(
772                 struct gadc_thermal_platform_data *pdata, int *val, int *val2)
773 {
774         int table_size = ARRAY_SIZE(thermistor_table);
775         int temp = 0, adc_hi, adc_lo;
776         int i;
777
778         for (i = 0; i < table_size; i++)
779                 if (*val >= thermistor_table[i].adc)
780                         break;
781
782         if (i == 0) {
783                 temp = thermistor_table[i].temp * 1000;
784         } else if (i >= (table_size - 1)) {
785                 temp = thermistor_table[table_size - 1].temp * 1000;
786         } else {
787                 adc_hi = thermistor_table[i - 1].adc;
788                 adc_lo = thermistor_table[i].adc;
789                 temp = thermistor_table[i].temp * 1000;
790                 temp -= ((*val - adc_lo) * 1000 / (adc_hi - adc_lo));
791         }
792
793         return temp;
794 };
795
796 #define TDIODE_PRECISION_MULTIPLIER     1000000000LL
797 #define TDIODE_MIN_TEMP                 -25000LL
798 #define TDIODE_MAX_TEMP                 125000LL
799
800 static int gadc_thermal_tdiode_adc_to_temp(
801                 struct gadc_thermal_platform_data *pdata, int *val, int *val2)
802 {
803         /*
804          * Series resistance cancellation using multi-current ADC measurement.
805          * diode temp = ((adc2 - k * adc1) - (b2 - k * b1)) / (m2 - k * m1)
806          * - adc1 : ADC raw with current source 400uA
807          * - m1, b1 : calculated with current source 400uA
808          * - adc2 : ADC raw with current source 800uA
809          * - m2, b2 : calculated with current source 800uA
810          * - k : 2 (= 800uA / 400uA)
811          */
812         const s64 m1 = -0.00571005 * TDIODE_PRECISION_MULTIPLIER;
813         const s64 b1 = 2524.29891 * TDIODE_PRECISION_MULTIPLIER;
814         const s64 m2 = -0.005519811 * TDIODE_PRECISION_MULTIPLIER;
815         const s64 b2 = 2579.354349 * TDIODE_PRECISION_MULTIPLIER;
816         s64 temp = TDIODE_PRECISION_MULTIPLIER;
817
818         temp *= (s64)((*val2) - 2 * (*val));
819         temp -= (b2 - 2 * b1);
820         temp = div64_s64(temp, (m2 - 2 * m1));
821         temp = min_t(s64, max_t(s64, temp, TDIODE_MIN_TEMP), TDIODE_MAX_TEMP);
822
823         return temp;
824 };
825
826 static struct gadc_thermal_platform_data gadc_thermal_thermistor_pdata = {
827         .iio_channel_name = "thermistor",
828         .tz_name = "Tboard",
829         .temp_offset = 0,
830         .adc_to_temp = gadc_thermal_thermistor_adc_to_temp,
831 };
832
833 static struct gadc_thermal_platform_data gadc_thermal_tdiode_pdata = {
834         .iio_channel_name = "tdiode",
835         .tz_name = "Tdiode",
836         .temp_offset = 0,
837         .adc_to_temp = gadc_thermal_tdiode_adc_to_temp,
838 };
839
840 static struct platform_device gadc_thermal_thermistor = {
841         .name   = "generic-adc-thermal",
842         .id     = 0,
843         .dev    = {
844                 .platform_data = &gadc_thermal_thermistor_pdata,
845         },
846 };
847
848 static struct platform_device gadc_thermal_tdiode = {
849         .name   = "generic-adc-thermal",
850         .id     = 1,
851         .dev    = {
852                 .platform_data = &gadc_thermal_tdiode_pdata,
853         },
854 };
855
856 static struct platform_device *gadc_thermal_devices[] = {
857         &gadc_thermal_thermistor,
858         &gadc_thermal_tdiode,
859 };
860
861 int __init tegratab_sensors_init(void)
862 {
863         int err;
864
865         tegra_get_board_info(&board_info);
866
867         if (board_info.board_id == BOARD_E1569 ||
868                         (board_info.board_id == BOARD_P1640 &&
869                         (board_info.fab == BOARD_FAB_A00 ||
870                         board_info.fab == BOARD_FAB_A01))) {
871                 err = tegratab_nct1008_init();
872                 if (err) {
873                         pr_err("%s: nct1008 register failed.\n", __func__);
874                         return err;
875                 }
876         } else {
877                 err = platform_add_devices(gadc_thermal_devices,
878                                            ARRAY_SIZE(gadc_thermal_devices));
879                 if (err) {
880                         pr_err("%s: gadc_thermal register failed\n", __func__);
881                         return err;
882                 }
883         }
884
885         tegratab_camera_init();
886         mpuirq_init();
887
888         return 0;
889 }