]>
Commit | Line | Data |
---|---|---|
9d200153 SM |
1 | /* Copyright (c) 2008-2009, Code Aurora Forum. All rights reserved. |
2 | * | |
3 | * This program is free software; you can redistribute it and/or modify | |
4 | * it under the terms of the GNU General Public License version 2 and | |
5 | * only version 2 as published by the Free Software Foundation. | |
6 | * | |
7 | * This program is distributed in the hope that it will be useful, | |
8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
10 | * GNU General Public License for more details. | |
11 | * | |
12 | * You should have received a copy of the GNU General Public License | |
13 | * along with this program; if not, write to the Free Software | |
14 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
15 | * 02110-1301, USA. | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/sched.h> | |
21 | #include <linux/time.h> | |
22 | #include <linux/init.h> | |
23 | #include <linux/interrupt.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include <linux/hrtimer.h> | |
26 | #include <linux/vmalloc.h> | |
27 | #include <linux/clk.h> | |
28 | ||
29 | #include <mach/hardware.h> | |
30 | #include <linux/io.h> | |
31 | ||
32 | #include <asm/system.h> | |
33 | #include <asm/mach-types.h> | |
34 | #include <linux/semaphore.h> | |
35 | #include <linux/uaccess.h> | |
36 | #include <mach/gpio.h> | |
37 | ||
38 | #include "mdp.h" | |
39 | #include "msm_fb.h" | |
40 | #include "mddihost.h" | |
41 | ||
42 | #ifdef CONFIG_FB_MSM_MDP40 | |
43 | #define MDP_SYNC_CFG_0 0x100 | |
44 | #define MDP_SYNC_STATUS_0 0x10c | |
45 | #define MDP_PRIM_VSYNC_OUT_CTRL 0x118 | |
46 | #define MDP_PRIM_VSYNC_INIT_VAL 0x128 | |
47 | #else | |
48 | #define MDP_SYNC_CFG_0 0x300 | |
49 | #define MDP_SYNC_STATUS_0 0x30c | |
50 | #define MDP_PRIM_VSYNC_OUT_CTRL 0x318 | |
51 | #define MDP_PRIM_VSYNC_INIT_VAL 0x328 | |
52 | #endif | |
53 | ||
54 | extern mddi_lcd_type mddi_lcd_idx; | |
55 | extern spinlock_t mdp_spin_lock; | |
56 | extern struct workqueue_struct *mdp_vsync_wq; | |
57 | extern int lcdc_mode; | |
58 | extern int vsync_mode; | |
59 | ||
60 | #ifdef MDP_HW_VSYNC | |
61 | int vsync_above_th = 4; | |
62 | int vsync_start_th = 1; | |
63 | int vsync_load_cnt; | |
64 | ||
65 | struct clk *mdp_vsync_clk; | |
66 | ||
67 | void mdp_hw_vsync_clk_enable(struct msm_fb_data_type *mfd) | |
68 | { | |
69 | if (mfd->use_mdp_vsync) | |
70 | clk_enable(mdp_vsync_clk); | |
71 | } | |
72 | ||
73 | void mdp_hw_vsync_clk_disable(struct msm_fb_data_type *mfd) | |
74 | { | |
75 | if (mfd->use_mdp_vsync) | |
76 | clk_disable(mdp_vsync_clk); | |
77 | } | |
78 | #endif | |
79 | ||
80 | static void mdp_set_vsync(unsigned long data) | |
81 | { | |
82 | struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)data; | |
83 | struct msm_fb_panel_data *pdata = NULL; | |
84 | ||
85 | pdata = (struct msm_fb_panel_data *)mfd->pdev->dev.platform_data; | |
86 | ||
87 | if ((pdata) && (pdata->set_vsync_notifier == NULL)) | |
88 | return; | |
89 | ||
90 | init_timer(&mfd->vsync_resync_timer); | |
91 | mfd->vsync_resync_timer.function = mdp_set_vsync; | |
92 | mfd->vsync_resync_timer.data = data; | |
93 | mfd->vsync_resync_timer.expires = | |
94 | jiffies + mfd->panel_info.lcd.vsync_notifier_period; | |
95 | add_timer(&mfd->vsync_resync_timer); | |
96 | ||
97 | if ((mfd->panel_info.lcd.vsync_enable) && (mfd->panel_power_on) | |
98 | && (!mfd->vsync_handler_pending)) { | |
99 | mfd->vsync_handler_pending = TRUE; | |
100 | if (!queue_work(mdp_vsync_wq, &mfd->vsync_resync_worker)) { | |
101 | MSM_FB_INFO | |
102 | ("mdp_set_vsync: can't queue_work! -> needs to increase vsync_resync_timer_duration\n"); | |
103 | } | |
104 | } else { | |
105 | MSM_FB_DEBUG | |
106 | ("mdp_set_vsync failed! EN:%d PWR:%d PENDING:%d\n", | |
107 | mfd->panel_info.lcd.vsync_enable, mfd->panel_power_on, | |
108 | mfd->vsync_handler_pending); | |
109 | } | |
110 | } | |
111 | ||
112 | static void mdp_vsync_handler(void *data) | |
113 | { | |
114 | struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)data; | |
115 | ||
116 | if (mfd->use_mdp_vsync) { | |
117 | #ifdef MDP_HW_VSYNC | |
118 | if (mfd->panel_power_on) | |
119 | MDP_OUTP(MDP_BASE + MDP_SYNC_STATUS_0, vsync_load_cnt); | |
120 | ||
121 | mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, TRUE); | |
122 | #endif | |
123 | } else { | |
124 | mfd->last_vsync_timetick = ktime_get_real(); | |
125 | } | |
126 | ||
127 | mfd->vsync_handler_pending = FALSE; | |
128 | } | |
129 | ||
130 | irqreturn_t mdp_hw_vsync_handler_proxy(int irq, void *data) | |
131 | { | |
132 | /* | |
133 | * ToDo: tried enabling/disabling GPIO MDP HW VSYNC interrupt | |
134 | * but getting inaccurate timing in mdp_vsync_handler() | |
135 | * disable_irq(MDP_HW_VSYNC_IRQ); | |
136 | */ | |
137 | mdp_vsync_handler(data); | |
138 | ||
139 | return IRQ_HANDLED; | |
140 | } | |
141 | ||
142 | #ifdef MDP_HW_VSYNC | |
143 | static void mdp_set_sync_cfg_0(struct msm_fb_data_type *mfd, int vsync_cnt) | |
144 | { | |
145 | unsigned long cfg; | |
146 | ||
147 | cfg = mfd->total_lcd_lines - 1; | |
148 | cfg <<= MDP_SYNCFG_HGT_LOC; | |
149 | if (mfd->panel_info.lcd.hw_vsync_mode) | |
150 | cfg |= MDP_SYNCFG_VSYNC_EXT_EN; | |
151 | cfg |= (MDP_SYNCFG_VSYNC_INT_EN | vsync_cnt); | |
152 | ||
153 | MDP_OUTP(MDP_BASE + MDP_SYNC_CFG_0, cfg); | |
154 | } | |
155 | #endif | |
156 | ||
157 | void mdp_config_vsync(struct msm_fb_data_type *mfd) | |
158 | { | |
159 | ||
160 | /* vsync on primary lcd only for now */ | |
161 | if ((mfd->dest != DISPLAY_LCD) || (mfd->panel_info.pdest != DISPLAY_1) | |
162 | || (!vsync_mode)) { | |
163 | goto err_handle; | |
164 | } | |
165 | ||
166 | if (mfd->panel_info.lcd.vsync_enable) { | |
167 | mfd->total_porch_lines = mfd->panel_info.lcd.v_back_porch + | |
168 | mfd->panel_info.lcd.v_front_porch + | |
169 | mfd->panel_info.lcd.v_pulse_width; | |
170 | mfd->total_lcd_lines = | |
171 | mfd->panel_info.yres + mfd->total_porch_lines; | |
172 | mfd->lcd_ref_usec_time = | |
173 | 100000000 / mfd->panel_info.lcd.refx100; | |
174 | mfd->vsync_handler_pending = FALSE; | |
175 | mfd->last_vsync_timetick.tv.sec = 0; | |
176 | mfd->last_vsync_timetick.tv.nsec = 0; | |
177 | ||
178 | #ifdef MDP_HW_VSYNC | |
179 | if (mdp_vsync_clk == NULL) | |
180 | mdp_vsync_clk = clk_get(NULL, "mdp_vsync_clk"); | |
181 | ||
182 | if (IS_ERR(mdp_vsync_clk)) { | |
183 | printk(KERN_ERR "error: can't get mdp_vsync_clk!\n"); | |
184 | mfd->use_mdp_vsync = 0; | |
185 | } else | |
186 | mfd->use_mdp_vsync = 1; | |
187 | ||
188 | if (mfd->use_mdp_vsync) { | |
189 | uint32 vsync_cnt_cfg, vsync_cnt_cfg_dem; | |
190 | uint32 mdp_vsync_clk_speed_hz; | |
191 | ||
192 | mdp_vsync_clk_speed_hz = clk_get_rate(mdp_vsync_clk); | |
193 | ||
194 | if (mdp_vsync_clk_speed_hz == 0) { | |
195 | mfd->use_mdp_vsync = 0; | |
196 | } else { | |
197 | /* | |
198 | * Do this calculation in 2 steps for | |
199 | * rounding uint32 properly. | |
200 | */ | |
201 | vsync_cnt_cfg_dem = | |
202 | (mfd->panel_info.lcd.refx100 * | |
203 | mfd->total_lcd_lines) / 100; | |
204 | vsync_cnt_cfg = | |
205 | (mdp_vsync_clk_speed_hz) / | |
206 | vsync_cnt_cfg_dem; | |
207 | ||
208 | /* MDP cmd block enable */ | |
209 | mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, | |
210 | FALSE); | |
211 | mdp_hw_vsync_clk_enable(mfd); | |
212 | ||
213 | mdp_set_sync_cfg_0(mfd, vsync_cnt_cfg); | |
214 | ||
215 | /* | |
216 | * load the last line + 1 to be in the | |
217 | * safety zone | |
218 | */ | |
219 | vsync_load_cnt = mfd->panel_info.yres; | |
220 | ||
221 | /* line counter init value at the next pulse */ | |
222 | MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_INIT_VAL, | |
223 | vsync_load_cnt); | |
224 | ||
225 | /* | |
226 | * external vsync source pulse width and | |
227 | * polarity flip | |
228 | */ | |
229 | MDP_OUTP(MDP_BASE + MDP_PRIM_VSYNC_OUT_CTRL, | |
230 | BIT(30) | BIT(0)); | |
231 | ||
232 | ||
233 | /* threshold */ | |
234 | MDP_OUTP(MDP_BASE + 0x200, | |
235 | (vsync_above_th << 16) | | |
236 | (vsync_start_th)); | |
237 | ||
238 | mdp_hw_vsync_clk_disable(mfd); | |
239 | /* MDP cmd block disable */ | |
240 | mdp_pipe_ctrl(MDP_CMD_BLOCK, | |
241 | MDP_BLOCK_POWER_OFF, FALSE); | |
242 | } | |
243 | } | |
244 | #else | |
245 | mfd->use_mdp_vsync = 0; | |
246 | hrtimer_init(&mfd->dma_hrtimer, CLOCK_MONOTONIC, | |
247 | HRTIMER_MODE_REL); | |
248 | mfd->dma_hrtimer.function = mdp_dma2_vsync_hrtimer_handler; | |
249 | mfd->vsync_width_boundary = vmalloc(mfd->panel_info.xres * 4); | |
250 | #endif | |
251 | ||
252 | mfd->channel_irq = 0; | |
253 | if (mfd->panel_info.lcd.hw_vsync_mode) { | |
254 | u32 vsync_gpio = mfd->vsync_gpio; | |
255 | u32 ret; | |
256 | ||
257 | if (vsync_gpio == -1) { | |
258 | MSM_FB_INFO("vsync_gpio not defined!\n"); | |
259 | goto err_handle; | |
260 | } | |
261 | ||
262 | ret = gpio_tlmm_config(GPIO_CFG | |
263 | (vsync_gpio, | |
264 | (mfd->use_mdp_vsync) ? 1 : 0, | |
265 | GPIO_INPUT, | |
266 | GPIO_PULL_DOWN, | |
267 | GPIO_2MA), | |
268 | GPIO_ENABLE); | |
269 | if (ret) | |
270 | goto err_handle; | |
271 | ||
272 | if (!mfd->use_mdp_vsync) { | |
273 | mfd->channel_irq = MSM_GPIO_TO_INT(vsync_gpio); | |
274 | if (request_irq | |
275 | (mfd->channel_irq, | |
276 | &mdp_hw_vsync_handler_proxy, | |
277 | IRQF_TRIGGER_FALLING, "VSYNC_GPIO", | |
278 | (void *)mfd)) { | |
279 | MSM_FB_INFO | |
280 | ("irq=%d failed! vsync_gpio=%d\n", | |
281 | mfd->channel_irq, | |
282 | vsync_gpio); | |
283 | goto err_handle; | |
284 | } | |
285 | } | |
286 | } | |
287 | ||
288 | mdp_set_vsync((unsigned long)mfd); | |
289 | } | |
290 | ||
291 | return; | |
292 | ||
293 | err_handle: | |
294 | if (mfd->vsync_width_boundary) | |
295 | vfree(mfd->vsync_width_boundary); | |
296 | mfd->panel_info.lcd.vsync_enable = FALSE; | |
297 | printk(KERN_ERR "%s: failed!\n", __func__); | |
298 | } | |
299 | ||
300 | void mdp_vsync_resync_workqueue_handler(struct work_struct *work) | |
301 | { | |
302 | struct msm_fb_data_type *mfd = NULL; | |
303 | int vsync_fnc_enabled = FALSE; | |
304 | struct msm_fb_panel_data *pdata = NULL; | |
305 | ||
306 | mfd = container_of(work, struct msm_fb_data_type, vsync_resync_worker); | |
307 | ||
308 | if (mfd) { | |
309 | if (mfd->panel_power_on) { | |
310 | pdata = | |
311 | (struct msm_fb_panel_data *)mfd->pdev->dev. | |
312 | platform_data; | |
313 | ||
314 | /* | |
315 | * we need to turn on MDP power if it uses MDP vsync | |
316 | * HW block in SW mode | |
317 | */ | |
318 | if ((!mfd->panel_info.lcd.hw_vsync_mode) && | |
319 | (mfd->use_mdp_vsync) && | |
320 | (pdata) && (pdata->set_vsync_notifier != NULL)) { | |
321 | /* | |
322 | * enable pwr here since we can't enable it in | |
323 | * vsync callback in isr mode | |
324 | */ | |
325 | mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, | |
326 | FALSE); | |
327 | } | |
328 | ||
329 | if (pdata->set_vsync_notifier != NULL) { | |
330 | vsync_fnc_enabled = TRUE; | |
331 | pdata->set_vsync_notifier(mdp_vsync_handler, | |
332 | (void *)mfd); | |
333 | } | |
334 | } | |
335 | } | |
336 | ||
337 | if ((mfd) && (!vsync_fnc_enabled)) | |
338 | mfd->vsync_handler_pending = FALSE; | |
339 | } | |
340 | ||
341 | boolean mdp_hw_vsync_set_handler(msm_fb_vsync_handler_type handler, void *data) | |
342 | { | |
343 | /* | |
344 | * ToDo: tried enabling/disabling GPIO MDP HW VSYNC interrupt | |
345 | * but getting inaccurate timing in mdp_vsync_handler() | |
346 | * enable_irq(MDP_HW_VSYNC_IRQ); | |
347 | */ | |
348 | ||
349 | return TRUE; | |
350 | } | |
351 | ||
352 | uint32 mdp_get_lcd_line_counter(struct msm_fb_data_type *mfd) | |
353 | { | |
354 | uint32 elapsed_usec_time; | |
355 | uint32 lcd_line; | |
356 | ktime_t last_vsync_timetick_local; | |
357 | ktime_t curr_time; | |
358 | unsigned long flag; | |
359 | ||
360 | if ((!mfd->panel_info.lcd.vsync_enable) || (!vsync_mode)) | |
361 | return 0; | |
362 | ||
363 | spin_lock_irqsave(&mdp_spin_lock, flag); | |
364 | last_vsync_timetick_local = mfd->last_vsync_timetick; | |
365 | spin_unlock_irqrestore(&mdp_spin_lock, flag); | |
366 | ||
367 | curr_time = ktime_get_real(); | |
368 | elapsed_usec_time = | |
369 | ((curr_time.tv.sec - last_vsync_timetick_local.tv.sec) * 1000000) + | |
370 | ((curr_time.tv.nsec - last_vsync_timetick_local.tv.nsec) / 1000); | |
371 | ||
372 | elapsed_usec_time = elapsed_usec_time % mfd->lcd_ref_usec_time; | |
373 | ||
374 | /* lcd line calculation referencing to line counter = 0 */ | |
375 | lcd_line = | |
376 | (elapsed_usec_time * mfd->total_lcd_lines) / mfd->lcd_ref_usec_time; | |
377 | ||
378 | /* lcd line adjusment referencing to the actual line counter at vsync */ | |
379 | lcd_line = | |
380 | (mfd->total_lcd_lines - mfd->panel_info.lcd.v_back_porch + | |
381 | lcd_line) % (mfd->total_lcd_lines + 1); | |
382 | ||
383 | if (lcd_line > mfd->total_lcd_lines) { | |
384 | MSM_FB_INFO | |
385 | ("mdp_get_lcd_line_counter: mdp_lcd_rd_cnt >= mfd->total_lcd_lines error!\n"); | |
386 | } | |
387 | ||
388 | return lcd_line; | |
389 | } |