1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright@ Samsung Electronics Co. LTD 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /*! 19 * \file exynos_gscaler.c 20 * \brief header file for Gscaler HAL 21 * \author ShinWon Lee (shinwon.lee (at) samsung.com) 22 * \date 2012/01/09 23 * 24 * <b>Revision History: </b> 25 * - 2012.01.09 : ShinWon Lee(shinwon.lee (at) samsung.com) \n 26 * Create 27 * 28 * - 2012.02.07 : ShinWon Lee(shinwon.lee (at) samsung.com) \n 29 * Change file name to exynos_gscaler.h 30 * 31 * - 2012.02.09 : Sangwoo, Parkk(sw5771.park (at) samsung.com) \n 32 * Use Multiple Gscaler by Multiple Process 33 * 34 * - 2012.02.20 : Sangwoo, Park(sw5771.park (at) samsung.com) \n 35 * Add exynos_gsc_set_rotation() API 36 * 37 * - 2012.02.20 : ShinWon Lee(shinwon.lee (at) samsung.com) \n 38 * Add size constrain 39 * 40 */ 41 42 //#define LOG_NDEBUG 0 43 #include "exynos_gsc_utils.h" 44 #include "content_protect.h" 45 46 static int exynos_gsc_m2m_wait_frame_done(void *handle); 47 static int exynos_gsc_m2m_stop(void *handle); 48 49 static unsigned int m_gsc_get_plane_count( 50 int v4l_pixel_format) 51 { 52 int plane_count = 0; 53 54 switch (v4l_pixel_format) { 55 case V4L2_PIX_FMT_RGB32: 56 case V4L2_PIX_FMT_BGR32: 57 case V4L2_PIX_FMT_RGB24: 58 case V4L2_PIX_FMT_RGB565: 59 case V4L2_PIX_FMT_RGB555X: 60 case V4L2_PIX_FMT_RGB444: 61 case V4L2_PIX_FMT_YUYV: 62 case V4L2_PIX_FMT_UYVY: 63 case V4L2_PIX_FMT_NV16: 64 case V4L2_PIX_FMT_NV61: 65 plane_count = 1; 66 break; 67 case V4L2_PIX_FMT_NV12M: 68 case V4L2_PIX_FMT_NV12MT_16X16: 69 case V4L2_PIX_FMT_NV12: 70 case V4L2_PIX_FMT_NV21: 71 case V4L2_PIX_FMT_NV21M: 72 plane_count = 2; 73 break; 74 case V4L2_PIX_FMT_YVU420M: 75 case V4L2_PIX_FMT_YUV422P: 76 case V4L2_PIX_FMT_YUV420M: 77 plane_count = 3; 78 break; 79 default: 80 ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n", 81 __func__, v4l_pixel_format); 82 plane_count = -1; 83 break; 84 } 85 86 return plane_count; 87 } 88 89 static unsigned int m_gsc_get_plane_size( 90 unsigned int *plane_size, 91 unsigned int width, 92 unsigned int height, 93 int v4l_pixel_format) 94 { 95 switch (v4l_pixel_format) { 96 /* 1 plane */ 97 case V4L2_PIX_FMT_RGB32: 98 case V4L2_PIX_FMT_BGR32: 99 plane_size[0] = width * height * 4; 100 plane_size[1] = 0; 101 plane_size[2] = 0; 102 break; 103 case V4L2_PIX_FMT_RGB24: 104 plane_size[0] = width * height * 3; 105 plane_size[1] = 0; 106 plane_size[2] = 0; 107 break; 108 case V4L2_PIX_FMT_RGB565: 109 case V4L2_PIX_FMT_RGB555X: 110 case V4L2_PIX_FMT_RGB444: 111 case V4L2_PIX_FMT_YUYV: 112 case V4L2_PIX_FMT_UYVY: 113 plane_size[0] = width * height * 2; 114 plane_size[1] = 0; 115 plane_size[2] = 0; 116 break; 117 /* 2 planes */ 118 case V4L2_PIX_FMT_NV12M: 119 case V4L2_PIX_FMT_NV12: 120 case V4L2_PIX_FMT_NV21: 121 case V4L2_PIX_FMT_NV21M: 122 plane_size[0] = width * height; 123 plane_size[1] = width * (height / 2); 124 plane_size[2] = 0; 125 break; 126 case V4L2_PIX_FMT_NV16: 127 case V4L2_PIX_FMT_NV61: 128 plane_size[0] = width * height * 2; 129 plane_size[1] = 0; 130 plane_size[2] = 0; 131 break; 132 case V4L2_PIX_FMT_NV12MT_16X16: 133 plane_size[0] = ALIGN(width, 16) * ALIGN(height, 16); 134 plane_size[1] = ALIGN(width, 16) * ALIGN(height / 2, 8); 135 plane_size[2] = 0; 136 break; 137 /* 3 planes */ 138 case V4L2_PIX_FMT_YVU420M: 139 case V4L2_PIX_FMT_YUV422P: 140 plane_size[0] = width * height; 141 plane_size[1] = (width / 2) * (height / 2); 142 plane_size[2] = (width / 2) * (height / 2); 143 break; 144 default: 145 ALOGE("%s::unmatched v4l_pixel_format color_space(0x%x)\n", 146 __func__, v4l_pixel_format); 147 return -1; 148 break; 149 } 150 151 return 0; 152 } 153 154 static int m_exynos_gsc_multiple_of_n( 155 int number, int N) 156 { 157 int result = number; 158 switch (N) { 159 case 1: 160 case 2: 161 case 4: 162 case 8: 163 case 16: 164 case 32: 165 case 64: 166 case 128: 167 case 256: 168 result = (number - (number & (N-1))); 169 break; 170 default: 171 result = number - (number % N); 172 break; 173 } 174 return result; 175 } 176 177 static bool m_exynos_gsc_check_src_size( 178 unsigned int *w, unsigned int *h, 179 unsigned int *crop_x, unsigned int *crop_y, 180 unsigned int *crop_w, unsigned int *crop_h, 181 int v4l2_colorformat) 182 { 183 if (*w < GSC_MIN_W_SIZE || *h < GSC_MIN_H_SIZE) { 184 ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", 185 __func__, GSC_MIN_W_SIZE, *w, GSC_MIN_H_SIZE, *h); 186 return false; 187 } 188 189 if (*crop_w < GSC_MIN_W_SIZE || *crop_h < GSC_MIN_H_SIZE) { 190 ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", 191 __func__, GSC_MIN_W_SIZE,* crop_w, GSC_MIN_H_SIZE, *crop_h); 192 return false; 193 } 194 195 switch (v4l2_colorformat) { 196 // YUV420 197 case V4L2_PIX_FMT_YUV420M: 198 case V4L2_PIX_FMT_YVU420M: 199 case V4L2_PIX_FMT_NV12M: 200 case V4L2_PIX_FMT_NV12MT: 201 case V4L2_PIX_FMT_NV21: 202 case V4L2_PIX_FMT_NV21M: 203 *w = (*w + 15) & ~15; 204 *h = (*h + 15) & ~15; 205 //*w = m_exynos_gsc_multiple_of_n(*w, 16); 206 //*h = m_exynos_gsc_multiple_of_n(*h, 16); 207 *crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 4); 208 *crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 4); 209 break; 210 // YUV422 211 case V4L2_PIX_FMT_YUYV: 212 case V4L2_PIX_FMT_YUV422P: 213 case V4L2_PIX_FMT_UYVY: 214 case V4L2_PIX_FMT_NV16: 215 case V4L2_PIX_FMT_YVYU: 216 case V4L2_PIX_FMT_VYUY: 217 *h = (*h + 7) & ~7; 218 //*h = m_exynos_gsc_multiple_of_n(*h, 8); 219 *crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 4); 220 *crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 2); 221 break; 222 // RGB 223 case V4L2_PIX_FMT_RGB32: 224 case V4L2_PIX_FMT_RGB24: 225 case V4L2_PIX_FMT_RGB565: 226 case V4L2_PIX_FMT_BGR32: 227 case V4L2_PIX_FMT_RGB555X: 228 case V4L2_PIX_FMT_RGB444: 229 default: 230 *h = (*h + 7) & ~7; 231 //*h = m_exynos_gsc_multiple_of_n(*h, 8); 232 *crop_w = m_exynos_gsc_multiple_of_n(*crop_w, 2); 233 *crop_h = m_exynos_gsc_multiple_of_n(*crop_h, 2); 234 break; 235 } 236 237 return true; 238 } 239 240 static bool m_exynos_gsc_check_dst_size( 241 unsigned int *w, unsigned int *h, 242 unsigned int *crop_x, unsigned int *crop_y, 243 unsigned int *crop_w, unsigned int *crop_h, 244 int v4l2_colorformat, 245 int rotation) 246 { 247 unsigned int *new_w; 248 unsigned int *new_h; 249 unsigned int *new_crop_w; 250 unsigned int *new_crop_h; 251 252 new_w = w; 253 new_h = h; 254 new_crop_w = crop_w; 255 new_crop_h = crop_h; 256 257 if (*w < GSC_MIN_W_SIZE || *h < GSC_MIN_H_SIZE) { 258 ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", 259 __func__, GSC_MIN_W_SIZE, *w, GSC_MIN_H_SIZE, *h); 260 return false; 261 } 262 263 if (*crop_w < GSC_MIN_W_SIZE || *crop_h < GSC_MIN_H_SIZE) { 264 ALOGE("%s::too small size (w : %d < %d) (h : %d < %d)", 265 __func__, GSC_MIN_W_SIZE,* crop_w, GSC_MIN_H_SIZE, *crop_h); 266 return false; 267 } 268 269 switch (v4l2_colorformat) { 270 // YUV420 271 case V4L2_PIX_FMT_NV12M: 272 case V4L2_PIX_FMT_NV12MT: 273 case V4L2_PIX_FMT_NV21: 274 case V4L2_PIX_FMT_NV21M: 275 case V4L2_PIX_FMT_YUV420M: 276 case V4L2_PIX_FMT_YVU420M: 277 *new_w = m_exynos_gsc_multiple_of_n(*new_w, 2); 278 *new_h = m_exynos_gsc_multiple_of_n(*new_h, 2); 279 break; 280 // YUV422 281 case V4L2_PIX_FMT_YUYV: 282 case V4L2_PIX_FMT_YUV422P: 283 case V4L2_PIX_FMT_UYVY: 284 case V4L2_PIX_FMT_NV16: 285 case V4L2_PIX_FMT_YVYU: 286 case V4L2_PIX_FMT_VYUY: 287 *new_w = m_exynos_gsc_multiple_of_n(*new_w, 2); 288 break; 289 // RGB 290 case V4L2_PIX_FMT_RGB32: 291 case V4L2_PIX_FMT_RGB24: 292 case V4L2_PIX_FMT_RGB565: 293 case V4L2_PIX_FMT_BGR32: 294 case V4L2_PIX_FMT_RGB555X: 295 case V4L2_PIX_FMT_RGB444: 296 default: 297 break; 298 } 299 300 return true; 301 } 302 303 static int m_exynos_gsc_output_create( 304 struct GSC_HANDLE *gsc_handle, 305 int dev_num, 306 int out_mode) 307 { 308 struct media_device *media0; 309 struct media_entity *gsc_sd_entity; 310 struct media_entity *gsc_vd_entity; 311 struct media_entity *sink_sd_entity; 312 struct media_link *links; 313 char node[32]; 314 char devname[32]; 315 unsigned int cap; 316 int i; 317 int fd = 0; 318 319 Exynos_gsc_In(); 320 321 if ((out_mode != GSC_OUT_FIMD) && 322 (out_mode != GSC_OUT_TV)) 323 return -1; 324 325 gsc_handle->out_mode = out_mode; 326 /* GSCX => FIMD_WINX : arbitrary linking is not allowed */ 327 if ((out_mode == GSC_OUT_FIMD) && 328 (dev_num > 2)) 329 return -1; 330 331 /* media0 */ 332 sprintf(node, "%s%d", PFX_NODE_MEDIADEV, 0); 333 media0 = exynos_media_open(node); 334 if (media0 == NULL) { 335 ALOGE("%s::exynos_media_open failed (node=%s)", __func__, node); 336 return false; 337 } 338 339 /* Get the sink subdev entity by name and make the node of sink subdev*/ 340 if (out_mode == GSC_OUT_FIMD) 341 sprintf(devname, PFX_FIMD_ENTITY, dev_num); 342 else 343 sprintf(devname, PFX_MXR_ENTITY, 0); 344 345 sink_sd_entity = exynos_media_get_entity_by_name(media0, devname, strlen(devname)); 346 sink_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR); 347 if ( sink_sd_entity->fd < 0) { 348 ALOGE("%s:: failed to open sink subdev node", __func__); 349 goto gsc_output_err; 350 } 351 352 /* get GSC video dev & sub dev entity by name*/ 353 sprintf(devname, PFX_GSC_VIDEODEV_ENTITY, dev_num); 354 gsc_vd_entity= exynos_media_get_entity_by_name(media0, devname, strlen(devname)); 355 356 sprintf(devname, PFX_GSC_SUBDEV_ENTITY, dev_num); 357 gsc_sd_entity= exynos_media_get_entity_by_name(media0, devname, strlen(devname)); 358 359 /* gsc sub-dev open */ 360 sprintf(devname, PFX_GSC_SUBDEV_ENTITY, dev_num); 361 gsc_sd_entity->fd = exynos_subdev_open_devname(devname, O_RDWR); 362 363 /* setup link : GSC : video device --> sub device */ 364 for (i = 0; i < (int) gsc_vd_entity->num_links; i++) { 365 links = &gsc_vd_entity->links[i]; 366 367 if (links == NULL || 368 links->source->entity != gsc_vd_entity || 369 links->sink->entity != gsc_sd_entity) { 370 continue; 371 } else if (exynos_media_setup_link(media0, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 372 ALOGE("%s::exynos_media_setup_link [src.entity=%d->sink.entity=%d] failed", 373 __func__, links->source->entity->info.id, links->sink->entity->info.id); 374 return -1; 375 } 376 } 377 378 /* setup link : GSC: sub device --> sink device */ 379 for (i = 0; i < (int) gsc_sd_entity->num_links; i++) { 380 links = &gsc_sd_entity->links[i]; 381 382 if (links == NULL || links->source->entity != gsc_sd_entity || 383 links->sink->entity != sink_sd_entity) { 384 continue; 385 } else if (exynos_media_setup_link(media0, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 386 ALOGE("%s::exynos_media_setup_link [src.entity=%d->sink.entity=%d] failed", 387 __func__, links->source->entity->info.id, links->sink->entity->info.id); 388 return -1; 389 } 390 } 391 392 /* gsc video-dev open */ 393 sprintf(devname, PFX_GSC_VIDEODEV_ENTITY, dev_num); 394 gsc_vd_entity->fd = exynos_v4l2_open_devname(devname, O_RDWR); 395 cap = V4L2_CAP_STREAMING | 396 V4L2_CAP_VIDEO_OUTPUT_MPLANE; 397 398 if (exynos_v4l2_querycap(gsc_vd_entity->fd, cap) == false) { 399 ALOGE("%s::exynos_v4l2_querycap() fail", __func__); 400 goto gsc_output_err; 401 } 402 gsc_handle->gsc_sd_entity = gsc_sd_entity; 403 gsc_handle->gsc_vd_entity = gsc_vd_entity; 404 gsc_handle->sink_sd_entity = sink_sd_entity; 405 gsc_handle->media0 = media0; 406 407 Exynos_gsc_Out(); 408 409 return 0; 410 411 gsc_output_err: 412 /* to do */ 413 return -1; 414 415 } 416 417 static int m_exynos_gsc_m2m_create( 418 int dev) 419 { 420 int fd = 0; 421 int video_node_num; 422 unsigned int cap; 423 char node[32]; 424 425 Exynos_gsc_In(); 426 427 switch(dev) { 428 case 0: 429 video_node_num = NODE_NUM_GSC_0; 430 break; 431 case 1: 432 video_node_num = NODE_NUM_GSC_1; 433 break; 434 case 2: 435 video_node_num = NODE_NUM_GSC_2; 436 break; 437 case 3: 438 video_node_num = NODE_NUM_GSC_3; 439 break; 440 default: 441 ALOGE("%s::unexpected dev(%d) fail", __func__, dev); 442 return -1; 443 break; 444 } 445 446 sprintf(node, "%s%d", PFX_NODE_GSC, video_node_num); 447 fd = exynos_v4l2_open(node, O_RDWR); 448 if (fd < 0) { 449 ALOGE("%s::exynos_v4l2_open(%s) fail", __func__, node); 450 return -1; 451 } 452 453 cap = V4L2_CAP_STREAMING | 454 V4L2_CAP_VIDEO_OUTPUT_MPLANE | 455 V4L2_CAP_VIDEO_CAPTURE_MPLANE; 456 457 if (exynos_v4l2_querycap(fd, cap) == false) { 458 ALOGE("%s::exynos_v4l2_querycap() fail", __func__); 459 if (0 < fd) 460 close(fd); 461 fd = 0; 462 return -1; 463 } 464 465 Exynos_gsc_Out(); 466 467 return fd; 468 } 469 470 471 static bool m_exynos_gsc_out_destroy(struct GSC_HANDLE *gsc_handle) 472 { 473 struct media_link * links; 474 int i; 475 476 Exynos_gsc_In(); 477 478 if (gsc_handle == NULL) { 479 ALOGE("%s::gsc_handle is NULL", __func__); 480 return false; 481 } 482 483 if (gsc_handle->src.stream_on == true) { 484 if (exynos_gsc_out_stop((void *)gsc_handle) < 0) 485 ALOGE("%s::exynos_gsc_out_stop() fail", __func__); 486 487 gsc_handle->src.stream_on = false; 488 } 489 490 /* unlink : gscaler-out --> fimd */ 491 for (i = 0; i < (int) gsc_handle->gsc_sd_entity->num_links; i++) { 492 links = &gsc_handle->gsc_sd_entity->links[i]; 493 494 if (links == NULL || links->source->entity != gsc_handle->gsc_sd_entity || 495 links->sink->entity != gsc_handle->sink_sd_entity) { 496 continue; 497 } else if (exynos_media_setup_link(gsc_handle->media0, links->source, 498 links->sink, 0) < 0) { 499 ALOGE("%s::exynos_media_setup_unlink [src.entity=%d->sink.entity=%d] failed", 500 __func__, links->source->entity->info.id, links->sink->entity->info.id); 501 } 502 } 503 504 close(gsc_handle->gsc_vd_entity->fd); 505 close(gsc_handle->gsc_sd_entity->fd); 506 gsc_handle->gsc_vd_entity->fd = -1; 507 gsc_handle->gsc_vd_entity->fd = -1; 508 509 Exynos_gsc_Out(); 510 511 return true; 512 513 } 514 515 static bool m_exynos_gsc_destroy( 516 struct GSC_HANDLE *gsc_handle) 517 { 518 Exynos_gsc_In(); 519 520 /* just in case, we call stop here because we cannot afford to leave 521 * secure side protection on if things failed. 522 */ 523 exynos_gsc_m2m_stop(gsc_handle); 524 525 if (0 < gsc_handle->gsc_fd) 526 close(gsc_handle->gsc_fd); 527 gsc_handle->gsc_fd = 0; 528 529 Exynos_gsc_Out(); 530 531 return true; 532 } 533 534 bool m_exynos_gsc_find_and_trylock_and_create( 535 struct GSC_HANDLE *gsc_handle) 536 { 537 int i = 0; 538 bool flag_find_new_gsc = false; 539 unsigned int total_sleep_time = 0; 540 541 Exynos_gsc_In(); 542 543 do { 544 for (i = 0; i < NUM_OF_GSC_HW; i++) { 545 // HACK : HWComposer, HDMI uses gscaler with their own code. 546 // So, This obj_mutex cannot defense their open() 547 if (i == 0 || i == 3) 548 continue; 549 550 if (exynos_mutex_trylock(gsc_handle->obj_mutex[i]) == true) { 551 552 // destroy old one. 553 m_exynos_gsc_destroy(gsc_handle); 554 555 // create new one. 556 gsc_handle->gsc_id = i; 557 gsc_handle->gsc_fd = m_exynos_gsc_m2m_create(i); 558 if (gsc_handle->gsc_fd < 0) { 559 gsc_handle->gsc_fd = 0; 560 exynos_mutex_unlock(gsc_handle->obj_mutex[i]); 561 continue; 562 } 563 564 /* Trade temporary object for one in the pool */ 565 if (gsc_handle->cur_obj_mutex) { 566 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 567 if (gsc_handle->destroy_cur_obj_mutex) 568 exynos_mutex_destroy(gsc_handle->cur_obj_mutex); 569 } 570 571 gsc_handle->destroy_cur_obj_mutex = false; 572 gsc_handle->cur_obj_mutex = gsc_handle->obj_mutex[i]; 573 574 flag_find_new_gsc = true; 575 break; 576 } 577 } 578 579 // waiting for another process doesn't use gscaler. 580 // we need to make decision how to do. 581 if (flag_find_new_gsc == false) { 582 usleep(GSC_WAITING_TIME_FOR_TRYLOCK); 583 total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK; 584 ALOGV("%s::waiting for anthere process doens't use gscaler", __func__); 585 } 586 587 } while( flag_find_new_gsc == false 588 && total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK); 589 590 if (flag_find_new_gsc == false) 591 ALOGE("%s::we don't have no available gsc.. fail", __func__); 592 593 Exynos_gsc_Out(); 594 595 return flag_find_new_gsc; 596 } 597 598 static bool m_exynos_gsc_set_format( 599 int fd, 600 struct gsc_info *info) 601 { 602 Exynos_gsc_In(); 603 604 struct v4l2_requestbuffers req_buf; 605 int plane_count; 606 607 plane_count = m_gsc_get_plane_count(info->v4l2_colorformat); 608 if (plane_count < 0) { 609 ALOGE("%s::not supported v4l2_colorformat", __func__); 610 return false; 611 } 612 613 if (exynos_v4l2_s_ctrl(fd, V4L2_CID_ROTATE, info->rotation) < 0) { 614 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_ROTATE) fail", __func__); 615 return false; 616 } 617 618 if (exynos_v4l2_s_ctrl(fd, V4L2_CID_VFLIP, info->flip_horizontal) < 0) { 619 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_VFLIP) fail", __func__); 620 return false; 621 } 622 623 if (exynos_v4l2_s_ctrl(fd, V4L2_CID_HFLIP, info->flip_vertical) < 0) { 624 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_HFLIP) fail", __func__); 625 return false; 626 } 627 628 if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CSC_RANGE, info->csc_range) < 0) { 629 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE) fail", __func__); 630 return false; 631 } 632 info->format.type = info->buf_type; 633 info->format.fmt.pix_mp.width = info->width; 634 info->format.fmt.pix_mp.height = info->height; 635 info->format.fmt.pix_mp.pixelformat = info->v4l2_colorformat; 636 info->format.fmt.pix_mp.field = V4L2_FIELD_ANY; 637 info->format.fmt.pix_mp.num_planes = plane_count; 638 639 if (exynos_v4l2_s_fmt(fd, &info->format) < 0) { 640 ALOGE("%s::exynos_v4l2_s_fmt() fail", __func__); 641 return false; 642 } 643 644 info->crop.type = info->buf_type; 645 info->crop.c.left = info->crop_left; 646 info->crop.c.top = info->crop_top; 647 info->crop.c.width = info->crop_width; 648 info->crop.c.height = info->crop_height; 649 650 if (exynos_v4l2_s_crop(fd, &info->crop) < 0) { 651 ALOGE("%s::exynos_v4l2_s_crop() fail", __func__); 652 return false; 653 } 654 655 if (exynos_v4l2_s_ctrl(fd, V4L2_CID_CACHEABLE, info->cacheable) < 0) { 656 ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__); 657 return false; 658 } 659 660 req_buf.count = 1; 661 req_buf.type = info->buf_type; 662 req_buf.memory = V4L2_MEMORY_DMABUF; 663 if (exynos_v4l2_reqbufs(fd, &req_buf) < 0) { 664 ALOGE("%s::exynos_v4l2_reqbufs() fail", __func__); 665 return false; 666 } 667 668 Exynos_gsc_Out(); 669 670 return true; 671 } 672 673 static bool m_exynos_gsc_set_addr( 674 int fd, 675 struct gsc_info *info) 676 { 677 unsigned int i; 678 unsigned int plane_size[NUM_OF_GSC_PLANES]; 679 680 m_gsc_get_plane_size(plane_size, 681 info->width, 682 info->height, 683 info->v4l2_colorformat); 684 685 info->buffer.index = 0; 686 info->buffer.flags = V4L2_BUF_FLAG_USE_SYNC; 687 info->buffer.type = info->buf_type; 688 info->buffer.memory = V4L2_MEMORY_DMABUF; 689 info->buffer.m.planes = info->planes; 690 info->buffer.length = info->format.fmt.pix_mp.num_planes; 691 info->buffer.reserved = info->acquireFenceFd; 692 693 for (i = 0; i < info->format.fmt.pix_mp.num_planes; i++) { 694 info->buffer.m.planes[i].m.fd = (int)info->addr[i]; 695 info->buffer.m.planes[i].length = plane_size[i]; 696 info->buffer.m.planes[i].bytesused = 0; 697 } 698 699 if (exynos_v4l2_qbuf(fd, &info->buffer) < 0) { 700 ALOGE("%s::exynos_v4l2_qbuf() fail", __func__); 701 return false; 702 } 703 info->buffer_queued = true; 704 705 info->releaseFenceFd = info->buffer.reserved; 706 707 return true; 708 } 709 710 void *exynos_gsc_create( 711 void) 712 { 713 int i = 0; 714 int op_id = 0; 715 char mutex_name[32]; 716 717 Exynos_gsc_In(); 718 719 struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE)); 720 if (gsc_handle == NULL) { 721 ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__); 722 goto err; 723 } 724 725 gsc_handle->gsc_fd = 0; 726 memset(&gsc_handle->src, 0, sizeof(struct gsc_info)); 727 memset(&gsc_handle->dst, 0, sizeof(struct gsc_info)); 728 729 gsc_handle->src.buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 730 gsc_handle->dst.buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 731 732 gsc_handle->op_mutex = NULL; 733 for (i = 0; i < NUM_OF_GSC_HW; i++) 734 gsc_handle->obj_mutex[i] = NULL; 735 736 gsc_handle->cur_obj_mutex = NULL; 737 gsc_handle->destroy_cur_obj_mutex = false; 738 gsc_handle->flag_local_path = false; 739 gsc_handle->flag_exclusive_open = false; 740 741 srand(time(NULL)); 742 op_id = rand() % 1000000; // just make random id 743 sprintf(mutex_name, "%sOp%d", LOG_TAG, op_id); 744 gsc_handle->op_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_PRIVATE, mutex_name); 745 if (gsc_handle->op_mutex == NULL) { 746 ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); 747 goto err; 748 } 749 750 exynos_mutex_lock(gsc_handle->op_mutex); 751 752 // check if it is available 753 for (i = 0; i < NUM_OF_GSC_HW; i++) { 754 sprintf(mutex_name, "%sObject%d", LOG_TAG, i); 755 756 gsc_handle->obj_mutex[i] = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name); 757 if (gsc_handle->obj_mutex[i] == NULL) { 758 ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); 759 goto err; 760 } 761 } 762 763 if (m_exynos_gsc_find_and_trylock_and_create(gsc_handle) == false) { 764 ALOGE("%s::m_exynos_gsc_find_and_trylock_and_create() fail", __func__); 765 goto err; 766 } 767 768 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 769 exynos_mutex_unlock(gsc_handle->op_mutex); 770 771 return (void *)gsc_handle; 772 773 err: 774 if (gsc_handle) { 775 m_exynos_gsc_destroy(gsc_handle); 776 777 if (gsc_handle->cur_obj_mutex) 778 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 779 780 for (i = 0; i < NUM_OF_GSC_HW; i++) { 781 if ((gsc_handle->obj_mutex[i] != NULL) && 782 (exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) { 783 if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false) 784 ALOGE("%s::exynos_mutex_destroy() fail", __func__); 785 } 786 } 787 788 if (gsc_handle->op_mutex) 789 exynos_mutex_unlock(gsc_handle->op_mutex); 790 791 if (exynos_mutex_destroy(gsc_handle->op_mutex) == false) 792 ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__); 793 794 free(gsc_handle); 795 } 796 797 Exynos_gsc_Out(); 798 799 return NULL; 800 } 801 802 void *exynos_gsc_reserve(int dev_num) 803 { 804 char mutex_name[32]; 805 unsigned int total_sleep_time = 0; 806 bool gsc_flag = false; 807 808 if ((dev_num < 0) || (dev_num >= NUM_OF_GSC_HW)) { 809 ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num); 810 return NULL; 811 } 812 813 struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE)); 814 if (gsc_handle == NULL) { 815 ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__); 816 goto err; 817 } 818 819 gsc_handle->gsc_fd = -1; 820 gsc_handle->op_mutex = NULL; 821 gsc_handle->cur_obj_mutex = NULL; 822 gsc_handle->destroy_cur_obj_mutex = true; 823 824 sprintf(mutex_name, "%sObject%d", LOG_TAG, dev_num); 825 gsc_handle->cur_obj_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name); 826 if (gsc_handle->cur_obj_mutex == NULL) { 827 ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); 828 goto err; 829 } 830 831 do { 832 if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == true) { 833 gsc_flag = true; 834 break; 835 } 836 usleep(GSC_WAITING_TIME_FOR_TRYLOCK); 837 total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK; 838 ALOGV("%s::waiting for another process to release the requested gscaler", __func__); 839 } while(total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK); 840 841 if (gsc_flag == true) 842 return (void *)gsc_handle; 843 844 err: 845 if (gsc_handle) { 846 free(gsc_handle); 847 } 848 849 return NULL; 850 } 851 852 void exynos_gsc_release(void *handle) 853 { 854 struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)handle; 855 856 if (handle == NULL) { 857 ALOGE("%s::handle == NULL() fail", __func__); 858 return; 859 } 860 861 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 862 exynos_mutex_destroy(gsc_handle->cur_obj_mutex); 863 free(gsc_handle); 864 return; 865 } 866 867 void *exynos_gsc_create_exclusive( 868 int dev_num, 869 int mode, 870 int out_mode, 871 int allow_drm) 872 { 873 int i = 0; 874 int op_id = 0; 875 char mutex_name[32]; 876 unsigned int total_sleep_time = 0; 877 bool gsc_flag = false; 878 int ret = 0; 879 880 Exynos_gsc_In(); 881 882 if ((dev_num < 0) || (dev_num >= NUM_OF_GSC_HW)) { 883 ALOGE("%s::fail:: dev_num is not valid(%d) ", __func__, dev_num); 884 return NULL; 885 } 886 887 if ((mode < 0) || (mode >= NUM_OF_GSC_HW)) { 888 ALOGE("%s::fail:: mode is not valid(%d) ", __func__, mode); 889 return NULL; 890 } 891 892 /* currently only gscalers 0 and 3 are DRM capable */ 893 if (allow_drm && (dev_num != 0 && dev_num != 3)) { 894 ALOGE("%s::fail:: gscaler %d does not support drm\n", __func__, 895 dev_num); 896 return NULL; 897 } 898 899 struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)malloc(sizeof(struct GSC_HANDLE)); 900 if (gsc_handle == NULL) { 901 ALOGE("%s::malloc(struct GSC_HANDLE) fail", __func__); 902 goto err; 903 } 904 memset(gsc_handle, 0, sizeof(struct GSC_HANDLE)); 905 gsc_handle->gsc_fd = -1; 906 gsc_handle->gsc_mode = mode; 907 gsc_handle->gsc_id = dev_num; 908 gsc_handle->allow_drm = allow_drm; 909 910 gsc_handle->src.buf_type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 911 gsc_handle->dst.buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 912 913 gsc_handle->op_mutex = NULL; 914 for (i = 0; i < NUM_OF_GSC_HW; i++) 915 gsc_handle->obj_mutex[i] = NULL; 916 917 gsc_handle->cur_obj_mutex = NULL; 918 gsc_handle->destroy_cur_obj_mutex = false; 919 gsc_handle->flag_local_path = false; 920 gsc_handle->flag_exclusive_open = true; 921 922 srand(time(NULL)); 923 op_id = rand() % 1000000; // just make random id 924 sprintf(mutex_name, "%sOp%d", LOG_TAG, op_id); 925 gsc_handle->op_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_PRIVATE, mutex_name); 926 if (gsc_handle->op_mutex == NULL) { 927 ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); 928 goto err; 929 } 930 931 exynos_mutex_lock(gsc_handle->op_mutex); 932 933 sprintf(mutex_name, "%sObject%d", LOG_TAG, dev_num); 934 gsc_handle->cur_obj_mutex = exynos_mutex_create(EXYNOS_MUTEX_TYPE_SHARED, mutex_name); 935 if (gsc_handle->cur_obj_mutex == NULL) { 936 ALOGE("%s::exynos_mutex_create(%s) fail", __func__, mutex_name); 937 goto err; 938 } 939 gsc_handle->destroy_cur_obj_mutex = true; 940 941 do { 942 if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == true) { 943 if (mode == GSC_M2M_MODE) { 944 gsc_handle->gsc_fd = m_exynos_gsc_m2m_create(dev_num); 945 if (gsc_handle->gsc_fd < 0) { 946 ALOGE("%s::m_exynos_gsc_m2m_create(%i) fail", __func__, dev_num); 947 goto err; 948 } 949 } else if (mode == GSC_OUTPUT_MODE) { 950 ret = m_exynos_gsc_output_create(gsc_handle, dev_num, out_mode); 951 if (ret < 0) { 952 ALOGE("%s::m_exynos_gsc_output_create(%i) fail", __func__, dev_num); 953 goto err; 954 } 955 } 956 /*else 957 gsc_handle->gsc_fd = m_exynos_gsc_capture_create(dev_num);*/ 958 959 gsc_flag = true; 960 break; 961 } 962 usleep(GSC_WAITING_TIME_FOR_TRYLOCK); 963 total_sleep_time += GSC_WAITING_TIME_FOR_TRYLOCK; 964 ALOGV("%s::waiting for anthere process doens't use gscaler", __func__); 965 } while(total_sleep_time < MAX_GSC_WAITING_TIME_FOR_TRYLOCK); 966 967 exynos_mutex_unlock(gsc_handle->op_mutex); 968 if (gsc_flag == true) { 969 Exynos_gsc_Out(); 970 return (void *)gsc_handle; 971 } 972 973 err: 974 if (gsc_handle) { 975 m_exynos_gsc_destroy(gsc_handle); 976 977 if (gsc_handle->cur_obj_mutex) { 978 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 979 if (gsc_handle->destroy_cur_obj_mutex) 980 exynos_mutex_destroy(gsc_handle->cur_obj_mutex); 981 } 982 983 for (i = 0; i < NUM_OF_GSC_HW; i++) { 984 if ((gsc_handle->obj_mutex[i] != NULL) && 985 (exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) { 986 if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false) 987 ALOGE("%s::exynos_mutex_destroy() fail", __func__); 988 } 989 } 990 991 if (gsc_handle->op_mutex) 992 exynos_mutex_unlock(gsc_handle->op_mutex); 993 994 if (exynos_mutex_destroy(gsc_handle->op_mutex) == false) 995 ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__); 996 997 free(gsc_handle); 998 } 999 1000 Exynos_gsc_Out(); 1001 1002 return NULL; 1003 } 1004 1005 void exynos_gsc_destroy( 1006 void *handle) 1007 { 1008 int i = 0; 1009 struct GSC_HANDLE *gsc_handle = (struct GSC_HANDLE *)handle; 1010 1011 Exynos_gsc_In(); 1012 1013 if (handle == NULL) { 1014 ALOGE("%s::handle == NULL() fail", __func__); 1015 return; 1016 } 1017 1018 exynos_mutex_lock(gsc_handle->op_mutex); 1019 1020 if (gsc_handle->flag_exclusive_open == false) 1021 exynos_mutex_lock(gsc_handle->cur_obj_mutex); 1022 1023 if (gsc_handle->gsc_mode == GSC_OUTPUT_MODE) 1024 m_exynos_gsc_out_destroy(gsc_handle); 1025 else 1026 m_exynos_gsc_destroy(gsc_handle); 1027 1028 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 1029 1030 for (i = 0; i < NUM_OF_GSC_HW; i++) { 1031 if ((gsc_handle->obj_mutex[i] != NULL) && 1032 (exynos_mutex_get_created_status(gsc_handle->obj_mutex[i]) == true)) { 1033 if (exynos_mutex_destroy(gsc_handle->obj_mutex[i]) == false) 1034 ALOGE("%s::exynos_mutex_destroy(obj_mutex) fail", __func__); 1035 } 1036 } 1037 1038 if (gsc_handle->destroy_cur_obj_mutex) 1039 exynos_mutex_destroy(gsc_handle->cur_obj_mutex); 1040 1041 exynos_mutex_unlock(gsc_handle->op_mutex); 1042 1043 if (exynos_mutex_destroy(gsc_handle->op_mutex) == false) 1044 ALOGE("%s::exynos_mutex_destroy(op_mutex) fail", __func__); 1045 1046 if (gsc_handle) 1047 free(gsc_handle); 1048 1049 Exynos_gsc_Out(); 1050 1051 } 1052 1053 int exynos_gsc_set_src_format( 1054 void *handle, 1055 unsigned int width, 1056 unsigned int height, 1057 unsigned int crop_left, 1058 unsigned int crop_top, 1059 unsigned int crop_width, 1060 unsigned int crop_height, 1061 unsigned int v4l2_colorformat, 1062 unsigned int cacheable, 1063 unsigned int mode_drm) 1064 { 1065 Exynos_gsc_In(); 1066 1067 struct GSC_HANDLE *gsc_handle; 1068 gsc_handle = (struct GSC_HANDLE *)handle; 1069 1070 if (handle == NULL) { 1071 ALOGE("%s::handle == NULL() fail", __func__); 1072 return -1; 1073 } 1074 1075 exynos_mutex_lock(gsc_handle->op_mutex); 1076 1077 gsc_handle->src.width = width; 1078 gsc_handle->src.height = height; 1079 gsc_handle->src.crop_left = crop_left; 1080 gsc_handle->src.crop_top = crop_top; 1081 gsc_handle->src.crop_width = crop_width; 1082 gsc_handle->src.crop_height = crop_height; 1083 gsc_handle->src.v4l2_colorformat = v4l2_colorformat; 1084 gsc_handle->src.cacheable = cacheable; 1085 gsc_handle->src.mode_drm = mode_drm; 1086 gsc_handle->src.dirty = true; 1087 1088 1089 exynos_mutex_unlock(gsc_handle->op_mutex); 1090 1091 Exynos_gsc_Out(); 1092 1093 return 0; 1094 } 1095 1096 int exynos_gsc_set_dst_format( 1097 void *handle, 1098 unsigned int width, 1099 unsigned int height, 1100 unsigned int crop_left, 1101 unsigned int crop_top, 1102 unsigned int crop_width, 1103 unsigned int crop_height, 1104 unsigned int v4l2_colorformat, 1105 unsigned int cacheable, 1106 unsigned int mode_drm, 1107 unsigned int narrowRgb) 1108 { 1109 Exynos_gsc_In(); 1110 1111 struct GSC_HANDLE *gsc_handle; 1112 gsc_handle = (struct GSC_HANDLE *)handle; 1113 1114 if (handle == NULL) { 1115 ALOGE("%s::handle == NULL() fail", __func__); 1116 return -1; 1117 } 1118 1119 exynos_mutex_lock(gsc_handle->op_mutex); 1120 1121 gsc_handle->dst.width = width; 1122 gsc_handle->dst.height = height; 1123 gsc_handle->dst.crop_left = crop_left; 1124 gsc_handle->dst.crop_top = crop_top; 1125 gsc_handle->dst.crop_width = crop_width; 1126 gsc_handle->dst.crop_height = crop_height; 1127 gsc_handle->dst.v4l2_colorformat = v4l2_colorformat; 1128 gsc_handle->dst.cacheable = cacheable; 1129 gsc_handle->dst.mode_drm = mode_drm; 1130 gsc_handle->dst.dirty = true; 1131 gsc_handle->dst.csc_range = !narrowRgb; 1132 1133 exynos_mutex_unlock(gsc_handle->op_mutex); 1134 1135 Exynos_gsc_Out(); 1136 return 0; 1137 } 1138 1139 int exynos_gsc_set_rotation( 1140 void *handle, 1141 int rotation, 1142 int flip_horizontal, 1143 int flip_vertical) 1144 { 1145 int ret = -1; 1146 struct GSC_HANDLE *gsc_handle; 1147 gsc_handle = (struct GSC_HANDLE *)handle; 1148 1149 if (handle == NULL) { 1150 ALOGE("%s::handle == NULL() fail", __func__); 1151 return ret; 1152 } 1153 1154 exynos_mutex_lock(gsc_handle->op_mutex); 1155 1156 int new_rotation = rotation % 360; 1157 1158 if (new_rotation % 90 != 0) { 1159 ALOGE("%s::rotation(%d) cannot be acceptable fail", __func__, rotation); 1160 goto done; 1161 } 1162 1163 if(new_rotation < 0) 1164 new_rotation = -new_rotation; 1165 1166 gsc_handle->dst.rotation = new_rotation; 1167 gsc_handle->dst.flip_horizontal = flip_horizontal; 1168 gsc_handle->dst.flip_vertical = flip_vertical; 1169 1170 ret = 0; 1171 done: 1172 exynos_mutex_unlock(gsc_handle->op_mutex); 1173 1174 return ret; 1175 } 1176 1177 int exynos_gsc_set_src_addr( 1178 void *handle, 1179 void *addr[3], 1180 int acquireFenceFd) 1181 { 1182 struct GSC_HANDLE *gsc_handle; 1183 gsc_handle = (struct GSC_HANDLE *)handle; 1184 1185 Exynos_gsc_In(); 1186 1187 if (handle == NULL) { 1188 ALOGE("%s::handle == NULL() fail", __func__); 1189 return -1; 1190 } 1191 1192 exynos_mutex_lock(gsc_handle->op_mutex); 1193 1194 gsc_handle->src.addr[0] = addr[0]; 1195 gsc_handle->src.addr[1] = addr[1]; 1196 gsc_handle->src.addr[2] = addr[2]; 1197 gsc_handle->src.acquireFenceFd = acquireFenceFd; 1198 1199 exynos_mutex_unlock(gsc_handle->op_mutex); 1200 1201 Exynos_gsc_Out(); 1202 1203 return 0; 1204 } 1205 1206 int exynos_gsc_set_dst_addr( 1207 void *handle, 1208 void *addr[3], 1209 int acquireFenceFd) 1210 { 1211 struct GSC_HANDLE *gsc_handle; 1212 gsc_handle = (struct GSC_HANDLE *)handle; 1213 int ret = 0; 1214 1215 Exynos_gsc_In(); 1216 1217 if (handle == NULL) { 1218 ALOGE("%s::handle == NULL() fail", __func__); 1219 return -1; 1220 } 1221 1222 exynos_mutex_lock(gsc_handle->op_mutex); 1223 1224 gsc_handle->dst.addr[0] = addr[0]; 1225 gsc_handle->dst.addr[1] = addr[1]; 1226 gsc_handle->dst.addr[2] = addr[2]; 1227 gsc_handle->dst.acquireFenceFd = acquireFenceFd; 1228 1229 1230 exynos_mutex_unlock(gsc_handle->op_mutex); 1231 1232 Exynos_gsc_Out(); 1233 1234 return ret; 1235 } 1236 1237 static void rotateValueHAL2GSC(unsigned int transform, 1238 unsigned int *rotate, 1239 unsigned int *hflip, 1240 unsigned int *vflip) 1241 { 1242 int rotate_flag = transform & 0x7; 1243 *rotate = 0; 1244 *hflip = 0; 1245 *vflip = 0; 1246 1247 switch (rotate_flag) { 1248 case HAL_TRANSFORM_ROT_90: 1249 *rotate = 90; 1250 break; 1251 case HAL_TRANSFORM_ROT_180: 1252 *rotate = 180; 1253 break; 1254 case HAL_TRANSFORM_ROT_270: 1255 *rotate = 270; 1256 break; 1257 case HAL_TRANSFORM_FLIP_H | HAL_TRANSFORM_ROT_90: 1258 *rotate = 90; 1259 *vflip = 1; /* set vflip to compensate the rot & flip order. */ 1260 break; 1261 case HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_ROT_90: 1262 *rotate = 90; 1263 *hflip = 1; /* set hflip to compensate the rot & flip order. */ 1264 break; 1265 case HAL_TRANSFORM_FLIP_H: 1266 *hflip = 1; 1267 break; 1268 case HAL_TRANSFORM_FLIP_V: 1269 *vflip = 1; 1270 break; 1271 default: 1272 break; 1273 } 1274 } 1275 1276 static bool get_plane_size(int V4L2_PIX, 1277 unsigned int * size, 1278 unsigned int frame_size, 1279 int src_planes) 1280 { 1281 unsigned int frame_ratio = 1; 1282 int src_bpp = get_yuv_bpp(V4L2_PIX); 1283 1284 src_planes = (src_planes == -1) ? 1 : src_planes; 1285 frame_ratio = 8 * (src_planes -1) / (src_bpp - 8); 1286 1287 switch (src_planes) { 1288 case 1: 1289 switch (V4L2_PIX) { 1290 case V4L2_PIX_FMT_BGR32: 1291 case V4L2_PIX_FMT_RGB32: 1292 size[0] = frame_size << 2; 1293 break; 1294 case V4L2_PIX_FMT_RGB565X: 1295 case V4L2_PIX_FMT_NV16: 1296 case V4L2_PIX_FMT_NV61: 1297 case V4L2_PIX_FMT_YUYV: 1298 case V4L2_PIX_FMT_UYVY: 1299 case V4L2_PIX_FMT_VYUY: 1300 case V4L2_PIX_FMT_YVYU: 1301 size[0] = frame_size << 1; 1302 break; 1303 case V4L2_PIX_FMT_YUV420: 1304 case V4L2_PIX_FMT_NV12: 1305 case V4L2_PIX_FMT_NV21: 1306 case V4L2_PIX_FMT_NV21M: 1307 size[0] = (frame_size * 3) >> 1; 1308 break; 1309 default: 1310 ALOGE("%s::invalid color type", __func__); 1311 return false; 1312 break; 1313 } 1314 size[1] = 0; 1315 size[2] = 0; 1316 break; 1317 case 2: 1318 size[0] = frame_size; 1319 size[1] = frame_size / frame_ratio; 1320 size[2] = 0; 1321 break; 1322 case 3: 1323 size[0] = frame_size; 1324 size[1] = frame_size / frame_ratio; 1325 size[2] = frame_size / frame_ratio; 1326 break; 1327 default: 1328 ALOGE("%s::invalid color foarmt", __func__); 1329 return false; 1330 break; 1331 } 1332 1333 return true; 1334 } 1335 1336 int exynos_gsc_m2m_config(void *handle, 1337 exynos_gsc_img *src_img, 1338 exynos_gsc_img *dst_img) 1339 { 1340 struct GSC_HANDLE *gsc_handle; 1341 int32_t src_color_space; 1342 int32_t dst_color_space; 1343 int ret; 1344 unsigned int rotate; 1345 unsigned int hflip; 1346 unsigned int vflip; 1347 1348 Exynos_gsc_In(); 1349 1350 gsc_handle = (struct GSC_HANDLE *)handle; 1351 if (gsc_handle == NULL) { 1352 ALOGE("%s::gsc_handle == NULL() fail", __func__); 1353 return -1; 1354 } 1355 1356 if ((src_img->drmMode && !gsc_handle->allow_drm) || 1357 (src_img->drmMode != dst_img->drmMode)) { 1358 ALOGE("%s::invalid drm state request for gsc%d (s=%d d=%d)", 1359 __func__, gsc_handle->gsc_id, 1360 src_img->drmMode, dst_img->drmMode); 1361 return -1; 1362 } 1363 1364 src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format); 1365 dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format); 1366 rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip); 1367 exynos_gsc_set_rotation(gsc_handle, rotate, hflip, vflip); 1368 1369 ret = exynos_gsc_set_src_format(gsc_handle, src_img->fw, src_img->fh, 1370 src_img->x, src_img->y, src_img->w, src_img->h, 1371 src_color_space, src_img->cacheable, src_img->drmMode); 1372 if (ret < 0) { 1373 ALOGE("%s: fail: exynos_gsc_set_src_format [fw %d fh %d x %d y %d w %d h %d f %x rot %d]", 1374 __func__, src_img->fw, src_img->fh, src_img->x, src_img->y, src_img->w, src_img->h, 1375 src_color_space, src_img->rot); 1376 return -1; 1377 } 1378 1379 ret = exynos_gsc_set_dst_format(gsc_handle, dst_img->fw, dst_img->fh, 1380 dst_img->x, dst_img->y, dst_img->w, dst_img->h, 1381 dst_color_space, dst_img->cacheable, dst_img->drmMode, 1382 dst_img->narrowRgb); 1383 if (ret < 0) { 1384 ALOGE("%s: fail: exynos_gsc_set_dst_format [fw %d fh %d x %d y %d w %d h %d f %x rot %d]", 1385 __func__, dst_img->fw, dst_img->fh, dst_img->x, dst_img->y, dst_img->w, dst_img->h, 1386 src_color_space, dst_img->rot); 1387 return -1; 1388 } 1389 1390 Exynos_gsc_Out(); 1391 1392 return 0; 1393 } 1394 1395 int exynos_gsc_out_config(void *handle, 1396 exynos_gsc_img *src_img, 1397 exynos_gsc_img *dst_img) 1398 { 1399 struct GSC_HANDLE *gsc_handle; 1400 struct v4l2_format fmt; 1401 struct v4l2_crop crop; 1402 struct v4l2_requestbuffers reqbuf; 1403 struct v4l2_subdev_format sd_fmt; 1404 struct v4l2_subdev_crop sd_crop; 1405 int i; 1406 unsigned int rotate; 1407 unsigned int hflip; 1408 unsigned int vflip; 1409 unsigned int plane_size[NUM_OF_GSC_PLANES]; 1410 bool rgb; 1411 int csc_range = !dst_img->narrowRgb; 1412 1413 struct v4l2_rect dst_rect; 1414 int32_t src_color_space; 1415 int32_t dst_color_space; 1416 int32_t src_planes; 1417 1418 gsc_handle = (struct GSC_HANDLE *)handle; 1419 if (gsc_handle == NULL) { 1420 ALOGE("%s::gsc_handle == NULL() fail", __func__); 1421 return -1; 1422 } 1423 1424 Exynos_gsc_In(); 1425 1426 if (gsc_handle->src.stream_on != false) { 1427 ALOGE("Error: Src is already streamed on !!!!"); 1428 return -1; 1429 } 1430 1431 memcpy(&gsc_handle->src_img, src_img, sizeof(exynos_gsc_img)); 1432 memcpy(&gsc_handle->dst_img, dst_img, sizeof(exynos_gsc_img)); 1433 src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(src_img->format); 1434 dst_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(dst_img->format); 1435 src_planes = get_yuv_planes(src_color_space); 1436 src_planes = (src_planes == -1) ? 1 : src_planes; 1437 rgb = get_yuv_planes(dst_color_space) == -1; 1438 rotateValueHAL2GSC(dst_img->rot, &rotate, &hflip, &vflip); 1439 1440 if (m_exynos_gsc_check_src_size(&gsc_handle->src_img.fw, &gsc_handle->src_img.fh, 1441 &gsc_handle->src_img.x, &gsc_handle->src_img.y, 1442 &gsc_handle->src_img.w, &gsc_handle->src_img.h, 1443 src_color_space) == false) { 1444 ALOGE("%s::m_exynos_gsc_check_src_size() fail", __func__); 1445 return -1; 1446 } 1447 1448 if (m_exynos_gsc_check_dst_size(&gsc_handle->dst_img.fw, &gsc_handle->dst_img.fh, 1449 &gsc_handle->dst_img.x, &gsc_handle->dst_img.y, 1450 &gsc_handle->dst_img.w, &gsc_handle->dst_img.h, 1451 dst_color_space, 1452 rotate) == false) { 1453 ALOGE("%s::m_exynos_gsc_check_dst_size() fail", __func__); 1454 return -1; 1455 } 1456 1457 /*set: src v4l2_buffer*/ 1458 gsc_handle->src.src_buf_idx = 0; 1459 gsc_handle->src.qbuf_cnt = 0; 1460 /* set format: src pad of GSC sub-dev*/ 1461 sd_fmt.pad = GSCALER_SUBDEV_PAD_SOURCE; 1462 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1463 if (gsc_handle->out_mode == GSC_OUT_FIMD) { 1464 sd_fmt.format.width = gsc_handle->dst_img.fw; 1465 sd_fmt.format.height = gsc_handle->dst_img.fh; 1466 } else { 1467 sd_fmt.format.width = gsc_handle->dst_img.w; 1468 sd_fmt.format.height = gsc_handle->dst_img.h; 1469 } 1470 sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE : 1471 V4L2_MBUS_FMT_YUV8_1X24; 1472 if (exynos_subdev_s_fmt(gsc_handle->gsc_sd_entity->fd, &sd_fmt) < 0) { 1473 ALOGE("%s::GSC subdev set format failed", __func__); 1474 return -1; 1475 } 1476 1477 /* set crop: src crop of GSC sub-dev*/ 1478 sd_crop.pad = GSCALER_SUBDEV_PAD_SOURCE; 1479 sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1480 if (gsc_handle->out_mode == GSC_OUT_FIMD) { 1481 sd_crop.rect.left = gsc_handle->dst_img.x; 1482 sd_crop.rect.top = gsc_handle->dst_img.y; 1483 sd_crop.rect.width = gsc_handle->dst_img.w; 1484 sd_crop.rect.height = gsc_handle->dst_img.h; 1485 } else { 1486 sd_crop.rect.left = 0; 1487 sd_crop.rect.top = 0; 1488 sd_crop.rect.width = gsc_handle->dst_img.w; 1489 sd_crop.rect.height = gsc_handle->dst_img.h; 1490 } 1491 if (exynos_subdev_s_crop(gsc_handle->gsc_sd_entity->fd, &sd_crop) < 0) { 1492 ALOGE("%s::GSC subdev set crop failed", __func__); 1493 return -1; 1494 } 1495 1496 /* sink pad is connected to GSC out */ 1497 /* set format: sink sub-dev */ 1498 if (gsc_handle->out_mode == GSC_OUT_FIMD) { 1499 sd_fmt.pad = FIMD_SUBDEV_PAD_SINK; 1500 sd_fmt.format.width = gsc_handle->dst_img.w; 1501 sd_fmt.format.height = gsc_handle->dst_img.h; 1502 } else { 1503 sd_fmt.pad = MIXER_V_SUBDEV_PAD_SINK; 1504 sd_fmt.format.width = gsc_handle->dst_img.w + gsc_handle->dst_img.x*2; 1505 sd_fmt.format.height = gsc_handle->dst_img.h + gsc_handle->dst_img.y*2; 1506 } 1507 1508 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1509 sd_fmt.format.code = rgb ? V4L2_MBUS_FMT_XRGB8888_4X8_LE : 1510 V4L2_MBUS_FMT_YUV8_1X24; 1511 if (exynos_subdev_s_fmt(gsc_handle->sink_sd_entity->fd, &sd_fmt) < 0) { 1512 ALOGE("%s::sink:set format failed (PAD=%d)", __func__, sd_fmt.pad); 1513 return -1; 1514 } 1515 1516 /* set crop: sink sub-dev */ 1517 if (gsc_handle->out_mode == GSC_OUT_FIMD) 1518 sd_crop.pad = FIMD_SUBDEV_PAD_SINK; 1519 else 1520 sd_crop.pad = MIXER_V_SUBDEV_PAD_SINK; 1521 1522 sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1523 if (gsc_handle->out_mode == GSC_OUT_FIMD) { 1524 sd_crop.rect.left = gsc_handle->dst_img.x; 1525 sd_crop.rect.top = gsc_handle->dst_img.y; 1526 sd_crop.rect.width = gsc_handle->dst_img.w; 1527 sd_crop.rect.height = gsc_handle->dst_img.h; 1528 } else { 1529 sd_crop.rect.left = 0; 1530 sd_crop.rect.top = 0; 1531 sd_crop.rect.width = gsc_handle->dst_img.w; 1532 sd_crop.rect.height = gsc_handle->dst_img.h; 1533 } 1534 if (exynos_subdev_s_crop(gsc_handle->sink_sd_entity->fd, &sd_crop) < 0) { 1535 ALOGE("%s::sink: subdev set crop failed(PAD=%d)", __func__, sd_crop.pad); 1536 return -1; 1537 } 1538 1539 if (gsc_handle->out_mode != GSC_OUT_FIMD) { 1540 sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE; 1541 sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1542 sd_fmt.format.width = gsc_handle->dst_img.w + gsc_handle->dst_img.x*2; 1543 sd_fmt.format.height = gsc_handle->dst_img.h + gsc_handle->dst_img.y*2; 1544 sd_fmt.format.code = V4L2_MBUS_FMT_XRGB8888_4X8_LE; 1545 if (exynos_subdev_s_fmt(gsc_handle->sink_sd_entity->fd, &sd_fmt) < 0) { 1546 ALOGE("%s::sink:set format failed (PAD=%d)", __func__, sd_fmt.pad); 1547 return -1; 1548 } 1549 1550 sd_fmt.pad = MIXER_V_SUBDEV_PAD_SOURCE; 1551 sd_crop.which = V4L2_SUBDEV_FORMAT_ACTIVE; 1552 sd_crop.rect.left = gsc_handle->dst_img.x; 1553 sd_crop.rect.top = gsc_handle->dst_img.y; 1554 sd_crop.rect.width = gsc_handle->dst_img.w; 1555 sd_crop.rect.height = gsc_handle->dst_img.h; 1556 if (exynos_subdev_s_crop(gsc_handle->sink_sd_entity->fd, &sd_crop) < 0) { 1557 ALOGE("%s::sink: subdev set crop failed(PAD=%d)", __func__, sd_crop.pad); 1558 return -1; 1559 } 1560 } 1561 1562 /*set GSC ctrls */ 1563 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_ROTATE, rotate) < 0) { 1564 ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_ROTATE: %d) failed", __func__, rotate); 1565 return -1; 1566 } 1567 1568 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_HFLIP, hflip) < 0) { 1569 ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_HFLIP: %d) failed", __func__, hflip); 1570 return -1; 1571 } 1572 1573 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_VFLIP, vflip) < 0) { 1574 ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_VFLIP: %d) failed", __func__, vflip); 1575 return -1; 1576 } 1577 1578 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_CACHEABLE, 1) < 0) { 1579 ALOGE("%s:: exynos_v4l2_s_ctrl (V4L2_CID_CACHEABLE: 1) failed", __func__); 1580 return -1; 1581 } 1582 1583 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, 1584 V4L2_CID_CONTENT_PROTECTION, gsc_handle->src_img.drmMode) < 0) { 1585 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail", __func__); 1586 return -1; 1587 } 1588 1589 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_vd_entity->fd, V4L2_CID_CSC_RANGE, 1590 csc_range)) { 1591 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CSC_RANGE: %d) fail", __func__, 1592 csc_range); 1593 return -1; 1594 } 1595 1596 /* set src format :GSC video dev*/ 1597 fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1598 fmt.fmt.pix_mp.width = gsc_handle->src_img.fw; 1599 fmt.fmt.pix_mp.height = gsc_handle->src_img.fh; 1600 fmt.fmt.pix_mp.pixelformat = src_color_space; 1601 fmt.fmt.pix_mp.field = V4L2_FIELD_NONE; 1602 fmt.fmt.pix_mp.num_planes = src_planes; 1603 1604 if (exynos_v4l2_s_fmt(gsc_handle->gsc_vd_entity->fd, &fmt) < 0) { 1605 ALOGE("%s::videodev set format failed", __func__); 1606 return -1; 1607 } 1608 1609 /* set src crop info :GSC video dev*/ 1610 crop.type = fmt.type; 1611 crop.c.left = gsc_handle->src_img.x; 1612 crop.c.top = gsc_handle->src_img.y; 1613 crop.c.width = gsc_handle->src_img.w; 1614 crop.c.height = gsc_handle->src_img.h; 1615 1616 if (exynos_v4l2_s_crop(gsc_handle->gsc_vd_entity->fd, &crop) < 0) { 1617 ALOGE("%s::videodev set crop failed", __func__); 1618 return -1; 1619 } 1620 1621 reqbuf.type = fmt.type; 1622 reqbuf.memory = V4L2_MEMORY_DMABUF; 1623 reqbuf.count = MAX_BUFFERS_GSCALER_OUT; 1624 1625 if (exynos_v4l2_reqbufs(gsc_handle->gsc_vd_entity->fd, &reqbuf) < 0) { 1626 ALOGE("%s::request buffers failed", __func__); 1627 return -1; 1628 } 1629 1630 Exynos_gsc_Out(); 1631 1632 return 0; 1633 } 1634 1635 static int exynos_gsc_out_run(void *handle, 1636 exynos_gsc_img *src_img) 1637 { 1638 struct GSC_HANDLE *gsc_handle; 1639 struct v4l2_plane planes[NUM_OF_GSC_PLANES]; 1640 struct v4l2_buffer buf; 1641 int32_t src_color_space; 1642 int32_t src_planes; 1643 int i; 1644 unsigned int plane_size[NUM_OF_GSC_PLANES]; 1645 1646 gsc_handle = (struct GSC_HANDLE *)handle; 1647 if (handle == NULL) { 1648 ALOGE("%s::handle == NULL() fail", __func__); 1649 return -1; 1650 } 1651 1652 /* All buffers have been queued, dequeue one */ 1653 if (gsc_handle->src.qbuf_cnt == MAX_BUFFERS_GSCALER_OUT) { 1654 memset(&buf, 0, sizeof(struct v4l2_buffer)); 1655 for (i = 0; i < MAX_BUFFERS_GSCALER_OUT; i++) 1656 memset(&planes[i], 0, sizeof(struct v4l2_plane)); 1657 1658 buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1659 buf.memory = V4L2_MEMORY_DMABUF; 1660 buf.length = src_planes; 1661 buf.m.planes = planes; 1662 1663 if (exynos_v4l2_dqbuf(gsc_handle->gsc_vd_entity->fd, &buf) < 0) { 1664 ALOGE("%s::dequeue buffer failed (index=%d)(mSrcBufNum=%d)", __func__, 1665 gsc_handle->src.src_buf_idx, MAX_BUFFERS_GSCALER_OUT); 1666 return -1; 1667 } 1668 gsc_handle->src.qbuf_cnt--; 1669 } 1670 1671 memset(&buf, 0, sizeof(struct v4l2_buffer)); 1672 for (i = 0; i < NUM_OF_GSC_PLANES; i++) 1673 memset(&planes[i], 0, sizeof(struct v4l2_plane)); 1674 1675 src_color_space = HAL_PIXEL_FORMAT_2_V4L2_PIX(gsc_handle->src_img.format); 1676 src_planes = get_yuv_planes(src_color_space); 1677 src_planes = (src_planes == -1) ? 1 : src_planes; 1678 1679 buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1680 buf.memory = V4L2_MEMORY_DMABUF; 1681 buf.flags = V4L2_BUF_FLAG_USE_SYNC; 1682 buf.length = src_planes; 1683 buf.index = gsc_handle->src.src_buf_idx; 1684 buf.m.planes = planes; 1685 buf.reserved = src_img->acquireFenceFd; 1686 1687 gsc_handle->src.addr[0] = src_img->yaddr; 1688 gsc_handle->src.addr[1] = src_img->uaddr; 1689 gsc_handle->src.addr[2] = src_img->vaddr; 1690 1691 if (get_plane_size(src_color_space, plane_size, 1692 gsc_handle->src_img.fw * gsc_handle->src_img.fh, src_planes) != true) { 1693 ALOGE("%s:get_plane_size:fail", __func__); 1694 return -1; 1695 } 1696 1697 for (i = 0; i < buf.length; i++) { 1698 buf.m.planes[i].m.fd = (int)gsc_handle->src.addr[i]; 1699 buf.m.planes[i].length = plane_size[i]; 1700 buf.m.planes[i].bytesused = plane_size[i]; 1701 } 1702 1703 /* Queue the buf */ 1704 if (exynos_v4l2_qbuf(gsc_handle->gsc_vd_entity->fd, &buf) < 0) { 1705 ALOGE("%s::queue buffer failed (index=%d)(mSrcBufNum=%d)", __func__, 1706 gsc_handle->src.src_buf_idx, MAX_BUFFERS_GSCALER_OUT); 1707 return -1; 1708 } 1709 gsc_handle->src.src_buf_idx++; 1710 gsc_handle->src.src_buf_idx = gsc_handle->src.src_buf_idx % MAX_BUFFERS_GSCALER_OUT; 1711 gsc_handle->src.qbuf_cnt++; 1712 1713 if (gsc_handle->src.stream_on == false) { 1714 if (exynos_v4l2_streamon(gsc_handle->gsc_vd_entity->fd, buf.type) < 0) { 1715 ALOGE("%s::stream on failed", __func__); 1716 return -1; 1717 } 1718 gsc_handle->src.stream_on = true; 1719 } 1720 1721 src_img->releaseFenceFd = buf.reserved; 1722 return 0; 1723 } 1724 1725 int exynos_gsc_out_stop(void *handle) 1726 { 1727 struct GSC_HANDLE *gsc_handle; 1728 struct v4l2_requestbuffers reqbuf; 1729 struct v4l2_buffer buf; 1730 struct v4l2_plane planes[NUM_OF_GSC_PLANES]; 1731 int i; 1732 1733 Exynos_gsc_In(); 1734 1735 gsc_handle = (struct GSC_HANDLE *)handle; 1736 if (handle == NULL) { 1737 ALOGE("%s::handle == NULL() fail", __func__); 1738 return -1; 1739 } 1740 1741 if (gsc_handle->src.stream_on == true) { 1742 if (exynos_v4l2_streamoff(gsc_handle->gsc_vd_entity->fd, 1743 V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) < 0) { 1744 ALOGE("%s::stream off failed", __func__); 1745 return -1; 1746 } 1747 gsc_handle->src.stream_on = false; 1748 } 1749 1750 gsc_handle->src.src_buf_idx = 0; 1751 gsc_handle->src.qbuf_cnt = 0; 1752 1753 reqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE; 1754 reqbuf.memory = V4L2_MEMORY_DMABUF; 1755 reqbuf.count = 0; 1756 1757 if (exynos_v4l2_reqbufs(gsc_handle->gsc_vd_entity->fd, &reqbuf) < 0) { 1758 ALOGE("%s::request buffers failed", __func__); 1759 return -1; 1760 } 1761 1762 Exynos_gsc_Out(); 1763 1764 return 0; 1765 } 1766 1767 static int exynos_gsc_m2m_run_core(void *handle) 1768 { 1769 struct GSC_HANDLE *gsc_handle; 1770 bool is_dirty; 1771 bool is_drm; 1772 1773 gsc_handle = (struct GSC_HANDLE *)handle; 1774 1775 Exynos_gsc_In(); 1776 1777 if (handle == NULL) { 1778 ALOGE("%s::handle == NULL() fail", __func__); 1779 return -1; 1780 } 1781 1782 is_dirty = gsc_handle->src.dirty || gsc_handle->dst.dirty; 1783 is_drm = gsc_handle->src.mode_drm; 1784 1785 if (is_dirty && (gsc_handle->src.mode_drm != gsc_handle->dst.mode_drm)) { 1786 ALOGE("%s: drm mode mismatch between src and dst, gsc%d (s=%d d=%d)", 1787 __func__, gsc_handle->gsc_id, gsc_handle->src.mode_drm, 1788 gsc_handle->dst.mode_drm); 1789 return -1; 1790 } else if (is_drm && !gsc_handle->allow_drm) { 1791 ALOGE("%s: drm mode is not supported on gsc%d", __func__, 1792 gsc_handle->gsc_id); 1793 return -1; 1794 } 1795 1796 if (m_exynos_gsc_check_src_size(&gsc_handle->src.width, &gsc_handle->src.height, 1797 &gsc_handle->src.crop_left, &gsc_handle->src.crop_top, 1798 &gsc_handle->src.crop_width, &gsc_handle->src.crop_height, 1799 gsc_handle->src.v4l2_colorformat) == false) { 1800 ALOGE("%s::m_exynos_gsc_check_src_size() fail", __func__); 1801 return -1; 1802 } 1803 1804 if (m_exynos_gsc_check_dst_size(&gsc_handle->dst.width, &gsc_handle->dst.height, 1805 &gsc_handle->dst.crop_left, &gsc_handle->dst.crop_top, 1806 &gsc_handle->dst.crop_width, &gsc_handle->dst.crop_height, 1807 gsc_handle->dst.v4l2_colorformat, 1808 gsc_handle->dst.rotation) == false) { 1809 ALOGE("%s::m_exynos_gsc_check_dst_size() fail", __func__); 1810 return -1; 1811 } 1812 1813 /* dequeue buffers from previous work if necessary */ 1814 if (gsc_handle->src.stream_on == true) { 1815 if (exynos_gsc_m2m_wait_frame_done(handle) < 0) { 1816 ALOGE("%s::exynos_gsc_m2m_wait_frame_done fail", __func__); 1817 return -1; 1818 } 1819 } 1820 1821 /* 1822 * need to set the content protection flag before doing reqbufs 1823 * in set_format 1824 */ 1825 if (is_dirty && gsc_handle->allow_drm && is_drm) { 1826 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_fd, 1827 V4L2_CID_CONTENT_PROTECTION, is_drm) < 0) { 1828 ALOGE("%s::exynos_v4l2_s_ctrl() fail", __func__); 1829 return -1; 1830 } 1831 } 1832 1833 /* 1834 * from this point on, we have to ensure to call stop to clean up whatever 1835 * state we have set. 1836 */ 1837 1838 if (gsc_handle->src.dirty) { 1839 if (m_exynos_gsc_set_format(gsc_handle->gsc_fd, &gsc_handle->src) == false) { 1840 ALOGE("%s::m_exynos_gsc_set_format(src) fail", __func__); 1841 goto done; 1842 } 1843 gsc_handle->src.dirty = false; 1844 } 1845 1846 if (gsc_handle->dst.dirty) { 1847 if (m_exynos_gsc_set_format(gsc_handle->gsc_fd, &gsc_handle->dst) == false) { 1848 ALOGE("%s::m_exynos_gsc_set_format(dst) fail", __func__); 1849 goto done; 1850 } 1851 gsc_handle->dst.dirty = false; 1852 } 1853 1854 /* if we are enabling drm, make sure to enable hw protection. 1855 * Need to do this before queuing buffers so that the mmu is reserved 1856 * and power domain is kept on. 1857 */ 1858 if (is_dirty && gsc_handle->allow_drm && is_drm) { 1859 unsigned int protect_id = 0; 1860 1861 if (gsc_handle->gsc_id == 0) { 1862 protect_id = CP_PROTECT_GSC0; 1863 } else if (gsc_handle->gsc_id == 3) { 1864 protect_id = CP_PROTECT_GSC3; 1865 } else { 1866 ALOGE("%s::invalid gscaler id %d for content protection", __func__, 1867 gsc_handle->gsc_id); 1868 goto done; 1869 } 1870 1871 if (CP_Enable_Path_Protection(protect_id) != 0) { 1872 ALOGE("%s::CP_Enable_Path_Protection failed", __func__); 1873 goto done; 1874 } 1875 gsc_handle->protection_enabled = true; 1876 } 1877 1878 if (m_exynos_gsc_set_addr(gsc_handle->gsc_fd, &gsc_handle->src) == false) { 1879 ALOGE("%s::m_exynos_gsc_set_addr(src) fail", __func__); 1880 goto done; 1881 } 1882 1883 if (m_exynos_gsc_set_addr(gsc_handle->gsc_fd, &gsc_handle->dst) == false) { 1884 ALOGE("%s::m_exynos_gsc_set_addr(dst) fail", __func__); 1885 goto done; 1886 } 1887 1888 if (gsc_handle->src.stream_on == false) { 1889 if (exynos_v4l2_streamon(gsc_handle->gsc_fd, gsc_handle->src.buf_type) < 0) { 1890 ALOGE("%s::exynos_v4l2_streamon(src) fail", __func__); 1891 goto done; 1892 } 1893 gsc_handle->src.stream_on = true; 1894 } 1895 1896 if (gsc_handle->dst.stream_on == false) { 1897 if (exynos_v4l2_streamon(gsc_handle->gsc_fd, gsc_handle->dst.buf_type) < 0) { 1898 ALOGE("%s::exynos_v4l2_streamon(dst) fail", __func__); 1899 goto done; 1900 } 1901 gsc_handle->dst.stream_on = true; 1902 } 1903 1904 Exynos_gsc_Out(); 1905 1906 return 0; 1907 1908 done: 1909 exynos_gsc_m2m_stop(handle); 1910 return -1; 1911 } 1912 1913 static int exynos_gsc_m2m_wait_frame_done(void *handle) 1914 { 1915 struct GSC_HANDLE *gsc_handle; 1916 1917 gsc_handle = (struct GSC_HANDLE *)handle; 1918 1919 Exynos_gsc_In(); 1920 1921 if (handle == NULL) { 1922 ALOGE("%s::handle == NULL() fail", __func__); 1923 return -1; 1924 } 1925 1926 if ((gsc_handle->src.stream_on == false) || (gsc_handle->dst.stream_on == false)) { 1927 ALOGE("%s:: src_strean_on or dst_stream_on are false", __func__); 1928 return -1; 1929 } 1930 1931 if (gsc_handle->src.buffer_queued) { 1932 if (exynos_v4l2_dqbuf(gsc_handle->gsc_fd, &gsc_handle->src.buffer) < 0) { 1933 ALOGE("%s::exynos_v4l2_dqbuf(src) fail", __func__); 1934 return -1; 1935 } 1936 gsc_handle->src.buffer_queued = false; 1937 } 1938 1939 if (gsc_handle->dst.buffer_queued) { 1940 if (exynos_v4l2_dqbuf(gsc_handle->gsc_fd, &gsc_handle->dst.buffer) < 0) { 1941 ALOGE("%s::exynos_v4l2_dqbuf(dst) fail", __func__); 1942 return -1; 1943 } 1944 gsc_handle->dst.buffer_queued = false; 1945 } 1946 1947 Exynos_gsc_Out(); 1948 1949 return 0; 1950 } 1951 1952 static int exynos_gsc_m2m_stop(void *handle) 1953 { 1954 struct GSC_HANDLE *gsc_handle; 1955 struct v4l2_requestbuffers req_buf; 1956 int ret = 0; 1957 1958 gsc_handle = (struct GSC_HANDLE *)handle; 1959 1960 Exynos_gsc_In(); 1961 1962 if (!gsc_handle->src.stream_on && !gsc_handle->dst.stream_on) { 1963 /* wasn't streaming, return success */ 1964 return 0; 1965 } else if (gsc_handle->src.stream_on != gsc_handle->dst.stream_on) { 1966 ALOGE("%s: invalid state, queue stream state doesn't match (%d != %d)", 1967 __func__, gsc_handle->src.stream_on, gsc_handle->dst.stream_on); 1968 ret = -1; 1969 } 1970 1971 /* 1972 * we need to plow forward on errors below to make sure that if we had 1973 * turned on content protection on secure side, we turn it off. 1974 * 1975 * also, if we only failed to turn on one of the streams, we'll turn 1976 * the other one off correctly. 1977 */ 1978 if (gsc_handle->src.stream_on == true) { 1979 if (exynos_v4l2_streamoff(gsc_handle->gsc_fd, gsc_handle->src.buf_type) < 0) { 1980 ALOGE("%s::exynos_v4l2_streamoff(src) fail", __func__); 1981 ret = -1; 1982 } 1983 gsc_handle->src.stream_on = false; 1984 } 1985 1986 1987 if (gsc_handle->dst.stream_on == true) { 1988 if (exynos_v4l2_streamoff(gsc_handle->gsc_fd, gsc_handle->dst.buf_type) < 0) { 1989 ALOGE("%s::exynos_v4l2_streamoff(dst) fail", __func__); 1990 ret = -1; 1991 } 1992 gsc_handle->dst.stream_on = false; 1993 } 1994 1995 /* if drm is enabled */ 1996 if (gsc_handle->allow_drm && gsc_handle->protection_enabled) { 1997 unsigned int protect_id = 0; 1998 1999 if (gsc_handle->gsc_id == 0) 2000 protect_id = CP_PROTECT_GSC0; 2001 else if (gsc_handle->gsc_id == 3) 2002 protect_id = CP_PROTECT_GSC3; 2003 2004 CP_Disable_Path_Protection(protect_id); 2005 gsc_handle->protection_enabled = false; 2006 } 2007 2008 if (exynos_v4l2_s_ctrl(gsc_handle->gsc_fd, 2009 V4L2_CID_CONTENT_PROTECTION, 0) < 0) { 2010 ALOGE("%s::exynos_v4l2_s_ctrl(V4L2_CID_CONTENT_PROTECTION) fail", 2011 __func__); 2012 ret = -1; 2013 } 2014 2015 /* src: clear_buf */ 2016 req_buf.count = 0; 2017 req_buf.type = gsc_handle->src.buf_type; 2018 req_buf.memory = V4L2_MEMORY_DMABUF; 2019 if (exynos_v4l2_reqbufs(gsc_handle->gsc_fd, &req_buf) < 0) { 2020 ALOGE("%s::exynos_v4l2_reqbufs():src: fail", __func__); 2021 ret = -1; 2022 } 2023 2024 /* dst: clear_buf */ 2025 req_buf.count = 0; 2026 req_buf.type = gsc_handle->dst.buf_type; 2027 req_buf.memory = V4L2_MEMORY_DMABUF; 2028 if (exynos_v4l2_reqbufs(gsc_handle->gsc_fd, &req_buf) < 0) { 2029 ALOGE("%s::exynos_v4l2_reqbufs():dst: fail", __func__); 2030 ret = -1; 2031 } 2032 2033 Exynos_gsc_Out(); 2034 2035 return ret; 2036 } 2037 2038 int exynos_gsc_convert( 2039 void *handle) 2040 { 2041 struct GSC_HANDLE *gsc_handle; 2042 int ret = -1; 2043 gsc_handle = (struct GSC_HANDLE *)handle; 2044 2045 Exynos_gsc_In(); 2046 2047 if (handle == NULL) { 2048 ALOGE("%s::handle == NULL() fail", __func__); 2049 return -1; 2050 } 2051 2052 exynos_mutex_lock(gsc_handle->op_mutex); 2053 2054 if (gsc_handle->flag_local_path == true) { 2055 ALOGE("%s::this exynos_gsc is connected by another hw internaly. So, don't call exynos_gsc_convert()", __func__); 2056 goto done; 2057 } 2058 2059 if (exynos_gsc_m2m_run_core(handle) < 0) { 2060 ALOGE("%s::exynos_gsc_run_core fail", __func__); 2061 goto done; 2062 } 2063 2064 if (exynos_gsc_m2m_wait_frame_done(handle) < 0) { 2065 ALOGE("%s::exynos_gsc_m2m_wait_frame_done", __func__); 2066 goto done; 2067 } 2068 2069 if (gsc_handle->src.releaseFenceFd >= 0) { 2070 close(gsc_handle->src.releaseFenceFd); 2071 gsc_handle->src.releaseFenceFd = -1; 2072 } 2073 2074 if (gsc_handle->dst.releaseFenceFd >= 0) { 2075 close(gsc_handle->dst.releaseFenceFd); 2076 gsc_handle->dst.releaseFenceFd = -1; 2077 } 2078 2079 if (exynos_gsc_m2m_stop(handle) < 0) { 2080 ALOGE("%s::exynos_gsc_m2m_stop", __func__); 2081 goto done; 2082 } 2083 2084 ret = 0; 2085 2086 done: 2087 if (gsc_handle->flag_exclusive_open == false) { 2088 if (gsc_handle->flag_local_path == false) 2089 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 2090 } 2091 2092 exynos_mutex_unlock(gsc_handle->op_mutex); 2093 2094 Exynos_gsc_Out(); 2095 2096 return ret; 2097 } 2098 2099 int exynos_gsc_m2m_run(void *handle, 2100 exynos_gsc_img *src_img, 2101 exynos_gsc_img *dst_img) 2102 { 2103 struct GSC_HANDLE *gsc_handle = handle; 2104 void *addr[3] = {NULL, NULL, NULL}; 2105 int ret = 0; 2106 2107 Exynos_gsc_In(); 2108 2109 addr[0] = (void *)src_img->yaddr; 2110 addr[1] = (void *)src_img->uaddr; 2111 addr[2] = (void *)src_img->vaddr; 2112 ret = exynos_gsc_set_src_addr(handle, addr, src_img->acquireFenceFd); 2113 if (ret < 0) { 2114 ALOGE("%s::fail: exynos_gsc_set_src_addr[%x %x %x]", __func__, 2115 (unsigned int)addr[0], (unsigned int)addr[1], (unsigned int)addr[2]); 2116 return -1; 2117 } 2118 2119 addr[0] = (void *)dst_img->yaddr; 2120 addr[1] = (void *)dst_img->uaddr; 2121 addr[2] = (void *)dst_img->vaddr; 2122 ret = exynos_gsc_set_dst_addr(handle, addr, dst_img->acquireFenceFd); 2123 if (ret < 0) { 2124 ALOGE("%s::fail: exynos_gsc_set_dst_addr[%x %x %x]", __func__, 2125 (unsigned int)addr[0], (unsigned int)addr[1], (unsigned int)addr[2]); 2126 return -1; 2127 } 2128 2129 ret = exynos_gsc_m2m_run_core(handle); 2130 if (ret < 0) { 2131 ALOGE("%s::fail: exynos_gsc_m2m_run_core", __func__); 2132 return -1; 2133 } 2134 2135 if (src_img->acquireFenceFd >= 0) { 2136 close(src_img->acquireFenceFd); 2137 src_img->acquireFenceFd = -1; 2138 } 2139 2140 if (dst_img->acquireFenceFd >= 0) { 2141 close(dst_img->acquireFenceFd); 2142 dst_img->acquireFenceFd = -1; 2143 } 2144 2145 src_img->releaseFenceFd = gsc_handle->src.releaseFenceFd; 2146 dst_img->releaseFenceFd = gsc_handle->dst.releaseFenceFd; 2147 2148 Exynos_gsc_Out(); 2149 2150 return 0; 2151 } 2152 2153 int exynos_gsc_config_exclusive(void *handle, 2154 exynos_gsc_img *src_img, 2155 exynos_gsc_img *dst_img) 2156 { 2157 2158 Exynos_gsc_In(); 2159 2160 struct GSC_HANDLE *gsc_handle; 2161 int ret = 0; 2162 gsc_handle = (struct GSC_HANDLE *)handle; 2163 if (handle == NULL) { 2164 ALOGE("%s::handle == NULL() fail", __func__); 2165 return -1; 2166 } 2167 2168 switch (gsc_handle->gsc_mode) { 2169 case GSC_M2M_MODE: 2170 ret = exynos_gsc_m2m_config(handle, src_img, dst_img); 2171 break; 2172 case GSC_OUTPUT_MODE: 2173 ret = exynos_gsc_out_config(handle, src_img, dst_img); 2174 break; 2175 case GSC_CAPTURE_MODE: 2176 //to do 2177 break; 2178 default: 2179 break; 2180 } 2181 2182 Exynos_gsc_Out(); 2183 2184 return ret; 2185 2186 } 2187 2188 int exynos_gsc_run_exclusive(void *handle, 2189 exynos_gsc_img *src_img, 2190 exynos_gsc_img *dst_img) 2191 { 2192 struct GSC_HANDLE *gsc_handle; 2193 int ret = 0; 2194 2195 Exynos_gsc_In(); 2196 2197 gsc_handle = (struct GSC_HANDLE *)handle; 2198 if (handle == NULL) { 2199 ALOGE("%s::handle == NULL() fail", __func__); 2200 return -1; 2201 } 2202 2203 switch (gsc_handle->gsc_mode) { 2204 case GSC_M2M_MODE: 2205 ret = exynos_gsc_m2m_run(handle, src_img, dst_img); 2206 break; 2207 case GSC_OUTPUT_MODE: 2208 ret = exynos_gsc_out_run(handle, src_img); 2209 break; 2210 case GSC_CAPTURE_MODE: 2211 //to do 2212 break; 2213 default: 2214 break; 2215 } 2216 2217 Exynos_gsc_Out(); 2218 2219 return ret; 2220 } 2221 2222 int exynos_gsc_wait_frame_done_exclusive(void *handle) 2223 { 2224 struct GSC_HANDLE *gsc_handle; 2225 int ret = 0; 2226 gsc_handle = (struct GSC_HANDLE *)handle; 2227 2228 Exynos_gsc_In(); 2229 2230 if (handle == NULL) { 2231 ALOGE("%s::handle == NULL() fail", __func__); 2232 return -1; 2233 } 2234 2235 if (gsc_handle->gsc_mode == GSC_M2M_MODE) 2236 ret = exynos_gsc_m2m_wait_frame_done(handle); 2237 2238 Exynos_gsc_Out(); 2239 2240 return ret; 2241 } 2242 2243 int exynos_gsc_stop_exclusive(void *handle) 2244 { 2245 struct GSC_HANDLE *gsc_handle; 2246 int ret = 0; 2247 gsc_handle = (struct GSC_HANDLE *)handle; 2248 2249 Exynos_gsc_In(); 2250 2251 if (handle == NULL) { 2252 ALOGE("%s::handle == NULL() fail", __func__); 2253 return -1; 2254 } 2255 2256 switch (gsc_handle->gsc_mode) { 2257 case GSC_M2M_MODE: 2258 ret = exynos_gsc_m2m_stop(handle); 2259 break; 2260 case GSC_OUTPUT_MODE: 2261 ret = exynos_gsc_out_stop(handle); 2262 break; 2263 case GSC_CAPTURE_MODE: 2264 //to do 2265 break; 2266 default: 2267 break; 2268 } 2269 2270 Exynos_gsc_Out(); 2271 2272 return ret; 2273 } 2274 2275 int exynos_gsc_connect( 2276 void *handle, 2277 void *hw) 2278 { 2279 struct GSC_HANDLE *gsc_handle; 2280 int ret = -1; 2281 gsc_handle = (struct GSC_HANDLE *)handle; 2282 2283 Exynos_gsc_In(); 2284 2285 if (handle == NULL) { 2286 ALOGE("%s::handle == NULL() fail", __func__); 2287 return -1; 2288 } 2289 2290 exynos_mutex_lock(gsc_handle->op_mutex); 2291 2292 gsc_handle->flag_local_path = true; 2293 2294 if (exynos_mutex_trylock(gsc_handle->cur_obj_mutex) == false) { 2295 if (m_exynos_gsc_find_and_trylock_and_create(gsc_handle) == false) { 2296 ALOGE("%s::m_exynos_gsc_find_and_trylock_and_create() fail", __func__); 2297 goto done; 2298 } 2299 } 2300 2301 ret = 0; 2302 2303 Exynos_gsc_Out(); 2304 2305 done: 2306 exynos_mutex_unlock(gsc_handle->op_mutex); 2307 2308 return ret; 2309 } 2310 2311 int exynos_gsc_disconnect( 2312 void *handle, 2313 void *hw) 2314 { 2315 struct GSC_HANDLE *gsc_handle; 2316 gsc_handle = (struct GSC_HANDLE *)handle; 2317 2318 Exynos_gsc_In(); 2319 2320 if (handle == NULL) { 2321 ALOGE("%s::handle == NULL() fail", __func__); 2322 return -1; 2323 } 2324 2325 exynos_mutex_lock(gsc_handle->op_mutex); 2326 2327 gsc_handle->flag_local_path = false; 2328 2329 exynos_mutex_unlock(gsc_handle->cur_obj_mutex); 2330 2331 exynos_mutex_unlock(gsc_handle->op_mutex); 2332 2333 Exynos_gsc_Out(); 2334 2335 return 0; 2336 } 2337
