1 /* drivers/video/msm_fb/mdp.c
3 * MSM MDP Interface (used by framebuffer core)
5 * Copyright (C) 2007 QUALCOMM Incorporated
6 * Copyright (C) 2007 Google Incorporated
8 * This software is licensed under the terms of the GNU General Public
9 * License version 2, as published by the Free Software Foundation, and
10 * may be copied, distributed, and modified under those terms.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
18 #include <linux/kernel.h>
20 #include <linux/msm_mdp.h>
21 #include <linux/interrupt.h>
22 #include <linux/wait.h>
23 #include <linux/clk.h>
24 #include <linux/file.h>
25 #include <linux/major.h>
26 #include <linux/slab.h>
28 #include <mach/msm_iomap.h>
29 #include <mach/msm_fb.h>
30 #include <linux/platform_device.h>
31 #include <linux/export.h>
35 struct class *mdp_class
;
37 #define MDP_CMD_DEBUG_ACCESS_BASE (0x10000)
39 static uint16_t mdp_default_ccs
[] = {
40 0x254, 0x000, 0x331, 0x254, 0xF38, 0xE61, 0x254, 0x409, 0x000,
44 static DECLARE_WAIT_QUEUE_HEAD(mdp_dma2_waitqueue
);
45 static DECLARE_WAIT_QUEUE_HEAD(mdp_ppp_waitqueue
);
46 static struct msmfb_callback
*dma_callback
;
47 static struct clk
*clk
;
48 static unsigned int mdp_irq_mask
;
49 static DEFINE_SPINLOCK(mdp_lock
);
50 DEFINE_MUTEX(mdp_mutex
);
52 static int enable_mdp_irq(struct mdp_info
*mdp
, uint32_t mask
)
54 unsigned long irq_flags
;
59 spin_lock_irqsave(&mdp_lock
, irq_flags
);
60 /* if the mask bits are already set return an error, this interrupt
61 * is already enabled */
62 if (mdp_irq_mask
& mask
) {
63 printk(KERN_ERR
"mdp irq already on already on %x %x\n",
67 /* if the mdp irq is not already enabled enable it */
74 /* update the irq mask to reflect the fact that the interrupt is
77 spin_unlock_irqrestore(&mdp_lock
, irq_flags
);
81 static int locked_disable_mdp_irq(struct mdp_info
*mdp
, uint32_t mask
)
83 /* this interrupt is already disabled! */
84 if (!(mdp_irq_mask
& mask
)) {
85 printk(KERN_ERR
"mdp irq already off %x %x\n",
89 /* update the irq mask to reflect the fact that the interrupt is
91 mdp_irq_mask
&= ~(mask
);
92 /* if no one is waiting on the interrupt, disable it */
94 disable_irq_nosync(mdp
->irq
);
101 static int disable_mdp_irq(struct mdp_info
*mdp
, uint32_t mask
)
103 unsigned long irq_flags
;
106 spin_lock_irqsave(&mdp_lock
, irq_flags
);
107 ret
= locked_disable_mdp_irq(mdp
, mask
);
108 spin_unlock_irqrestore(&mdp_lock
, irq_flags
);
112 static irqreturn_t
mdp_isr(int irq
, void *data
)
115 unsigned long irq_flags
;
116 struct mdp_info
*mdp
= data
;
118 spin_lock_irqsave(&mdp_lock
, irq_flags
);
120 status
= mdp_readl(mdp
, MDP_INTR_STATUS
);
121 mdp_writel(mdp
, status
, MDP_INTR_CLEAR
);
123 status
&= mdp_irq_mask
;
124 if (status
& DL0_DMA2_TERM_DONE
) {
126 dma_callback
->func(dma_callback
);
129 wake_up(&mdp_dma2_waitqueue
);
132 if (status
& DL0_ROI_DONE
)
133 wake_up(&mdp_ppp_waitqueue
);
136 locked_disable_mdp_irq(mdp
, status
);
138 spin_unlock_irqrestore(&mdp_lock
, irq_flags
);
142 static uint32_t mdp_check_mask(uint32_t mask
)
145 unsigned long irq_flags
;
147 spin_lock_irqsave(&mdp_lock
, irq_flags
);
148 ret
= mdp_irq_mask
& mask
;
149 spin_unlock_irqrestore(&mdp_lock
, irq_flags
);
153 static int mdp_wait(struct mdp_info
*mdp
, uint32_t mask
, wait_queue_head_t
*wq
)
156 unsigned long irq_flags
;
158 wait_event_timeout(*wq
, !mdp_check_mask(mask
), HZ
);
160 spin_lock_irqsave(&mdp_lock
, irq_flags
);
161 if (mdp_irq_mask
& mask
) {
162 locked_disable_mdp_irq(mdp
, mask
);
163 printk(KERN_WARNING
"timeout waiting for mdp to complete %x\n",
167 spin_unlock_irqrestore(&mdp_lock
, irq_flags
);
172 void mdp_dma_wait(struct mdp_device
*mdp_dev
)
174 #define MDP_MAX_TIMEOUTS 20
175 static int timeout_count
;
176 struct mdp_info
*mdp
= container_of(mdp_dev
, struct mdp_info
, mdp_dev
);
178 if (mdp_wait(mdp
, DL0_DMA2_TERM_DONE
, &mdp_dma2_waitqueue
) == -ETIMEDOUT
)
183 if (timeout_count
> MDP_MAX_TIMEOUTS
) {
184 printk(KERN_ERR
"mdp: dma failed %d times, somethings wrong!\n",
190 static int mdp_ppp_wait(struct mdp_info
*mdp
)
192 return mdp_wait(mdp
, DL0_ROI_DONE
, &mdp_ppp_waitqueue
);
195 void mdp_dma_to_mddi(struct mdp_info
*mdp
, uint32_t addr
, uint32_t stride
,
196 uint32_t width
, uint32_t height
, uint32_t x
, uint32_t y
,
197 struct msmfb_callback
*callback
)
200 uint16_t ld_param
= 0; /* 0=PRIM, 1=SECD, 2=EXT */
202 if (enable_mdp_irq(mdp
, DL0_DMA2_TERM_DONE
)) {
203 printk(KERN_ERR
"mdp_dma_to_mddi: busy\n");
207 dma_callback
= callback
;
209 dma2_cfg
= DMA_PACK_TIGHT
|
211 DMA_PACK_PATTERN_RGB
|
213 DMA_IBUF_NONCONTIGUOUS
;
215 dma2_cfg
|= DMA_IBUF_FORMAT_RGB565
;
217 dma2_cfg
|= DMA_OUT_SEL_MDDI
;
219 dma2_cfg
|= DMA_MDDI_DMAOUT_LCD_SEL_PRIMARY
;
221 dma2_cfg
|= DMA_DITHER_EN
;
223 /* setup size, address, and stride */
224 mdp_writel(mdp
, (height
<< 16) | (width
),
225 MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0184);
226 mdp_writel(mdp
, addr
, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0188);
227 mdp_writel(mdp
, stride
, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x018C);
230 dma2_cfg
|= DMA_DSTC0G_6BITS
| DMA_DSTC1B_6BITS
| DMA_DSTC2R_6BITS
;
232 /* set y & x offset and MDDI transaction parameters */
233 mdp_writel(mdp
, (y
<< 16) | (x
), MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0194);
234 mdp_writel(mdp
, ld_param
, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01a0);
235 mdp_writel(mdp
, (MDDI_VDO_PACKET_DESC
<< 16) | MDDI_VDO_PACKET_PRIM
,
236 MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01a4);
238 mdp_writel(mdp
, dma2_cfg
, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0180);
241 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0044);
244 void mdp_dma(struct mdp_device
*mdp_dev
, uint32_t addr
, uint32_t stride
,
245 uint32_t width
, uint32_t height
, uint32_t x
, uint32_t y
,
246 struct msmfb_callback
*callback
, int interface
)
248 struct mdp_info
*mdp
= container_of(mdp_dev
, struct mdp_info
, mdp_dev
);
250 if (interface
== MSM_MDDI_PMDH_INTERFACE
) {
251 mdp_dma_to_mddi(mdp
, addr
, stride
, width
, height
, x
, y
,
256 int get_img(struct mdp_img
*img
, struct fb_info
*info
,
257 unsigned long *start
, unsigned long *len
,
261 struct fd f
= fdget(img
->memory_id
);
265 if (MAJOR(f
.file
->f_dentry
->d_inode
->i_rdev
) == FB_MAJOR
) {
266 *start
= info
->fix
.smem_start
;
267 *len
= info
->fix
.smem_len
;
275 void put_img(struct file
*src_file
, struct file
*dst_file
)
279 int mdp_blit(struct mdp_device
*mdp_dev
, struct fb_info
*fb
,
280 struct mdp_blit_req
*req
)
283 unsigned long src_start
= 0, src_len
= 0, dst_start
= 0, dst_len
= 0;
284 struct mdp_info
*mdp
= container_of(mdp_dev
, struct mdp_info
, mdp_dev
);
285 struct file
*src_file
= 0, *dst_file
= 0;
287 /* WORKAROUND FOR HARDWARE BUG IN BG TILE FETCH */
288 if (unlikely(req
->src_rect
.h
== 0 ||
289 req
->src_rect
.w
== 0)) {
290 printk(KERN_ERR
"mpd_ppp: src img of zero size!\n");
293 if (unlikely(req
->dst_rect
.h
== 0 ||
294 req
->dst_rect
.w
== 0))
297 /* do this first so that if this fails, the caller can always
298 * safely call put_img */
299 if (unlikely(get_img(&req
->src
, fb
, &src_start
, &src_len
, &src_file
))) {
300 printk(KERN_ERR
"mpd_ppp: could not retrieve src image from "
305 if (unlikely(get_img(&req
->dst
, fb
, &dst_start
, &dst_len
, &dst_file
))) {
306 printk(KERN_ERR
"mpd_ppp: could not retrieve dst image from "
310 mutex_lock(&mdp_mutex
);
312 /* transp_masking unimplemented */
313 req
->transp_mask
= MDP_TRANSP_NOP
;
314 if (unlikely((req
->transp_mask
!= MDP_TRANSP_NOP
||
315 req
->alpha
!= MDP_ALPHA_NOP
||
316 HAS_ALPHA(req
->src
.format
)) &&
317 (req
->flags
& MDP_ROT_90
&&
318 req
->dst_rect
.w
<= 16 && req
->dst_rect
.h
>= 16))) {
320 unsigned int tiles
= req
->dst_rect
.h
/ 16;
321 unsigned int remainder
= req
->dst_rect
.h
% 16;
322 req
->src_rect
.w
= 16*req
->src_rect
.w
/ req
->dst_rect
.h
;
323 req
->dst_rect
.h
= 16;
324 for (i
= 0; i
< tiles
; i
++) {
325 enable_mdp_irq(mdp
, DL0_ROI_DONE
);
326 ret
= mdp_ppp_blit(mdp
, req
, src_file
, src_start
,
327 src_len
, dst_file
, dst_start
,
331 ret
= mdp_ppp_wait(mdp
);
333 goto err_wait_failed
;
334 req
->dst_rect
.y
+= 16;
335 req
->src_rect
.x
+= req
->src_rect
.w
;
339 req
->src_rect
.w
= remainder
*req
->src_rect
.w
/ req
->dst_rect
.h
;
340 req
->dst_rect
.h
= remainder
;
342 enable_mdp_irq(mdp
, DL0_ROI_DONE
);
343 ret
= mdp_ppp_blit(mdp
, req
, src_file
, src_start
, src_len
, dst_file
,
348 ret
= mdp_ppp_wait(mdp
);
350 goto err_wait_failed
;
352 put_img(src_file
, dst_file
);
353 mutex_unlock(&mdp_mutex
);
356 disable_mdp_irq(mdp
, DL0_ROI_DONE
);
358 put_img(src_file
, dst_file
);
359 mutex_unlock(&mdp_mutex
);
363 void mdp_set_grp_disp(struct mdp_device
*mdp_dev
, unsigned disp_id
)
365 struct mdp_info
*mdp
= container_of(mdp_dev
, struct mdp_info
, mdp_dev
);
368 mdp_writel(mdp
, disp_id
, MDP_FULL_BYPASS_WORD43
);
371 int register_mdp_client(struct class_interface
*cint
)
374 pr_err("mdp: no mdp_class when registering mdp client\n");
377 cint
->class = mdp_class
;
378 return class_interface_register(cint
);
381 #include "mdp_csc_table.h"
382 #include "mdp_scale_tables.h"
384 int mdp_probe(struct platform_device
*pdev
)
386 struct resource
*resource
;
389 struct mdp_info
*mdp
;
391 resource
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
393 pr_err("mdp: can not get mdp mem resource!\n");
397 mdp
= kzalloc(sizeof(struct mdp_info
), GFP_KERNEL
);
401 mdp
->irq
= platform_get_irq(pdev
, 0);
403 pr_err("mdp: can not get mdp irq\n");
408 mdp
->base
= ioremap(resource
->start
, resource_size(resource
));
409 if (mdp
->base
== 0) {
410 printk(KERN_ERR
"msmfb: cannot allocate mdp regs!\n");
415 mdp
->mdp_dev
.dma
= mdp_dma
;
416 mdp
->mdp_dev
.dma_wait
= mdp_dma_wait
;
417 mdp
->mdp_dev
.blit
= mdp_blit
;
418 mdp
->mdp_dev
.set_grp_disp
= mdp_set_grp_disp
;
420 clk
= clk_get(&pdev
->dev
, "mdp_clk");
422 printk(KERN_INFO
"mdp: failed to get mdp clk");
427 ret
= request_irq(mdp
->irq
, mdp_isr
, 0, "msm_mdp", mdp
);
429 goto error_request_irq
;
430 disable_irq(mdp
->irq
);
433 /* debug interface write access */
434 mdp_writel(mdp
, 1, 0x60);
436 mdp_writel(mdp
, MDP_ANY_INTR_MASK
, MDP_INTR_ENABLE
);
437 mdp_writel(mdp
, 1, MDP_EBI2_PORTMAP_MODE
);
439 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01f8);
440 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01fc);
442 for (n
= 0; n
< ARRAY_SIZE(csc_table
); n
++)
443 mdp_writel(mdp
, csc_table
[n
].val
, csc_table
[n
].reg
);
445 /* clear up unused fg/main registers */
446 /* comp.plane 2&3 ystride */
447 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0120);
449 /* unpacked pattern */
450 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x012c);
451 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0130);
452 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0134);
453 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0158);
454 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x015c);
455 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0160);
456 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0170);
457 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0174);
458 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x017c);
460 /* comp.plane 2 & 3 */
461 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0114);
462 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x0118);
464 /* clear unused bg registers */
465 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01c8);
466 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01d0);
467 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01dc);
468 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01e0);
469 mdp_writel(mdp
, 0, MDP_CMD_DEBUG_ACCESS_BASE
+ 0x01e4);
471 for (n
= 0; n
< ARRAY_SIZE(mdp_upscale_table
); n
++)
472 mdp_writel(mdp
, mdp_upscale_table
[n
].val
,
473 mdp_upscale_table
[n
].reg
);
475 for (n
= 0; n
< 9; n
++)
476 mdp_writel(mdp
, mdp_default_ccs
[n
], 0x40440 + 4 * n
);
477 mdp_writel(mdp
, mdp_default_ccs
[9], 0x40500 + 4 * 0);
478 mdp_writel(mdp
, mdp_default_ccs
[10], 0x40500 + 4 * 0);
479 mdp_writel(mdp
, mdp_default_ccs
[11], 0x40500 + 4 * 0);
481 /* register mdp device */
482 mdp
->mdp_dev
.dev
.parent
= &pdev
->dev
;
483 mdp
->mdp_dev
.dev
.class = mdp_class
;
484 dev_set_name(&mdp
->mdp_dev
.dev
, "mdp%d", pdev
->id
);
486 /* if you can remove the platform device you'd have to implement
488 mdp_dev.release = mdp_class; */
490 ret
= device_register(&mdp
->mdp_dev
.dev
);
492 goto error_device_register
;
495 error_device_register
:
496 free_irq(mdp
->irq
, mdp
);
506 static struct platform_driver msm_mdp_driver
= {
508 .driver
= {.name
= "msm_mdp"},
511 static int __init
mdp_init(void)
513 mdp_class
= class_create(THIS_MODULE
, "msm_mdp");
514 if (IS_ERR(mdp_class
)) {
515 printk(KERN_ERR
"Error creating mdp class\n");
516 return PTR_ERR(mdp_class
);
518 return platform_driver_register(&msm_mdp_driver
);
521 subsys_initcall(mdp_init
);