ARM: tegra: fix regulator_get() return value check
[linux-3.10.git] / arch / arm / mach-tegra / panel-a-edp-1080p-14-0.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 "board.h"
29 #include "board-panel.h"
30 #include "devices.h"
31 #include "gpio-names.h"
32 #include "tegra12_host1x_devices.h"
33
34 #define DC_CTRL_MODE    TEGRA_DC_OUT_CONTINUOUS_MODE
35
36 #define EDP_PANEL_BL_PWM        TEGRA_GPIO_PH1
37
38 static bool reg_requested;
39 static bool gpio_requested;
40 static struct platform_device *disp_device;
41
42 static struct regulator *vdd_lcd_bl;
43 static struct regulator *vdd_lcd_bl_en;
44 static struct regulator *avdd_lcd;
45 static struct regulator *vdd_ds_1v8;
46
47 static tegra_dc_bl_output edp_a_1080p_14_0_bl_output_measured = {
48         0, 0, 1, 2, 3, 4, 5, 6,
49         7, 8, 9, 9, 10, 11, 12, 13,
50         13, 14, 15, 16, 17, 17, 18, 19,
51         20, 21, 22, 22, 23, 24, 25, 26,
52         27, 27, 28, 29, 30, 31, 32, 32,
53         33, 34, 35, 36, 37, 37, 38, 39,
54         40, 41, 42, 42, 43, 44, 45, 46,
55         47, 48, 48, 49, 50, 51, 52, 53,
56         54, 55, 56, 57, 57, 58, 59, 60,
57         61, 62, 63, 64, 65, 66, 67, 68,
58         69, 70, 71, 71, 72, 73, 74, 75,
59         76, 77, 77, 78, 79, 80, 81, 82,
60         83, 84, 85, 87, 88, 89, 90, 91,
61         92, 93, 94, 95, 96, 97, 98, 99,
62         100, 101, 102, 103, 104, 105, 106, 107,
63         108, 109, 110, 111, 112, 113, 115, 116,
64         117, 118, 119, 120, 121, 122, 123, 124,
65         125, 126, 127, 128, 129, 130, 131, 132,
66         133, 134, 135, 136, 137, 138, 139, 141,
67         142, 143, 144, 146, 147, 148, 149, 151,
68         152, 153, 154, 155, 156, 157, 158, 158,
69         159, 160, 161, 162, 163, 165, 166, 167,
70         168, 169, 170, 171, 172, 173, 174, 176,
71         177, 178, 179, 180, 182, 183, 184, 185,
72         186, 187, 188, 189, 190, 191, 192, 194,
73         195, 196, 197, 198, 199, 200, 201, 202,
74         203, 204, 205, 206, 207, 208, 209, 210,
75         211, 212, 213, 214, 215, 216, 217, 219,
76         220, 221, 222, 224, 225, 226, 227, 229,
77         230, 231, 232, 233, 234, 235, 236, 238,
78         239, 240, 241, 242, 243, 244, 245, 246,
79         247, 248, 249, 250, 251, 252, 253, 255
80 };
81
82 static unsigned int dsi_a_laguna_edp_states[] = {
83         909, 809, 709, 609, 509, 410, 310, 210, 110, 0
84 };
85 static unsigned int dsi_a_laguna_edp_brightness[] = {
86         255, 227, 199, 171, 143, 115, 87, 59, 31, 0
87 };
88
89 static int laguna_edp_regulator_get(struct device *dev)
90 {
91         int err = 0;
92
93         if (reg_requested)
94                 return 0;
95
96         vdd_ds_1v8 = regulator_get(dev, "vdd_ds_1v8");
97         if (IS_ERR(vdd_ds_1v8)) {
98                 pr_err("vdd_ds_1v8 regulator get failed\n");
99                 err = PTR_ERR(vdd_ds_1v8);
100                 vdd_ds_1v8 = NULL;
101                 goto fail;
102         }
103
104         vdd_lcd_bl = regulator_get(dev, "vdd_lcd_bl");
105         if (IS_ERR(vdd_lcd_bl)) {
106                 pr_err("vdd_lcd_bl regulator get failed\n");
107                 err = PTR_ERR(vdd_lcd_bl);
108                 vdd_lcd_bl = NULL;
109                 goto fail;
110         }
111
112         vdd_lcd_bl_en = regulator_get(dev, "vdd_lcd_bl_en");
113         if (IS_ERR(vdd_lcd_bl_en)) {
114                 pr_err("vdd_lcd_bl_en regulator get failed\n");
115                 err = PTR_ERR(vdd_lcd_bl_en);
116                 vdd_lcd_bl_en = NULL;
117                 goto fail;
118         }
119
120         avdd_lcd = regulator_get(dev, "avdd_lcd");
121         if (IS_ERR(avdd_lcd)) {
122                 pr_err("avdd_lcd regulator get failed\n");
123                 err = PTR_ERR(avdd_lcd);
124                 avdd_lcd = NULL;
125                 goto fail;
126         }
127
128         reg_requested = true;
129         return 0;
130 fail:
131         return err;
132 }
133
134 static int laguna_edp_gpio_get(void)
135 {
136         int err = 0;
137
138         if (gpio_requested)
139                 return 0;
140
141         err = gpio_request(EDP_PANEL_BL_PWM, "panel pwm");
142         if (err < 0) {
143                 pr_err("panel pwm gpio request failed\n");
144                 goto fail;
145         }
146         gpio_free(EDP_PANEL_BL_PWM);
147
148         gpio_requested = true;
149         return 0;
150 fail:
151         return err;
152 }
153
154 static int edp_a_1080p_14_0_enable(struct device *dev)
155 {
156         int err = 0;
157
158         err = laguna_edp_regulator_get(dev);
159         if (err < 0) {
160                 pr_err("edp regulator get failed\n");
161                 goto fail;
162         }
163
164         err = laguna_edp_gpio_get();
165         if (err < 0) {
166                 pr_err("edp gpio request failed\n");
167                 goto fail;
168         }
169
170         if (vdd_lcd_bl) {
171                 err = regulator_enable(vdd_lcd_bl);
172                 if (err < 0) {
173                         pr_err("vdd_lcd_bl regulator enable failed\n");
174                         goto fail;
175                 }
176         }
177
178         msleep(20);
179
180         if (vdd_ds_1v8) {
181                 err = regulator_enable(vdd_ds_1v8);
182                 if (err < 0) {
183                         pr_err("vdd_ds_1v8 regulator enable failed\n");
184                         goto fail;
185                 }
186         }
187
188         if (avdd_lcd) {
189                 err = regulator_enable(avdd_lcd);
190                 if (err < 0) {
191                         pr_err("avdd_lcd regulator enable failed\n");
192                         goto fail;
193                 }
194         }
195
196         msleep(10);
197
198         if (vdd_lcd_bl_en) {
199                 err = regulator_enable(vdd_lcd_bl_en);
200                 if (err < 0) {
201                         pr_err("vdd_lcd_bl_en regulator enable failed\n");
202                         goto fail;
203                 }
204         }
205         msleep(180);
206
207         return 0;
208 fail:
209         return err;
210 }
211
212 static int edp_a_1080p_14_0_disable(void)
213 {
214         if (vdd_lcd_bl_en)
215                 regulator_disable(vdd_lcd_bl_en);
216
217         msleep(10);
218
219         if (avdd_lcd)
220                 regulator_disable(avdd_lcd);
221
222         if (vdd_ds_1v8)
223                 regulator_disable(vdd_ds_1v8);
224
225         msleep(10);
226
227         if (vdd_lcd_bl)
228                 regulator_disable(vdd_lcd_bl);
229
230         msleep(500);
231
232         return 0;
233 }
234
235 static int edp_a_1080p_14_0_postsuspend(void)
236 {
237         return 0;
238 }
239
240 static struct tegra_dc_out_pin edp_out_pins[] = {
241         {
242                 .name   = TEGRA_DC_OUT_PIN_H_SYNC,
243                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
244         },
245         {
246                 .name   = TEGRA_DC_OUT_PIN_V_SYNC,
247                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
248         },
249         {
250                 .name   = TEGRA_DC_OUT_PIN_PIXEL_CLOCK,
251                 .pol    = TEGRA_DC_OUT_PIN_POL_LOW,
252         },
253         {
254                 .name   = TEGRA_DC_OUT_PIN_DATA_ENABLE,
255                 .pol    = TEGRA_DC_OUT_PIN_POL_HIGH,
256         },
257 };
258
259 static struct tegra_dc_mode edp_a_1080p_14_0_modes[] = {
260         {
261                 .pclk = 137986200,
262                 .h_ref_to_sync = 1,
263                 .v_ref_to_sync = 1,
264                 .h_sync_width = 16,
265                 .v_sync_width = 14,
266                 .h_back_porch = 152,
267                 .v_back_porch = 19,
268                 .h_active = 1920,
269                 .v_active = 1080,
270                 .h_front_porch = 16,
271                 .v_front_porch = 3,
272         },
273 };
274
275 static int edp_a_1080p_14_0_bl_notify(struct device *unused, int brightness)
276 {
277         int cur_sd_brightness = atomic_read(&sd_brightness);
278
279         /* SD brightness is a percentage */
280         brightness = (brightness * cur_sd_brightness) / 255;
281
282         /* Apply any backlight response curve */
283         if (brightness > 255)
284                 pr_info("Error: Brightness > 255!\n");
285         else
286                 brightness = edp_a_1080p_14_0_bl_output_measured[brightness];
287
288         return brightness;
289 }
290
291 static int edp_a_1080p_14_0_check_fb(struct device *dev, struct fb_info *info)
292 {
293         return info->device == &disp_device->dev;
294 }
295
296 static struct platform_pwm_backlight_data edp_a_1080p_14_0_bl_data = {
297         .pwm_id         = 1,
298         .max_brightness = 255,
299         .dft_brightness = 224,
300         .pwm_period_ns  = 1000000,
301         .pwm_gpio       = TEGRA_GPIO_INVALID,
302         .notify         = edp_a_1080p_14_0_bl_notify,
303         /* Only toggle backlight on fb blank notifications for disp1 */
304         .check_fb       = edp_a_1080p_14_0_check_fb,
305         .edp_states = dsi_a_laguna_edp_states,
306         .edp_brightness = dsi_a_laguna_edp_brightness,
307 };
308
309 static struct platform_device __maybe_unused
310                 edp_a_1080p_14_0_bl_device = {
311         .name   = "pwm-backlight",
312         .id     = -1,
313         .dev    = {
314                 .platform_data = &edp_a_1080p_14_0_bl_data,
315         },
316 };
317
318 static struct platform_device __maybe_unused
319                         *edp_a_1080p_14_0_bl_devices[] __initdata = {
320         &tegra_pwfm_device,
321         &edp_a_1080p_14_0_bl_device,
322 };
323
324 static int  __init edp_a_1080p_14_0_register_bl_dev(void)
325 {
326         int err = 0;
327         err = platform_add_devices(edp_a_1080p_14_0_bl_devices,
328                                 ARRAY_SIZE(edp_a_1080p_14_0_bl_devices));
329         if (err) {
330                 pr_err("disp1 bl device registration failed");
331                 return err;
332         }
333         return err;
334 }
335
336 static void edp_a_1080p_14_0_set_disp_device(
337         struct platform_device *laguna_display_device)
338 {
339         disp_device = laguna_display_device;
340 }
341
342 static void edp_a_1080p_14_0_dc_out_init(struct tegra_dc_out *dc)
343 {
344         dc->align = TEGRA_DC_ALIGN_MSB,
345         dc->order = TEGRA_DC_ORDER_RED_BLUE,
346         dc->flags = DC_CTRL_MODE;
347         dc->modes = edp_a_1080p_14_0_modes;
348         dc->n_modes = ARRAY_SIZE(edp_a_1080p_14_0_modes);
349         dc->out_pins = edp_out_pins,
350         dc->n_out_pins = ARRAY_SIZE(edp_out_pins),
351         dc->depth = 18,
352         dc->parent_clk = "pll_d_out0";
353         dc->enable = edp_a_1080p_14_0_enable;
354         dc->disable = edp_a_1080p_14_0_disable;
355         dc->postsuspend = edp_a_1080p_14_0_postsuspend,
356         dc->width = 320;
357         dc->height = 205;
358         dc->hotplug_gpio = TEGRA_GPIO_PFF0;
359 }
360
361 static void edp_a_1080p_14_0_fb_data_init(struct tegra_fb_data *fb)
362 {
363         fb->xres = edp_a_1080p_14_0_modes[0].h_active;
364         fb->yres = edp_a_1080p_14_0_modes[0].v_active;
365 }
366
367 static void
368 edp_a_1080p_14_0_sd_settings_init(struct tegra_dc_sd_settings *settings)
369 {
370         settings->bl_device_name = "pwm-backlight";
371 }
372
373 struct tegra_panel __initdata edp_a_1080p_14_0 = {
374         .init_sd_settings = edp_a_1080p_14_0_sd_settings_init,
375         .init_dc_out = edp_a_1080p_14_0_dc_out_init,
376         .init_fb_data = edp_a_1080p_14_0_fb_data_init,
377         .register_bl_dev = edp_a_1080p_14_0_register_bl_dev,
378         .set_disp_device = edp_a_1080p_14_0_set_disp_device,
379 };
380 EXPORT_SYMBOL(edp_a_1080p_14_0);
381