EDP: tn8: support 2d rbat_lut tables
[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[] = {  70000,   /* 100% */
103                             70000,   /*  13% */
104                             90000 }; /*   0% */
105 static int rbat_temp_axis[] = { 25 };
106 static int rbat_capacity_axis[] = { 100, 13, 0 };
107 #endif
108 struct sysedp_batmon_rbat_lut tn8_rbat_lut = {
109         .temp_axis = rbat_temp_axis,
110         .temp_size = ARRAY_SIZE(rbat_temp_axis),
111         .capacity_axis = rbat_capacity_axis,
112         .capacity_size = ARRAY_SIZE(rbat_capacity_axis),
113         .data = rbat_data,
114         .data_size = ARRAY_SIZE(rbat_data),
115 };
116
117 static struct sysedp_batmon_calc_platform_data tn8_batmon_pdata = {
118         .power_supply = "battery",
119         .r_const = 60000,
120         .vsys_min = 2900000,
121         .ibat_lut = tn8_ibat_lut,
122         .rbat_lut = &tn8_rbat_lut,
123 };
124
125 static struct platform_device tn8_batmon_device = {
126         .name = "sysedp_batmon_calc",
127         .id = -1,
128         .dev = { .platform_data = &tn8_batmon_pdata }
129 };
130
131 void __init tn8_sysedp_batmon_init(void)
132 {
133         int r;
134
135         if (get_power_supply_type() != POWER_SUPPLY_TYPE_BATTERY) {
136                 /* modify platform data on-the-fly to enable virtual battery */
137                 tn8_batmon_pdata.power_supply = "test_battery";
138                 tn8_batmon_pdata.update_interval = 2000;
139         }
140
141         r = platform_device_register(&tn8_batmon_device);
142         WARN_ON(r);
143 }
144
145 /* --- sysedp capping device data --- */
146 static struct tegra_sysedp_corecap tn8_sysedp_corecap[] = {
147         { 5000,  {2000,  108000, 924000 }, {2000, 108000, 924000 } },
148         { 6000,  {3000,  108000, 924000 }, {2000, 180000, 924000 } },
149         { 7000,  {4000,  108000, 924000 }, {2000, 252000, 924000 } },
150         { 8000,  {5000,  180000, 924000 }, {2000, 396000, 924000 } },
151         { 9000,  {6000,  180000, 924000 }, {2000, 396000, 924000 } },
152         { 10000, {7000,  108000, 924000 }, {4000, 396000, 924000 } },
153         { 11000, {7000,  252000, 924000 }, {4000, 468000, 924000 } },
154         { 12000, {8000,  180000, 924000 }, {3000, 540000, 924000 } },
155         { 13000, {9000,  108000, 924000 }, {5000, 540000, 924000 } },
156         { 14000, {10000, 108000, 924000 }, {3000, 648000, 924000 } },
157         { 15000, {11000, 108000, 924000 }, {4000, 648000, 924000 } },
158         { 16000, {11000, 180000, 924000 }, {3000, 708000, 924000 } },
159         { 17000, {12000, 180000, 924000 }, {5000, 708000, 924000 } },
160         { 18000, {13000, 108000, 924000 }, {3000, 756000, 924000 } },
161         { 19000, {14000, 108000, 924000 }, {5000, 756000, 924000 } },
162         { 20000, {14000, 180000, 924000 }, {3000, 804000, 924000 } },
163         { 21000, {14000, 252000, 924000 }, {4000, 804000, 924000 } },
164         { 22000, {16000, 108000, 924000 }, {5000, 804000, 924000 } },
165         { 23000, {16000, 180000, 924000 }, {6000, 804000, 924000 } },
166 };
167 static struct tegra_sysedp_platform_data tn8_sysedp_dynamic_capping_platdata = {
168         .corecap = tn8_sysedp_corecap,
169         .corecap_size = ARRAY_SIZE(tn8_sysedp_corecap),
170         .core_gain = 100,
171         .init_req_watts = 20000,
172 };
173
174 static struct platform_device tn8_sysedp_dynamic_capping = {
175         .name = "sysedp_dynamic_capping",
176         .id = -1,
177         .dev = { .platform_data = &tn8_sysedp_dynamic_capping_platdata }
178 };
179
180 void __init tn8_sysedp_dynamic_capping_init(void)
181 {
182         int r;
183
184         tn8_sysedp_dynamic_capping_platdata.cpufreq_lim = tegra_get_system_edp_entries(
185                 &tn8_sysedp_dynamic_capping_platdata.cpufreq_lim_size);
186         if (!tn8_sysedp_dynamic_capping_platdata.cpufreq_lim) {
187                 WARN_ON(1);
188                 return;
189         }
190
191         r = platform_device_register(&tn8_sysedp_dynamic_capping);
192         WARN_ON(r);
193 }