ARM: tegra: powermon: Fix copyrights from GPLv3 to GPLv2
[linux-3.10.git] / arch / arm / mach-tegra / panel-a-1080p-11-6.c
1 /*
2  * arch/arm/mach-tegra/panel-a-1080p-11-6.c
3  *
4  * Copyright (c) 2012, 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/max8831_backlight.h>
26 #include <linux/leds.h>
27 #include <linux/ioport.h>
28 #include <linux/export.h>
29
30 #include "board.h"
31 #include "board-panel.h"
32 #include "devices.h"
33 #include "gpio-names.h"
34 #include "tegra11_host1x_devices.h"
35
36 #define TEGRA_DSI_GANGED_MODE   0
37
38 #define DSI_PANEL_RESET         1
39
40 #define DC_CTRL_MODE    TEGRA_DC_OUT_CONTINUOUS_MODE
41
42 #define en_vdd_bl       TEGRA_GPIO_PG0
43 #define lvds_en         TEGRA_GPIO_PG3
44
45
46 static bool reg_requested;
47 static bool gpio_requested;
48 static struct platform_device *disp_device;
49 static struct regulator *avdd_lcd_3v3;
50 static struct regulator *vdd_lcd_bl;
51 static struct regulator *vdd_lcd_bl_en;
52 static struct regulator *dvdd_lcd_1v8;
53 static struct regulator *vdd_ds_1v8;
54
55 #define en_vdd_bl       TEGRA_GPIO_PG0
56 #define lvds_en         TEGRA_GPIO_PG3
57
58 static tegra_dc_bl_output dsi_a_1080p_11_6_bl_output_measured = {
59         0, 0, 1, 2, 3, 4, 5, 6,
60         7, 8, 9, 9, 10, 11, 12, 13,
61         13, 14, 15, 16, 17, 17, 18, 19,
62         20, 21, 22, 22, 23, 24, 25, 26,
63         27, 27, 28, 29, 30, 31, 32, 32,
64         33, 34, 35, 36, 37, 37, 38, 39,
65         40, 41, 42, 42, 43, 44, 45, 46,
66         47, 48, 48, 49, 50, 51, 52, 53,
67         54, 55, 56, 57, 57, 58, 59, 60,
68         61, 62, 63, 64, 65, 66, 67, 68,
69         69, 70, 71, 71, 72, 73, 74, 75,
70         76, 77, 77, 78, 79, 80, 81, 82,
71         83, 84, 85, 87, 88, 89, 90, 91,
72         92, 93, 94, 95, 96, 97, 98, 99,
73         100, 101, 102, 103, 104, 105, 106, 107,
74         108, 109, 110, 111, 112, 113, 115, 116,
75         117, 118, 119, 120, 121, 122, 123, 124,
76         125, 126, 127, 128, 129, 130, 131, 132,
77         133, 134, 135, 136, 137, 138, 139, 141,
78         142, 143, 144, 146, 147, 148, 149, 151,
79         152, 153, 154, 155, 156, 157, 158, 158,
80         159, 160, 161, 162, 163, 165, 166, 167,
81         168, 169, 170, 171, 172, 173, 174, 176,
82         177, 178, 179, 180, 182, 183, 184, 185,
83         186, 187, 188, 189, 190, 191, 192, 194,
84         195, 196, 197, 198, 199, 200, 201, 202,
85         203, 204, 205, 206, 207, 208, 209, 210,
86         211, 212, 213, 214, 215, 216, 217, 219,
87         220, 221, 222, 224, 225, 226, 227, 229,
88         230, 231, 232, 233, 234, 235, 236, 238,
89         239, 240, 241, 242, 243, 244, 245, 246,
90         247, 248, 249, 250, 251, 252, 253, 255
91 };
92
93 static struct tegra_dsi_cmd dsi_a_1080p_11_6_init_cmd[] = {
94         /* no init command required */
95 };
96
97 static struct tegra_dsi_out dsi_a_1080p_11_6_pdata = {
98 #ifdef CONFIG_ARCH_TEGRA_3x_SOC
99         .n_data_lanes = 2,
100         .controller_vs = DSI_VS_0,
101 #else
102         .controller_vs = DSI_VS_1,
103 #endif
104         .dsi2edp_bridge_enable = true,
105         .n_data_lanes = 4,
106         .video_burst_mode = TEGRA_DSI_VIDEO_NONE_BURST_MODE_WITH_SYNC_END,
107
108         .pixel_format = TEGRA_DSI_PIXEL_FORMAT_24BIT_P,
109         .refresh_rate = 61,
110         .virtual_channel = TEGRA_DSI_VIRTUAL_CHANNEL_0,
111
112         .dsi_instance = DSI_INSTANCE_0,
113
114         .panel_reset = DSI_PANEL_RESET,
115         .power_saving_suspend = true,
116         .video_data_type = TEGRA_DSI_VIDEO_TYPE_VIDEO_MODE,
117         .video_clock_mode = TEGRA_DSI_VIDEO_CLOCK_TX_ONLY,
118         .dsi_init_cmd = dsi_a_1080p_11_6_init_cmd,
119         .n_init_cmd = ARRAY_SIZE(dsi_a_1080p_11_6_init_cmd),
120         .phy_timing = {
121                 .t_hsdexit_ns = 123,
122                 .t_hstrail_ns = 85,
123                 .t_datzero_ns = 170,
124                 .t_hsprepare_ns = 57,
125         },
126 };
127
128 static int dalmore_dsi_regulator_get(struct device *dev)
129 {
130         int err = 0;
131
132         if (reg_requested)
133                 return 0;
134
135         dvdd_lcd_1v8 = regulator_get(dev, "dvdd_lcd");
136                 if (IS_ERR_OR_NULL(dvdd_lcd_1v8)) {
137                         pr_err("dvdd_lcd regulator get failed\n");
138                         err = PTR_ERR(dvdd_lcd_1v8);
139                         dvdd_lcd_1v8 = NULL;
140                         goto fail;
141         }
142
143         vdd_ds_1v8 = regulator_get(dev, "vdd_ds_1v8");
144         if (IS_ERR_OR_NULL(vdd_ds_1v8)) {
145                 pr_err("vdd_ds_1v8 regulator get failed\n");
146                 err = PTR_ERR(vdd_ds_1v8);
147                 vdd_ds_1v8 = NULL;
148                 goto fail;
149         }
150
151         avdd_lcd_3v3 = regulator_get(dev, "avdd_lcd");
152         if (IS_ERR_OR_NULL(avdd_lcd_3v3)) {
153                 pr_err("avdd_lcd regulator get failed\n");
154                 err = PTR_ERR(avdd_lcd_3v3);
155                 avdd_lcd_3v3 = NULL;
156                 goto fail;
157         }
158
159         vdd_lcd_bl = regulator_get(dev, "vdd_lcd_bl");
160         if (IS_ERR_OR_NULL(vdd_lcd_bl)) {
161                 pr_err("vdd_lcd_bl regulator get failed\n");
162                 err = PTR_ERR(vdd_lcd_bl);
163                 vdd_lcd_bl = NULL;
164                 goto fail;
165         }
166
167         vdd_lcd_bl_en = regulator_get(dev, "vdd_lcd_bl_en");
168         if (IS_ERR_OR_NULL(vdd_lcd_bl_en)) {
169                 pr_err("vdd_lcd_bl_en regulator get failed\n");
170                 err = PTR_ERR(vdd_lcd_bl_en);
171                 vdd_lcd_bl_en = NULL;
172                 goto fail;
173         }
174
175         reg_requested = true;
176         return 0;
177 fail:
178         return err;
179 }
180
181 static int dalmore_dsi_gpio_get(void)
182 {
183         int err = 0;
184
185         if (gpio_requested)
186                 return 0;
187
188         err = gpio_request(dsi_a_1080p_11_6_pdata.dsi_panel_rst_gpio,
189                 "panel rst");
190         if (err < 0) {
191                 pr_err("panel reset gpio request failed\n");
192                 goto fail;
193         }
194
195         /* free pwm GPIO */
196         err = gpio_request(dsi_a_1080p_11_6_pdata.dsi_panel_bl_pwm_gpio,
197                 "panel pwm");
198         if (err < 0) {
199                 pr_err("panel pwm gpio request failed\n");
200                 goto fail;
201         }
202         gpio_free(dsi_a_1080p_11_6_pdata.dsi_panel_bl_pwm_gpio);
203
204         err = gpio_request(en_vdd_bl, "edp bridge 1v2 enable");
205         if (err < 0) {
206                 pr_err("edp bridge 1v2 enable gpio request failed\n");
207                 goto fail;
208         }
209
210         err = gpio_request(lvds_en, "edp bridge 1v8 enable");
211         if (err < 0) {
212                 pr_err("edp bridge 1v8 enable gpio request failed\n");
213                 goto fail;
214         }
215         gpio_requested = true;
216         return 0;
217 fail:
218         return err;
219 }
220
221 static int dalmore_dsi2edp_bridge_enable(struct device *dev)
222 {
223         int err = 0;
224
225         /* enable 1.2v */
226         if (dvdd_lcd_1v8) {
227                 err = regulator_enable(dvdd_lcd_1v8);
228                 if (err < 0) {
229                         pr_err("dvdd_lcd regulator enable failed\n");
230                         goto fail;
231                 }
232         }
233
234         gpio_direction_output(en_vdd_bl, 1);
235
236         /* enable 1.8v */
237         if (vdd_ds_1v8) {
238                 err = regulator_enable(vdd_ds_1v8);
239                 if (err < 0) {
240                         pr_err("vdd_ds_1v8 regulator enable failed\n");
241                         goto fail;
242                 }
243         }
244
245         gpio_direction_output(lvds_en, 1);
246
247         return 0;
248 fail:
249         return err;
250 }
251
252 static int dsi_a_1080p_11_6_enable(struct device *dev)
253 {
254         int err = 0;
255
256         err = dalmore_dsi_regulator_get(dev);
257         if (err < 0) {
258                 pr_err("dsi regulator get failed\n");
259                 goto fail;
260         }
261         err = dalmore_dsi_gpio_get();
262         if (err < 0) {
263                 pr_err("dsi gpio request failed\n");
264                 goto fail;
265         }
266
267         if (avdd_lcd_3v3) {
268                 err = regulator_enable(avdd_lcd_3v3);
269                 if (err < 0) {
270                         pr_err("avdd_lcd regulator enable failed\n");
271                         goto fail;
272                 }
273         }
274
275         err = dalmore_dsi2edp_bridge_enable(dev);
276         if (err < 0) {
277                 pr_err("bridge enable failed\n");
278                 goto fail;
279         }
280
281         if (vdd_lcd_bl) {
282                 err = regulator_enable(vdd_lcd_bl);
283                 if (err < 0) {
284                         pr_err("vdd_lcd_bl regulator enable failed\n");
285                         goto fail;
286                 }
287         }
288
289         if (vdd_lcd_bl_en) {
290                 err = regulator_enable(vdd_lcd_bl_en);
291                 if (err < 0) {
292                         pr_err("vdd_lcd_bl_en regulator enable failed\n");
293                         goto fail;
294                 }
295         }
296
297 #if DSI_PANEL_RESET
298         gpio_direction_output(dsi_a_1080p_11_6_pdata.dsi_panel_rst_gpio, 1);
299         usleep_range(1000, 5000);
300         gpio_set_value(dsi_a_1080p_11_6_pdata.dsi_panel_rst_gpio, 0);
301         msleep(150);
302         gpio_set_value(dsi_a_1080p_11_6_pdata.dsi_panel_rst_gpio, 1);
303         msleep(1500);
304 #endif
305         gpio_direction_output(dsi_a_1080p_11_6_pdata.dsi_panel_bl_pwm_gpio, 1);
306
307         return 0;
308 fail:
309         return err;
310 }
311
312 static int dsi_a_1080p_11_6_disable(void)
313 {
314         gpio_set_value(lvds_en, 0);
315         gpio_set_value(en_vdd_bl, 0);
316
317         if (vdd_lcd_bl)
318                 regulator_disable(vdd_lcd_bl);
319
320         if (vdd_lcd_bl_en)
321                 regulator_disable(vdd_lcd_bl_en);
322
323         if (avdd_lcd_3v3)
324                 regulator_disable(avdd_lcd_3v3);
325
326         if (dvdd_lcd_1v8)
327                 regulator_disable(dvdd_lcd_1v8);
328
329         if (vdd_ds_1v8)
330                 regulator_disable(vdd_ds_1v8);
331
332         return 0;
333 }
334
335 static int dsi_a_1080p_11_6_postsuspend(void)
336 {
337         return 0;
338 }
339
340 static struct tegra_dc_mode dsi_a_1080p_11_6_modes[] = {
341         {
342                 .pclk = 137986200,
343                 .h_ref_to_sync = 4,
344                 .v_ref_to_sync = 1,
345                 .h_sync_width = 72,
346                 .v_sync_width = 5,
347                 .h_back_porch = 28,
348                 .v_back_porch = 23,
349                 .h_active = 1920,
350                 .v_active = 1080,
351                 .h_front_porch = 60,
352                 .v_front_porch = 3,
353         },
354 };
355
356 static int dsi_a_1080p_11_6_bl_notify(struct device *unused, int brightness)
357 {
358         int cur_sd_brightness = atomic_read(&sd_brightness);
359
360         /* SD brightness is a percentage */
361         brightness = (brightness * cur_sd_brightness) / 255;
362
363         /* Apply any backlight response curve */
364         if (brightness > 255)
365                 pr_info("Error: Brightness > 255!\n");
366         else
367                 brightness = dsi_a_1080p_11_6_bl_output_measured[brightness];
368
369         return brightness;
370 }
371
372 static int dsi_a_1080p_11_6_check_fb(struct device *dev, struct fb_info *info)
373 {
374         return info->device == &disp_device->dev;
375 }
376
377 static struct platform_pwm_backlight_data dsi_a_1080p_11_6_bl_data = {
378         .pwm_id         = 1,
379         .max_brightness = 255,
380         .dft_brightness = 224,
381         .pwm_period_ns  = 1000000,
382         .notify         = dsi_a_1080p_11_6_bl_notify,
383         /* Only toggle backlight on fb blank notifications for disp1 */
384         .check_fb       = dsi_a_1080p_11_6_check_fb,
385 };
386
387 static struct platform_device __maybe_unused
388                 dsi_a_1080p_11_6_bl_device = {
389         .name   = "pwm-backlight",
390         .id     = -1,
391         .dev    = {
392                 .platform_data = &dsi_a_1080p_11_6_bl_data,
393         },
394 };
395
396 static struct platform_device __maybe_unused
397                         *dsi_a_1080p_11_6_bl_devices[] __initdata = {
398         &tegra_pwfm_device,
399         &dsi_a_1080p_11_6_bl_device,
400 };
401
402 static int  __init dsi_a_1080p_11_6_register_bl_dev(void)
403 {
404         int err = 0;
405         err = platform_add_devices(dsi_a_1080p_11_6_bl_devices,
406                                 ARRAY_SIZE(dsi_a_1080p_11_6_bl_devices));
407         if (err) {
408                 pr_err("disp1 bl device registration failed");
409                 return err;
410         }
411         return err;
412 }
413
414 static void dsi_a_1080p_11_6_set_disp_device(
415         struct platform_device *dalmore_display_device)
416 {
417         disp_device = dalmore_display_device;
418 }
419
420 static void dsi_a_1080p_11_6_dc_out_init(struct tegra_dc_out *dc)
421 {
422         dc->dsi = &dsi_a_1080p_11_6_pdata;
423         dc->parent_clk = "pll_d_out0";
424         dc->modes = dsi_a_1080p_11_6_modes;
425         dc->n_modes = ARRAY_SIZE(dsi_a_1080p_11_6_modes);
426         dc->enable = dsi_a_1080p_11_6_enable;
427         dc->disable = dsi_a_1080p_11_6_disable;
428         dc->postsuspend = dsi_a_1080p_11_6_postsuspend,
429         dc->width = 256;
430         dc->height = 144;
431         dc->flags = DC_CTRL_MODE;
432 }
433
434 static void dsi_a_1080p_11_6_fb_data_init(struct tegra_fb_data *fb)
435 {
436         fb->xres = dsi_a_1080p_11_6_modes[0].h_active;
437         fb->yres = dsi_a_1080p_11_6_modes[0].v_active;
438 }
439
440 static void
441 dsi_a_1080p_11_6_sd_settings_init(struct tegra_dc_sd_settings *settings)
442 {
443         settings->bl_device_name = "pwm-backlight";
444 }
445
446 static struct i2c_board_info dalmore_tc358767_dsi2edp_board_info __initdata = {
447                 I2C_BOARD_INFO("tc358767_dsi2edp", 0x0f),
448 };
449
450 static int __init dsi_a_1080p_11_6_i2c_bridge_register(void)
451 {
452         int err = 0;
453         err = i2c_register_board_info(0,
454                         &dalmore_tc358767_dsi2edp_board_info, 1);
455         return err;
456 }
457 struct tegra_panel __initdata dsi_a_1080p_11_6 = {
458         .init_sd_settings = dsi_a_1080p_11_6_sd_settings_init,
459         .init_dc_out = dsi_a_1080p_11_6_dc_out_init,
460         .init_fb_data = dsi_a_1080p_11_6_fb_data_init,
461         .register_bl_dev = dsi_a_1080p_11_6_register_bl_dev,
462         .register_i2c_bridge = dsi_a_1080p_11_6_i2c_bridge_register,
463         .set_disp_device = dsi_a_1080p_11_6_set_disp_device,
464 };
465 EXPORT_SYMBOL(dsi_a_1080p_11_6);
466