blob: 02f0c7e2048b9feed04a661e5c9d6bfdf0462dcb [file] [log] [blame]
Naseer Ahmed29a26812012-06-14 00:56:20 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +05303 * Copyright (c) 2010 - 2014, The Linux Foundation. All rights reserved.
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -08004 *
5 * Not a Contribution, Apache license notifications and license are retained
6 * for attribution purposes only.
Naseer Ahmed29a26812012-06-14 00:56:20 -07007 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
Naseer Ahmed29a26812012-06-14 00:56:20 -070021#include <cutils/log.h>
22
23#include <linux/msm_mdp.h>
24#include <linux/fb.h>
25
26#include <stdint.h>
27#include <string.h>
28#include <unistd.h>
29#include <errno.h>
30#include <fcntl.h>
31
32#include <sys/ioctl.h>
33#include <sys/types.h>
34#include <sys/mman.h>
35
36#include <copybit.h>
37
38#include "gralloc_priv.h"
39#include "software_converter.h"
Sushil Chauhan0265c472014-10-01 16:39:02 -070040#include <qdMetaData.h>
Naseer Ahmed29a26812012-06-14 00:56:20 -070041
42#define DEBUG_MDP_ERRORS 1
43
44/******************************************************************************/
45
Naseer Ahmed29a26812012-06-14 00:56:20 -070046#define MAX_SCALE_FACTOR (4)
47#define MAX_DIMENSION (4096)
Naseer Ahmed29a26812012-06-14 00:56:20 -070048
49/******************************************************************************/
Terence Hampsonadf47302013-05-23 12:21:02 -040050struct blitReq{
51 struct mdp_buf_sync sync;
52 uint32_t count;
53 struct mdp_blit_req req[10];
54};
Naseer Ahmed29a26812012-06-14 00:56:20 -070055
56/** State information for each device instance */
57struct copybit_context_t {
58 struct copybit_device_t device;
59 int mFD;
60 uint8_t mAlpha;
61 int mFlags;
Naseer Ahmed31da0b12012-07-31 18:55:33 -070062 bool mBlitToFB;
Terence Hampsonadf47302013-05-23 12:21:02 -040063 int acqFence[MDP_MAX_FENCE_FD];
64 int relFence;
65 struct mdp_buf_sync sync;
66 struct blitReq list;
Ramakant Singh140965d2015-01-08 23:45:04 +053067 uint8_t dynamic_fps;
Naseer Ahmed29a26812012-06-14 00:56:20 -070068};
69
70/**
71 * Common hardware methods
72 */
73
74static int open_copybit(const struct hw_module_t* module, const char* name,
75 struct hw_device_t** device);
76
77static struct hw_module_methods_t copybit_module_methods = {
78open: open_copybit
79};
80
81/*
82 * The COPYBIT Module
83 */
84struct copybit_module_t HAL_MODULE_INFO_SYM = {
85common: {
86tag: HARDWARE_MODULE_TAG,
87 version_major: 1,
88 version_minor: 0,
89 id: COPYBIT_HARDWARE_MODULE_ID,
90 name: "QCT MSM7K COPYBIT Module",
91 author: "Google, Inc.",
92 methods: &copybit_module_methods
93 }
94};
95
96/******************************************************************************/
97
98/** min of int a, b */
99static inline int min(int a, int b) {
100 return (a<b) ? a : b;
101}
102
103/** max of int a, b */
104static inline int max(int a, int b) {
105 return (a>b) ? a : b;
106}
107
108/** scale each parameter by mul/div. Assume div isn't 0 */
109static inline void MULDIV(uint32_t *a, uint32_t *b, int mul, int div) {
110 if (mul != div) {
111 *a = (mul * *a) / div;
112 *b = (mul * *b) / div;
113 }
114}
115
116/** Determine the intersection of lhs & rhs store in out */
117static void intersect(struct copybit_rect_t *out,
118 const struct copybit_rect_t *lhs,
119 const struct copybit_rect_t *rhs) {
120 out->l = max(lhs->l, rhs->l);
121 out->t = max(lhs->t, rhs->t);
122 out->r = min(lhs->r, rhs->r);
123 out->b = min(lhs->b, rhs->b);
124}
125
Ramakant Singh17fabdb2014-12-15 12:28:01 +0530126static bool validateCopybitRect(struct copybit_rect_t *rect) {
127 return ((rect->b > rect->t) && (rect->r > rect->l)) ;
128}
129
Naseer Ahmed29a26812012-06-14 00:56:20 -0700130/** convert COPYBIT_FORMAT to MDP format */
131static int get_format(int format) {
132 switch (format) {
133 case HAL_PIXEL_FORMAT_RGB_565: return MDP_RGB_565;
Ramkumar Radhakrishnanb8eb16d2014-10-09 13:54:07 -0700134 case HAL_PIXEL_FORMAT_RGBA_5551: return MDP_RGBA_5551;
135 case HAL_PIXEL_FORMAT_RGBA_4444: return MDP_RGBA_4444;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700136 case HAL_PIXEL_FORMAT_RGBX_8888: return MDP_RGBX_8888;
Sushil Chauhan1f6d68f2013-10-11 11:49:35 -0700137 case HAL_PIXEL_FORMAT_BGRX_8888: return MDP_BGRX_8888;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700138 case HAL_PIXEL_FORMAT_RGB_888: return MDP_RGB_888;
139 case HAL_PIXEL_FORMAT_RGBA_8888: return MDP_RGBA_8888;
140 case HAL_PIXEL_FORMAT_BGRA_8888: return MDP_BGRA_8888;
Ramkumar Radhakrishnanb52399c2013-08-06 20:17:29 -0700141 case HAL_PIXEL_FORMAT_YCrCb_422_I: return MDP_YCRYCB_H2V1;
142 case HAL_PIXEL_FORMAT_YCbCr_422_I: return MDP_YCBYCR_H2V1;
Raj kamale77f4ec2013-07-03 23:57:50 +0530143 case HAL_PIXEL_FORMAT_YCrCb_422_SP: return MDP_Y_CRCB_H2V1;
144 case HAL_PIXEL_FORMAT_YCrCb_420_SP: return MDP_Y_CRCB_H2V2;
145 case HAL_PIXEL_FORMAT_YCbCr_422_SP: return MDP_Y_CBCR_H2V1;
146 case HAL_PIXEL_FORMAT_YCbCr_420_SP: return MDP_Y_CBCR_H2V2;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700147 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO: return MDP_Y_CBCR_H2V2_ADRENO;
Radhika Ranjan Soni21175f92013-07-12 17:32:15 +0530148 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: return MDP_Y_CBCR_H2V2_VENUS;
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800149 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: return MDP_Y_CBCR_H2V2;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700150 }
151 return -1;
152}
153
154/** convert from copybit image to mdp image structure */
155static void set_image(struct mdp_img *img, const struct copybit_image_t *rhs)
156{
157 private_handle_t* hnd = (private_handle_t*)rhs->handle;
158 if(hnd == NULL){
159 ALOGE("copybit: Invalid handle");
160 return;
161 }
162 img->width = rhs->w;
163 img->height = rhs->h;
164 img->format = get_format(rhs->format);
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530165 img->offset = (uint32_t)hnd->offset;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700166 img->memory_id = hnd->fd;
167}
168/** setup rectangles */
Ramakant Singh17fabdb2014-12-15 12:28:01 +0530169static bool set_rects(struct copybit_context_t *dev,
Naseer Ahmed29a26812012-06-14 00:56:20 -0700170 struct mdp_blit_req *e,
171 const struct copybit_rect_t *dst,
172 const struct copybit_rect_t *src,
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530173 const struct copybit_rect_t *scissor) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700174 struct copybit_rect_t clip;
175 intersect(&clip, scissor, dst);
176
Ramakant Singh17fabdb2014-12-15 12:28:01 +0530177 if (!validateCopybitRect(&clip))
178 return false;
179
Naseer Ahmed29a26812012-06-14 00:56:20 -0700180 e->dst_rect.x = clip.l;
181 e->dst_rect.y = clip.t;
182 e->dst_rect.w = clip.r - clip.l;
183 e->dst_rect.h = clip.b - clip.t;
184
185 uint32_t W, H, delta_x, delta_y;
186 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
187 delta_x = (clip.t - dst->t);
188 delta_y = (dst->r - clip.r);
189 e->src_rect.w = (clip.b - clip.t);
190 e->src_rect.h = (clip.r - clip.l);
191 W = dst->b - dst->t;
192 H = dst->r - dst->l;
193 } else {
194 delta_x = (clip.l - dst->l);
195 delta_y = (clip.t - dst->t);
196 e->src_rect.w = (clip.r - clip.l);
197 e->src_rect.h = (clip.b - clip.t);
198 W = dst->r - dst->l;
199 H = dst->b - dst->t;
200 }
201
202 MULDIV(&delta_x, &e->src_rect.w, src->r - src->l, W);
203 MULDIV(&delta_y, &e->src_rect.h, src->b - src->t, H);
204
205 e->src_rect.x = delta_x + src->l;
206 e->src_rect.y = delta_y + src->t;
207
208 if (dev->mFlags & COPYBIT_TRANSFORM_FLIP_V) {
209 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
210 e->src_rect.x = (src->l + src->r) - (e->src_rect.x + e->src_rect.w);
211 }else{
212 e->src_rect.y = (src->t + src->b) - (e->src_rect.y + e->src_rect.h);
213 }
214 }
215
216 if (dev->mFlags & COPYBIT_TRANSFORM_FLIP_H) {
217 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
218 e->src_rect.y = (src->t + src->b) - (e->src_rect.y + e->src_rect.h);
219 }else{
220 e->src_rect.x = (src->l + src->r) - (e->src_rect.x + e->src_rect.w);
221 }
222 }
Ramakant Singh17fabdb2014-12-15 12:28:01 +0530223 return true;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700224}
225
226/** setup mdp request */
227static void set_infos(struct copybit_context_t *dev,
228 struct mdp_blit_req *req, int flags)
229{
230 req->alpha = dev->mAlpha;
Ramakant Singh140965d2015-01-08 23:45:04 +0530231 req->fps = dev->dynamic_fps;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700232 req->transp_mask = MDP_TRANSP_NOP;
233 req->flags = dev->mFlags | flags;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700234 // check if we are blitting to f/b
235 if (COPYBIT_ENABLE == dev->mBlitToFB) {
236 req->flags |= MDP_MEMORY_ID_TYPE_FB;
237 }
Naseer Ahmed29a26812012-06-14 00:56:20 -0700238#if defined(COPYBIT_QSD8K)
239 req->flags |= MDP_BLEND_FG_PREMULT;
240#endif
241}
242
243/** copy the bits */
244static int msm_copybit(struct copybit_context_t *dev, void const *list)
245{
Terence Hampsonb6e4b1e2013-09-13 17:17:11 -0400246 int err;
247 if (dev->relFence != -1) {
248 close(dev->relFence);
249 dev->relFence = -1;
250 }
251 err = ioctl(dev->mFD, MSMFB_ASYNC_BLIT,
Terence Hampsonadf47302013-05-23 12:21:02 -0400252 (struct mdp_async_blit_req_list const*)list);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700253 ALOGE_IF(err<0, "copyBits failed (%s)", strerror(errno));
254 if (err == 0) {
255 return 0;
256 } else {
257#if DEBUG_MDP_ERRORS
Terence Hampsonadf47302013-05-23 12:21:02 -0400258 struct mdp_async_blit_req_list const* l =
259 (struct mdp_async_blit_req_list const*)list;
Naseer Ahmedb16edac2012-07-15 23:56:21 -0700260 for (unsigned int i=0 ; i<l->count ; i++) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700261 ALOGE("%d: src={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
262 " dst={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
Ramakant Singh140965d2015-01-08 23:45:04 +0530263 " flags=%08x, fps=%d"
Naseer Ahmed29a26812012-06-14 00:56:20 -0700264 ,
265 i,
266 l->req[i].src.width,
267 l->req[i].src.height,
268 l->req[i].src.format,
269 l->req[i].src_rect.x,
270 l->req[i].src_rect.y,
271 l->req[i].src_rect.w,
272 l->req[i].src_rect.h,
273 l->req[i].dst.width,
274 l->req[i].dst.height,
275 l->req[i].dst.format,
276 l->req[i].dst_rect.x,
277 l->req[i].dst_rect.y,
278 l->req[i].dst_rect.w,
279 l->req[i].dst_rect.h,
Ramakant Singh140965d2015-01-08 23:45:04 +0530280 l->req[i].flags,
281 l->req[i].fps
Naseer Ahmed29a26812012-06-14 00:56:20 -0700282 );
283 }
284#endif
285 return -errno;
286 }
287}
288
289/*****************************************************************************/
290
291/** Set a parameter to value */
292static int set_parameter_copybit(
293 struct copybit_device_t *dev,
294 int name,
295 int value)
296{
297 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
298 int status = 0;
299 if (ctx) {
300 switch(name) {
301 case COPYBIT_ROTATION_DEG:
302 switch (value) {
303 case 0:
304 ctx->mFlags &= ~0x7;
305 break;
306 case 90:
307 ctx->mFlags &= ~0x7;
308 ctx->mFlags |= MDP_ROT_90;
309 break;
310 case 180:
311 ctx->mFlags &= ~0x7;
312 ctx->mFlags |= MDP_ROT_180;
313 break;
314 case 270:
315 ctx->mFlags &= ~0x7;
316 ctx->mFlags |= MDP_ROT_270;
317 break;
318 default:
319 ALOGE("Invalid value for COPYBIT_ROTATION_DEG");
320 status = -EINVAL;
321 break;
322 }
323 break;
324 case COPYBIT_PLANE_ALPHA:
325 if (value < 0) value = MDP_ALPHA_NOP;
326 if (value >= 256) value = 255;
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530327 ctx->mAlpha = (uint8_t)value;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700328 break;
Ramakant Singh140965d2015-01-08 23:45:04 +0530329 case COPYBIT_DYNAMIC_FPS:
330 ctx->dynamic_fps = (uint8_t)value;
331 break;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700332 case COPYBIT_DITHER:
333 if (value == COPYBIT_ENABLE) {
334 ctx->mFlags |= MDP_DITHER;
335 } else if (value == COPYBIT_DISABLE) {
336 ctx->mFlags &= ~MDP_DITHER;
337 }
338 break;
339 case COPYBIT_BLUR:
340 if (value == COPYBIT_ENABLE) {
341 ctx->mFlags |= MDP_BLUR;
342 } else if (value == COPYBIT_DISABLE) {
343 ctx->mFlags &= ~MDP_BLUR;
344 }
345 break;
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800346 case COPYBIT_BLEND_MODE:
347 if(value == COPYBIT_BLENDING_PREMULT) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700348 ctx->mFlags |= MDP_BLEND_FG_PREMULT;
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800349 } else {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700350 ctx->mFlags &= ~MDP_BLEND_FG_PREMULT;
351 }
352 break;
353 case COPYBIT_TRANSFORM:
354 ctx->mFlags &= ~0x7;
355 ctx->mFlags |= value & 0x7;
356 break;
Naseer Ahmed31da0b12012-07-31 18:55:33 -0700357 case COPYBIT_BLIT_TO_FRAMEBUFFER:
358 if (COPYBIT_ENABLE == value) {
359 ctx->mBlitToFB = value;
360 } else if (COPYBIT_DISABLE == value) {
361 ctx->mBlitToFB = value;
362 } else {
363 ALOGE ("%s:Invalid input for COPYBIT_BLIT_TO_FRAMEBUFFER : %d",
364 __FUNCTION__, value);
365 }
366 break;
Shivaraj Shettye86506a2013-08-06 12:56:30 +0530367 case COPYBIT_FG_LAYER:
368 if(value == COPYBIT_ENABLE) {
369 ctx->mFlags |= MDP_IS_FG;
370 } else if (value == COPYBIT_DISABLE) {
371 ctx->mFlags &= ~MDP_IS_FG;
372 }
373 break ;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700374 default:
375 status = -EINVAL;
376 break;
377 }
378 } else {
379 status = -EINVAL;
380 }
381 return status;
382}
383
384/** Get a static info value */
385static int get(struct copybit_device_t *dev, int name)
386{
387 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
388 int value;
389 if (ctx) {
390 switch(name) {
391 case COPYBIT_MINIFICATION_LIMIT:
392 value = MAX_SCALE_FACTOR;
393 break;
394 case COPYBIT_MAGNIFICATION_LIMIT:
395 value = MAX_SCALE_FACTOR;
396 break;
397 case COPYBIT_SCALING_FRAC_BITS:
398 value = 32;
399 break;
400 case COPYBIT_ROTATION_STEP_DEG:
401 value = 90;
402 break;
403 default:
404 value = -EINVAL;
405 }
406 } else {
407 value = -EINVAL;
408 }
409 return value;
410}
411
Terence Hampsonadf47302013-05-23 12:21:02 -0400412static int set_sync_copybit(struct copybit_device_t *dev,
413 int acquireFenceFd)
414{
415 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
416 if (acquireFenceFd != -1) {
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400417 if (ctx->list.sync.acq_fen_fd_cnt < (MDP_MAX_FENCE_FD - 1)) {
418 ctx->acqFence[ctx->list.sync.acq_fen_fd_cnt++] = acquireFenceFd;
Terence Hampsonadf47302013-05-23 12:21:02 -0400419 } else {
420 int ret = -EINVAL;
421 struct blitReq *list = &ctx->list;
422
423 // Since fence is full kick off what is already in the list
424 ret = msm_copybit(ctx, list);
425 if (ret < 0) {
426 ALOGE("%s: Blit call failed", __FUNCTION__);
427 return -EINVAL;
428 }
429 list->count = 0;
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400430 list->sync.acq_fen_fd_cnt = 0;
431 ctx->acqFence[list->sync.acq_fen_fd_cnt++] = acquireFenceFd;
Terence Hampsonadf47302013-05-23 12:21:02 -0400432 }
433 }
434 return 0;
435}
436
Naseer Ahmed29a26812012-06-14 00:56:20 -0700437/** do a stretch blit type operation */
438static int stretch_copybit(
439 struct copybit_device_t *dev,
440 struct copybit_image_t const *dst,
441 struct copybit_image_t const *src,
442 struct copybit_rect_t const *dst_rect,
443 struct copybit_rect_t const *src_rect,
444 struct copybit_region_t const *region)
445{
446 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
Terence Hampsonadf47302013-05-23 12:21:02 -0400447 struct blitReq *list;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700448 int status = 0;
449 private_handle_t *yv12_handle = NULL;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700450
Terence Hampsonadf47302013-05-23 12:21:02 -0400451 if (ctx) {
452 list = &ctx->list;
453
Naseer Ahmed29a26812012-06-14 00:56:20 -0700454 if (ctx->mAlpha < 255) {
455 switch (src->format) {
456 // we don't support plane alpha with RGBA formats
457 case HAL_PIXEL_FORMAT_RGBA_8888:
458 case HAL_PIXEL_FORMAT_BGRA_8888:
Ramkumar Radhakrishnan96439522014-10-09 13:37:52 -0700459 case HAL_PIXEL_FORMAT_RGBA_5551:
460 case HAL_PIXEL_FORMAT_RGBA_4444:
Naseer Ahmed29a26812012-06-14 00:56:20 -0700461 ALOGE ("%s : Unsupported Pixel format %d", __FUNCTION__,
462 src->format);
463 return -EINVAL;
464 }
465 }
466
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800467 if (src_rect->l < 0 || (uint32_t)src_rect->r > src->w ||
468 src_rect->t < 0 || (uint32_t)src_rect->b > src->h) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700469 // this is always invalid
470 ALOGE ("%s : Invalid source rectangle : src_rect l %d t %d r %d b %d",\
471 __FUNCTION__, src_rect->l, src_rect->t, src_rect->r, src_rect->b);
472
473 return -EINVAL;
474 }
475
476 if (src->w > MAX_DIMENSION || src->h > MAX_DIMENSION) {
477 ALOGE ("%s : Invalid source dimensions w %d h %d", __FUNCTION__, src->w, src->h);
478 return -EINVAL;
479 }
480
481 if (dst->w > MAX_DIMENSION || dst->h > MAX_DIMENSION) {
482 ALOGE ("%s : Invalid DST dimensions w %d h %d", __FUNCTION__, dst->w, dst->h);
483 return -EINVAL;
484 }
485
486 if(src->format == HAL_PIXEL_FORMAT_YV12) {
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800487 int usage =
Terence Hampson0124cc72013-04-18 23:45:56 -0700488 GRALLOC_USAGE_PRIVATE_IOMMU_HEAP | GRALLOC_USAGE_PRIVATE_UNCACHED;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700489 if (0 == alloc_buffer(&yv12_handle,src->w,src->h,
490 src->format, usage)){
491 if(0 == convertYV12toYCrCb420SP(src,yv12_handle)){
492 (const_cast<copybit_image_t *>(src))->format =
493 HAL_PIXEL_FORMAT_YCrCb_420_SP;
494 (const_cast<copybit_image_t *>(src))->handle =
495 yv12_handle;
496 (const_cast<copybit_image_t *>(src))->base =
497 (void *)yv12_handle->base;
498 }
499 else{
500 ALOGE("Error copybit conversion from yv12 failed");
501 if(yv12_handle)
502 free_buffer(yv12_handle);
503 return -EINVAL;
504 }
505 }
506 else{
507 ALOGE("Error:unable to allocate memeory for yv12 software conversion");
508 return -EINVAL;
509 }
510 }
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530511 const uint32_t maxCount =
512 (uint32_t)(sizeof(list->req)/sizeof(list->req[0]));
Dhivya Subramanian7c4baa42013-06-21 14:44:15 -0700513 const struct copybit_rect_t bounds = { 0, 0, (int)dst->w, (int)dst->h };
Naseer Ahmed29a26812012-06-14 00:56:20 -0700514 struct copybit_rect_t clip;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700515 status = 0;
516 while ((status == 0) && region->next(region, &clip)) {
517 intersect(&clip, &bounds, &clip);
Terence Hampsonadf47302013-05-23 12:21:02 -0400518 mdp_blit_req* req = &list->req[list->count];
Naseer Ahmed29a26812012-06-14 00:56:20 -0700519 int flags = 0;
520
521 private_handle_t* src_hnd = (private_handle_t*)src->handle;
Saurabh Shah1adcafe2014-12-19 10:05:41 -0800522 if(src_hnd != NULL &&
523 (!(src_hnd->flags & private_handle_t::PRIV_FLAGS_CACHED))) {
Naseer Ahmed29a26812012-06-14 00:56:20 -0700524 flags |= MDP_BLIT_NON_CACHED;
525 }
526
Sushil Chauhan0265c472014-10-01 16:39:02 -0700527 // Set Color Space for MDP to configure CSC matrix
528 req->color_space = ITU_R_601;
Ramakant Singhcab868b2015-02-25 16:19:43 +0530529 MetaData_t *metadata = NULL;
530
531 if (src_hnd != NULL)
532 metadata = (MetaData_t *)src_hnd->base_metadata;
533
Sushil Chauhan0265c472014-10-01 16:39:02 -0700534 if (metadata && (metadata->operation & UPDATE_COLOR_SPACE)) {
535 req->color_space = metadata->colorSpace;
536 }
537
Naseer Ahmed29a26812012-06-14 00:56:20 -0700538 set_infos(ctx, req, flags);
539 set_image(&req->dst, dst);
540 set_image(&req->src, src);
Ramakant Singh17fabdb2014-12-15 12:28:01 +0530541 if (set_rects(ctx, req, dst_rect, src_rect, &clip) == false)
542 continue;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700543
544 if (req->src_rect.w<=0 || req->src_rect.h<=0)
545 continue;
546
547 if (req->dst_rect.w<=0 || req->dst_rect.h<=0)
548 continue;
549
Terence Hampsonadf47302013-05-23 12:21:02 -0400550 if (++list->count == maxCount) {
551 status = msm_copybit(ctx, list);
Terence Hampsonb6e4b1e2013-09-13 17:17:11 -0400552 list->sync.acq_fen_fd_cnt = 0;
Terence Hampsonadf47302013-05-23 12:21:02 -0400553 list->count = 0;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700554 }
555 }
Terence Hampsonc67e87f2013-07-04 15:45:47 -0400556 if(yv12_handle) {
557 //Before freeing the buffer we need buffer passed through blit call
558 if (list->count != 0) {
559 status = msm_copybit(ctx, list);
Terence Hampsonb6e4b1e2013-09-13 17:17:11 -0400560 list->sync.acq_fen_fd_cnt = 0;
Terence Hampsonc67e87f2013-07-04 15:45:47 -0400561 list->count = 0;
562 }
563 free_buffer(yv12_handle);
564 }
Naseer Ahmed29a26812012-06-14 00:56:20 -0700565 } else {
566 ALOGE ("%s : Invalid COPYBIT context", __FUNCTION__);
567 status = -EINVAL;
568 }
Naseer Ahmed29a26812012-06-14 00:56:20 -0700569 return status;
570}
571
572/** Perform a blit type operation */
573static int blit_copybit(
574 struct copybit_device_t *dev,
575 struct copybit_image_t const *dst,
576 struct copybit_image_t const *src,
577 struct copybit_region_t const *region)
578{
Dhivya Subramanian7c4baa42013-06-21 14:44:15 -0700579 struct copybit_rect_t dr = { 0, 0, (int)dst->w, (int)dst->h };
580 struct copybit_rect_t sr = { 0, 0, (int)src->w, (int)src->h };
Naseer Ahmed29a26812012-06-14 00:56:20 -0700581 return stretch_copybit(dev, dst, src, &dr, &sr, region);
582}
583
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800584static int finish_copybit(struct copybit_device_t *dev)
585{
586 // NOP for MDP copybit
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530587 if(!dev)
588 return -EINVAL;
589
Terence Hampson0124cc72013-04-18 23:45:56 -0700590 return 0;
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800591}
Ramakant Singh613e3572013-10-17 15:25:14 +0530592static int clear_copybit(struct copybit_device_t *dev,
593 struct copybit_image_t const *buf,
594 struct copybit_rect_t *rect)
595{
596 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
597 uint32_t color = 0; // black color
598
599 if (!ctx) {
600 ALOGE ("%s: Invalid copybit context", __FUNCTION__);
601 return -EINVAL;
602 }
603
604 struct blitReq list1;
605 memset((char *)&list1 , 0 ,sizeof (struct blitReq) );
606 list1.count = 1;
Ramakant Singh613e3572013-10-17 15:25:14 +0530607 int my_tmp_get_fence = -1;
608
Terence Hampsonffbcf432013-12-30 17:18:33 -0500609 list1.sync.acq_fen_fd = ctx->acqFence;
Ramakant Singh613e3572013-10-17 15:25:14 +0530610 list1.sync.rel_fen_fd = &my_tmp_get_fence;
Terence Hampsonffbcf432013-12-30 17:18:33 -0500611 list1.sync.acq_fen_fd_cnt = ctx->list.sync.acq_fen_fd_cnt;
Ramakant Singh613e3572013-10-17 15:25:14 +0530612 mdp_blit_req* req = &list1.req[0];
613
614 if(!req) {
615 ALOGE ("%s : Invalid request", __FUNCTION__);
616 return -EINVAL;
617 }
618
619 set_image(&req->dst, buf);
620 set_image(&req->src, buf);
621
622 if (rect->l < 0 || (uint32_t)(rect->r - rect->l) > req->dst.width ||
623 rect->t < 0 || (uint32_t)(rect->b - rect->t) > req->dst.height) {
624 ALOGE ("%s : Invalid rect : src_rect l %d t %d r %d b %d",\
625 __FUNCTION__, rect->l, rect->t, rect->r, rect->b);
626 return -EINVAL;
627 }
628
629 req->dst_rect.x = rect->l;
630 req->dst_rect.y = rect->t;
631 req->dst_rect.w = rect->r - rect->l;
632 req->dst_rect.h = rect->b - rect->t;
633
634 req->src_rect = req->dst_rect;
635
636 req->const_color.b = (uint32_t)((color >> 16) & 0xff);
637 req->const_color.g = (uint32_t)((color >> 8) & 0xff);
638 req->const_color.r = (uint32_t)((color >> 0) & 0xff);
639 req->const_color.alpha = MDP_ALPHA_NOP;
640
641 req->transp_mask = MDP_TRANSP_NOP;
642 req->flags = MDP_SOLID_FILL | MDP_MEMORY_ID_TYPE_FB | MDP_BLEND_FG_PREMULT;
643 int status = msm_copybit(ctx, &list1);
644
Terence Hampsonffbcf432013-12-30 17:18:33 -0500645 ctx->list.sync.acq_fen_fd_cnt = 0;
Ramakant Singh613e3572013-10-17 15:25:14 +0530646 if (my_tmp_get_fence != -1)
647 close(my_tmp_get_fence);
648
649 return status;
650}
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800651
Sushil Chauhan943797c2013-10-21 17:35:55 -0700652/** Fill the rect on dst with RGBA color **/
653static int fill_color(struct copybit_device_t *dev,
654 struct copybit_image_t const *dst,
655 struct copybit_rect_t const *rect,
656 uint32_t color)
657{
658 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
659 if (!ctx) {
660 ALOGE("%s: Invalid copybit context", __FUNCTION__);
661 return -EINVAL;
662 }
663
664 if (dst->w > MAX_DIMENSION || dst->h > MAX_DIMENSION) {
665 ALOGE("%s: Invalid DST w=%d h=%d", __FUNCTION__, dst->w, dst->h);
666 return -EINVAL;
667 }
668
669 if (rect->l < 0 || (uint32_t)(rect->r - rect->l) > dst->w ||
670 rect->t < 0 || (uint32_t)(rect->b - rect->t) > dst->h) {
671 ALOGE("%s: Invalid destination rect: l=%d t=%d r=%d b=%d",
672 __FUNCTION__, rect->l, rect->t, rect->r, rect->b);
673 return -EINVAL;
674 }
675
Sushil Chauhan2babecc2013-12-04 17:29:48 -0800676 int status = 0;
Sushil Chauhan943797c2013-10-21 17:35:55 -0700677 struct blitReq* list = &ctx->list;
678 mdp_blit_req* req = &list->req[list->count++];
679 set_infos(ctx, req, MDP_SOLID_FILL);
680 set_image(&req->src, dst);
681 set_image(&req->dst, dst);
682
683 req->dst_rect.x = rect->l;
684 req->dst_rect.y = rect->t;
685 req->dst_rect.w = rect->r - rect->l;
686 req->dst_rect.h = rect->b - rect->t;
687 req->src_rect = req->dst_rect;
688
689 req->const_color.r = (uint32_t)((color >> 0) & 0xff);
690 req->const_color.g = (uint32_t)((color >> 8) & 0xff);
691 req->const_color.b = (uint32_t)((color >> 16) & 0xff);
692 req->const_color.alpha = (uint32_t)((color >> 24) & 0xff);
693
Sushil Chauhan2babecc2013-12-04 17:29:48 -0800694 if (list->count == sizeof(list->req)/sizeof(list->req[0])) {
695 status = msm_copybit(ctx, list);
696 list->sync.acq_fen_fd_cnt = 0;
697 list->count = 0;
698 }
Sushil Chauhan943797c2013-10-21 17:35:55 -0700699 return status;
700}
701
Naseer Ahmed29a26812012-06-14 00:56:20 -0700702/*****************************************************************************/
703
704/** Close the copybit device */
705static int close_copybit(struct hw_device_t *dev)
706{
707 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
708 if (ctx) {
709 close(ctx->mFD);
710 free(ctx);
711 }
712 return 0;
713}
714
Terence Hampson0124cc72013-04-18 23:45:56 -0700715static int flush_get_fence(struct copybit_device_t *dev, int* fd)
716{
Terence Hampsonadf47302013-05-23 12:21:02 -0400717 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
718 struct blitReq *list = &ctx->list;
719 int ret = -EINVAL;
720
721 if (list->count) {
722 ret = msm_copybit(ctx, list);
723 if (ret < 0)
724 ALOGE("%s: Blit call failed", __FUNCTION__);
725 list->count = 0;
Terence Hampsonadf47302013-05-23 12:21:02 -0400726 }
727 *fd = ctx->relFence;
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400728 list->sync.acq_fen_fd_cnt = 0;
Terence Hampsonadf47302013-05-23 12:21:02 -0400729 ctx->relFence = -1;
730 return ret;
Terence Hampson0124cc72013-04-18 23:45:56 -0700731}
732
Naseer Ahmed29a26812012-06-14 00:56:20 -0700733/** Open a new instance of a copybit device using name */
734static int open_copybit(const struct hw_module_t* module, const char* name,
735 struct hw_device_t** device)
736{
737 int status = -EINVAL;
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530738
Dileep Kumar Reddi8ec85af2014-06-26 09:43:49 +0530739 if (strcmp(name, COPYBIT_HARDWARE_COPYBIT0)) {
Praveena Pachipulusuaef031c2014-02-12 11:46:39 +0530740 return COPYBIT_FAILURE;
741 }
Naseer Ahmed29a26812012-06-14 00:56:20 -0700742 copybit_context_t *ctx;
743 ctx = (copybit_context_t *)malloc(sizeof(copybit_context_t));
Ramakant Singhcab868b2015-02-25 16:19:43 +0530744
745 if (ctx == NULL ) {
746 return COPYBIT_FAILURE;
747 }
748
Naseer Ahmed29a26812012-06-14 00:56:20 -0700749 memset(ctx, 0, sizeof(*ctx));
750
751 ctx->device.common.tag = HARDWARE_DEVICE_TAG;
752 ctx->device.common.version = 1;
753 ctx->device.common.module = const_cast<hw_module_t*>(module);
754 ctx->device.common.close = close_copybit;
755 ctx->device.set_parameter = set_parameter_copybit;
756 ctx->device.get = get;
757 ctx->device.blit = blit_copybit;
Terence Hampsonadf47302013-05-23 12:21:02 -0400758 ctx->device.set_sync = set_sync_copybit;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700759 ctx->device.stretch = stretch_copybit;
Arun Kumar K.R6b353bd2012-11-27 17:18:45 -0800760 ctx->device.finish = finish_copybit;
Sushil Chauhan943797c2013-10-21 17:35:55 -0700761 ctx->device.fill_color = fill_color;
Terence Hampson0124cc72013-04-18 23:45:56 -0700762 ctx->device.flush_get_fence = flush_get_fence;
Ramakant Singh613e3572013-10-17 15:25:14 +0530763 ctx->device.clear = clear_copybit;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700764 ctx->mAlpha = MDP_ALPHA_NOP;
Ramakant Singh140965d2015-01-08 23:45:04 +0530765 //dynamic_fps is zero means default
766 //panel refresh rate for driver.
767 ctx->dynamic_fps = 0;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700768 ctx->mFlags = 0;
Terence Hampsonadf47302013-05-23 12:21:02 -0400769 ctx->sync.flags = 0;
Sushil Chauhan9be65422013-12-02 13:27:53 -0800770 ctx->relFence = -1;
771 for (int i=0; i < MDP_MAX_FENCE_FD; i++) {
772 ctx->acqFence[i] = -1;
773 }
Terence Hampsonadf47302013-05-23 12:21:02 -0400774 ctx->sync.acq_fen_fd = ctx->acqFence;
775 ctx->sync.rel_fen_fd = &ctx->relFence;
776 ctx->list.count = 0;
Terence Hampson1d8db6f2013-07-17 11:05:36 -0400777 ctx->list.sync.acq_fen_fd_cnt = 0;
Terence Hampsonadf47302013-05-23 12:21:02 -0400778 ctx->list.sync.rel_fen_fd = ctx->sync.rel_fen_fd;
779 ctx->list.sync.acq_fen_fd = ctx->sync.acq_fen_fd;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700780 ctx->mFD = open("/dev/graphics/fb0", O_RDWR, 0);
781 if (ctx->mFD < 0) {
782 status = errno;
783 ALOGE("Error opening frame buffer errno=%d (%s)",
784 status, strerror(status));
785 status = -status;
786 } else {
Terence Hampson0124cc72013-04-18 23:45:56 -0700787 status = 0;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700788 *device = &ctx->device.common;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700789 }
790 return status;
791}