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