ARM: tegra: pcie: Remove dock detect variable
[linux-3.10.git] / arch / arm / mach-tegra / board-tn8-sysedp.c
1 /*
2  * Copyright (c) 2013 NVIDIA Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11  * GNU General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License along
14  * with this program; if not, write to the Free Software Foundation, Inc.,
15  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
16  */
17
18 #include <linux/sysedp.h>
19 #include <linux/platform_device.h>
20 #include <linux/platform_data/tegra_edp.h>
21 #include <linux/power_supply.h>
22 #include <mach/edp.h>
23 #include "board.h"
24 #include "board-panel.h"
25
26 /* --- EDP consumers data --- */
27 static unsigned int ov5693_states[] = { 0, 300 };
28 static unsigned int mt9m114_states[] = { 0, 150 };
29 static unsigned int sdhci_states[] = { 0, 966 };
30 static unsigned int speaker_states[] = { 0, 1080 };
31 static unsigned int wifi_states[] = { 0, 1020 };
32 static unsigned int modem_states[] = { 0, 4100 };
33 static unsigned int pwm_backlight_states[] = {
34         0, 125, 250, 375, 500, 625, 750, 875, 1000, 1125, 1250
35 };
36
37 /* (optional) 10" panel */
38 static unsigned int pwm_backlight_10_states[] = {
39         0, 425, 851, 1276, 1702, 2127, 2553, 2978, 3404, 3829, 4255
40 };
41 static unsigned int as364x_states[] = {
42         0, 350, 700, 1050, 1400, 1750, 2100, 2450, 2800, 3150, 3500
43 };
44
45 static struct sysedp_consumer_data tn8_sysedp_consumer_data[] = {
46         SYSEDP_CONSUMER_DATA("ov5693", ov5693_states),
47         SYSEDP_CONSUMER_DATA("mt9m114", mt9m114_states),
48         SYSEDP_CONSUMER_DATA("speaker", speaker_states),
49         SYSEDP_CONSUMER_DATA("wifi", wifi_states),
50         SYSEDP_CONSUMER_DATA("pwm-backlight", pwm_backlight_states),
51         SYSEDP_CONSUMER_DATA("sdhci-tegra.2", sdhci_states),
52         SYSEDP_CONSUMER_DATA("sdhci-tegra.3", sdhci_states),
53         SYSEDP_CONSUMER_DATA("as364x", as364x_states),
54         SYSEDP_CONSUMER_DATA("modem", modem_states),
55 };
56
57 static struct sysedp_platform_data tn8_sysedp_platform_data = {
58         .consumer_data = tn8_sysedp_consumer_data,
59         .consumer_data_size = ARRAY_SIZE(tn8_sysedp_consumer_data),
60         .margin = 0,
61 };
62
63 static struct platform_device tn8_sysedp_device = {
64         .name = "sysedp",
65         .id = -1,
66         .dev = { .platform_data = &tn8_sysedp_platform_data }
67 };
68
69 void __init tn8_new_sysedp_init(void)
70 {
71         int r;
72         struct board_info board;
73
74         tegra_get_display_board_info(&board);
75
76         /* Some TN8 boards use non-default display */
77         if (board.board_id != BOARD_E1549)
78                 memcpy(pwm_backlight_states, pwm_backlight_10_states,
79                        sizeof(pwm_backlight_states));
80
81         r = platform_device_register(&tn8_sysedp_device);
82         WARN_ON(r);
83 }
84
85 /* --- Battery monitor data --- */
86 static struct sysedp_batmon_ibat_lut tn8_ibat_lut[] = {
87         {  60, 6150 }, /* TODO until battery temp is fixed*/
88         {  40, 6150 },
89         {   0, 6150 },
90         { -30,    0 }
91 };
92
93 #if 0
94 /* TODO: use this table when battery temp sensing is fixed */
95 /*                           60C    40C    25C    0C      -20C      */
96 static int rbat_data[] = {  90000, 60000, 70000,  90000, 110000,   /* 100% */
97                             90000, 60000, 70000,  90000, 110000,   /*  13% */
98                            110000, 80000, 90000, 110000, 130000 }; /*   0% */
99 static int rbat_temp_axis[] = { 60, 40, 25, 0, -20 };
100 static int rbat_capacity_axis[] = { 100, 13, 0 };
101 #else
102 static int rbat_data[] = { 110000,   /* 100% */
103                            110000,   /*  25% */
104                            150000,   /*  10% */
105                            170000 }; /*   0% */
106 static int rbat_temp_axis[] = { 25 };
107 static int rbat_capacity_axis[] = { 100, 25, 10, 0 };
108 #endif
109 struct sysedp_batmon_rbat_lut tn8_rbat_lut = {
110         .temp_axis = rbat_temp_axis,
111         .temp_size = ARRAY_SIZE(rbat_temp_axis),
112         .capacity_axis = rbat_capacity_axis,
113         .capacity_size = ARRAY_SIZE(rbat_capacity_axis),
114         .data = rbat_data,
115         .data_size = ARRAY_SIZE(rbat_data),
116 };
117
118 static struct sysedp_batmon_calc_platform_data tn8_batmon_pdata = {
119         .power_supply = "battery",
120         .r_const = 60000,
121         .vsys_min = 3000000,
122         .ibat_lut = tn8_ibat_lut,
123         .rbat_lut = &tn8_rbat_lut,
124 };
125
126 static struct platform_device tn8_batmon_device = {
127         .name = "sysedp_batmon_calc",
128         .id = -1,
129         .dev = { .platform_data = &tn8_batmon_pdata }
130 };
131
132 void __init tn8_sysedp_batmon_init(void)
133 {
134         int r;
135
136         if (get_power_supply_type() != POWER_SUPPLY_TYPE_BATTERY) {
137                 /* modify platform data on-the-fly to enable virtual battery */
138                 tn8_batmon_pdata.power_supply = "test_battery";
139                 tn8_batmon_pdata.update_interval = 2000;
140         }
141
142         r = platform_device_register(&tn8_batmon_device);
143         WARN_ON(r);
144 }
145
146 static struct tegra_sysedp_platform_data tn8_sysedp_dynamic_capping_platdata = {
147         .corecap = td570d_sysedp_corecap,
148         .corecap_size = td570d_sysedp_corecap_sz,
149         .core_gain = 100,
150         .init_req_watts = 20000,
151 };
152
153 static struct platform_device tn8_sysedp_dynamic_capping = {
154         .name = "sysedp_dynamic_capping",
155         .id = -1,
156         .dev = { .platform_data = &tn8_sysedp_dynamic_capping_platdata }
157 };
158
159 void __init tn8_sysedp_dynamic_capping_init(void)
160 {
161         int r;
162
163         tn8_sysedp_dynamic_capping_platdata.cpufreq_lim = tegra_get_system_edp_entries(
164                 &tn8_sysedp_dynamic_capping_platdata.cpufreq_lim_size);
165         if (!tn8_sysedp_dynamic_capping_platdata.cpufreq_lim) {
166                 WARN_ON(1);
167                 return;
168         }
169
170         r = platform_device_register(&tn8_sysedp_dynamic_capping);
171         WARN_ON(r);
172 }