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 <log/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: &copybit_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