1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 * Copyright (c) 2010 - 2014, The Linux Foundation. All rights reserved.
4 *
5 * Not a Contribution, Apache license notifications and license are retained
6 * for attribution purposes only.
7 *
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
21 #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"
40 #include <qdMetaData.h>
41
42 #define DEBUG_MDP_ERRORS 1
43
44 /******************************************************************************/
45
46 #define MAX_SCALE_FACTOR (4)
47 #define MAX_DIMENSION (4096)
48
49 /******************************************************************************/
50 struct blitReq{
51 struct mdp_buf_sync sync;
52 uint32_t count;
53 struct mdp_blit_req req[10];
54 };
55
56 /** State information for each device instance */
57 struct copybit_context_t {
58 struct copybit_device_t device;
59 int mFD;
60 uint8_t mAlpha;
61 int mFlags;
62 bool mBlitToFB;
63 int acqFence[MDP_MAX_FENCE_FD];
64 int relFence;
65 struct mdp_buf_sync sync;
66 struct blitReq list;
67 uint8_t dynamic_fps;
68 };
69
70 /**
71 * Common hardware methods
72 */
73
74 static int open_copybit(const struct hw_module_t* module, const char* name,
75 struct hw_device_t** device);
76
77 static struct hw_module_methods_t copybit_module_methods = {
78 open: open_copybit
79 };
80
81 /*
82 * The COPYBIT Module
83 */
84 struct copybit_module_t HAL_MODULE_INFO_SYM = {
85 common: {
86 tag: 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: ©bit_module_methods
93 }
94 };
95
96 /******************************************************************************/
97
98 /** min of int a, b */
min(int a,int b)99 static inline int min(int a, int b) {
100 return (a<b) ? a : b;
101 }
102
103 /** max of int a, b */
max(int a,int b)104 static 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 */
MULDIV(uint32_t * a,uint32_t * b,int mul,int div)109 static 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 */
intersect(struct copybit_rect_t * out,const struct copybit_rect_t * lhs,const struct copybit_rect_t * rhs)117 static 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
validateCopybitRect(struct copybit_rect_t * rect)126 static bool validateCopybitRect(struct copybit_rect_t *rect) {
127 return ((rect->b > rect->t) && (rect->r > rect->l)) ;
128 }
129
130 /** convert COPYBIT_FORMAT to MDP format */
get_format(int format)131 static int get_format(int format) {
132 switch (format) {
133 case HAL_PIXEL_FORMAT_RGB_565: return MDP_RGB_565;
134 case HAL_PIXEL_FORMAT_RGBA_5551: return MDP_RGBA_5551;
135 case HAL_PIXEL_FORMAT_RGBA_4444: return MDP_RGBA_4444;
136 case HAL_PIXEL_FORMAT_RGBX_8888: return MDP_RGBX_8888;
137 case HAL_PIXEL_FORMAT_BGRX_8888: return MDP_BGRX_8888;
138 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;
141 case HAL_PIXEL_FORMAT_YCrCb_422_I: return MDP_YCRYCB_H2V1;
142 case HAL_PIXEL_FORMAT_YCbCr_422_I: return MDP_YCBYCR_H2V1;
143 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;
147 case HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO: return MDP_Y_CBCR_H2V2_ADRENO;
148 case HAL_PIXEL_FORMAT_YCbCr_420_SP_VENUS: return MDP_Y_CBCR_H2V2_VENUS;
149 case HAL_PIXEL_FORMAT_YCrCb_420_SP_VENUS: return MDP_Y_CRCB_H2V2_VENUS;
150 case HAL_PIXEL_FORMAT_NV12_ENCODEABLE: return MDP_Y_CBCR_H2V2;
151 case HAL_PIXEL_FORMAT_CbYCrY_422_I: return MDP_CBYCRY_H2V1;
152 case HAL_PIXEL_FORMAT_BGR_888: return MDP_BGR_888;
153 }
154 return -1;
155 }
156
157 /** convert from copybit image to mdp image structure */
set_image(struct mdp_img * img,const struct copybit_image_t * rhs)158 static void set_image(struct mdp_img *img, const struct copybit_image_t *rhs)
159 {
160 private_handle_t* hnd = (private_handle_t*)rhs->handle;
161 if(hnd == NULL){
162 ALOGE("copybit: Invalid handle");
163 return;
164 }
165 img->width = rhs->w;
166 img->height = rhs->h;
167 img->format = get_format(rhs->format);
168 img->offset = (uint32_t)hnd->offset;
169 img->memory_id = hnd->fd;
170 }
171 /** setup rectangles */
set_rects(struct copybit_context_t * dev,struct mdp_blit_req * e,const struct copybit_rect_t * dst,const struct copybit_rect_t * src,const struct copybit_rect_t * scissor)172 static bool set_rects(struct copybit_context_t *dev,
173 struct mdp_blit_req *e,
174 const struct copybit_rect_t *dst,
175 const struct copybit_rect_t *src,
176 const struct copybit_rect_t *scissor) {
177 struct copybit_rect_t clip;
178 intersect(&clip, scissor, dst);
179
180 if (!validateCopybitRect(&clip))
181 return false;
182
183 e->dst_rect.x = clip.l;
184 e->dst_rect.y = clip.t;
185 e->dst_rect.w = clip.r - clip.l;
186 e->dst_rect.h = clip.b - clip.t;
187
188 uint32_t W, H, delta_x, delta_y;
189 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
190 delta_x = (clip.t - dst->t);
191 delta_y = (dst->r - clip.r);
192 e->src_rect.w = (clip.b - clip.t);
193 e->src_rect.h = (clip.r - clip.l);
194 W = dst->b - dst->t;
195 H = dst->r - dst->l;
196 } else {
197 delta_x = (clip.l - dst->l);
198 delta_y = (clip.t - dst->t);
199 e->src_rect.w = (clip.r - clip.l);
200 e->src_rect.h = (clip.b - clip.t);
201 W = dst->r - dst->l;
202 H = dst->b - dst->t;
203 }
204
205 MULDIV(&delta_x, &e->src_rect.w, src->r - src->l, W);
206 MULDIV(&delta_y, &e->src_rect.h, src->b - src->t, H);
207
208 e->src_rect.x = delta_x + src->l;
209 e->src_rect.y = delta_y + src->t;
210
211 if (dev->mFlags & COPYBIT_TRANSFORM_FLIP_V) {
212 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
213 e->src_rect.x = (src->l + src->r) - (e->src_rect.x + e->src_rect.w);
214 }else{
215 e->src_rect.y = (src->t + src->b) - (e->src_rect.y + e->src_rect.h);
216 }
217 }
218
219 if (dev->mFlags & COPYBIT_TRANSFORM_FLIP_H) {
220 if (dev->mFlags & COPYBIT_TRANSFORM_ROT_90) {
221 e->src_rect.y = (src->t + src->b) - (e->src_rect.y + e->src_rect.h);
222 }else{
223 e->src_rect.x = (src->l + src->r) - (e->src_rect.x + e->src_rect.w);
224 }
225 }
226 return true;
227 }
228
229 /** setup mdp request */
set_infos(struct copybit_context_t * dev,struct mdp_blit_req * req,int flags)230 static void set_infos(struct copybit_context_t *dev,
231 struct mdp_blit_req *req, int flags)
232 {
233 req->alpha = dev->mAlpha;
234 req->fps = dev->dynamic_fps;
235 req->transp_mask = MDP_TRANSP_NOP;
236 req->flags = dev->mFlags | flags;
237 // check if we are blitting to f/b
238 if (COPYBIT_ENABLE == dev->mBlitToFB) {
239 req->flags |= MDP_MEMORY_ID_TYPE_FB;
240 }
241 #if defined(COPYBIT_QSD8K)
242 req->flags |= MDP_BLEND_FG_PREMULT;
243 #endif
244 }
245
246 /** copy the bits */
msm_copybit(struct copybit_context_t * dev,void const * list)247 static int msm_copybit(struct copybit_context_t *dev, void const *list)
248 {
249 int err;
250 if (dev->relFence != -1) {
251 close(dev->relFence);
252 dev->relFence = -1;
253 }
254 err = ioctl(dev->mFD, MSMFB_ASYNC_BLIT,
255 (struct mdp_async_blit_req_list const*)list);
256 ALOGE_IF(err<0, "copyBits failed (%s)", strerror(errno));
257 if (err == 0) {
258 return 0;
259 } else {
260 #if DEBUG_MDP_ERRORS
261 struct mdp_async_blit_req_list const* l =
262 (struct mdp_async_blit_req_list const*)list;
263 for (unsigned int i=0 ; i<l->count ; i++) {
264 ALOGE("%d: src={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
265 " dst={w=%d, h=%d, f=%d, rect={%d,%d,%d,%d}}\n"
266 " flags=%08x, fps=%d"
267 ,
268 i,
269 l->req[i].src.width,
270 l->req[i].src.height,
271 l->req[i].src.format,
272 l->req[i].src_rect.x,
273 l->req[i].src_rect.y,
274 l->req[i].src_rect.w,
275 l->req[i].src_rect.h,
276 l->req[i].dst.width,
277 l->req[i].dst.height,
278 l->req[i].dst.format,
279 l->req[i].dst_rect.x,
280 l->req[i].dst_rect.y,
281 l->req[i].dst_rect.w,
282 l->req[i].dst_rect.h,
283 l->req[i].flags,
284 l->req[i].fps
285 );
286 }
287 #endif
288 return -errno;
289 }
290 }
291
292 /*****************************************************************************/
293
294 /** Set a parameter to value */
set_parameter_copybit(struct copybit_device_t * dev,int name,int value)295 static int set_parameter_copybit(
296 struct copybit_device_t *dev,
297 int name,
298 int value)
299 {
300 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
301 int status = 0;
302 if (ctx) {
303 switch(name) {
304 case COPYBIT_ROTATION_DEG:
305 switch (value) {
306 case 0:
307 ctx->mFlags &= ~0x7;
308 break;
309 case 90:
310 ctx->mFlags &= ~0x7;
311 ctx->mFlags |= MDP_ROT_90;
312 break;
313 case 180:
314 ctx->mFlags &= ~0x7;
315 ctx->mFlags |= MDP_ROT_180;
316 break;
317 case 270:
318 ctx->mFlags &= ~0x7;
319 ctx->mFlags |= MDP_ROT_270;
320 break;
321 default:
322 ALOGE("Invalid value for COPYBIT_ROTATION_DEG");
323 status = -EINVAL;
324 break;
325 }
326 break;
327 case COPYBIT_PLANE_ALPHA:
328 if (value < 0) value = MDP_ALPHA_NOP;
329 if (value >= 256) value = 255;
330 ctx->mAlpha = (uint8_t)value;
331 break;
332 case COPYBIT_DYNAMIC_FPS:
333 ctx->dynamic_fps = (uint8_t)value;
334 break;
335 case COPYBIT_DITHER:
336 if (value == COPYBIT_ENABLE) {
337 ctx->mFlags |= MDP_DITHER;
338 } else if (value == COPYBIT_DISABLE) {
339 ctx->mFlags &= ~MDP_DITHER;
340 }
341 break;
342 case COPYBIT_BLUR:
343 if (value == COPYBIT_ENABLE) {
344 ctx->mFlags |= MDP_BLUR;
345 } else if (value == COPYBIT_DISABLE) {
346 ctx->mFlags &= ~MDP_BLUR;
347 }
348 break;
349 case COPYBIT_BLEND_MODE:
350 if(value == COPYBIT_BLENDING_PREMULT) {
351 ctx->mFlags |= MDP_BLEND_FG_PREMULT;
352 } else {
353 ctx->mFlags &= ~MDP_BLEND_FG_PREMULT;
354 }
355 break;
356 case COPYBIT_TRANSFORM:
357 ctx->mFlags &= ~0x7;
358 ctx->mFlags |= value & 0x7;
359 break;
360 case COPYBIT_BLIT_TO_FRAMEBUFFER:
361 if (COPYBIT_ENABLE == value) {
362 ctx->mBlitToFB = value;
363 } else if (COPYBIT_DISABLE == value) {
364 ctx->mBlitToFB = value;
365 } else {
366 ALOGE ("%s:Invalid input for COPYBIT_BLIT_TO_FRAMEBUFFER : %d",
367 __FUNCTION__, value);
368 }
369 break;
370 case COPYBIT_FG_LAYER:
371 if(value == COPYBIT_ENABLE) {
372 ctx->mFlags |= MDP_IS_FG;
373 } else if (value == COPYBIT_DISABLE) {
374 ctx->mFlags &= ~MDP_IS_FG;
375 }
376 break ;
377 default:
378 status = -EINVAL;
379 break;
380 }
381 } else {
382 status = -EINVAL;
383 }
384 return status;
385 }
386
387 /** Get a static info value */
get(struct copybit_device_t * dev,int name)388 static int get(struct copybit_device_t *dev, int name)
389 {
390 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
391 int value;
392 if (ctx) {
393 switch(name) {
394 case COPYBIT_MINIFICATION_LIMIT:
395 value = MAX_SCALE_FACTOR;
396 break;
397 case COPYBIT_MAGNIFICATION_LIMIT:
398 value = MAX_SCALE_FACTOR;
399 break;
400 case COPYBIT_SCALING_FRAC_BITS:
401 value = 32;
402 break;
403 case COPYBIT_ROTATION_STEP_DEG:
404 value = 90;
405 break;
406 default:
407 value = -EINVAL;
408 }
409 } else {
410 value = -EINVAL;
411 }
412 return value;
413 }
414
set_sync_copybit(struct copybit_device_t * dev,int acquireFenceFd)415 static int set_sync_copybit(struct copybit_device_t *dev,
416 int acquireFenceFd)
417 {
418 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
419 if (acquireFenceFd != -1) {
420 if (ctx->list.sync.acq_fen_fd_cnt < (MDP_MAX_FENCE_FD - 1)) {
421 ctx->acqFence[ctx->list.sync.acq_fen_fd_cnt++] = acquireFenceFd;
422 } else {
423 int ret = -EINVAL;
424 struct blitReq *list = &ctx->list;
425
426 // Since fence is full kick off what is already in the list
427 ret = msm_copybit(ctx, list);
428 if (ret < 0) {
429 ALOGE("%s: Blit call failed", __FUNCTION__);
430 return -EINVAL;
431 }
432 list->count = 0;
433 list->sync.acq_fen_fd_cnt = 0;
434 ctx->acqFence[list->sync.acq_fen_fd_cnt++] = acquireFenceFd;
435 }
436 }
437 return 0;
438 }
439
440 /** do a stretch blit type operation */
stretch_copybit(struct copybit_device_t * dev,struct copybit_image_t const * dst,struct copybit_image_t const * src,struct copybit_rect_t const * dst_rect,struct copybit_rect_t const * src_rect,struct copybit_region_t const * region)441 static int stretch_copybit(
442 struct copybit_device_t *dev,
443 struct copybit_image_t const *dst,
444 struct copybit_image_t const *src,
445 struct copybit_rect_t const *dst_rect,
446 struct copybit_rect_t const *src_rect,
447 struct copybit_region_t const *region)
448 {
449 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
450 struct blitReq *list;
451 int status = 0;
452 private_handle_t *yv12_handle = NULL;
453
454 if (ctx) {
455 list = &ctx->list;
456
457 if (ctx->mAlpha < 255) {
458 switch (src->format) {
459 // we don't support plane alpha with RGBA formats
460 case HAL_PIXEL_FORMAT_RGBA_8888:
461 case HAL_PIXEL_FORMAT_BGRA_8888:
462 case HAL_PIXEL_FORMAT_RGBA_5551:
463 case HAL_PIXEL_FORMAT_RGBA_4444:
464 ALOGE ("%s : Unsupported Pixel format %d", __FUNCTION__,
465 src->format);
466 return -EINVAL;
467 }
468 }
469
470 if (src_rect->l < 0 || (uint32_t)src_rect->r > src->w ||
471 src_rect->t < 0 || (uint32_t)src_rect->b > src->h) {
472 // this is always invalid
473 ALOGE ("%s : Invalid source rectangle : src_rect l %d t %d r %d b %d",\
474 __FUNCTION__, src_rect->l, src_rect->t, src_rect->r, src_rect->b);
475
476 return -EINVAL;
477 }
478
479 if (src->w > MAX_DIMENSION || src->h > MAX_DIMENSION) {
480 ALOGE ("%s : Invalid source dimensions w %d h %d", __FUNCTION__, src->w, src->h);
481 return -EINVAL;
482 }
483
484 if (dst->w > MAX_DIMENSION || dst->h > MAX_DIMENSION) {
485 ALOGE ("%s : Invalid DST dimensions w %d h %d", __FUNCTION__, dst->w, dst->h);
486 return -EINVAL;
487 }
488
489 if(src->format == HAL_PIXEL_FORMAT_YV12) {
490 int usage =
491 GRALLOC_USAGE_PRIVATE_IOMMU_HEAP | GRALLOC_USAGE_PRIVATE_UNCACHED;
492 if (0 == alloc_buffer(&yv12_handle,src->w,src->h,
493 src->format, usage)){
494 if(0 == convertYV12toYCrCb420SP(src,yv12_handle)){
495 (const_cast<copybit_image_t *>(src))->format =
496 HAL_PIXEL_FORMAT_YCrCb_420_SP;
497 (const_cast<copybit_image_t *>(src))->handle =
498 yv12_handle;
499 (const_cast<copybit_image_t *>(src))->base =
500 (void *)yv12_handle->base;
501 }
502 else{
503 ALOGE("Error copybit conversion from yv12 failed");
504 if(yv12_handle)
505 free_buffer(yv12_handle);
506 return -EINVAL;
507 }
508 }
509 else{
510 ALOGE("Error:unable to allocate memeory for yv12 software conversion");
511 return -EINVAL;
512 }
513 }
514 const uint32_t maxCount =
515 (uint32_t)(sizeof(list->req)/sizeof(list->req[0]));
516 const struct copybit_rect_t bounds = { 0, 0, (int)dst->w, (int)dst->h };
517 struct copybit_rect_t clip;
518 status = 0;
519 while ((status == 0) && region->next(region, &clip)) {
520 intersect(&clip, &bounds, &clip);
521 mdp_blit_req* req = &list->req[list->count];
522 int flags = 0;
523
524 private_handle_t* src_hnd = (private_handle_t*)src->handle;
525 if(src_hnd != NULL &&
526 (!(src_hnd->flags & private_handle_t::PRIV_FLAGS_CACHED))) {
527 flags |= MDP_BLIT_NON_CACHED;
528 }
529
530 // Set Color Space for MDP to configure CSC matrix
531 req->color_space = ITU_R_601;
532 MetaData_t *metadata = NULL;
533
534 if (src_hnd != NULL)
535 metadata = (MetaData_t *)src_hnd->base_metadata;
536
537 if (metadata && (metadata->operation & UPDATE_COLOR_SPACE)) {
538 req->color_space = metadata->colorSpace;
539 }
540
541 set_infos(ctx, req, flags);
542 set_image(&req->dst, dst);
543 set_image(&req->src, src);
544 if (set_rects(ctx, req, dst_rect, src_rect, &clip) == false)
545 continue;
546
547 if (req->src_rect.w<=0 || req->src_rect.h<=0)
548 continue;
549
550 if (req->dst_rect.w<=0 || req->dst_rect.h<=0)
551 continue;
552
553 if (++list->count == maxCount) {
554 status = msm_copybit(ctx, list);
555 list->sync.acq_fen_fd_cnt = 0;
556 list->count = 0;
557 }
558 }
559 if(yv12_handle) {
560 //Before freeing the buffer we need buffer passed through blit call
561 if (list->count != 0) {
562 status = msm_copybit(ctx, list);
563 list->sync.acq_fen_fd_cnt = 0;
564 list->count = 0;
565 }
566 free_buffer(yv12_handle);
567 }
568 } else {
569 ALOGE ("%s : Invalid COPYBIT context", __FUNCTION__);
570 status = -EINVAL;
571 }
572 return status;
573 }
574
575 /** Perform a blit type operation */
blit_copybit(struct copybit_device_t * dev,struct copybit_image_t const * dst,struct copybit_image_t const * src,struct copybit_region_t const * region)576 static int blit_copybit(
577 struct copybit_device_t *dev,
578 struct copybit_image_t const *dst,
579 struct copybit_image_t const *src,
580 struct copybit_region_t const *region)
581 {
582 struct copybit_rect_t dr = { 0, 0, (int)dst->w, (int)dst->h };
583 struct copybit_rect_t sr = { 0, 0, (int)src->w, (int)src->h };
584 return stretch_copybit(dev, dst, src, &dr, &sr, region);
585 }
586
finish_copybit(struct copybit_device_t * dev)587 static int finish_copybit(struct copybit_device_t *dev)
588 {
589 // NOP for MDP copybit
590 if(!dev)
591 return -EINVAL;
592
593 return 0;
594 }
clear_copybit(struct copybit_device_t * dev,struct copybit_image_t const * buf,struct copybit_rect_t * rect)595 static int clear_copybit(struct copybit_device_t *dev,
596 struct copybit_image_t const *buf,
597 struct copybit_rect_t *rect)
598 {
599 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
600 uint32_t color = 0; // black color
601
602 if (!ctx) {
603 ALOGE ("%s: Invalid copybit context", __FUNCTION__);
604 return -EINVAL;
605 }
606
607 struct blitReq list1;
608 memset((char *)&list1 , 0 ,sizeof (struct blitReq) );
609 list1.count = 1;
610 int my_tmp_get_fence = -1;
611
612 list1.sync.acq_fen_fd = ctx->acqFence;
613 list1.sync.rel_fen_fd = &my_tmp_get_fence;
614 list1.sync.acq_fen_fd_cnt = ctx->list.sync.acq_fen_fd_cnt;
615 mdp_blit_req* req = &list1.req[0];
616
617 if(!req) {
618 ALOGE ("%s : Invalid request", __FUNCTION__);
619 return -EINVAL;
620 }
621
622 set_image(&req->dst, buf);
623 set_image(&req->src, buf);
624
625 if (rect->l < 0 || (uint32_t)(rect->r - rect->l) > req->dst.width ||
626 rect->t < 0 || (uint32_t)(rect->b - rect->t) > req->dst.height) {
627 ALOGE ("%s : Invalid rect : src_rect l %d t %d r %d b %d",\
628 __FUNCTION__, rect->l, rect->t, rect->r, rect->b);
629 return -EINVAL;
630 }
631
632 req->dst_rect.x = rect->l;
633 req->dst_rect.y = rect->t;
634 req->dst_rect.w = rect->r - rect->l;
635 req->dst_rect.h = rect->b - rect->t;
636
637 req->src_rect = req->dst_rect;
638
639 req->const_color.b = (uint32_t)((color >> 16) & 0xff);
640 req->const_color.g = (uint32_t)((color >> 8) & 0xff);
641 req->const_color.r = (uint32_t)((color >> 0) & 0xff);
642 req->const_color.alpha = MDP_ALPHA_NOP;
643
644 req->transp_mask = MDP_TRANSP_NOP;
645 req->flags = MDP_SOLID_FILL | MDP_MEMORY_ID_TYPE_FB | MDP_BLEND_FG_PREMULT;
646 int status = msm_copybit(ctx, &list1);
647
648 ctx->list.sync.acq_fen_fd_cnt = 0;
649 if (my_tmp_get_fence != -1)
650 close(my_tmp_get_fence);
651
652 return status;
653 }
654
655 /** Fill the rect on dst with RGBA color **/
fill_color(struct copybit_device_t * dev,struct copybit_image_t const * dst,struct copybit_rect_t const * rect,uint32_t color)656 static int fill_color(struct copybit_device_t *dev,
657 struct copybit_image_t const *dst,
658 struct copybit_rect_t const *rect,
659 uint32_t color)
660 {
661 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
662 if (!ctx) {
663 ALOGE("%s: Invalid copybit context", __FUNCTION__);
664 return -EINVAL;
665 }
666
667 if (dst->w > MAX_DIMENSION || dst->h > MAX_DIMENSION) {
668 ALOGE("%s: Invalid DST w=%d h=%d", __FUNCTION__, dst->w, dst->h);
669 return -EINVAL;
670 }
671
672 if (rect->l < 0 || (uint32_t)(rect->r - rect->l) > dst->w ||
673 rect->t < 0 || (uint32_t)(rect->b - rect->t) > dst->h) {
674 ALOGE("%s: Invalid destination rect: l=%d t=%d r=%d b=%d",
675 __FUNCTION__, rect->l, rect->t, rect->r, rect->b);
676 return -EINVAL;
677 }
678
679 int status = 0;
680 struct blitReq* list = &ctx->list;
681 mdp_blit_req* req = &list->req[list->count++];
682 set_infos(ctx, req, MDP_SOLID_FILL);
683 set_image(&req->src, dst);
684 set_image(&req->dst, dst);
685
686 req->dst_rect.x = rect->l;
687 req->dst_rect.y = rect->t;
688 req->dst_rect.w = rect->r - rect->l;
689 req->dst_rect.h = rect->b - rect->t;
690 req->src_rect = req->dst_rect;
691
692 req->const_color.r = (uint32_t)((color >> 0) & 0xff);
693 req->const_color.g = (uint32_t)((color >> 8) & 0xff);
694 req->const_color.b = (uint32_t)((color >> 16) & 0xff);
695 req->const_color.alpha = (uint32_t)((color >> 24) & 0xff);
696
697 if (list->count == sizeof(list->req)/sizeof(list->req[0])) {
698 status = msm_copybit(ctx, list);
699 list->sync.acq_fen_fd_cnt = 0;
700 list->count = 0;
701 }
702 return status;
703 }
704
705 /*****************************************************************************/
706
707 /** Close the copybit device */
close_copybit(struct hw_device_t * dev)708 static int close_copybit(struct hw_device_t *dev)
709 {
710 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
711 if (ctx) {
712 close(ctx->mFD);
713 free(ctx);
714 }
715 return 0;
716 }
717
flush_get_fence(struct copybit_device_t * dev,int * fd)718 static int flush_get_fence(struct copybit_device_t *dev, int* fd)
719 {
720 struct copybit_context_t* ctx = (struct copybit_context_t*)dev;
721 struct blitReq *list = &ctx->list;
722 int ret = -EINVAL;
723
724 if (list->count) {
725 ret = msm_copybit(ctx, list);
726 if (ret < 0)
727 ALOGE("%s: Blit call failed", __FUNCTION__);
728 list->count = 0;
729 }
730 *fd = ctx->relFence;
731 list->sync.acq_fen_fd_cnt = 0;
732 ctx->relFence = -1;
733 return ret;
734 }
735
736 /** Open a new instance of a copybit device using name */
open_copybit(const struct hw_module_t * module,const char * name,struct hw_device_t ** device)737 static int open_copybit(const struct hw_module_t* module, const char* name,
738 struct hw_device_t** device)
739 {
740 int status = -EINVAL;
741
742 if (strcmp(name, COPYBIT_HARDWARE_COPYBIT0)) {
743 return COPYBIT_FAILURE;
744 }
745 copybit_context_t *ctx;
746 ctx = (copybit_context_t *)malloc(sizeof(copybit_context_t));
747
748 if (ctx == NULL ) {
749 return COPYBIT_FAILURE;
750 }
751
752 memset(ctx, 0, sizeof(*ctx));
753
754 ctx->device.common.tag = HARDWARE_DEVICE_TAG;
755 ctx->device.common.version = 1;
756 ctx->device.common.module = const_cast<hw_module_t*>(module);
757 ctx->device.common.close = close_copybit;
758 ctx->device.set_parameter = set_parameter_copybit;
759 ctx->device.get = get;
760 ctx->device.blit = blit_copybit;
761 ctx->device.set_sync = set_sync_copybit;
762 ctx->device.stretch = stretch_copybit;
763 ctx->device.finish = finish_copybit;
764 ctx->device.fill_color = fill_color;
765 ctx->device.flush_get_fence = flush_get_fence;
766 ctx->device.clear = clear_copybit;
767 ctx->mAlpha = MDP_ALPHA_NOP;
768 //dynamic_fps is zero means default
769 //panel refresh rate for driver.
770 ctx->dynamic_fps = 0;
771 ctx->mFlags = 0;
772 ctx->sync.flags = 0;
773 ctx->relFence = -1;
774 for (int i=0; i < MDP_MAX_FENCE_FD; i++) {
775 ctx->acqFence[i] = -1;
776 }
777 ctx->sync.acq_fen_fd = ctx->acqFence;
778 ctx->sync.rel_fen_fd = &ctx->relFence;
779 ctx->list.count = 0;
780 ctx->list.sync.acq_fen_fd_cnt = 0;
781 ctx->list.sync.rel_fen_fd = ctx->sync.rel_fen_fd;
782 ctx->list.sync.acq_fen_fd = ctx->sync.acq_fen_fd;
783 ctx->mFD = open("/dev/graphics/fb0", O_RDWR, 0);
784 if (ctx->mFD < 0) {
785 status = errno;
786 ALOGE("Error opening frame buffer errno=%d (%s)",
787 status, strerror(status));
788 status = -status;
789 } else {
790 status = 0;
791 *device = &ctx->device.common;
792 }
793 return status;
794 }
795