arm: tegra: Move all tj dependent thermals from nct to soc_therm
[linux-3.10.git] / arch / arm / mach-tegra / board-dalmore-sensors.c
1 /*
2  * arch/arm/mach-tegra/board-dalmore-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 <mach/edp.h>
39 #include <linux/edp.h>
40 #include <mach/gpio-tegra.h>
41 #include <mach/pinmux-t11.h>
42 #include <mach/pinmux.h>
43 #include <media/imx091.h>
44 #include <media/ov9772.h>
45 #include <media/as364x.h>
46 #include <media/ad5816.h>
47 #include <generated/mach-types.h>
48 #include <linux/power/sbs-battery.h>
49
50 #include "gpio-names.h"
51 #include "board.h"
52 #include "board-common.h"
53 #include "board-dalmore.h"
54 #include "cpu-tegra.h"
55 #include "devices.h"
56 #include "tegra-board-id.h"
57 #include "dvfs.h"
58
59 static struct nvc_gpio_pdata imx091_gpio_pdata[] = {
60         {IMX091_GPIO_RESET, CAM_RSTN, true, false},
61         {IMX091_GPIO_PWDN, CAM1_POWER_DWN_GPIO, true, false},
62         {IMX091_GPIO_GP1, CAM_GPIO1, true, false}
63 };
64
65 static struct board_info board_info;
66
67 static struct throttle_table tj_throttle_table[] = {
68                 /* CPU_THROT_LOW cannot be used by other than CPU */
69                 /* NO_CAP cannot be used by CPU */
70                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
71                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
72                 { { 1428000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
73                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
74                 { { 1224000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
75                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
76                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
77                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
78                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
79                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
80                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
81                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
82                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
83                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
84                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
85                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
86                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
87                 { {  612000,  360000,  360000,  312000,  NO_CAP } },
88                 { {  510000,  360000,  360000,  312000,  480000 } },
89                 { {  468000,  360000,  360000,  312000,  480000 } },
90                 { {  468000,  276000,  276000,  208000,  480000 } },
91                 { {  372000,  276000,  276000,  208000,  204000 } },
92                 { {  288000,  276000,  276000,  208000,  204000 } },
93                 { {  252000,  276000,  228000,  208000,  102000 } },
94                 { {  204000,  276000,  228000,  208000,  102000 } },
95                 { {  102000,  276000,  228000,  208000,  102000 } },
96           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
97 };
98
99 static struct balanced_throttle tj_throttle = {
100         .throt_tab_size = ARRAY_SIZE(tj_throttle_table),
101         .throt_tab = tj_throttle_table,
102 };
103
104 static int __init dalmore_throttle_init(void)
105 {
106         if (machine_is_dalmore())
107                 balanced_throttle_register(&tj_throttle, "tegra-balanced");
108         return 0;
109 }
110 module_init(dalmore_throttle_init);
111
112 static struct nct1008_platform_data dalmore_nct1008_pdata = {
113         .supported_hwrev = true,
114         .ext_range = true,
115         .conv_rate = 0x08,
116         .shutdown_ext_limit = 105, /* C */
117         .shutdown_local_limit = 120, /* C */
118 };
119
120 static struct i2c_board_info dalmore_i2c4_nct1008_board_info[] = {
121         {
122                 I2C_BOARD_INFO("nct1008", 0x4C),
123                 .platform_data = &dalmore_nct1008_pdata,
124                 .irq = -1,
125         }
126 };
127
128 #define VI_PINMUX(_pingroup, _mux, _pupd, _tri, _io, _lock, _ioreset) \
129         {                                                       \
130                 .pingroup       = TEGRA_PINGROUP_##_pingroup,   \
131                 .func           = TEGRA_MUX_##_mux,             \
132                 .pupd           = TEGRA_PUPD_##_pupd,           \
133                 .tristate       = TEGRA_TRI_##_tri,             \
134                 .io             = TEGRA_PIN_##_io,              \
135                 .lock           = TEGRA_PIN_LOCK_##_lock,       \
136                 .od             = TEGRA_PIN_OD_DEFAULT,         \
137                 .ioreset        = TEGRA_PIN_IO_RESET_##_ioreset \
138 }
139
140 static int dalmore_focuser_power_on(struct ad5816_power_rail *pw)
141 {
142         int err;
143
144         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
145                 return -EFAULT;
146
147         err = regulator_enable(pw->vdd_i2c);
148         if (unlikely(err))
149                 goto ad5816_vdd_i2c_fail;
150
151         err = regulator_enable(pw->vdd);
152         if (unlikely(err))
153                 goto ad5816_vdd_fail;
154
155         return 0;
156
157 ad5816_vdd_fail:
158         regulator_disable(pw->vdd_i2c);
159
160 ad5816_vdd_i2c_fail:
161         pr_err("%s FAILED\n", __func__);
162
163         return -ENODEV;
164 }
165
166 static int dalmore_focuser_power_off(struct ad5816_power_rail *pw)
167 {
168         if (unlikely(WARN_ON(!pw || !pw->vdd || !pw->vdd_i2c)))
169                 return -EFAULT;
170
171         regulator_disable(pw->vdd);
172         regulator_disable(pw->vdd_i2c);
173
174         return 0;
175 }
176
177 static struct tegra_pingroup_config mclk_disable =
178         VI_PINMUX(CAM_MCLK, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
179
180 static struct tegra_pingroup_config mclk_enable =
181         VI_PINMUX(CAM_MCLK, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
182
183 static struct tegra_pingroup_config pbb0_disable =
184         VI_PINMUX(GPIO_PBB0, VI, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
185
186 static struct tegra_pingroup_config pbb0_enable =
187         VI_PINMUX(GPIO_PBB0, VI_ALT3, NORMAL, NORMAL, OUTPUT, DEFAULT, DEFAULT);
188
189 /*
190  * As a workaround, dalmore_vcmvdd need to be allocated to activate the
191  * sensor devices. This is due to the focuser device(AD5816) will hook up
192  * the i2c bus if it is not powered up.
193 */
194 static struct regulator *dalmore_vcmvdd;
195
196 static int dalmore_get_vcmvdd(void)
197 {
198         if (!dalmore_vcmvdd) {
199                 dalmore_vcmvdd = regulator_get(NULL, "vdd_af_cam1");
200                 if (unlikely(WARN_ON(IS_ERR(dalmore_vcmvdd)))) {
201                         pr_err("%s: can't get regulator vcmvdd: %ld\n",
202                                 __func__, PTR_ERR(dalmore_vcmvdd));
203                         dalmore_vcmvdd = NULL;
204                         return -ENODEV;
205                 }
206         }
207         return 0;
208 }
209
210 static int dalmore_imx091_power_on(struct nvc_regulator *vreg)
211 {
212         int err;
213
214         if (unlikely(WARN_ON(!vreg)))
215                 return -EFAULT;
216
217         if (dalmore_get_vcmvdd())
218                 goto imx091_poweron_fail;
219
220         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
221         usleep_range(10, 20);
222
223         err = regulator_enable(vreg[IMX091_VREG_AVDD].vreg);
224         if (err)
225                 goto imx091_avdd_fail;
226
227         err = regulator_enable(vreg[IMX091_VREG_IOVDD].vreg);
228         if (err)
229                 goto imx091_iovdd_fail;
230
231         usleep_range(1, 2);
232         gpio_set_value(CAM1_POWER_DWN_GPIO, 1);
233
234         err = regulator_enable(dalmore_vcmvdd);
235         if (unlikely(err))
236                 goto imx091_vcmvdd_fail;
237
238         tegra_pinmux_config_table(&mclk_enable, 1);
239         usleep_range(300, 310);
240
241         return 1;
242
243 imx091_vcmvdd_fail:
244         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
245
246 imx091_iovdd_fail:
247         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
248
249 imx091_avdd_fail:
250         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
251
252 imx091_poweron_fail:
253         pr_err("%s FAILED\n", __func__);
254         return -ENODEV;
255 }
256
257 static int dalmore_imx091_power_off(struct nvc_regulator *vreg)
258 {
259         if (unlikely(WARN_ON(!vreg)))
260                 return -EFAULT;
261
262         usleep_range(1, 2);
263         tegra_pinmux_config_table(&mclk_disable, 1);
264         gpio_set_value(CAM1_POWER_DWN_GPIO, 0);
265         usleep_range(1, 2);
266
267         regulator_disable(dalmore_vcmvdd);
268         regulator_disable(vreg[IMX091_VREG_IOVDD].vreg);
269         regulator_disable(vreg[IMX091_VREG_AVDD].vreg);
270
271         return 1;
272 }
273
274 static struct nvc_imager_cap imx091_cap = {
275         .identifier             = "IMX091",
276         .sensor_nvc_interface   = 3,
277         .pixel_types[0]         = 0x100,
278         .orientation            = 0,
279         .direction              = 0,
280         .initial_clock_rate_khz = 6000,
281         .clock_profiles[0] = {
282                 .external_clock_khz     = 24000,
283                 .clock_multiplier       = 850000, /* value / 1,000,000 */
284         },
285         .clock_profiles[1] = {
286                 .external_clock_khz     = 0,
287                 .clock_multiplier       = 0,
288         },
289         .h_sync_edge            = 0,
290         .v_sync_edge            = 0,
291         .mclk_on_vgp0           = 0,
292         .csi_port               = 0,
293         .data_lanes             = 4,
294         .virtual_channel_id     = 0,
295         .discontinuous_clk_mode = 1,
296         .cil_threshold_settle   = 0x0,
297         .min_blank_time_width   = 16,
298         .min_blank_time_height  = 16,
299         .preferred_mode_index   = 0,
300         .focuser_guid           = NVC_FOCUS_GUID(0),
301         .torch_guid             = NVC_TORCH_GUID(0),
302         .cap_version            = NVC_IMAGER_CAPABILITIES_VERSION2,
303 };
304
305 static struct imx091_platform_data imx091_pdata = {
306         .num                    = 0,
307         .sync                   = 0,
308         .dev_name               = "camera",
309         .gpio_count             = ARRAY_SIZE(imx091_gpio_pdata),
310         .gpio                   = imx091_gpio_pdata,
311         .flash_cap              = {
312                 .sdo_trigger_enabled = 1,
313                 .adjustable_flash_timing = 1,
314         },
315         .cap                    = &imx091_cap,
316         .power_on               = dalmore_imx091_power_on,
317         .power_off              = dalmore_imx091_power_off,
318 };
319
320 static struct sbs_platform_data sbs_pdata = {
321         .poll_retry_count = 100,
322         .i2c_retry_count = 2,
323 };
324
325 static int dalmore_ov9772_power_on(struct ov9772_power_rail *pw)
326 {
327         int err;
328
329         if (unlikely(!pw || !pw->avdd || !pw->dovdd))
330                 return -EFAULT;
331
332         if (dalmore_get_vcmvdd())
333                 goto ov9772_get_vcmvdd_fail;
334
335         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
336         gpio_set_value(CAM_RSTN, 0);
337
338         err = regulator_enable(pw->avdd);
339         if (unlikely(err))
340                 goto ov9772_avdd_fail;
341
342         err = regulator_enable(pw->dovdd);
343         if (unlikely(err))
344                 goto ov9772_dovdd_fail;
345
346         gpio_set_value(CAM_RSTN, 1);
347         gpio_set_value(CAM2_POWER_DWN_GPIO, 1);
348
349         err = regulator_enable(dalmore_vcmvdd);
350         if (unlikely(err))
351                 goto ov9772_vcmvdd_fail;
352
353         tegra_pinmux_config_table(&pbb0_enable, 1);
354         usleep_range(340, 380);
355
356         /* return 1 to skip the in-driver power_on sequence */
357         return 1;
358
359 ov9772_vcmvdd_fail:
360         regulator_disable(pw->dovdd);
361
362 ov9772_dovdd_fail:
363         regulator_disable(pw->avdd);
364
365 ov9772_avdd_fail:
366         gpio_set_value(CAM_RSTN, 0);
367         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
368
369 ov9772_get_vcmvdd_fail:
370         pr_err("%s FAILED\n", __func__);
371         return -ENODEV;
372 }
373
374 static int dalmore_ov9772_power_off(struct ov9772_power_rail *pw)
375 {
376         if (unlikely(!pw || !dalmore_vcmvdd || !pw->avdd || !pw->dovdd))
377                 return -EFAULT;
378
379         usleep_range(21, 25);
380         tegra_pinmux_config_table(&pbb0_disable, 1);
381
382         gpio_set_value(CAM2_POWER_DWN_GPIO, 0);
383         gpio_set_value(CAM_RSTN, 0);
384
385         regulator_disable(dalmore_vcmvdd);
386         regulator_disable(pw->dovdd);
387         regulator_disable(pw->avdd);
388
389         /* return 1 to skip the in-driver power_off sequence */
390         return 1;
391 }
392
393 static struct nvc_gpio_pdata ov9772_gpio_pdata[] = {
394         { OV9772_GPIO_TYPE_SHTDN, CAM2_POWER_DWN_GPIO, true, 0, },
395         { OV9772_GPIO_TYPE_PWRDN, CAM_RSTN, true, 0, },
396 };
397
398 static struct ov9772_platform_data dalmore_ov9772_pdata = {
399         .num            = 1,
400         .dev_name       = "camera",
401         .gpio_count     = ARRAY_SIZE(ov9772_gpio_pdata),
402         .gpio           = ov9772_gpio_pdata,
403         .power_on       = dalmore_ov9772_power_on,
404         .power_off      = dalmore_ov9772_power_off,
405 };
406
407 static int dalmore_as3648_power_on(struct as364x_power_rail *pw)
408 {
409         int err = dalmore_get_vcmvdd();
410
411         if (err)
412                 return err;
413
414         return regulator_enable(dalmore_vcmvdd);
415 }
416
417 static int dalmore_as3648_power_off(struct as364x_power_rail *pw)
418 {
419         if (!dalmore_vcmvdd)
420                 return -ENODEV;
421
422         return regulator_disable(dalmore_vcmvdd);
423 }
424
425 static struct as364x_platform_data dalmore_as3648_pdata = {
426         .config         = {
427                 .max_total_current_mA = 1000,
428                 .max_peak_current_mA = 600,
429                 .vin_low_v_run_mV = 3070,
430                 .strobe_type = 1,
431                 },
432         .pinstate       = {
433                 .mask   = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0),
434                 .values = 1 << (CAM_FLASH_STROBE - TEGRA_GPIO_PBB0)
435                 },
436         .dev_name       = "torch",
437         .type           = AS3648,
438         .gpio_strobe    = CAM_FLASH_STROBE,
439         .led_mask       = 3,
440
441         .power_on_callback = dalmore_as3648_power_on,
442         .power_off_callback = dalmore_as3648_power_off,
443 };
444
445 static struct ad5816_platform_data dalmore_ad5816_pdata = {
446         .cfg = 0,
447         .num = 0,
448         .sync = 0,
449         .dev_name = "focuser",
450         .power_on = dalmore_focuser_power_on,
451         .power_off = dalmore_focuser_power_off,
452 };
453
454 static struct i2c_board_info dalmore_i2c_board_info_e1625[] = {
455         {
456                 I2C_BOARD_INFO("imx091", 0x36),
457                 .platform_data = &imx091_pdata,
458         },
459         {
460                 I2C_BOARD_INFO("ov9772", 0x10),
461                 .platform_data = &dalmore_ov9772_pdata,
462         },
463         {
464                 I2C_BOARD_INFO("as3648", 0x30),
465                 .platform_data = &dalmore_as3648_pdata,
466         },
467         {
468                 I2C_BOARD_INFO("ad5816", 0x0E),
469                 .platform_data = &dalmore_ad5816_pdata,
470         },
471 };
472
473 static int dalmore_camera_init(void)
474 {
475         tegra_pinmux_config_table(&mclk_disable, 1);
476         tegra_pinmux_config_table(&pbb0_disable, 1);
477
478         i2c_register_board_info(2, dalmore_i2c_board_info_e1625,
479                 ARRAY_SIZE(dalmore_i2c_board_info_e1625));
480         return 0;
481 }
482
483 /* MPU board file definition    */
484 static struct mpu_platform_data mpu9150_gyro_data = {
485         .int_config     = 0x10,
486         .level_shifter  = 0,
487         /* Located in board_[platformname].h */
488         .orientation    = MPU_GYRO_ORIENTATION,
489         .sec_slave_type = SECONDARY_SLAVE_TYPE_COMPASS,
490         .sec_slave_id   = COMPASS_ID_AK8975,
491         .secondary_i2c_addr     = MPU_COMPASS_ADDR,
492         .secondary_read_reg     = 0x06,
493         .secondary_orientation  = MPU_COMPASS_ORIENTATION,
494         .key            = {0x4E, 0xCC, 0x7E, 0xEB, 0xF6, 0x1E, 0x35, 0x22,
495                            0x00, 0x34, 0x0D, 0x65, 0x32, 0xE9, 0x94, 0x89},
496 };
497
498 #define TEGRA_CAMERA_GPIO(_gpio, _label, _value)                \
499         {                                                       \
500                 .gpio = _gpio,                                  \
501                 .label = _label,                                \
502                 .value = _value,                                \
503         }
504
505 static struct i2c_board_info dalmore_i2c_board_info_cm3218[] = {
506         {
507                 I2C_BOARD_INFO("cm3218", 0x48),
508         },
509 };
510
511 static struct i2c_board_info __initdata inv_mpu9150_i2c2_board_info[] = {
512         {
513                 I2C_BOARD_INFO(MPU_GYRO_NAME, MPU_GYRO_ADDR),
514                 .platform_data = &mpu9150_gyro_data,
515         },
516 };
517
518 static void mpuirq_init(void)
519 {
520         int ret = 0;
521         unsigned gyro_irq_gpio = MPU_GYRO_IRQ_GPIO;
522         unsigned gyro_bus_num = MPU_GYRO_BUS_NUM;
523         char *gyro_name = MPU_GYRO_NAME;
524
525         pr_info("*** MPU START *** mpuirq_init...\n");
526
527         ret = gpio_request(gyro_irq_gpio, gyro_name);
528
529         if (ret < 0) {
530                 pr_err("%s: gpio_request failed %d\n", __func__, ret);
531                 return;
532         }
533
534         ret = gpio_direction_input(gyro_irq_gpio);
535         if (ret < 0) {
536                 pr_err("%s: gpio_direction_input failed %d\n", __func__, ret);
537                 gpio_free(gyro_irq_gpio);
538                 return;
539         }
540         pr_info("*** MPU END *** mpuirq_init...\n");
541
542         inv_mpu9150_i2c2_board_info[0].irq = gpio_to_irq(MPU_GYRO_IRQ_GPIO);
543         i2c_register_board_info(gyro_bus_num, inv_mpu9150_i2c2_board_info,
544                 ARRAY_SIZE(inv_mpu9150_i2c2_board_info));
545 }
546
547 static int dalmore_nct1008_init(void)
548 {
549         int nct1008_port;
550         int ret = 0;
551
552         if ((board_info.board_id == BOARD_E1612) ||
553             (board_info.board_id == BOARD_E1641) ||
554             (board_info.board_id == BOARD_E1613) ||
555             (board_info.board_id == BOARD_P2454))
556         {
557                 /* per email from Matt 9/10/2012 */
558                 nct1008_port = TEGRA_GPIO_PX6;
559         } else if (board_info.board_id == BOARD_E1611) {
560                 if (board_info.fab == 0x04)
561                         nct1008_port = TEGRA_GPIO_PO4;
562                 else
563                         nct1008_port = TEGRA_GPIO_PX6;
564         } else {
565                 nct1008_port = TEGRA_GPIO_PX6;
566                 pr_err("Warning: nct alert_port assumed TEGRA_GPIO_PX6"
567                         " for unknown dalmore board id E%d\n",
568                         board_info.board_id);
569         }
570
571         tegra_add_cdev_trips(dalmore_nct1008_pdata.trips,
572                                 &dalmore_nct1008_pdata.num_trips);
573
574         dalmore_i2c4_nct1008_board_info[0].irq = gpio_to_irq(nct1008_port);
575         pr_info("%s: dalmore nct1008 irq %d",
576                         __func__, dalmore_i2c4_nct1008_board_info[0].irq);
577
578         ret = gpio_request(nct1008_port, "temp_alert");
579         if (ret < 0)
580                 return ret;
581
582         ret = gpio_direction_input(nct1008_port);
583         if (ret < 0) {
584                 pr_info("%s: calling gpio_free(nct1008_port)", __func__);
585                 gpio_free(nct1008_port);
586         }
587
588         /* dalmore has thermal sensor on GEN1-I2C i.e. instance 0 */
589         i2c_register_board_info(0, dalmore_i2c4_nct1008_board_info,
590                 ARRAY_SIZE(dalmore_i2c4_nct1008_board_info));
591
592         return ret;
593 }
594
595 static struct i2c_board_info __initdata bq20z45_pdata[] = {
596         {
597                 I2C_BOARD_INFO("sbs-battery", 0x0B),
598                 .platform_data = &sbs_pdata,
599         },
600 };
601
602 #ifdef CONFIG_TEGRA_SKIN_THROTTLE
603 static int tegra_skin_match(struct thermal_zone_device *thz, void *data)
604 {
605         return strcmp((char *)data, thz->type) == 0;
606 }
607
608 static int tegra_skin_get_temp(void *data, long *temp)
609 {
610         struct thermal_zone_device *thz;
611
612         thz = thermal_zone_device_find(data, tegra_skin_match);
613
614         if (!thz || thz->ops->get_temp(thz, temp))
615                 *temp = 25000;
616
617         return 0;
618 }
619
620 static struct therm_est_data skin_data = {
621         .cdev_type = "skin-balanced",
622         .toffset = 9793,
623         .polling_period = 1100,
624         .ndevs = 2,
625         .tc1 = 5,
626         .tc2 = 1,
627         .devs = {
628                         {
629                                 .dev_data = "nct_ext",
630                                 .get_temp = tegra_skin_get_temp,
631                                 .coeffs = {
632                                         2, 1, 1, 1,
633                                         1, 1, 1, 1,
634                                         1, 1, 1, 0,
635                                         1, 1, 0, 0,
636                                         0, 0, -1, -7
637                                 },
638                         },
639                         {
640                                 .dev_data = "nct_int",
641                                 .get_temp = tegra_skin_get_temp,
642                                 .coeffs = {
643                                         -11, -7, -5, -3,
644                                         -3, -2, -1, 0,
645                                         0, 0, 1, 1,
646                                         1, 2, 2, 3,
647                                         4, 6, 11, 18
648                                 },
649                         },
650         },
651         .trip_temp = 43000,
652         .passive_delay = 5000,
653 };
654
655 static struct throttle_table skin_throttle_table[] = {
656                 /* CPU_THROT_LOW cannot be used by other than CPU */
657                 /* NO_CAP cannot be used by CPU */
658                 /*    CPU,   C2BUS,   C3BUS,    SCLK,     EMC */
659                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
660                 { { 1530000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
661                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
662                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
663                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
664                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
665                 { { 1326000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
666                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
667                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
668                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
669                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
670                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
671                 { { 1122000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
672                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
673                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
674                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
675                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
676                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
677                 { { 1020000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
678                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
679                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
680                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
681                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
682                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
683                 { {  918000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
684                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
685                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
686                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
687                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
688                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
689                 { {  816000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
690                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
691                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
692                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
693                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
694                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
695                 { {  714000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
696                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
697                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
698                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
699                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
700                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
701                 { {  612000,  NO_CAP,  NO_CAP,  NO_CAP,  NO_CAP } },
702                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
703                 { {  612000,  564000,  564000,  NO_CAP,  NO_CAP } },
704                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
705                 { {  612000,  528000,  528000,  NO_CAP,  NO_CAP } },
706                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
707                 { {  612000,  492000,  492000,  NO_CAP,  NO_CAP } },
708                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
709                 { {  612000,  420000,  420000,  NO_CAP,  NO_CAP } },
710                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
711                 { {  612000,  408000,  408000,  NO_CAP,  NO_CAP } },
712                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
713                 { {  612000,  360000,  360000,  NO_CAP,  NO_CAP } },
714                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
715                 { {  510000,  360000,  360000,  312000,  NO_CAP } },
716                 { {  510000,  360000,  360000,  312000,  480000 } },
717                 { {  510000,  360000,  360000,  312000,  480000 } },
718                 { {  510000,  360000,  360000,  312000,  480000 } },
719                 { {  510000,  360000,  360000,  312000,  480000 } },
720                 { {  510000,  360000,  360000,  312000,  480000 } },
721                 { {  510000,  360000,  360000,  312000,  480000 } },
722                 { {  468000,  360000,  360000,  312000,  480000 } },
723                 { {  468000,  360000,  360000,  312000,  480000 } },
724                 { {  468000,  276000,  276000,  208000,  480000 } },
725                 { {  468000,  276000,  276000,  208000,  480000 } },
726                 { {  372000,  276000,  276000,  208000,  204000 } },
727                 { {  372000,  276000,  276000,  208000,  204000 } },
728                 { {  288000,  276000,  276000,  208000,  204000 } },
729                 { {  288000,  276000,  276000,  208000,  204000 } },
730                 { {  252000,  276000,  228000,  208000,  102000 } },
731                 { {  252000,  276000,  228000,  208000,  102000 } },
732                 { {  204000,  276000,  228000,  208000,  102000 } },
733                 { {  204000,  276000,  228000,  208000,  102000 } },
734                 { {  102000,  276000,  228000,  208000,  102000 } },
735           { { CPU_THROT_LOW,  276000,  228000,  208000,  102000 } },
736 };
737
738 static struct balanced_throttle skin_throttle = {
739         .throt_tab_size = ARRAY_SIZE(skin_throttle_table),
740         .throt_tab = skin_throttle_table,
741 };
742
743 static int __init dalmore_skin_init(void)
744 {
745         if (machine_is_dalmore()) {
746                 balanced_throttle_register(&skin_throttle, "skin-balanced");
747                 tegra_skin_therm_est_device.dev.platform_data = &skin_data;
748                 platform_device_register(&tegra_skin_therm_est_device);
749         }
750
751         return 0;
752 }
753 late_initcall(dalmore_skin_init);
754 #endif
755
756 int __init dalmore_sensors_init(void)
757 {
758         int err;
759
760         tegra_get_board_info(&board_info);
761
762         err = dalmore_nct1008_init();
763         if (err)
764                 return err;
765
766         dalmore_camera_init();
767         mpuirq_init();
768
769         i2c_register_board_info(0, dalmore_i2c_board_info_cm3218,
770                 ARRAY_SIZE(dalmore_i2c_board_info_cm3218));
771
772         i2c_register_board_info(0, bq20z45_pdata,
773                 ARRAY_SIZE(bq20z45_pdata));
774
775         return 0;
776 }