/* drivers/video/msm/src/drv/mdp/mdp_ppp.c * * Copyright (C) 2007 Google Incorporated * Copyright (c) 2008-2010, Code Aurora Forum. All rights reserved. * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #include #include #include #include #include #include #include #include #include #include #include "linux/proc_fs.h" #include #include #include #include #include #include "mdp.h" #include "msm_fb.h" #define MDP_IS_IMGTYPE_BAD(x) (((x) >= MDP_IMGTYPE_LIMIT) && \ (((x) < MDP_IMGTYPE2_START) || \ ((x) >= MDP_IMGTYPE_LIMIT2))) static uint32_t bytes_per_pixel[] = { [MDP_RGB_565] = 2, [MDP_RGB_888] = 3, [MDP_XRGB_8888] = 4, [MDP_ARGB_8888] = 4, [MDP_RGBA_8888] = 4, [MDP_BGRA_8888] = 4, [MDP_Y_CBCR_H2V1] = 1, [MDP_Y_CBCR_H2V2] = 1, [MDP_Y_CRCB_H2V1] = 1, [MDP_Y_CRCB_H2V2] = 1, [MDP_YCRYCB_H2V1] = 2, [MDP_BGR_565] = 2 }; extern uint32 mdp_plv[]; extern struct semaphore mdp_ppp_mutex; uint32_t mdp_get_bytes_per_pixel(uint32_t format) { uint32_t bpp = 0; if (format < ARRAY_SIZE(bytes_per_pixel)) bpp = bytes_per_pixel[format]; BUG_ON(!bpp); return bpp; } static uint32 mdp_conv_matx_rgb2yuv(uint32 input_pixel, uint16 *matrix_and_bias_vector, uint32 *clamp_vector, uint32 *look_up_table) { uint8 input_C2, input_C0, input_C1; uint32 output; int32 comp_C2, comp_C1, comp_C0, temp; int32 temp1, temp2, temp3; int32 matrix[9]; int32 bias_vector[3]; int32 Y_low_limit, Y_high_limit, C_low_limit, C_high_limit; int32 i; uint32 _is_lookup_table_enabled; input_C2 = (input_pixel >> 16) & 0xFF; input_C1 = (input_pixel >> 8) & 0xFF; input_C0 = (input_pixel >> 0) & 0xFF; comp_C0 = input_C0; comp_C1 = input_C1; comp_C2 = input_C2; for (i = 0; i < 9; i++) matrix[i] = ((int32) (((int32) matrix_and_bias_vector[i]) << 20)) >> 20; bias_vector[0] = (int32) (matrix_and_bias_vector[9] & 0xFF); bias_vector[1] = (int32) (matrix_and_bias_vector[10] & 0xFF); bias_vector[2] = (int32) (matrix_and_bias_vector[11] & 0xFF); Y_low_limit = (int32) clamp_vector[0]; Y_high_limit = (int32) clamp_vector[1]; C_low_limit = (int32) clamp_vector[2]; C_high_limit = (int32) clamp_vector[3]; if (look_up_table == 0) /* check for NULL point */ _is_lookup_table_enabled = 0; else _is_lookup_table_enabled = 1; if (_is_lookup_table_enabled == 1) { comp_C2 = (look_up_table[comp_C2] >> 16) & 0xFF; comp_C1 = (look_up_table[comp_C1] >> 8) & 0xFF; comp_C0 = (look_up_table[comp_C0] >> 0) & 0xFF; } /* * Color Conversion * reorder input colors */ temp = comp_C2; comp_C2 = comp_C1; comp_C1 = comp_C0; comp_C0 = temp; /* matrix multiplication */ temp1 = comp_C0 * matrix[0] + comp_C1 * matrix[1] + comp_C2 * matrix[2]; temp2 = comp_C0 * matrix[3] + comp_C1 * matrix[4] + comp_C2 * matrix[5]; temp3 = comp_C0 * matrix[6] + comp_C1 * matrix[7] + comp_C2 * matrix[8]; comp_C0 = temp1 + 0x100; comp_C1 = temp2 + 0x100; comp_C2 = temp3 + 0x100; /* take interger part */ comp_C0 >>= 9; comp_C1 >>= 9; comp_C2 >>= 9; /* post bias (+) */ comp_C0 += bias_vector[0]; comp_C1 += bias_vector[1]; comp_C2 += bias_vector[2]; /* limit pixel to 8-bit */ if (comp_C0 < 0) comp_C0 = 0; if (comp_C0 > 255) comp_C0 = 255; if (comp_C1 < 0) comp_C1 = 0; if (comp_C1 > 255) comp_C1 = 255; if (comp_C2 < 0) comp_C2 = 0; if (comp_C2 > 255) comp_C2 = 255; /* clamp */ if (comp_C0 < Y_low_limit) comp_C0 = Y_low_limit; if (comp_C0 > Y_high_limit) comp_C0 = Y_high_limit; if (comp_C1 < C_low_limit) comp_C1 = C_low_limit; if (comp_C1 > C_high_limit) comp_C1 = C_high_limit; if (comp_C2 < C_low_limit) comp_C2 = C_low_limit; if (comp_C2 > C_high_limit) comp_C2 = C_high_limit; output = (comp_C2 << 16) | (comp_C1 << 8) | comp_C0; return output; } uint32 mdp_conv_matx_yuv2rgb(uint32 input_pixel, uint16 *matrix_and_bias_vector, uint32 *clamp_vector, uint32 *look_up_table) { uint8 input_C2, input_C0, input_C1; uint32 output; int32 comp_C2, comp_C1, comp_C0, temp; int32 temp1, temp2, temp3; int32 matrix[9]; int32 bias_vector[3]; int32 Y_low_limit, Y_high_limit, C_low_limit, C_high_limit; int32 i; uint32 _is_lookup_table_enabled; input_C2 = (input_pixel >> 16) & 0xFF; input_C1 = (input_pixel >> 8) & 0xFF; input_C0 = (input_pixel >> 0) & 0xFF; comp_C0 = input_C0; comp_C1 = input_C1; comp_C2 = input_C2; for (i = 0; i < 9; i++) matrix[i] = ((int32) (((int32) matrix_and_bias_vector[i]) << 20)) >> 20; bias_vector[0] = (int32) (matrix_and_bias_vector[9] & 0xFF); bias_vector[1] = (int32) (matrix_and_bias_vector[10] & 0xFF); bias_vector[2] = (int32) (matrix_and_bias_vector[11] & 0xFF); Y_low_limit = (int32) clamp_vector[0]; Y_high_limit = (int32) clamp_vector[1]; C_low_limit = (int32) clamp_vector[2]; C_high_limit = (int32) clamp_vector[3]; if (look_up_table == 0) /* check for NULL point */ _is_lookup_table_enabled = 0; else _is_lookup_table_enabled = 1; /* clamp */ if (comp_C0 < Y_low_limit) comp_C0 = Y_low_limit; if (comp_C0 > Y_high_limit) comp_C0 = Y_high_limit; if (comp_C1 < C_low_limit) comp_C1 = C_low_limit; if (comp_C1 > C_high_limit) comp_C1 = C_high_limit; if (comp_C2 < C_low_limit) comp_C2 = C_low_limit; if (comp_C2 > C_high_limit) comp_C2 = C_high_limit; /* * Color Conversion * pre bias (-) */ comp_C0 -= bias_vector[0]; comp_C1 -= bias_vector[1]; comp_C2 -= bias_vector[2]; /* matrix multiplication */ temp1 = comp_C0 * matrix[0] + comp_C1 * matrix[1] + comp_C2 * matrix[2]; temp2 = comp_C0 * matrix[3] + comp_C1 * matrix[4] + comp_C2 * matrix[5]; temp3 = comp_C0 * matrix[6] + comp_C1 * matrix[7] + comp_C2 * matrix[8]; comp_C0 = temp1 + 0x100; comp_C1 = temp2 + 0x100; comp_C2 = temp3 + 0x100; /* take interger part */ comp_C0 >>= 9; comp_C1 >>= 9; comp_C2 >>= 9; /* reorder output colors */ temp = comp_C0; comp_C0 = comp_C1; comp_C1 = comp_C2; comp_C2 = temp; /* limit pixel to 8-bit */ if (comp_C0 < 0) comp_C0 = 0; if (comp_C0 > 255) comp_C0 = 255; if (comp_C1 < 0) comp_C1 = 0; if (comp_C1 > 255) comp_C1 = 255; if (comp_C2 < 0) comp_C2 = 0; if (comp_C2 > 255) comp_C2 = 255; /* Look-up table */ if (_is_lookup_table_enabled == 1) { comp_C2 = (look_up_table[comp_C2] >> 16) & 0xFF; comp_C1 = (look_up_table[comp_C1] >> 8) & 0xFF; comp_C0 = (look_up_table[comp_C0] >> 0) & 0xFF; } output = (comp_C2 << 16) | (comp_C1 << 8) | comp_C0; return output; } static uint32 mdp_calc_tpval(MDPIMG *mdpImg) { uint32 tpVal; uint8 plane_tp; tpVal = 0; if ((mdpImg->imgType == MDP_RGB_565) || (mdpImg->imgType == MDP_BGR_565)) { /* * transparent color conversion into 24 bpp * * C2R_8BIT * left shift the entire bit and or it with the upper most bits */ plane_tp = (uint8) ((mdpImg->tpVal & 0xF800) >> 11); tpVal |= ((plane_tp << 3) | ((plane_tp & 0x1C) >> 2)) << 16; /* C1B_8BIT */ plane_tp = (uint8) (mdpImg->tpVal & 0x1F); tpVal |= ((plane_tp << 3) | ((plane_tp & 0x1C) >> 2)) << 8; /* C0G_8BIT */ plane_tp = (uint8) ((mdpImg->tpVal & 0x7E0) >> 5); tpVal |= ((plane_tp << 2) | ((plane_tp & 0x30) >> 4)); } else { /* 24bit RGB to RBG conversion */ tpVal = (mdpImg->tpVal & 0xFF00) >> 8; tpVal |= (mdpImg->tpVal & 0xFF) << 8; tpVal |= (mdpImg->tpVal & 0xFF0000); } return tpVal; } static uint8 *mdp_get_chroma_addr(MDPIBUF *iBuf) { uint8 *dest1; dest1 = NULL; switch (iBuf->ibuf_type) { case MDP_Y_CBCR_H2V2: case MDP_Y_CRCB_H2V2: case MDP_Y_CBCR_H2V1: case MDP_Y_CRCB_H2V1: dest1 = (uint8 *) iBuf->buf; dest1 += iBuf->ibuf_width * iBuf->ibuf_height * iBuf->bpp; break; default: break; } return dest1; } static void mdp_ppp_setbg(MDPIBUF *iBuf) { uint8 *bg0_addr; uint8 *bg1_addr; uint32 bg0_ystride, bg1_ystride; uint32 ppp_src_cfg_reg, unpack_pattern; int v_slice, h_slice; v_slice = h_slice = 1; bg0_addr = (uint8 *) iBuf->buf; bg1_addr = mdp_get_chroma_addr(iBuf); bg0_ystride = iBuf->ibuf_width * iBuf->bpp; bg1_ystride = iBuf->ibuf_width * iBuf->bpp; switch (iBuf->ibuf_type) { case MDP_BGR_565: case MDP_RGB_565: /* 888 = 3bytes * RGB = 3Components * RGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_5BITS | PPP_SRC_C0G_6BITS | PPP_SRC_C1B_5BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_3COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; if (iBuf->ibuf_type == MDP_RGB_565) unpack_pattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); else unpack_pattern = MDP_GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8); break; case MDP_RGB_888: /* * 888 = 3bytes * RGB = 3Components * RGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_BPP_INTERLVD_3BYTES | PPP_SRC_INTERLVD_3COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; unpack_pattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); break; case MDP_BGRA_8888: case MDP_RGBA_8888: case MDP_ARGB_8888: case MDP_XRGB_8888: /* * 8888 = 4bytes * ARGB = 4Components * ARGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_C3_ALPHA_EN | PPP_SRC_BPP_INTERLVD_4BYTES | PPP_SRC_INTERLVD_4COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; if (iBuf->ibuf_type == MDP_BGRA_8888) unpack_pattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); else if (iBuf->ibuf_type == MDP_RGBA_8888) unpack_pattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G, CLR_R, 8); else unpack_pattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); break; case MDP_Y_CBCR_H2V2: case MDP_Y_CRCB_H2V2: ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_2COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_PSEUDOPLNR; if (iBuf->ibuf_type == MDP_Y_CBCR_H2V1) unpack_pattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); else unpack_pattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); v_slice = h_slice = 2; break; case MDP_YCRYCB_H2V1: ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_4COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB; unpack_pattern = MDP_GET_PACK_PATTERN(CLR_Y, CLR_CR, CLR_Y, CLR_CB, 8); h_slice = 2; break; case MDP_Y_CBCR_H2V1: case MDP_Y_CRCB_H2V1: ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_2COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_PSEUDOPLNR; if (iBuf->ibuf_type == MDP_Y_CBCR_H2V1) unpack_pattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); else unpack_pattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); h_slice = 2; break; default: return; } /* starting input address adjustment */ mdp_adjust_start_addr(&bg0_addr, &bg1_addr, v_slice, h_slice, iBuf->roi.lcd_x, iBuf->roi.lcd_y, iBuf->ibuf_width, iBuf->ibuf_height, iBuf->bpp, iBuf, 1); /* * 0x01c0: background plane 0 addr * 0x01c4: background plane 1 addr * 0x01c8: background plane 2 addr * 0x01cc: bg y stride for plane 0 and 1 * 0x01d0: bg y stride for plane 2 * 0x01d4: bg src PPP config * 0x01d8: unpack pattern */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x01c0, bg0_addr); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x01c4, bg1_addr); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x01cc, (bg1_ystride << 16) | bg0_ystride); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x01d4, ppp_src_cfg_reg); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x01d8, unpack_pattern); } #define IS_PSEUDOPLNR(img) ((img == MDP_Y_CRCB_H2V2) | \ (img == MDP_Y_CBCR_H2V2) | \ (img == MDP_Y_CRCB_H2V1) | \ (img == MDP_Y_CBCR_H2V1)) #define IMG_LEN(rect_h, w, rect_w, bpp) (((rect_h) * w) * bpp) #define Y_TO_CRCB_RATIO(format) \ ((format == MDP_Y_CBCR_H2V2 || format == MDP_Y_CRCB_H2V2) ? 2 :\ (format == MDP_Y_CBCR_H2V1 || format == MDP_Y_CRCB_H2V1) ? 1 : 1) static void get_len(struct mdp_img *img, struct mdp_rect *rect, uint32_t bpp, uint32_t *len0, uint32_t *len1) { *len0 = IMG_LEN(rect->h, img->width, rect->w, bpp); if (IS_PSEUDOPLNR(img->format)) *len1 = *len0/Y_TO_CRCB_RATIO(img->format); else *len1 = 0; } static void flush_imgs(struct mdp_blit_req *req, int src_bpp, int dst_bpp, struct file *p_src_file, struct file *p_dst_file) { #ifdef CONFIG_ANDROID_PMEM uint32_t src0_len, src1_len, dst0_len, dst1_len; /* flush src images to memory before dma to mdp */ get_len(&req->src, &req->src_rect, src_bpp, &src0_len, &src1_len); flush_pmem_file(p_src_file, req->src.offset, src0_len); if (IS_PSEUDOPLNR(req->src.format)) flush_pmem_file(p_src_file, req->src.offset + src0_len, src1_len); get_len(&req->dst, &req->dst_rect, dst_bpp, &dst0_len, &dst1_len); flush_pmem_file(p_dst_file, req->dst.offset, dst0_len); if (IS_PSEUDOPLNR(req->dst.format)) flush_pmem_file(p_dst_file, req->dst.offset + dst0_len, dst1_len); #endif } static void mdp_start_ppp(struct msm_fb_data_type *mfd, MDPIBUF *iBuf, struct mdp_blit_req *req, struct file *p_src_file, struct file *p_dst_file) { uint8 *src0, *src1; uint8 *dest0, *dest1; uint16 inpBpp; uint32 dest0_ystride; uint32 src_width; uint32 src_height; uint32 src0_ystride; uint32 dst_roi_width; uint32 dst_roi_height; uint32 ppp_src_cfg_reg, ppp_operation_reg, ppp_dst_cfg_reg; uint32 alpha, tpVal; uint32 packPattern; uint32 dst_packPattern; boolean inputRGB, outputRGB, pseudoplanr_output; int sv_slice, sh_slice; int dv_slice, dh_slice; boolean perPixelAlpha = FALSE; boolean ppp_lookUp_enable = FALSE; sv_slice = sh_slice = dv_slice = dh_slice = 1; alpha = tpVal = 0; src_width = iBuf->mdpImg.width; src_height = iBuf->roi.y + iBuf->roi.height; src1 = NULL; dest1 = NULL; inputRGB = outputRGB = TRUE; pseudoplanr_output = FALSE; ppp_operation_reg = 0; ppp_dst_cfg_reg = 0; ppp_src_cfg_reg = 0; /* Wait for the pipe to clear */ do { } while (mdp_ppp_pipe_wait() <= 0); /* * destination config */ switch (iBuf->ibuf_type) { case MDP_RGB_888: dst_packPattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); ppp_dst_cfg_reg = PPP_DST_C0G_8BIT | PPP_DST_C1B_8BIT | PPP_DST_C2R_8BIT | PPP_DST_PACKET_CNT_INTERLVD_3ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_3BYTES | PPP_DST_PLANE_INTERLVD; break; case MDP_XRGB_8888: case MDP_ARGB_8888: case MDP_RGBA_8888: if (iBuf->ibuf_type == MDP_BGRA_8888) dst_packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); else if (iBuf->ibuf_type == MDP_RGBA_8888) dst_packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G, CLR_R, 8); else dst_packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); ppp_dst_cfg_reg = PPP_DST_C0G_8BIT | PPP_DST_C1B_8BIT | PPP_DST_C2R_8BIT | PPP_DST_C3A_8BIT | PPP_DST_C3ALPHA_EN | PPP_DST_PACKET_CNT_INTERLVD_4ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_4BYTES | PPP_DST_PLANE_INTERLVD; break; case MDP_Y_CBCR_H2V2: case MDP_Y_CRCB_H2V2: if (iBuf->ibuf_type == MDP_Y_CBCR_H2V2) dst_packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); else dst_packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); ppp_dst_cfg_reg = PPP_DST_C2R_8BIT | PPP_DST_C0G_8BIT | PPP_DST_C1B_8BIT | PPP_DST_C3A_8BIT | PPP_DST_PACKET_CNT_INTERLVD_2ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_2BYTES; ppp_operation_reg |= PPP_OP_DST_CHROMA_420; outputRGB = FALSE; pseudoplanr_output = TRUE; /* * vertically (y direction) and horizontally (x direction) * sample reduction by 2 */ /* * H2V2(YUV420) Cosite * * Y Y Y Y * CbCr CbCr * Y Y Y Y * Y Y Y Y * CbCr CbCr * Y Y Y Y */ dv_slice = dh_slice = 2; /* (x,y) and (width,height) must be even numbern */ iBuf->roi.lcd_x = (iBuf->roi.lcd_x / 2) * 2; iBuf->roi.dst_width = (iBuf->roi.dst_width / 2) * 2; iBuf->roi.x = (iBuf->roi.x / 2) * 2; iBuf->roi.width = (iBuf->roi.width / 2) * 2; iBuf->roi.lcd_y = (iBuf->roi.lcd_y / 2) * 2; iBuf->roi.dst_height = (iBuf->roi.dst_height / 2) * 2; iBuf->roi.y = (iBuf->roi.y / 2) * 2; iBuf->roi.height = (iBuf->roi.height / 2) * 2; break; case MDP_YCRYCB_H2V1: dst_packPattern = MDP_GET_PACK_PATTERN(CLR_Y, CLR_CR, CLR_Y, CLR_CB, 8); ppp_dst_cfg_reg = PPP_DST_C2R_8BIT | PPP_DST_C0G_8BIT | PPP_DST_C1B_8BIT | PPP_DST_C3A_8BIT | PPP_DST_PACKET_CNT_INTERLVD_4ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_2BYTES | PPP_DST_PLANE_INTERLVD; ppp_operation_reg |= PPP_OP_DST_CHROMA_H2V1; outputRGB = FALSE; /* * horizontally (x direction) sample reduction by 2 * * H2V1(YUV422) Cosite * * YCbCr Y YCbCr Y * YCbCr Y YCbCr Y * YCbCr Y YCbCr Y * YCbCr Y YCbCr Y */ dh_slice = 2; /* * if it's TV-Out/MDP_YCRYCB_H2V1, let's go through the * preloaded gamma setting of 2.2 when the content is * non-linear ppp_lookUp_enable = TRUE; */ /* x and width must be even number */ iBuf->roi.lcd_x = (iBuf->roi.lcd_x / 2) * 2; iBuf->roi.dst_width = (iBuf->roi.dst_width / 2) * 2; iBuf->roi.x = (iBuf->roi.x / 2) * 2; iBuf->roi.width = (iBuf->roi.width / 2) * 2; break; case MDP_Y_CBCR_H2V1: case MDP_Y_CRCB_H2V1: if (iBuf->ibuf_type == MDP_Y_CBCR_H2V1) dst_packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); else dst_packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); ppp_dst_cfg_reg = PPP_DST_C2R_8BIT | PPP_DST_C0G_8BIT | PPP_DST_C1B_8BIT | PPP_DST_C3A_8BIT | PPP_DST_PACKET_CNT_INTERLVD_2ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_2BYTES; ppp_operation_reg |= PPP_OP_DST_CHROMA_H2V1; outputRGB = FALSE; pseudoplanr_output = TRUE; /* horizontally (x direction) sample reduction by 2 */ dh_slice = 2; /* x and width must be even number */ iBuf->roi.lcd_x = (iBuf->roi.lcd_x / 2) * 2; iBuf->roi.dst_width = (iBuf->roi.dst_width / 2) * 2; iBuf->roi.x = (iBuf->roi.x / 2) * 2; iBuf->roi.width = (iBuf->roi.width / 2) * 2; break; case MDP_BGR_565: case MDP_RGB_565: default: if (iBuf->ibuf_type == MDP_RGB_565) dst_packPattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); else dst_packPattern = MDP_GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8); ppp_dst_cfg_reg = PPP_DST_C0G_6BIT | PPP_DST_C1B_5BIT | PPP_DST_C2R_5BIT | PPP_DST_PACKET_CNT_INTERLVD_3ELEM | PPP_DST_PACK_TIGHT | PPP_DST_PACK_ALIGN_LSB | PPP_DST_OUT_SEL_AXI | PPP_DST_BPP_2BYTES | PPP_DST_PLANE_INTERLVD; break; } /* source config */ switch (iBuf->mdpImg.imgType) { case MDP_RGB_888: inpBpp = 3; /* * 565 = 2bytes * RGB = 3Components * RGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_BPP_INTERLVD_3BYTES | PPP_SRC_INTERLVD_3COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; packPattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); ppp_operation_reg |= PPP_OP_COLOR_SPACE_RGB | PPP_OP_SRC_CHROMA_RGB | PPP_OP_DST_CHROMA_RGB; break; case MDP_BGRA_8888: case MDP_RGBA_8888: case MDP_ARGB_8888: perPixelAlpha = TRUE; case MDP_XRGB_8888: inpBpp = 4; /* * 8888 = 4bytes * ARGB = 4Components * ARGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_C3_ALPHA_EN | PPP_SRC_BPP_INTERLVD_4BYTES | PPP_SRC_INTERLVD_4COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; if (iBuf->mdpImg.imgType == MDP_BGRA_8888) packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); else if (iBuf->mdpImg.imgType == MDP_RGBA_8888) packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_B, CLR_G, CLR_R, 8); else packPattern = MDP_GET_PACK_PATTERN(CLR_ALPHA, CLR_R, CLR_G, CLR_B, 8); ppp_operation_reg |= PPP_OP_COLOR_SPACE_RGB | PPP_OP_SRC_CHROMA_RGB | PPP_OP_DST_CHROMA_RGB; break; case MDP_Y_CBCR_H2V2: case MDP_Y_CRCB_H2V2: inpBpp = 1; src1 = (uint8 *) iBuf->mdpImg.cbcr_addr; /* * CbCr = 2bytes * CbCr = 2Components * Y+CbCr */ ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_2COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_PSEUDOPLNR; if (iBuf->mdpImg.imgType == MDP_Y_CRCB_H2V2) packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); else packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); ppp_operation_reg |= PPP_OP_COLOR_SPACE_YCBCR | PPP_OP_SRC_CHROMA_420 | PPP_OP_SRC_CHROMA_COSITE | PPP_OP_DST_CHROMA_RGB | PPP_OP_DST_CHROMA_COSITE; inputRGB = FALSE; sh_slice = sv_slice = 2; break; case MDP_YCRYCB_H2V1: inpBpp = 2; ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_4COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB; packPattern = MDP_GET_PACK_PATTERN(CLR_Y, CLR_CR, CLR_Y, CLR_CB, 8); ppp_operation_reg |= PPP_OP_SRC_CHROMA_H2V1 | PPP_OP_SRC_CHROMA_COSITE | PPP_OP_DST_CHROMA_COSITE; /* * if it's TV-Out/MDP_YCRYCB_H2V1, let's go through the * preloaded inverse gamma setting of 2.2 since they're * symetric when the content is non-linear * ppp_lookUp_enable = TRUE; */ /* x and width must be even number */ iBuf->roi.lcd_x = (iBuf->roi.lcd_x / 2) * 2; iBuf->roi.dst_width = (iBuf->roi.dst_width / 2) * 2; iBuf->roi.x = (iBuf->roi.x / 2) * 2; iBuf->roi.width = (iBuf->roi.width / 2) * 2; inputRGB = FALSE; sh_slice = 2; break; case MDP_Y_CBCR_H2V1: case MDP_Y_CRCB_H2V1: inpBpp = 1; src1 = (uint8 *) iBuf->mdpImg.cbcr_addr; ppp_src_cfg_reg = PPP_SRC_C2R_8BITS | PPP_SRC_C0G_8BITS | PPP_SRC_C1B_8BITS | PPP_SRC_C3A_8BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_2COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_PSEUDOPLNR; if (iBuf->mdpImg.imgType == MDP_Y_CBCR_H2V1) packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CB, CLR_CR, 8); else packPattern = MDP_GET_PACK_PATTERN(0, 0, CLR_CR, CLR_CB, 8); ppp_operation_reg |= PPP_OP_SRC_CHROMA_H2V1 | PPP_OP_SRC_CHROMA_COSITE | PPP_OP_DST_CHROMA_COSITE; inputRGB = FALSE; sh_slice = 2; break; case MDP_BGR_565: case MDP_RGB_565: default: inpBpp = 2; /* * 565 = 2bytes * RGB = 3Components * RGB interleaved */ ppp_src_cfg_reg = PPP_SRC_C2R_5BITS | PPP_SRC_C0G_6BITS | PPP_SRC_C1B_5BITS | PPP_SRC_BPP_INTERLVD_2BYTES | PPP_SRC_INTERLVD_3COMPONENTS | PPP_SRC_UNPACK_TIGHT | PPP_SRC_UNPACK_ALIGN_LSB | PPP_SRC_FETCH_PLANES_INTERLVD; if (iBuf->mdpImg.imgType == MDP_RGB_565) packPattern = MDP_GET_PACK_PATTERN(0, CLR_R, CLR_G, CLR_B, 8); else packPattern = MDP_GET_PACK_PATTERN(0, CLR_B, CLR_G, CLR_R, 8); ppp_operation_reg |= PPP_OP_COLOR_SPACE_RGB | PPP_OP_SRC_CHROMA_RGB | PPP_OP_DST_CHROMA_RGB; break; } if (pseudoplanr_output) ppp_dst_cfg_reg |= PPP_DST_PLANE_PSEUDOPLN; /* YCbCr to RGB color conversion flag */ if ((!inputRGB) && (outputRGB)) { ppp_operation_reg |= PPP_OP_CONVERT_YCBCR2RGB | PPP_OP_CONVERT_ON; /* * primary/secondary is sort of misleading term...but * in mdp2.2/3.0 we only use primary matrix (forward/rev) * in mdp3.1 we use set1(prim) and set2(secd) */ #ifdef CONFIG_FB_MSM_MDP31 ppp_operation_reg |= PPP_OP_CONVERT_MATRIX_SECONDARY | PPP_OP_DST_RGB; MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0240, 0); #endif if (ppp_lookUp_enable) { ppp_operation_reg |= PPP_OP_LUT_C0_ON | PPP_OP_LUT_C1_ON | PPP_OP_LUT_C2_ON; } } /* RGB to YCbCr color conversion flag */ if ((inputRGB) && (!outputRGB)) { ppp_operation_reg |= PPP_OP_CONVERT_RGB2YCBCR | PPP_OP_CONVERT_ON; #ifdef CONFIG_FB_MSM_MDP31 ppp_operation_reg |= PPP_OP_CONVERT_MATRIX_PRIMARY | PPP_OP_DST_YCBCR; MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0240, 0x1e); #endif if (ppp_lookUp_enable) { ppp_operation_reg |= PPP_OP_LUT_C0_ON | PPP_OP_LUT_C1_ON | PPP_OP_LUT_C2_ON; } } /* YCbCr to YCbCr color conversion flag */ if ((!inputRGB) && (!outputRGB)) { if ((ppp_lookUp_enable) && (iBuf->mdpImg.imgType != iBuf->ibuf_type)) { ppp_operation_reg |= PPP_OP_LUT_C0_ON; } } ppp_src_cfg_reg |= (iBuf->roi.x % 2) ? PPP_SRC_BPP_ROI_ODD_X : 0; ppp_src_cfg_reg |= (iBuf->roi.y % 2) ? PPP_SRC_BPP_ROI_ODD_Y : 0; if (req->flags & MDP_DEINTERLACE) ppp_operation_reg |= PPP_OP_DEINT_EN; /* Dither at DMA side only since iBuf format is RGB888 */ if (iBuf->mdpImg.mdpOp & MDPOP_DITHER) ppp_operation_reg |= PPP_OP_DITHER_EN; if (iBuf->mdpImg.mdpOp & MDPOP_ROTATION) { ppp_operation_reg |= PPP_OP_ROT_ON; if (iBuf->mdpImg.mdpOp & MDPOP_ROT90) { ppp_operation_reg |= PPP_OP_ROT_90; } if (iBuf->mdpImg.mdpOp & MDPOP_LR) { ppp_operation_reg |= PPP_OP_FLIP_LR; } if (iBuf->mdpImg.mdpOp & MDPOP_UD) { ppp_operation_reg |= PPP_OP_FLIP_UD; } } src0_ystride = src_width * inpBpp; dest0_ystride = iBuf->ibuf_width * iBuf->bpp; /* no need to care about rotation since it's the real-XY. */ dst_roi_width = iBuf->roi.dst_width; dst_roi_height = iBuf->roi.dst_height; src0 = (uint8 *) iBuf->mdpImg.bmy_addr; dest0 = (uint8 *) iBuf->buf; /* Jumping from Y-Plane to Chroma Plane */ dest1 = mdp_get_chroma_addr(iBuf); /* first pixel addr calculation */ mdp_adjust_start_addr(&src0, &src1, sv_slice, sh_slice, iBuf->roi.x, iBuf->roi.y, src_width, src_height, inpBpp, iBuf, 0); mdp_adjust_start_addr(&dest0, &dest1, dv_slice, dh_slice, iBuf->roi.lcd_x, iBuf->roi.lcd_y, iBuf->ibuf_width, iBuf->ibuf_height, iBuf->bpp, iBuf, 2); /* set scale operation */ mdp_set_scale(iBuf, dst_roi_width, dst_roi_height, inputRGB, outputRGB, &ppp_operation_reg); /* * setting background source for blending */ mdp_set_blend_attr(iBuf, &alpha, &tpVal, perPixelAlpha, &ppp_operation_reg); if (ppp_operation_reg & PPP_OP_BLEND_ON) { mdp_ppp_setbg(iBuf); if (iBuf->ibuf_type == MDP_YCRYCB_H2V1) { ppp_operation_reg |= PPP_OP_BG_CHROMA_H2V1; if (iBuf->mdpImg.mdpOp & MDPOP_TRANSP) { tpVal = mdp_conv_matx_rgb2yuv(tpVal, (uint16 *) & mdp_ccs_rgb2yuv, &mdp_plv[0], NULL); } } } /* * 0x0004: enable dbg bus * 0x0100: "don't care" Edge Condit until scaling is on * 0x0104: xrc tile x&y size u7.6 format = 7bit.6bit * 0x0108: src pixel size * 0x010c: component plane 0 starting address * 0x011c: component plane 0 ystride * 0x0124: PPP source config register * 0x0128: unpacked pattern from lsb to msb (eg. RGB->BGR) */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0108, (iBuf->roi.height << 16 | iBuf->roi.width)); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x010c, src0); /* comp.plane 0 */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0110, src1); /* comp.plane 1 */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x011c, (src0_ystride << 16 | src0_ystride)); /* setup for rgb 565 */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0124, ppp_src_cfg_reg); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0128, packPattern); /* * 0x0138: PPP destination operation register * 0x014c: constant_alpha|transparent_color * 0x0150: PPP destination config register * 0x0154: PPP packing pattern */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0138, ppp_operation_reg); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x014c, alpha << 24 | tpVal); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0150, ppp_dst_cfg_reg); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0154, dst_packPattern); /* * 0x0164: ROI height and width * 0x0168: Component Plane 0 starting addr * 0x016c: Component Plane 1 starting addr * 0x0178: Component Plane 1/0 y stride */ MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0164, (dst_roi_height << 16 | dst_roi_width)); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0168, dest0); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x016c, dest1); MDP_OUTP(MDP_CMD_DEBUG_ACCESS_BASE + 0x0178, (dest0_ystride << 16 | dest0_ystride)); flush_imgs(req, inpBpp, iBuf->bpp, p_src_file, p_dst_file); #ifdef CONFIG_MDP_PPP_ASYNC_OP mdp_ppp_process_curr_djob(); #else mdp_pipe_kickoff(MDP_PPP_TERM, mfd); #endif } static int mdp_ppp_verify_req(struct mdp_blit_req *req) { u32 src_width, src_height, dst_width, dst_height; if (req == NULL) return -1; if (MDP_IS_IMGTYPE_BAD(req->src.format) || MDP_IS_IMGTYPE_BAD(req->dst.format)) return -1; if ((req->src.width == 0) || (req->src.height == 0) || (req->src_rect.w == 0) || (req->src_rect.h == 0) || (req->dst.width == 0) || (req->dst.height == 0) || (req->dst_rect.w == 0) || (req->dst_rect.h == 0)) return -1; if (((req->src_rect.x + req->src_rect.w) > req->src.width) || ((req->src_rect.y + req->src_rect.h) > req->src.height)) return -1; if (((req->dst_rect.x + req->dst_rect.w) > req->dst.width) || ((req->dst_rect.y + req->dst_rect.h) > req->dst.height)) return -1; /* * scaling range check */ src_width = req->src_rect.w; src_height = req->src_rect.h; if (req->flags & MDP_ROT_90) { dst_width = req->dst_rect.h; dst_height = req->dst_rect.w; } else { dst_width = req->dst_rect.w; dst_height = req->dst_rect.h; } switch (req->dst.format) { case MDP_Y_CRCB_H2V2: case MDP_Y_CBCR_H2V2: src_width = (src_width / 2) * 2; src_height = (src_height / 2) * 2; dst_width = (src_width / 2) * 2; dst_height = (src_height / 2) * 2; break; case MDP_Y_CRCB_H2V1: case MDP_Y_CBCR_H2V1: case MDP_YCRYCB_H2V1: src_width = (src_width / 2) * 2; dst_width = (src_width / 2) * 2; break; default: break; } if (((MDP_SCALE_Q_FACTOR * dst_width) / src_width > MDP_MAX_X_SCALE_FACTOR) || ((MDP_SCALE_Q_FACTOR * dst_width) / src_width < MDP_MIN_X_SCALE_FACTOR)) return -1; if (((MDP_SCALE_Q_FACTOR * dst_height) / src_height > MDP_MAX_Y_SCALE_FACTOR) || ((MDP_SCALE_Q_FACTOR * dst_height) / src_height < MDP_MIN_Y_SCALE_FACTOR)) return -1; return 0; } /** * get_gem_img() - retrieve drm obj's start address and size * @img: contains drm file descriptor and gem handle * @start: repository of starting address of drm obj allocated memory * @len: repository of size of drm obj alloacted memory * **/ int get_gem_img(struct mdp_img *img, unsigned long *start, unsigned long *len) { panic("waaaaaaaah"); //return kgsl_gem_obj_addr(img->memory_id, (int)img->priv, start, len); } int get_img(struct mdp_img *img, struct fb_info *info, unsigned long *start, unsigned long *len, struct file **pp_file) { int put_needed, ret = 0; struct file *file; unsigned long vstart; #ifdef CONFIG_ANDROID_PMEM if (!get_pmem_file(img->memory_id, start, &vstart, len, pp_file)) return 0; #endif file = fget_light(img->memory_id, &put_needed); if (file == NULL) return -1; if (MAJOR(file->f_dentry->d_inode->i_rdev) == FB_MAJOR) { *start = info->fix.smem_start; *len = info->fix.smem_len; *pp_file = file; } else { ret = -1; fput_light(file, put_needed); } return ret; } int mdp_ppp_blit(struct fb_info *info, struct mdp_blit_req *req, struct file **pp_src_file, struct file **pp_dst_file) { unsigned long src_start, dst_start; unsigned long src_len = 0; unsigned long dst_len = 0; MDPIBUF iBuf; u32 dst_width, dst_height; struct file *p_src_file = 0 , *p_dst_file = 0; struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par; if (req->dst.format == MDP_FB_FORMAT) req->dst.format = mfd->fb_imgType; if (req->src.format == MDP_FB_FORMAT) req->src.format = mfd->fb_imgType; if (req->flags & MDP_BLIT_SRC_GEM) { if (get_gem_img(&req->src, &src_start, &src_len) < 0) return -1; } else { get_img(&req->src, info, &src_start, &src_len, &p_src_file); } if (src_len == 0) { printk(KERN_ERR "mdp_ppp: could not retrieve image from " "memory\n"); return -1; } if (req->flags & MDP_BLIT_DST_GEM) { if (get_gem_img(&req->dst, &dst_start, &dst_len) < 0) return -1; } else { get_img(&req->dst, info, &dst_start, &dst_len, &p_dst_file); } if (dst_len == 0) { printk(KERN_ERR "mdp_ppp: could not retrieve image from " "memory\n"); return -1; } *pp_src_file = p_src_file; *pp_dst_file = p_dst_file; if (mdp_ppp_verify_req(req)) { printk(KERN_ERR "mdp_ppp: invalid image!\n"); return -1; } iBuf.ibuf_width = req->dst.width; iBuf.ibuf_height = req->dst.height; iBuf.bpp = bytes_per_pixel[req->dst.format]; iBuf.ibuf_type = req->dst.format; iBuf.buf = (uint8 *) dst_start; iBuf.buf += req->dst.offset; iBuf.roi.lcd_x = req->dst_rect.x; iBuf.roi.lcd_y = req->dst_rect.y; iBuf.roi.dst_width = req->dst_rect.w; iBuf.roi.dst_height = req->dst_rect.h; iBuf.roi.x = req->src_rect.x; iBuf.roi.width = req->src_rect.w; iBuf.roi.y = req->src_rect.y; iBuf.roi.height = req->src_rect.h; iBuf.mdpImg.width = req->src.width; iBuf.mdpImg.imgType = req->src.format; iBuf.mdpImg.bmy_addr = (uint32 *) (src_start + req->src.offset); iBuf.mdpImg.cbcr_addr = (uint32 *) ((uint32) iBuf.mdpImg.bmy_addr + req->src.width * req->src.height); iBuf.mdpImg.mdpOp = MDPOP_NOP; /* blending check */ if (req->transp_mask != MDP_TRANSP_NOP) { iBuf.mdpImg.mdpOp |= MDPOP_TRANSP; iBuf.mdpImg.tpVal = req->transp_mask; iBuf.mdpImg.tpVal = mdp_calc_tpval(&iBuf.mdpImg); } req->alpha &= 0xff; if (req->alpha < MDP_ALPHA_NOP) { iBuf.mdpImg.mdpOp |= MDPOP_ALPHAB; iBuf.mdpImg.alpha = req->alpha; } /* rotation check */ if (req->flags & MDP_FLIP_LR) iBuf.mdpImg.mdpOp |= MDPOP_LR; if (req->flags & MDP_FLIP_UD) iBuf.mdpImg.mdpOp |= MDPOP_UD; if (req->flags & MDP_ROT_90) iBuf.mdpImg.mdpOp |= MDPOP_ROT90; if (req->flags & MDP_DITHER) iBuf.mdpImg.mdpOp |= MDPOP_DITHER; if (req->flags & MDP_BLEND_FG_PREMULT) { #ifdef CONFIG_FB_MSM_MDP31 iBuf.mdpImg.mdpOp |= MDPOP_FG_PM_ALPHA; #else return -EINVAL; #endif } if (req->flags & MDP_DEINTERLACE) { #ifdef CONFIG_FB_MSM_MDP31 if ((req->src.format != MDP_Y_CBCR_H2V2) && (req->src.format != MDP_Y_CRCB_H2V2)) #endif return -EINVAL; } /* scale check */ if (req->flags & MDP_ROT_90) { dst_width = req->dst_rect.h; dst_height = req->dst_rect.w; } else { dst_width = req->dst_rect.w; dst_height = req->dst_rect.h; } if ((iBuf.roi.width != dst_width) || (iBuf.roi.height != dst_height)) iBuf.mdpImg.mdpOp |= MDPOP_ASCALE; if (req->flags & MDP_BLUR) { #ifdef CONFIG_FB_MSM_MDP31 if (req->flags & MDP_SHARPENING) printk(KERN_WARNING "mdp: MDP_SHARPENING is set with MDP_BLUR!\n"); req->flags |= MDP_SHARPENING; req->sharpening_strength = -127; #else iBuf.mdpImg.mdpOp |= MDPOP_ASCALE | MDPOP_BLUR; #endif } if (req->flags & MDP_SHARPENING) { #ifdef CONFIG_FB_MSM_MDP31 if ((req->sharpening_strength > 127) || (req->sharpening_strength < -127)) { printk(KERN_ERR "%s: sharpening strength out of range\n", __func__); return -EINVAL; } iBuf.mdpImg.mdpOp |= MDPOP_ASCALE | MDPOP_SHARPENING; iBuf.mdpImg.sp_value = req->sharpening_strength & 0xff; #else return -EINVAL; #endif } down(&mdp_ppp_mutex); /* MDP cmd block enable */ mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_ON, FALSE); #ifdef CONFIG_FB_MSM_MDP31 mdp_start_ppp(mfd, &iBuf, req, p_src_file, p_dst_file); #else /* bg tile fetching HW workaround */ if (((iBuf.mdpImg.mdpOp & (MDPOP_TRANSP | MDPOP_ALPHAB)) || (req->src.format == MDP_ARGB_8888) || (req->src.format == MDP_BGRA_8888) || (req->src.format == MDP_RGBA_8888)) && (iBuf.mdpImg.mdpOp & MDPOP_ROT90) && (req->dst_rect.w <= 16)) { int dst_h, src_w, i; src_w = req->src_rect.w; dst_h = iBuf.roi.dst_height; for (i = 0; i < (req->dst_rect.h / 16); i++) { /* this tile size */ iBuf.roi.dst_height = 16; iBuf.roi.width = (16 * req->src_rect.w) / req->dst_rect.h; /* if it's out of scale range... */ if (((MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / iBuf.roi.width) > MDP_MAX_X_SCALE_FACTOR) iBuf.roi.width = (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / MDP_MAX_X_SCALE_FACTOR; else if (((MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / iBuf.roi.width) < MDP_MIN_X_SCALE_FACTOR) iBuf.roi.width = (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / MDP_MIN_X_SCALE_FACTOR; mdp_start_ppp(mfd, &iBuf, req, p_src_file, p_dst_file); /* next tile location */ iBuf.roi.lcd_y += 16; iBuf.roi.x += iBuf.roi.width; /* this is for a remainder update */ dst_h -= 16; src_w -= iBuf.roi.width; } if ((dst_h < 0) || (src_w < 0)) printk ("msm_fb: mdp_blt_ex() unexpected result! line:%d\n", __LINE__); /* remainder update */ if ((dst_h > 0) && (src_w > 0)) { u32 tmp_v; iBuf.roi.dst_height = dst_h; iBuf.roi.width = src_w; if (((MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / iBuf.roi.width) > MDP_MAX_X_SCALE_FACTOR) { tmp_v = (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / MDP_MAX_X_SCALE_FACTOR + (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) % MDP_MAX_X_SCALE_FACTOR ? 1 : 0; /* move x location as roi width gets bigger */ iBuf.roi.x -= tmp_v - iBuf.roi.width; iBuf.roi.width = tmp_v; } else if (((MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / iBuf.roi.width) < MDP_MIN_X_SCALE_FACTOR) { tmp_v = (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) / MDP_MIN_X_SCALE_FACTOR + (MDP_SCALE_Q_FACTOR * iBuf.roi.dst_height) % MDP_MIN_X_SCALE_FACTOR ? 1 : 0; /* * we don't move x location for continuity of * source image */ iBuf.roi.width = tmp_v; } mdp_start_ppp(mfd, &iBuf, req, p_src_file, p_dst_file); } } else { mdp_start_ppp(mfd, &iBuf, req, p_src_file, p_dst_file); } #endif /* MDP cmd block disable */ mdp_pipe_ctrl(MDP_CMD_BLOCK, MDP_BLOCK_POWER_OFF, FALSE); up(&mdp_ppp_mutex); return 0; }