ARM: tegra: pcie: Remove dock detect variable
[linux-3.10.git] / arch / arm / mach-tegra / panel-s-edp-wqxgap-15-6.c
1 /*
2  * arch/arm/mach-tegra/panel-s-edp-wqxgap-15-6.c
3  *
4  * Copyright (c) 2012-2013, NVIDIA CORPORATION. All rights reserved.
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms and conditions of the GNU General Public License,
8  * version 2, as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
13  * more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
17  */
18
19 #include <mach/dc.h>
20 #include <linux/delay.h>
21 #include <linux/gpio.h>
22 #include <linux/tegra_pwm_bl.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/pwm_backlight.h>
25 #include <linux/leds.h>
26 #include <linux/ioport.h>
27 #include "board.h"
28 #include "board-panel.h"
29 #include "devices.h"
30 #include "gpio-names.h"
31 #include "tegra12_host1x_devices.h"
32
33 #define DC_CTRL_MODE    TEGRA_DC_OUT_CONTINUOUS_MODE
34
35 #define EDP_PANEL_BL_PWM        TEGRA_GPIO_PH1
36
37 static bool reg_requested;
38 static bool gpio_requested;
39 static struct platform_device *disp_device;
40
41 static struct regulator *vdd_lcd_bl_en;
42 static struct regulator *avdd_lcd;
43 static struct regulator *avdd_3v3_dp;
44 static struct regulator *vdd_ds_1v8;
45
46 static struct tegra_dc_sd_settings edp_s_wqxgap_15_6_sd_settings = {
47         .enable = 1, /* enabled by default. */
48         .use_auto_pwm = false,
49         .hw_update_delay = 0,
50         .bin_width = -1,
51         .aggressiveness = 5,
52         .use_vid_luma = false,
53         .phase_in_adjustments = 0,
54         .k_limit_enable = true,
55         .k_limit = 200,
56         .sd_window_enable = false,
57         .soft_clipping_enable = true,
58         /* Low soft clipping threshold to compensate for aggressive k_limit */
59         .soft_clipping_threshold = 128,
60         .smooth_k_enable = false,
61         .smooth_k_incr = 64,
62         /* Default video coefficients */
63         .coeff = {5, 9, 2},
64         .fc = {0, 0},
65         /* Immediate backlight changes */
66         .blp = {1024, 255},
67         /* Gammas: R: 2.2 G: 2.2 B: 2.2 */
68         /* Default BL TF */
69         .bltf = {
70                         {
71                                 {57, 65, 73, 82},
72                                 {92, 103, 114, 125},
73                                 {138, 150, 164, 178},
74                                 {193, 208, 224, 241},
75                         },
76                 },
77         /* Default LUT */
78         .lut = {
79                         {
80                                 {255, 255, 255},
81                                 {199, 199, 199},
82                                 {153, 153, 153},
83                                 {116, 116, 116},
84                                 {85, 85, 85},
85                                 {59, 59, 59},
86                                 {36, 36, 36},
87                                 {17, 17, 17},
88                                 {0, 0, 0},
89                         },
90                 },
91         .sd_brightness = &sd_brightness,
92         .use_vpulse2 = true,
93 };
94
95 static int shield_edp_regulator_get(struct device *dev)
96 {
97         int err = 0;
98
99         if (reg_requested)
100                 return 0;
101
102         vdd_ds_1v8 = regulator_get(dev, "vdd_lcd_1v8_s");
103         if (IS_ERR(vdd_ds_1v8)) {
104                 pr_err("vdd_ds_1v8 regulator get failed\n");
105                 err = PTR_ERR(vdd_ds_1v8);
106                 vdd_ds_1v8 = NULL;
107                 goto fail;
108         }
109
110         vdd_lcd_bl_en = regulator_get(dev, "vdd_lcd_bl_en");
111         if (IS_ERR(vdd_lcd_bl_en)) {
112                 pr_err("vdd_lcd_bl_en regulator get failed\n");
113                 err = PTR_ERR(vdd_lcd_bl_en);
114                 vdd_lcd_bl_en = NULL;
115                 goto fail;
116         }
117
118         avdd_lcd = regulator_get(dev, "avdd_lcd");
119         if (IS_ERR(avdd_lcd)) {
120                 pr_err("avdd_lcd regulator get failed\n");
121                 err = PTR_ERR(avdd_lcd);
122                 avdd_lcd = NULL;
123                 goto fail;
124         }
125
126         avdd_3v3_dp = regulator_get(dev, "avdd_3v3_dp");
127         if (IS_ERR(avdd_3v3_dp)) {
128                 pr_err("avdd_3v3_dp regulator get failed\n");
129                 err = PTR_ERR(avdd_3v3_dp);
130                 avdd_3v3_dp = NULL;
131                 goto fail;
132         }
133
134         reg_requested = true;
135         return 0;
136 fail:
137         return err;
138 }
139
140 static int shield_edp_gpio_get(void)
141 {
142         int err = 0;
143
144         if (gpio_requested)
145                 return 0;
146
147         gpio_requested = true;
148
149         return err;
150 }
151
152 static int edp_s_wqxgap_15_6_enable(struct device *dev)
153 {
154         int err = 0;
155
156         err = shield_edp_regulator_get(dev);
157         if (err < 0) {
158                 pr_err("edp regulator get failed\n");
159                 goto fail;
160         }
161
162         err = shield_edp_gpio_get();
163         if (err < 0) {
164                 pr_err("edp gpio request failed\n");
165                 goto fail;
166         }
167
168         if (vdd_ds_1v8) {
169                 err = regulator_enable(vdd_ds_1v8);
170                 if (err < 0) {
171                         pr_err("vdd_ds_1v8 regulator enable failed\n");
172                         goto fail;
173                 }
174         }
175
176         if (avdd_3v3_dp) {
177                 err = regulator_enable(avdd_3v3_dp);
178                 if (err < 0) {
179                         pr_err("avdd_3v3_dp regulator enable failed\n");
180                         goto fail;
181                 }
182         }
183
184         if (avdd_lcd) {
185                 err = regulator_enable(avdd_lcd);
186                 if (err < 0) {
187                         pr_err("avdd_lcd regulator enable failed\n");
188                         goto fail;
189                 }
190         }
191
192         msleep(10);
193
194         if (vdd_lcd_bl_en) {
195                 err = regulator_enable(vdd_lcd_bl_en);
196                 if (err < 0) {
197                         pr_err("vdd_lcd_bl_en regulator enable failed\n");
198                         goto fail;
199                 }
200         }
201         msleep(200);
202
203         return 0;
204 fail:
205         return err;
206 }
207
208 static int edp_s_wqxgap_15_6_disable(void)
209 {
210         if (vdd_lcd_bl_en)
211                 regulator_disable(vdd_lcd_bl_en);
212
213         if (avdd_lcd)
214                 regulator_disable(avdd_lcd);
215
216         if (avdd_3v3_dp)
217                 regulator_disable(avdd_3v3_dp);
218
219         if (vdd_ds_1v8)
220                 regulator_disable(vdd_ds_1v8);
221
222         msleep(50);
223
224         return 0;
225 }
226
227 static int edp_s_wqxgap_15_6_postsuspend(void)
228 {
229         return 0;
230 }
231
232 static struct tegra_dc_out_pin edp_out_pins[] = {
233         {
234                 .name   = TEGRA_DC_OUT_PIN_H_SYNC,
235                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
236         },
237         {
238                 .name   = TEGRA_DC_OUT_PIN_V_SYNC,
239                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
240         },
241         {
242                 .name   = TEGRA_DC_OUT_PIN_PIXEL_CLOCK,
243                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
244         },
245         {
246                 .name   = TEGRA_DC_OUT_PIN_DATA_ENABLE,
247                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
248         },
249 };
250
251 static struct tegra_dc_mode edp_s_wqxgap_15_6_modes[] = {
252         {
253                 .pclk = 373680000,
254                 .h_ref_to_sync = 1,
255                 .v_ref_to_sync = 1,
256                 .h_sync_width = 32,
257                 .v_sync_width = 5,
258                 .h_back_porch = 80,
259                 .v_back_porch = 44,
260                 .h_active = 3200,
261                 .v_active = 1800,
262                 .h_front_porch = 48,
263                 .v_front_porch = 3,
264         },
265 };
266
267 static int edp_s_wqxgap_15_6_bl_notify(struct device *unused, int brightness)
268 {
269         int cur_sd_brightness = atomic_read(&sd_brightness);
270
271         /* SD brightness is a percentage */
272         brightness = (brightness * cur_sd_brightness) / 255;
273
274         /* Apply any backlight response curve */
275         if (brightness > 255)
276                 pr_info("Error: Brightness > 255!\n");
277
278         return brightness;
279 }
280
281 static int edp_s_wqxgap_15_6_check_fb(struct device *dev, struct fb_info *info)
282 {
283         return info->device == &disp_device->dev;
284 }
285
286 static struct platform_pwm_backlight_data edp_s_wqxgap_15_6_bl_data = {
287         .pwm_id         = 1,
288         .max_brightness = 255,
289         .dft_brightness = 224,
290         .pwm_period_ns  = 5000000,
291         .pwm_gpio       = EDP_PANEL_BL_PWM,
292         .notify         = edp_s_wqxgap_15_6_bl_notify,
293         /* Only toggle backlight on fb blank notifications for disp1 */
294         .check_fb       = edp_s_wqxgap_15_6_check_fb,
295 };
296
297 static struct platform_device __maybe_unused
298                 edp_s_wqxgap_15_6_bl_device = {
299         .name   = "pwm-backlight",
300         .id     = -1,
301         .dev    = {
302                 .platform_data = &edp_s_wqxgap_15_6_bl_data,
303         },
304 };
305
306 static struct platform_device __maybe_unused
307                         *edp_s_wqxgap_15_6_bl_devices[] __initdata = {
308         &tegra_pwfm_device,
309         &edp_s_wqxgap_15_6_bl_device,
310 };
311
312 static int  __init edp_s_wqxgap_15_6_register_bl_dev(void)
313 {
314         int err = 0;
315         err = platform_add_devices(edp_s_wqxgap_15_6_bl_devices,
316                                 ARRAY_SIZE(edp_s_wqxgap_15_6_bl_devices));
317         if (err) {
318                 pr_err("disp1 bl device registration failed");
319                 return err;
320         }
321         return err;
322 }
323
324 static void edp_s_wqxgap_15_6_set_disp_device(
325         struct platform_device *shield_display_device)
326 {
327         disp_device = shield_display_device;
328 }
329
330 static void edp_s_wqxgap_15_6_dc_out_init(struct tegra_dc_out *dc)
331 {
332         dc->align = TEGRA_DC_ALIGN_MSB;
333         dc->order = TEGRA_DC_ORDER_RED_BLUE;
334         dc->flags = DC_CTRL_MODE;
335         dc->modes = edp_s_wqxgap_15_6_modes;
336         dc->n_modes = ARRAY_SIZE(edp_s_wqxgap_15_6_modes);
337         dc->out_pins = edp_out_pins;
338         dc->n_out_pins = ARRAY_SIZE(edp_out_pins);
339         dc->depth = 24;
340         dc->parent_clk = "pll_d_out0";
341         dc->enable = edp_s_wqxgap_15_6_enable;
342         dc->disable = edp_s_wqxgap_15_6_disable;
343         dc->postsuspend = edp_s_wqxgap_15_6_postsuspend;
344         dc->width = 346;
345         dc->height = 194;
346         dc->hotplug_gpio = TEGRA_GPIO_PFF0;
347 }
348
349 static void edp_s_wqxgap_15_6_fb_data_init(struct tegra_fb_data *fb)
350 {
351         fb->xres = edp_s_wqxgap_15_6_modes[0].h_active;
352         fb->yres = edp_s_wqxgap_15_6_modes[0].v_active;
353 }
354
355 static void
356 edp_s_wqxgap_15_6_sd_settings_init(struct tegra_dc_sd_settings *settings)
357 {
358         *settings = edp_s_wqxgap_15_6_sd_settings;
359         settings->bl_device_name = "pwm-backlight";
360 }
361
362 struct tegra_panel __initdata edp_s_wqxgap_15_6 = {
363         .init_sd_settings = edp_s_wqxgap_15_6_sd_settings_init,
364         .init_dc_out = edp_s_wqxgap_15_6_dc_out_init,
365         .init_fb_data = edp_s_wqxgap_15_6_fb_data_init,
366         .register_bl_dev = edp_s_wqxgap_15_6_register_bl_dev,
367         .set_disp_device = edp_s_wqxgap_15_6_set_disp_device,
368 };
369 EXPORT_SYMBOL(edp_s_wqxgap_15_6);
370