Commit | Line | Data |
---|---|---|
569755c7 ID |
1 | /* |
2 | * OMAP1 internal LCD controller | |
3 | * | |
4 | * Copyright (C) 2004 Nokia Corporation | |
5 | * Author: Imre Deak <imre.deak@nokia.com> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify it | |
8 | * under the terms of the GNU General Public License as published by the | |
9 | * Free Software Foundation; either version 2 of the License, or (at your | |
10 | * option) any later version. | |
11 | * | |
12 | * This program is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 | * General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License along | |
18 | * with this program; if not, write to the Free Software Foundation, Inc., | |
19 | * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
20 | */ | |
21 | #include <linux/module.h> | |
22 | #include <linux/device.h> | |
23 | #include <linux/interrupt.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include <linux/err.h> | |
26 | #include <linux/mm.h> | |
27 | #include <linux/fb.h> | |
28 | #include <linux/dma-mapping.h> | |
29 | #include <linux/vmalloc.h> | |
30 | #include <linux/clk.h> | |
31 | ||
a09e64fb RK |
32 | #include <mach/dma.h> |
33 | #include <mach/omapfb.h> | |
569755c7 ID |
34 | |
35 | #include <asm/mach-types.h> | |
36 | ||
7c8ad982 RK |
37 | #include "lcdc.h" |
38 | ||
569755c7 ID |
39 | #define MODULE_NAME "lcdc" |
40 | ||
41 | #define OMAP_LCDC_BASE 0xfffec000 | |
42 | #define OMAP_LCDC_SIZE 256 | |
43 | #define OMAP_LCDC_IRQ INT_LCD_CTRL | |
44 | ||
45 | #define OMAP_LCDC_CONTROL (OMAP_LCDC_BASE + 0x00) | |
46 | #define OMAP_LCDC_TIMING0 (OMAP_LCDC_BASE + 0x04) | |
47 | #define OMAP_LCDC_TIMING1 (OMAP_LCDC_BASE + 0x08) | |
48 | #define OMAP_LCDC_TIMING2 (OMAP_LCDC_BASE + 0x0c) | |
49 | #define OMAP_LCDC_STATUS (OMAP_LCDC_BASE + 0x10) | |
50 | #define OMAP_LCDC_SUBPANEL (OMAP_LCDC_BASE + 0x14) | |
51 | #define OMAP_LCDC_LINE_INT (OMAP_LCDC_BASE + 0x18) | |
52 | #define OMAP_LCDC_DISPLAY_STATUS (OMAP_LCDC_BASE + 0x1c) | |
53 | ||
54 | #define OMAP_LCDC_STAT_DONE (1 << 0) | |
55 | #define OMAP_LCDC_STAT_VSYNC (1 << 1) | |
56 | #define OMAP_LCDC_STAT_SYNC_LOST (1 << 2) | |
57 | #define OMAP_LCDC_STAT_ABC (1 << 3) | |
58 | #define OMAP_LCDC_STAT_LINE_INT (1 << 4) | |
59 | #define OMAP_LCDC_STAT_FUF (1 << 5) | |
60 | #define OMAP_LCDC_STAT_LOADED_PALETTE (1 << 6) | |
61 | ||
62 | #define OMAP_LCDC_CTRL_LCD_EN (1 << 0) | |
63 | #define OMAP_LCDC_CTRL_LCD_TFT (1 << 7) | |
64 | #define OMAP_LCDC_CTRL_LINE_IRQ_CLR_SEL (1 << 10) | |
65 | ||
66 | #define OMAP_LCDC_IRQ_VSYNC (1 << 2) | |
67 | #define OMAP_LCDC_IRQ_DONE (1 << 3) | |
68 | #define OMAP_LCDC_IRQ_LOADED_PALETTE (1 << 4) | |
69 | #define OMAP_LCDC_IRQ_LINE_NIRQ (1 << 5) | |
70 | #define OMAP_LCDC_IRQ_LINE (1 << 6) | |
71 | #define OMAP_LCDC_IRQ_MASK (((1 << 5) - 1) << 2) | |
72 | ||
73 | #define MAX_PALETTE_SIZE PAGE_SIZE | |
74 | ||
75 | enum lcdc_load_mode { | |
76 | OMAP_LCDC_LOAD_PALETTE, | |
77 | OMAP_LCDC_LOAD_FRAME, | |
78 | OMAP_LCDC_LOAD_PALETTE_AND_FRAME | |
79 | }; | |
80 | ||
81 | static struct omap_lcd_controller { | |
82 | enum omapfb_update_mode update_mode; | |
83 | int ext_mode; | |
84 | ||
85 | unsigned long frame_offset; | |
86 | int screen_width; | |
87 | int xres; | |
88 | int yres; | |
89 | ||
90 | enum omapfb_color_format color_mode; | |
91 | int bpp; | |
92 | void *palette_virt; | |
93 | dma_addr_t palette_phys; | |
94 | int palette_code; | |
95 | int palette_size; | |
96 | ||
97 | unsigned int irq_mask; | |
98 | struct completion last_frame_complete; | |
99 | struct completion palette_load_complete; | |
100 | struct clk *lcd_ck; | |
101 | struct omapfb_device *fbdev; | |
102 | ||
103 | void (*dma_callback)(void *data); | |
104 | void *dma_callback_data; | |
105 | ||
106 | int fbmem_allocated; | |
107 | dma_addr_t vram_phys; | |
108 | void *vram_virt; | |
109 | unsigned long vram_size; | |
110 | } lcdc; | |
111 | ||
112 | static void inline enable_irqs(int mask) | |
113 | { | |
114 | lcdc.irq_mask |= mask; | |
115 | } | |
116 | ||
117 | static void inline disable_irqs(int mask) | |
118 | { | |
119 | lcdc.irq_mask &= ~mask; | |
120 | } | |
121 | ||
122 | static void set_load_mode(enum lcdc_load_mode mode) | |
123 | { | |
124 | u32 l; | |
125 | ||
126 | l = omap_readl(OMAP_LCDC_CONTROL); | |
127 | l &= ~(3 << 20); | |
128 | switch (mode) { | |
129 | case OMAP_LCDC_LOAD_PALETTE: | |
130 | l |= 1 << 20; | |
131 | break; | |
132 | case OMAP_LCDC_LOAD_FRAME: | |
133 | l |= 2 << 20; | |
134 | break; | |
135 | case OMAP_LCDC_LOAD_PALETTE_AND_FRAME: | |
136 | break; | |
137 | default: | |
138 | BUG(); | |
139 | } | |
140 | omap_writel(l, OMAP_LCDC_CONTROL); | |
141 | } | |
142 | ||
143 | static void enable_controller(void) | |
144 | { | |
145 | u32 l; | |
146 | ||
147 | l = omap_readl(OMAP_LCDC_CONTROL); | |
148 | l |= OMAP_LCDC_CTRL_LCD_EN; | |
149 | l &= ~OMAP_LCDC_IRQ_MASK; | |
150 | l |= lcdc.irq_mask | OMAP_LCDC_IRQ_DONE; /* enabled IRQs */ | |
151 | omap_writel(l, OMAP_LCDC_CONTROL); | |
152 | } | |
153 | ||
154 | static void disable_controller_async(void) | |
155 | { | |
156 | u32 l; | |
157 | u32 mask; | |
158 | ||
159 | l = omap_readl(OMAP_LCDC_CONTROL); | |
160 | mask = OMAP_LCDC_CTRL_LCD_EN | OMAP_LCDC_IRQ_MASK; | |
161 | /* | |
162 | * Preserve the DONE mask, since we still want to get the | |
163 | * final DONE irq. It will be disabled in the IRQ handler. | |
164 | */ | |
165 | mask &= ~OMAP_LCDC_IRQ_DONE; | |
166 | l &= ~mask; | |
167 | omap_writel(l, OMAP_LCDC_CONTROL); | |
168 | } | |
169 | ||
170 | static void disable_controller(void) | |
171 | { | |
172 | init_completion(&lcdc.last_frame_complete); | |
173 | disable_controller_async(); | |
174 | if (!wait_for_completion_timeout(&lcdc.last_frame_complete, | |
175 | msecs_to_jiffies(500))) | |
176 | dev_err(lcdc.fbdev->dev, "timeout waiting for FRAME DONE\n"); | |
177 | } | |
178 | ||
179 | static void reset_controller(u32 status) | |
180 | { | |
181 | static unsigned long reset_count; | |
182 | static unsigned long last_jiffies; | |
183 | ||
184 | disable_controller_async(); | |
185 | reset_count++; | |
186 | if (reset_count == 1 || time_after(jiffies, last_jiffies + HZ)) { | |
187 | dev_err(lcdc.fbdev->dev, | |
188 | "resetting (status %#010x,reset count %lu)\n", | |
189 | status, reset_count); | |
190 | last_jiffies = jiffies; | |
191 | } | |
192 | if (reset_count < 100) { | |
193 | enable_controller(); | |
194 | } else { | |
195 | reset_count = 0; | |
196 | dev_err(lcdc.fbdev->dev, | |
197 | "too many reset attempts, giving up.\n"); | |
198 | } | |
199 | } | |
200 | ||
201 | /* | |
202 | * Configure the LCD DMA according to the current mode specified by parameters | |
203 | * in lcdc.fbdev and fbdev->var. | |
204 | */ | |
205 | static void setup_lcd_dma(void) | |
206 | { | |
207 | static const int dma_elem_type[] = { | |
208 | 0, | |
209 | OMAP_DMA_DATA_TYPE_S8, | |
210 | OMAP_DMA_DATA_TYPE_S16, | |
211 | 0, | |
212 | OMAP_DMA_DATA_TYPE_S32, | |
213 | }; | |
214 | struct omapfb_plane_struct *plane = lcdc.fbdev->fb_info[0]->par; | |
215 | struct fb_var_screeninfo *var = &lcdc.fbdev->fb_info[0]->var; | |
216 | unsigned long src; | |
217 | int esize, xelem, yelem; | |
218 | ||
219 | src = lcdc.vram_phys + lcdc.frame_offset; | |
220 | ||
221 | switch (var->rotate) { | |
222 | case 0: | |
223 | if (plane->info.mirror || (src & 3) || | |
224 | lcdc.color_mode == OMAPFB_COLOR_YUV420 || | |
225 | (lcdc.xres & 1)) | |
226 | esize = 2; | |
227 | else | |
228 | esize = 4; | |
229 | xelem = lcdc.xres * lcdc.bpp / 8 / esize; | |
230 | yelem = lcdc.yres; | |
231 | break; | |
232 | case 90: | |
233 | case 180: | |
234 | case 270: | |
235 | if (cpu_is_omap15xx()) { | |
236 | BUG(); | |
237 | } | |
238 | esize = 2; | |
239 | xelem = lcdc.yres * lcdc.bpp / 16; | |
240 | yelem = lcdc.xres; | |
241 | break; | |
242 | default: | |
243 | BUG(); | |
244 | return; | |
245 | } | |
246 | #ifdef VERBOSE | |
247 | dev_dbg(lcdc.fbdev->dev, | |
248 | "setup_dma: src %#010lx esize %d xelem %d yelem %d\n", | |
249 | src, esize, xelem, yelem); | |
250 | #endif | |
251 | omap_set_lcd_dma_b1(src, xelem, yelem, dma_elem_type[esize]); | |
252 | if (!cpu_is_omap15xx()) { | |
253 | int bpp = lcdc.bpp; | |
254 | ||
255 | /* | |
256 | * YUV support is only for external mode when we have the | |
257 | * YUV window embedded in a 16bpp frame buffer. | |
258 | */ | |
259 | if (lcdc.color_mode == OMAPFB_COLOR_YUV420) | |
260 | bpp = 16; | |
261 | /* Set virtual xres elem size */ | |
262 | omap_set_lcd_dma_b1_vxres( | |
263 | lcdc.screen_width * bpp / 8 / esize); | |
264 | /* Setup transformations */ | |
265 | omap_set_lcd_dma_b1_rotation(var->rotate); | |
266 | omap_set_lcd_dma_b1_mirror(plane->info.mirror); | |
267 | } | |
268 | omap_setup_lcd_dma(); | |
269 | } | |
270 | ||
271 | static irqreturn_t lcdc_irq_handler(int irq, void *dev_id) | |
272 | { | |
273 | u32 status; | |
274 | ||
275 | status = omap_readl(OMAP_LCDC_STATUS); | |
276 | ||
277 | if (status & (OMAP_LCDC_STAT_FUF | OMAP_LCDC_STAT_SYNC_LOST)) | |
278 | reset_controller(status); | |
279 | else { | |
280 | if (status & OMAP_LCDC_STAT_DONE) { | |
281 | u32 l; | |
282 | ||
283 | /* | |
284 | * Disable IRQ_DONE. The status bit will be cleared | |
285 | * only when the controller is reenabled and we don't | |
286 | * want to get more interrupts. | |
287 | */ | |
288 | l = omap_readl(OMAP_LCDC_CONTROL); | |
289 | l &= ~OMAP_LCDC_IRQ_DONE; | |
290 | omap_writel(l, OMAP_LCDC_CONTROL); | |
291 | complete(&lcdc.last_frame_complete); | |
292 | } | |
293 | if (status & OMAP_LCDC_STAT_LOADED_PALETTE) { | |
294 | disable_controller_async(); | |
295 | complete(&lcdc.palette_load_complete); | |
296 | } | |
297 | } | |
298 | ||
299 | /* | |
300 | * Clear these interrupt status bits. | |
301 | * Sync_lost, FUF bits were cleared by disabling the LCD controller | |
302 | * LOADED_PALETTE can be cleared this way only in palette only | |
303 | * load mode. In other load modes it's cleared by disabling the | |
304 | * controller. | |
305 | */ | |
306 | status &= ~(OMAP_LCDC_STAT_VSYNC | | |
307 | OMAP_LCDC_STAT_LOADED_PALETTE | | |
308 | OMAP_LCDC_STAT_ABC | | |
309 | OMAP_LCDC_STAT_LINE_INT); | |
310 | omap_writel(status, OMAP_LCDC_STATUS); | |
311 | return IRQ_HANDLED; | |
312 | } | |
313 | ||
314 | /* | |
315 | * Change to a new video mode. We defer this to a later time to avoid any | |
316 | * flicker and not to mess up the current LCD DMA context. For this we disable | |
44363f14 | 317 | * the LCD controller, which will generate a DONE irq after the last frame has |
569755c7 ID |
318 | * been transferred. Then it'll be safe to reconfigure both the LCD controller |
319 | * as well as the LCD DMA. | |
320 | */ | |
321 | static int omap_lcdc_setup_plane(int plane, int channel_out, | |
322 | unsigned long offset, int screen_width, | |
323 | int pos_x, int pos_y, int width, int height, | |
324 | int color_mode) | |
325 | { | |
326 | struct fb_var_screeninfo *var = &lcdc.fbdev->fb_info[0]->var; | |
327 | struct lcd_panel *panel = lcdc.fbdev->panel; | |
328 | int rot_x, rot_y; | |
329 | ||
330 | if (var->rotate == 0) { | |
331 | rot_x = panel->x_res; | |
332 | rot_y = panel->y_res; | |
333 | } else { | |
334 | rot_x = panel->y_res; | |
335 | rot_y = panel->x_res; | |
336 | } | |
337 | if (plane != 0 || channel_out != 0 || pos_x != 0 || pos_y != 0 || | |
338 | width > rot_x || height > rot_y) { | |
339 | #ifdef VERBOSE | |
340 | dev_dbg(lcdc.fbdev->dev, | |
341 | "invalid plane params plane %d pos_x %d pos_y %d " | |
342 | "w %d h %d\n", plane, pos_x, pos_y, width, height); | |
343 | #endif | |
344 | return -EINVAL; | |
345 | } | |
346 | ||
347 | lcdc.frame_offset = offset; | |
348 | lcdc.xres = width; | |
349 | lcdc.yres = height; | |
350 | lcdc.screen_width = screen_width; | |
351 | lcdc.color_mode = color_mode; | |
352 | ||
353 | switch (color_mode) { | |
354 | case OMAPFB_COLOR_CLUT_8BPP: | |
355 | lcdc.bpp = 8; | |
356 | lcdc.palette_code = 0x3000; | |
357 | lcdc.palette_size = 512; | |
358 | break; | |
359 | case OMAPFB_COLOR_RGB565: | |
360 | lcdc.bpp = 16; | |
361 | lcdc.palette_code = 0x4000; | |
362 | lcdc.palette_size = 32; | |
363 | break; | |
364 | case OMAPFB_COLOR_RGB444: | |
365 | lcdc.bpp = 16; | |
366 | lcdc.palette_code = 0x4000; | |
367 | lcdc.palette_size = 32; | |
368 | break; | |
369 | case OMAPFB_COLOR_YUV420: | |
370 | if (lcdc.ext_mode) { | |
371 | lcdc.bpp = 12; | |
372 | break; | |
373 | } | |
374 | /* fallthrough */ | |
375 | case OMAPFB_COLOR_YUV422: | |
376 | if (lcdc.ext_mode) { | |
377 | lcdc.bpp = 16; | |
378 | break; | |
379 | } | |
380 | /* fallthrough */ | |
381 | default: | |
382 | /* FIXME: other BPPs. | |
383 | * bpp1: code 0, size 256 | |
384 | * bpp2: code 0x1000 size 256 | |
385 | * bpp4: code 0x2000 size 256 | |
386 | * bpp12: code 0x4000 size 32 | |
387 | */ | |
388 | dev_dbg(lcdc.fbdev->dev, "invalid color mode %d\n", color_mode); | |
389 | BUG(); | |
390 | return -1; | |
391 | } | |
392 | ||
393 | if (lcdc.ext_mode) { | |
394 | setup_lcd_dma(); | |
395 | return 0; | |
396 | } | |
397 | ||
398 | if (lcdc.update_mode == OMAPFB_AUTO_UPDATE) { | |
399 | disable_controller(); | |
400 | omap_stop_lcd_dma(); | |
401 | setup_lcd_dma(); | |
402 | enable_controller(); | |
403 | } | |
404 | ||
405 | return 0; | |
406 | } | |
407 | ||
408 | static int omap_lcdc_enable_plane(int plane, int enable) | |
409 | { | |
410 | dev_dbg(lcdc.fbdev->dev, | |
411 | "plane %d enable %d update_mode %d ext_mode %d\n", | |
412 | plane, enable, lcdc.update_mode, lcdc.ext_mode); | |
413 | if (plane != OMAPFB_PLANE_GFX) | |
414 | return -EINVAL; | |
415 | ||
416 | return 0; | |
417 | } | |
418 | ||
419 | /* | |
420 | * Configure the LCD DMA for a palette load operation and do the palette | |
421 | * downloading synchronously. We don't use the frame+palette load mode of | |
422 | * the controller, since the palette can always be downloaded seperately. | |
423 | */ | |
424 | static void load_palette(void) | |
425 | { | |
426 | u16 *palette; | |
427 | ||
428 | palette = (u16 *)lcdc.palette_virt; | |
429 | ||
430 | *(u16 *)palette &= 0x0fff; | |
431 | *(u16 *)palette |= lcdc.palette_code; | |
432 | ||
433 | omap_set_lcd_dma_b1(lcdc.palette_phys, | |
434 | lcdc.palette_size / 4 + 1, 1, OMAP_DMA_DATA_TYPE_S32); | |
435 | ||
436 | omap_set_lcd_dma_single_transfer(1); | |
437 | omap_setup_lcd_dma(); | |
438 | ||
439 | init_completion(&lcdc.palette_load_complete); | |
440 | enable_irqs(OMAP_LCDC_IRQ_LOADED_PALETTE); | |
441 | set_load_mode(OMAP_LCDC_LOAD_PALETTE); | |
442 | enable_controller(); | |
443 | if (!wait_for_completion_timeout(&lcdc.palette_load_complete, | |
444 | msecs_to_jiffies(500))) | |
445 | dev_err(lcdc.fbdev->dev, "timeout waiting for FRAME DONE\n"); | |
446 | /* The controller gets disabled in the irq handler */ | |
447 | disable_irqs(OMAP_LCDC_IRQ_LOADED_PALETTE); | |
448 | omap_stop_lcd_dma(); | |
449 | ||
450 | omap_set_lcd_dma_single_transfer(lcdc.ext_mode); | |
451 | } | |
452 | ||
453 | /* Used only in internal controller mode */ | |
454 | static int omap_lcdc_setcolreg(u_int regno, u16 red, u16 green, u16 blue, | |
455 | u16 transp, int update_hw_pal) | |
456 | { | |
457 | u16 *palette; | |
458 | ||
459 | if (lcdc.color_mode != OMAPFB_COLOR_CLUT_8BPP || regno > 255) | |
460 | return -EINVAL; | |
461 | ||
462 | palette = (u16 *)lcdc.palette_virt; | |
463 | ||
464 | palette[regno] &= ~0x0fff; | |
465 | palette[regno] |= ((red >> 12) << 8) | ((green >> 12) << 4 ) | | |
466 | (blue >> 12); | |
467 | ||
468 | if (update_hw_pal) { | |
469 | disable_controller(); | |
470 | omap_stop_lcd_dma(); | |
471 | load_palette(); | |
472 | setup_lcd_dma(); | |
473 | set_load_mode(OMAP_LCDC_LOAD_FRAME); | |
474 | enable_controller(); | |
475 | } | |
476 | ||
477 | return 0; | |
478 | } | |
479 | ||
480 | static void calc_ck_div(int is_tft, int pck, int *pck_div) | |
481 | { | |
482 | unsigned long lck; | |
483 | ||
484 | pck = max(1, pck); | |
485 | lck = clk_get_rate(lcdc.lcd_ck); | |
486 | *pck_div = (lck + pck - 1) / pck; | |
487 | if (is_tft) | |
488 | *pck_div = max(2, *pck_div); | |
489 | else | |
490 | *pck_div = max(3, *pck_div); | |
491 | if (*pck_div > 255) { | |
492 | /* FIXME: try to adjust logic clock divider as well */ | |
493 | *pck_div = 255; | |
494 | dev_warn(lcdc.fbdev->dev, "pixclock %d kHz too low.\n", | |
495 | pck / 1000); | |
496 | } | |
497 | } | |
498 | ||
499 | static void inline setup_regs(void) | |
500 | { | |
501 | u32 l; | |
502 | struct lcd_panel *panel = lcdc.fbdev->panel; | |
503 | int is_tft = panel->config & OMAP_LCDC_PANEL_TFT; | |
504 | unsigned long lck; | |
505 | int pcd; | |
506 | ||
507 | l = omap_readl(OMAP_LCDC_CONTROL); | |
508 | l &= ~OMAP_LCDC_CTRL_LCD_TFT; | |
509 | l |= is_tft ? OMAP_LCDC_CTRL_LCD_TFT : 0; | |
510 | #ifdef CONFIG_MACH_OMAP_PALMTE | |
511 | /* FIXME:if (machine_is_omap_palmte()) { */ | |
512 | /* PalmTE uses alternate TFT setting in 8BPP mode */ | |
513 | l |= (is_tft && panel->bpp == 8) ? 0x810000 : 0; | |
514 | /* } */ | |
515 | #endif | |
516 | omap_writel(l, OMAP_LCDC_CONTROL); | |
517 | ||
518 | l = omap_readl(OMAP_LCDC_TIMING2); | |
519 | l &= ~(((1 << 6) - 1) << 20); | |
520 | l |= (panel->config & OMAP_LCDC_SIGNAL_MASK) << 20; | |
521 | omap_writel(l, OMAP_LCDC_TIMING2); | |
522 | ||
523 | l = panel->x_res - 1; | |
524 | l |= (panel->hsw - 1) << 10; | |
525 | l |= (panel->hfp - 1) << 16; | |
526 | l |= (panel->hbp - 1) << 24; | |
527 | omap_writel(l, OMAP_LCDC_TIMING0); | |
528 | ||
529 | l = panel->y_res - 1; | |
530 | l |= (panel->vsw - 1) << 10; | |
531 | l |= panel->vfp << 16; | |
532 | l |= panel->vbp << 24; | |
533 | omap_writel(l, OMAP_LCDC_TIMING1); | |
534 | ||
535 | l = omap_readl(OMAP_LCDC_TIMING2); | |
536 | l &= ~0xff; | |
537 | ||
538 | lck = clk_get_rate(lcdc.lcd_ck); | |
539 | ||
540 | if (!panel->pcd) | |
541 | calc_ck_div(is_tft, panel->pixel_clock * 1000, &pcd); | |
542 | else { | |
543 | dev_warn(lcdc.fbdev->dev, | |
544 | "Pixel clock divider value is obsolete.\n" | |
545 | "Try to set pixel_clock to %lu and pcd to 0 " | |
546 | "in drivers/video/omap/lcd_%s.c and submit a patch.\n", | |
547 | lck / panel->pcd / 1000, panel->name); | |
548 | ||
549 | pcd = panel->pcd; | |
550 | } | |
551 | l |= pcd & 0xff; | |
552 | l |= panel->acb << 8; | |
553 | omap_writel(l, OMAP_LCDC_TIMING2); | |
554 | ||
555 | /* update panel info with the exact clock */ | |
556 | panel->pixel_clock = lck / pcd / 1000; | |
557 | } | |
558 | ||
559 | /* | |
560 | * Configure the LCD controller, download the color palette and start a looped | |
561 | * DMA transfer of the frame image data. Called only in internal | |
562 | * controller mode. | |
563 | */ | |
564 | static int omap_lcdc_set_update_mode(enum omapfb_update_mode mode) | |
565 | { | |
566 | int r = 0; | |
567 | ||
568 | if (mode != lcdc.update_mode) { | |
569 | switch (mode) { | |
570 | case OMAPFB_AUTO_UPDATE: | |
571 | setup_regs(); | |
572 | load_palette(); | |
573 | ||
574 | /* Setup and start LCD DMA */ | |
575 | setup_lcd_dma(); | |
576 | ||
577 | set_load_mode(OMAP_LCDC_LOAD_FRAME); | |
578 | enable_irqs(OMAP_LCDC_IRQ_DONE); | |
579 | /* This will start the actual DMA transfer */ | |
580 | enable_controller(); | |
581 | lcdc.update_mode = mode; | |
582 | break; | |
583 | case OMAPFB_UPDATE_DISABLED: | |
584 | disable_controller(); | |
585 | omap_stop_lcd_dma(); | |
586 | lcdc.update_mode = mode; | |
587 | break; | |
588 | default: | |
589 | r = -EINVAL; | |
590 | } | |
591 | } | |
592 | ||
593 | return r; | |
594 | } | |
595 | ||
596 | static enum omapfb_update_mode omap_lcdc_get_update_mode(void) | |
597 | { | |
598 | return lcdc.update_mode; | |
599 | } | |
600 | ||
601 | /* PM code called only in internal controller mode */ | |
602 | static void omap_lcdc_suspend(void) | |
603 | { | |
604 | if (lcdc.update_mode == OMAPFB_AUTO_UPDATE) { | |
605 | disable_controller(); | |
606 | omap_stop_lcd_dma(); | |
607 | } | |
608 | } | |
609 | ||
610 | static void omap_lcdc_resume(void) | |
611 | { | |
612 | if (lcdc.update_mode == OMAPFB_AUTO_UPDATE) { | |
613 | setup_regs(); | |
614 | load_palette(); | |
615 | setup_lcd_dma(); | |
616 | set_load_mode(OMAP_LCDC_LOAD_FRAME); | |
617 | enable_irqs(OMAP_LCDC_IRQ_DONE); | |
618 | enable_controller(); | |
619 | } | |
620 | } | |
621 | ||
622 | static void omap_lcdc_get_caps(int plane, struct omapfb_caps *caps) | |
623 | { | |
624 | return; | |
625 | } | |
626 | ||
627 | int omap_lcdc_set_dma_callback(void (*callback)(void *data), void *data) | |
628 | { | |
629 | BUG_ON(callback == NULL); | |
630 | ||
631 | if (lcdc.dma_callback) | |
632 | return -EBUSY; | |
633 | else { | |
634 | lcdc.dma_callback = callback; | |
635 | lcdc.dma_callback_data = data; | |
636 | } | |
637 | return 0; | |
638 | } | |
639 | EXPORT_SYMBOL(omap_lcdc_set_dma_callback); | |
640 | ||
641 | void omap_lcdc_free_dma_callback(void) | |
642 | { | |
643 | lcdc.dma_callback = NULL; | |
644 | } | |
645 | EXPORT_SYMBOL(omap_lcdc_free_dma_callback); | |
646 | ||
647 | static void lcdc_dma_handler(u16 status, void *data) | |
648 | { | |
649 | if (lcdc.dma_callback) | |
650 | lcdc.dma_callback(lcdc.dma_callback_data); | |
651 | } | |
652 | ||
653 | static int mmap_kern(void) | |
654 | { | |
655 | struct vm_struct *kvma; | |
656 | struct vm_area_struct vma; | |
657 | pgprot_t pgprot; | |
658 | unsigned long vaddr; | |
659 | ||
660 | kvma = get_vm_area(lcdc.vram_size, VM_IOREMAP); | |
661 | if (kvma == NULL) { | |
662 | dev_err(lcdc.fbdev->dev, "can't get kernel vm area\n"); | |
663 | return -ENOMEM; | |
664 | } | |
665 | vma.vm_mm = &init_mm; | |
666 | ||
667 | vaddr = (unsigned long)kvma->addr; | |
668 | vma.vm_start = vaddr; | |
669 | vma.vm_end = vaddr + lcdc.vram_size; | |
670 | ||
671 | pgprot = pgprot_writecombine(pgprot_kernel); | |
672 | if (io_remap_pfn_range(&vma, vaddr, | |
673 | lcdc.vram_phys >> PAGE_SHIFT, | |
674 | lcdc.vram_size, pgprot) < 0) { | |
675 | dev_err(lcdc.fbdev->dev, "kernel mmap for FB memory failed\n"); | |
676 | return -EAGAIN; | |
677 | } | |
678 | ||
679 | lcdc.vram_virt = (void *)vaddr; | |
680 | ||
681 | return 0; | |
682 | } | |
683 | ||
684 | static void unmap_kern(void) | |
685 | { | |
686 | vunmap(lcdc.vram_virt); | |
687 | } | |
688 | ||
689 | static int alloc_palette_ram(void) | |
690 | { | |
691 | lcdc.palette_virt = dma_alloc_writecombine(lcdc.fbdev->dev, | |
692 | MAX_PALETTE_SIZE, &lcdc.palette_phys, GFP_KERNEL); | |
693 | if (lcdc.palette_virt == NULL) { | |
694 | dev_err(lcdc.fbdev->dev, "failed to alloc palette memory\n"); | |
695 | return -ENOMEM; | |
696 | } | |
697 | memset(lcdc.palette_virt, 0, MAX_PALETTE_SIZE); | |
698 | ||
699 | return 0; | |
700 | } | |
701 | ||
702 | static void free_palette_ram(void) | |
703 | { | |
704 | dma_free_writecombine(lcdc.fbdev->dev, MAX_PALETTE_SIZE, | |
705 | lcdc.palette_virt, lcdc.palette_phys); | |
706 | } | |
707 | ||
708 | static int alloc_fbmem(struct omapfb_mem_region *region) | |
709 | { | |
710 | int bpp; | |
711 | int frame_size; | |
712 | struct lcd_panel *panel = lcdc.fbdev->panel; | |
713 | ||
714 | bpp = panel->bpp; | |
715 | if (bpp == 12) | |
716 | bpp = 16; | |
717 | frame_size = PAGE_ALIGN(panel->x_res * bpp / 8 * panel->y_res); | |
718 | if (region->size > frame_size) | |
719 | frame_size = region->size; | |
720 | lcdc.vram_size = frame_size; | |
721 | lcdc.vram_virt = dma_alloc_writecombine(lcdc.fbdev->dev, | |
722 | lcdc.vram_size, &lcdc.vram_phys, GFP_KERNEL); | |
723 | if (lcdc.vram_virt == NULL) { | |
724 | dev_err(lcdc.fbdev->dev, "unable to allocate FB DMA memory\n"); | |
725 | return -ENOMEM; | |
726 | } | |
727 | region->size = frame_size; | |
728 | region->paddr = lcdc.vram_phys; | |
729 | region->vaddr = lcdc.vram_virt; | |
730 | region->alloc = 1; | |
731 | ||
732 | memset(lcdc.vram_virt, 0, lcdc.vram_size); | |
733 | ||
734 | return 0; | |
735 | } | |
736 | ||
737 | static void free_fbmem(void) | |
738 | { | |
739 | dma_free_writecombine(lcdc.fbdev->dev, lcdc.vram_size, | |
740 | lcdc.vram_virt, lcdc.vram_phys); | |
741 | } | |
742 | ||
743 | static int setup_fbmem(struct omapfb_mem_desc *req_md) | |
744 | { | |
745 | int r; | |
746 | ||
747 | if (!req_md->region_cnt) { | |
748 | dev_err(lcdc.fbdev->dev, "no memory regions defined\n"); | |
749 | return -EINVAL; | |
750 | } | |
751 | ||
752 | if (req_md->region_cnt > 1) { | |
753 | dev_err(lcdc.fbdev->dev, "only one plane is supported\n"); | |
754 | req_md->region_cnt = 1; | |
755 | } | |
756 | ||
757 | if (req_md->region[0].paddr == 0) { | |
758 | lcdc.fbmem_allocated = 1; | |
759 | if ((r = alloc_fbmem(&req_md->region[0])) < 0) | |
760 | return r; | |
761 | return 0; | |
762 | } | |
763 | ||
764 | lcdc.vram_phys = req_md->region[0].paddr; | |
765 | lcdc.vram_size = req_md->region[0].size; | |
766 | ||
767 | if ((r = mmap_kern()) < 0) | |
768 | return r; | |
769 | ||
770 | dev_dbg(lcdc.fbdev->dev, "vram at %08x size %08lx mapped to 0x%p\n", | |
771 | lcdc.vram_phys, lcdc.vram_size, lcdc.vram_virt); | |
772 | ||
773 | return 0; | |
774 | } | |
775 | ||
776 | static void cleanup_fbmem(void) | |
777 | { | |
778 | if (lcdc.fbmem_allocated) | |
779 | free_fbmem(); | |
780 | else | |
781 | unmap_kern(); | |
782 | } | |
783 | ||
784 | static int omap_lcdc_init(struct omapfb_device *fbdev, int ext_mode, | |
785 | struct omapfb_mem_desc *req_vram) | |
786 | { | |
787 | int r; | |
788 | u32 l; | |
789 | int rate; | |
790 | struct clk *tc_ck; | |
791 | ||
792 | lcdc.irq_mask = 0; | |
793 | ||
794 | lcdc.fbdev = fbdev; | |
795 | lcdc.ext_mode = ext_mode; | |
796 | ||
797 | l = 0; | |
798 | omap_writel(l, OMAP_LCDC_CONTROL); | |
799 | ||
800 | /* FIXME: | |
801 | * According to errata some platforms have a clock rate limitiation | |
802 | */ | |
953a7e84 | 803 | lcdc.lcd_ck = clk_get(fbdev->dev, "lcd_ck"); |
569755c7 ID |
804 | if (IS_ERR(lcdc.lcd_ck)) { |
805 | dev_err(fbdev->dev, "unable to access LCD clock\n"); | |
806 | r = PTR_ERR(lcdc.lcd_ck); | |
807 | goto fail0; | |
808 | } | |
809 | ||
953a7e84 | 810 | tc_ck = clk_get(fbdev->dev, "tc_ck"); |
569755c7 ID |
811 | if (IS_ERR(tc_ck)) { |
812 | dev_err(fbdev->dev, "unable to access TC clock\n"); | |
813 | r = PTR_ERR(tc_ck); | |
814 | goto fail1; | |
815 | } | |
816 | ||
817 | rate = clk_get_rate(tc_ck); | |
818 | clk_put(tc_ck); | |
819 | ||
820 | if (machine_is_ams_delta()) | |
821 | rate /= 4; | |
822 | if (machine_is_omap_h3()) | |
823 | rate /= 3; | |
824 | r = clk_set_rate(lcdc.lcd_ck, rate); | |
825 | if (r) { | |
826 | dev_err(fbdev->dev, "failed to adjust LCD rate\n"); | |
827 | goto fail1; | |
828 | } | |
829 | clk_enable(lcdc.lcd_ck); | |
830 | ||
831 | r = request_irq(OMAP_LCDC_IRQ, lcdc_irq_handler, 0, MODULE_NAME, fbdev); | |
832 | if (r) { | |
833 | dev_err(fbdev->dev, "unable to get IRQ\n"); | |
834 | goto fail2; | |
835 | } | |
836 | ||
837 | r = omap_request_lcd_dma(lcdc_dma_handler, NULL); | |
838 | if (r) { | |
839 | dev_err(fbdev->dev, "unable to get LCD DMA\n"); | |
840 | goto fail3; | |
841 | } | |
842 | ||
843 | omap_set_lcd_dma_single_transfer(ext_mode); | |
844 | omap_set_lcd_dma_ext_controller(ext_mode); | |
845 | ||
846 | if (!ext_mode) | |
847 | if ((r = alloc_palette_ram()) < 0) | |
848 | goto fail4; | |
849 | ||
850 | if ((r = setup_fbmem(req_vram)) < 0) | |
851 | goto fail5; | |
852 | ||
853 | pr_info("omapfb: LCDC initialized\n"); | |
854 | ||
855 | return 0; | |
856 | fail5: | |
857 | if (!ext_mode) | |
858 | free_palette_ram(); | |
859 | fail4: | |
860 | omap_free_lcd_dma(); | |
861 | fail3: | |
862 | free_irq(OMAP_LCDC_IRQ, lcdc.fbdev); | |
863 | fail2: | |
864 | clk_disable(lcdc.lcd_ck); | |
865 | fail1: | |
866 | clk_put(lcdc.lcd_ck); | |
867 | fail0: | |
868 | return r; | |
869 | } | |
870 | ||
871 | static void omap_lcdc_cleanup(void) | |
872 | { | |
873 | if (!lcdc.ext_mode) | |
874 | free_palette_ram(); | |
875 | cleanup_fbmem(); | |
876 | omap_free_lcd_dma(); | |
877 | free_irq(OMAP_LCDC_IRQ, lcdc.fbdev); | |
878 | clk_disable(lcdc.lcd_ck); | |
879 | clk_put(lcdc.lcd_ck); | |
880 | } | |
881 | ||
882 | const struct lcd_ctrl omap1_int_ctrl = { | |
883 | .name = "internal", | |
884 | .init = omap_lcdc_init, | |
885 | .cleanup = omap_lcdc_cleanup, | |
886 | .get_caps = omap_lcdc_get_caps, | |
887 | .set_update_mode = omap_lcdc_set_update_mode, | |
888 | .get_update_mode = omap_lcdc_get_update_mode, | |
889 | .update_window = NULL, | |
890 | .suspend = omap_lcdc_suspend, | |
891 | .resume = omap_lcdc_resume, | |
892 | .setup_plane = omap_lcdc_setup_plane, | |
893 | .enable_plane = omap_lcdc_enable_plane, | |
894 | .setcolreg = omap_lcdc_setcolreg, | |
895 | }; |