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