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