ARM: DT: Add DT entry for PWMs and Backlight
[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         err = gpio_request(LCD_TE, "lcd_te");
203         if (err < 0) {
204                 pr_err("panel lcd te request failed\n");
205                 goto fail;
206         }
207
208         err = gpio_request(DSI_PANEL_BL_PWM_GPIO, "panel pwm");
209         if (err < 0) {
210                 pr_err("panel pwm gpio request failed\n");
211                 goto fail;
212         }
213
214         /* Free pwm GPIO */
215         gpio_free(DSI_PANEL_BL_PWM_GPIO);
216
217         err = gpio_request(lvds_en, "edp bridge 1v8 enable");
218         if (err < 0) {
219                 pr_err("edp bridge 1v8 enable gpio request failed\n");
220                 goto fail;
221         }
222
223         err = gpio_request(refclk_en, "edp bridge refclk enable");
224         if (err < 0) {
225                 pr_err("edp bridge refclk enable gpio request failed\n");
226                 goto fail;
227         }
228
229         gpio_requested = true;
230         return 0;
231 fail:
232         return err;
233 }
234
235 static int dsi_a_1080p_14_0_enable(struct device *dev)
236 {
237         int err = 0;
238         err = laguna_dsi_regulator_get(dev);
239         if (err < 0) {
240                 pr_err("dsi regulator get failed\n");
241                 goto fail;
242         }
243         err = laguna_dsi_gpio_get();
244         if (err < 0) {
245                 pr_err("dsi gpio request failed\n");
246                 goto fail;
247         }
248
249         if (dvdd_lcd_1v8) {
250                 err = regulator_enable(dvdd_lcd_1v8);
251                 if (err < 0) {
252                         pr_err("dvdd_lcd regulator enable failed\n");
253                         goto fail;
254                 }
255         }
256         if (avdd_lcd_3v3) {
257                 err = regulator_enable(avdd_lcd_3v3);
258                 if (err < 0) {
259                         pr_err("avdd_lcd regulator enable failed\n");
260                         goto fail;
261                 }
262         }
263
264         /* enable 1.8v */
265         if (vdd_ds_1v8) {
266                 err = regulator_enable(vdd_ds_1v8);
267                 if (err < 0) {
268                         pr_err("vdd_ds_1v8 regulator enable failed\n");
269                         goto fail;
270                 }
271         }
272
273         if (vdd_1v2_en) {
274                 err = regulator_enable(vdd_1v2_en);
275                 if (err < 0) {
276                         pr_err("vdd_1v2_en regulator enable failed\n");
277                         goto fail;
278                 }
279         }
280
281         if (vdd_lcd_bl_en) {
282                 err = regulator_enable(vdd_lcd_bl_en);
283                 if (err < 0) {
284                         pr_err("vdd_lcd_bl_en regulator enable failed\n");
285                         goto fail;
286                 }
287         }
288
289         if (vdd_lcd_bl) {
290                 err = regulator_enable(vdd_lcd_bl);
291                 if (err < 0) {
292                         pr_err("vdd_lcd_bl regulator enable failed\n");
293                         goto fail;
294                 }
295         }
296         gpio_direction_output(DSI_PANEL_RST_GPIO, 0);
297         usleep_range(10000, 12000);
298         gpio_direction_output(lvds_en, 1);
299         usleep_range(8000, 10000);
300         gpio_direction_output(refclk_en, 1);
301         usleep_range(5000, 8000);
302         gpio_direction_output(DSI_PANEL_RST_GPIO, 1);
303         return 0;
304 fail:
305         return err;
306
307 }
308
309 static int dsi_a_1080p_14_0_disable(void)
310 {
311         gpio_set_value(lvds_en, 0);
312         gpio_set_value(refclk_en, 0);
313
314         if (vdd_lcd_bl)
315                 regulator_disable(vdd_lcd_bl);
316
317         if (vdd_1v2_en)
318                 regulator_disable(vdd_1v2_en);
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         return 0;
332 }
333
334 static int dsi_a_1080p_14_0_postsuspend(void)
335 {
336         return 0;
337 }
338
339 static struct tegra_dc_mode dsi_a_1080p_14_0_modes[] = {
340         {
341                 .pclk = 137986200,
342                 .h_ref_to_sync = 11,
343                 .v_ref_to_sync = 1,
344                 .h_sync_width = 16,
345                 .v_sync_width = 14,
346                 .h_back_porch = 152,
347                 .v_back_porch = 19,
348                 .h_active = 1920,
349                 .v_active = 1080,
350                 .h_front_porch = 16,
351                 .v_front_porch = 3,
352         },
353 };
354
355 static int dsi_a_1080p_14_0_bl_notify(struct device *unused, int brightness)
356 {
357         atomic_t __maybe_unused sd_brightness = ATOMIC_INIT(255);
358         int cur_sd_brightness = atomic_read(&sd_brightness);
359
360         /* Apply any backlight response curve */
361         if (brightness > 255)
362                 pr_info("Error: Brightness > 255!\n");
363         else
364                 brightness = dsi_a_1080p_14_0_bl_output_measured[brightness];
365
366         /* SD brightness is a percentage */
367         brightness = (brightness * cur_sd_brightness) / 255;
368
369         return brightness;
370 }
371
372 static int dsi_a_1080p_14_0_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_14_0_bl_data = {
378         .pwm_id         = 1,
379         .max_brightness = 255,
380         .dft_brightness = 224,
381         .pwm_period_ns  = 1000000,
382         .pwm_gpio       = TEGRA_GPIO_INVALID,
383         .notify         = dsi_a_1080p_14_0_bl_notify,
384         /* Only toggle backlight on fb blank notifications for disp1 */
385         .check_fb       = dsi_a_1080p_14_0_check_fb,
386 };
387
388 static struct platform_device __maybe_unused
389                 dsi_a_1080p_14_0_bl_device = {
390         .name   = "pwm-backlight",
391         .id     = -1,
392         .dev    = {
393                 .platform_data = &dsi_a_1080p_14_0_bl_data,
394         },
395 };
396
397 static struct platform_device __maybe_unused
398                         *dsi_a_1080p_14_0_bl_devices[] __initdata = {
399         &tegra_pwfm_device,
400         &dsi_a_1080p_14_0_bl_device,
401 };
402
403 static int  __init __dsi_a_1080p_14_0_register_bl_dev(void)
404 {
405         int err = 0;
406         err = platform_add_devices(dsi_a_1080p_14_0_bl_devices,
407                                 ARRAY_SIZE(dsi_a_1080p_14_0_bl_devices));
408         if (err) {
409                 pr_err("disp1 bl device registration failed");
410                 return err;
411         }
412         return err;
413 }
414
415 static int  __init dsi_a_1080p_14_0_register_bl_dev(void)
416 {
417         int err = 0;
418         if (!of_have_populated_dt())
419                 err = __dsi_a_1080p_14_0_register_bl_dev();
420         return err;
421 }
422
423 static void dsi_a_1080p_14_0_set_disp_device(
424         struct platform_device *laguna_display_device)
425 {
426         disp_device = laguna_display_device;
427 }
428
429 static void dsi_a_1080p_14_0_dc_out_init(struct tegra_dc_out *dc)
430 {
431         dc->dsi = &dsi_a_1080p_14_0_pdata;
432         dc->parent_clk = "pll_d_out0";
433         dc->modes = dsi_a_1080p_14_0_modes;
434         dc->n_modes = ARRAY_SIZE(dsi_a_1080p_14_0_modes);
435         dc->enable = dsi_a_1080p_14_0_enable;
436         dc->disable = dsi_a_1080p_14_0_disable;
437         dc->postsuspend = dsi_a_1080p_14_0_postsuspend,
438         dc->width = 256;
439         dc->height = 144;
440         dc->flags = DC_CTRL_MODE;
441 }
442
443 static void dsi_a_1080p_14_0_fb_data_init(struct tegra_fb_data *fb)
444 {
445         fb->xres = dsi_a_1080p_14_0_modes[0].h_active;
446         fb->yres = dsi_a_1080p_14_0_modes[0].v_active;
447 }
448
449 static void
450 dsi_a_1080p_14_0_sd_settings_init(struct tegra_dc_sd_settings *settings)
451 {
452         settings->bl_device_name = "pwm-backlight";
453 }
454
455 static struct i2c_board_info laguna_sn65dsi86_dsi2edp_board_info __initdata = {
456                 I2C_BOARD_INFO("sn65dsi86_dsi2edp", 0x2d),
457 };
458
459 static int __init dsi_a_1080p_14_0_i2c_bridge_register(void)
460 {
461         int err = 0;
462         pr_info("dsi_a_1080p_14_0_i2c_bridge_register\n");
463         err = i2c_register_board_info(0,
464                         &laguna_sn65dsi86_dsi2edp_board_info, 1);
465         return err;
466 }
467 struct tegra_panel __initdata dsi_a_1080p_14_0 = {
468         .init_sd_settings = dsi_a_1080p_14_0_sd_settings_init,
469         .init_dc_out = dsi_a_1080p_14_0_dc_out_init,
470         .init_fb_data = dsi_a_1080p_14_0_fb_data_init,
471         .register_bl_dev = dsi_a_1080p_14_0_register_bl_dev,
472         .register_i2c_bridge = dsi_a_1080p_14_0_i2c_bridge_register,
473         .set_disp_device = dsi_a_1080p_14_0_set_disp_device,
474 };
475 EXPORT_SYMBOL(dsi_a_1080p_14_0);
476