1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. 4 */ 5 6 #include <media/v4l2-mem2mem.h> 7 8 #include "iris_hfi_gen2.h" 9 #include "iris_hfi_gen2_defines.h" 10 #include "iris_hfi_gen2_packet.h" 11 #include "iris_vdec.h" 12 #include "iris_vpu_buffer.h" 13 #include "iris_vpu_common.h" 14 15 struct iris_hfi_gen2_core_hfi_range { 16 u32 begin; 17 u32 end; 18 int (*handle)(struct iris_core *core, struct iris_hfi_packet *pkt); 19 }; 20 21 struct iris_hfi_gen2_inst_hfi_range { 22 u32 begin; 23 u32 end; 24 int (*handle)(struct iris_inst *inst, struct iris_hfi_packet *pkt); 25 }; 26 27 struct iris_hfi_gen2_packet_handle { 28 enum hfi_buffer_type type; 29 int (*handle)(struct iris_inst *inst, struct iris_hfi_packet *pkt); 30 }; 31 32 static u32 iris_hfi_gen2_buf_type_to_driver(enum hfi_buffer_type buf_type) 33 { 34 switch (buf_type) { 35 case HFI_BUFFER_BITSTREAM: 36 return BUF_INPUT; 37 case HFI_BUFFER_RAW: 38 return BUF_OUTPUT; 39 case HFI_BUFFER_BIN: 40 return BUF_BIN; 41 case HFI_BUFFER_ARP: 42 return BUF_ARP; 43 case HFI_BUFFER_COMV: 44 return BUF_COMV; 45 case HFI_BUFFER_NON_COMV: 46 return BUF_NON_COMV; 47 case HFI_BUFFER_LINE: 48 return BUF_LINE; 49 case HFI_BUFFER_DPB: 50 return BUF_DPB; 51 case HFI_BUFFER_PERSIST: 52 return BUF_PERSIST; 53 default: 54 return 0; 55 } 56 } 57 58 static bool iris_hfi_gen2_is_valid_hfi_buffer_type(u32 buffer_type) 59 { 60 switch (buffer_type) { 61 case HFI_BUFFER_BITSTREAM: 62 case HFI_BUFFER_RAW: 63 case HFI_BUFFER_BIN: 64 case HFI_BUFFER_ARP: 65 case HFI_BUFFER_COMV: 66 case HFI_BUFFER_NON_COMV: 67 case HFI_BUFFER_LINE: 68 case HFI_BUFFER_DPB: 69 case HFI_BUFFER_PERSIST: 70 case HFI_BUFFER_VPSS: 71 return true; 72 default: 73 return false; 74 } 75 } 76 77 static bool iris_hfi_gen2_is_valid_hfi_port(u32 port, u32 buffer_type) 78 { 79 if (port == HFI_PORT_NONE && buffer_type != HFI_BUFFER_PERSIST) 80 return false; 81 82 if (port != HFI_PORT_BITSTREAM && port != HFI_PORT_RAW) 83 return false; 84 85 return true; 86 } 87 88 static int iris_hfi_gen2_get_driver_buffer_flags(struct iris_inst *inst, u32 hfi_flags) 89 { 90 u32 keyframe = HFI_PICTURE_IDR | HFI_PICTURE_I | HFI_PICTURE_CRA | HFI_PICTURE_BLA; 91 struct iris_inst_hfi_gen2 *inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 92 u32 driver_flags = 0; 93 94 if (inst_hfi_gen2->hfi_frame_info.picture_type & HFI_PICTURE_NOSHOW) 95 driver_flags |= V4L2_BUF_FLAG_ERROR; 96 else if (inst_hfi_gen2->hfi_frame_info.picture_type & keyframe) 97 driver_flags |= V4L2_BUF_FLAG_KEYFRAME; 98 else if (inst_hfi_gen2->hfi_frame_info.picture_type & HFI_PICTURE_P) 99 driver_flags |= V4L2_BUF_FLAG_PFRAME; 100 else if (inst_hfi_gen2->hfi_frame_info.picture_type & HFI_PICTURE_B) 101 driver_flags |= V4L2_BUF_FLAG_BFRAME; 102 103 if (inst_hfi_gen2->hfi_frame_info.data_corrupt || inst_hfi_gen2->hfi_frame_info.overflow) 104 driver_flags |= V4L2_BUF_FLAG_ERROR; 105 106 if (hfi_flags & HFI_BUF_FW_FLAG_LAST || 107 hfi_flags & HFI_BUF_FW_FLAG_PSC_LAST) 108 driver_flags |= V4L2_BUF_FLAG_LAST; 109 110 return driver_flags; 111 } 112 113 static bool iris_hfi_gen2_validate_packet_payload(struct iris_hfi_packet *pkt) 114 { 115 u32 payload_size = 0; 116 117 switch (pkt->payload_info) { 118 case HFI_PAYLOAD_U32: 119 case HFI_PAYLOAD_S32: 120 case HFI_PAYLOAD_Q16: 121 case HFI_PAYLOAD_U32_ENUM: 122 case HFI_PAYLOAD_32_PACKED: 123 payload_size = 4; 124 break; 125 case HFI_PAYLOAD_U64: 126 case HFI_PAYLOAD_S64: 127 case HFI_PAYLOAD_64_PACKED: 128 payload_size = 8; 129 break; 130 case HFI_PAYLOAD_STRUCTURE: 131 if (pkt->type == HFI_CMD_BUFFER) 132 payload_size = sizeof(struct iris_hfi_buffer); 133 break; 134 default: 135 payload_size = 0; 136 break; 137 } 138 139 if (pkt->size < sizeof(struct iris_hfi_packet) + payload_size) 140 return false; 141 142 return true; 143 } 144 145 static int iris_hfi_gen2_validate_packet(u8 *response_pkt, u8 *core_resp_pkt) 146 { 147 u8 *response_limit = core_resp_pkt + IFACEQ_CORE_PKT_SIZE; 148 u32 response_pkt_size = *(u32 *)response_pkt; 149 150 if (!response_pkt_size) 151 return -EINVAL; 152 153 if (response_pkt_size < sizeof(struct iris_hfi_packet)) 154 return -EINVAL; 155 156 if (response_pkt + response_pkt_size > response_limit) 157 return -EINVAL; 158 159 return 0; 160 } 161 162 static int iris_hfi_gen2_validate_hdr_packet(struct iris_core *core, struct iris_hfi_header *hdr) 163 { 164 struct iris_hfi_packet *packet; 165 int ret; 166 u8 *pkt; 167 u32 i; 168 169 if (hdr->size < sizeof(*hdr) + sizeof(*packet)) 170 return -EINVAL; 171 172 pkt = (u8 *)((u8 *)hdr + sizeof(*hdr)); 173 174 for (i = 0; i < hdr->num_packets; i++) { 175 packet = (struct iris_hfi_packet *)pkt; 176 ret = iris_hfi_gen2_validate_packet(pkt, core->response_packet); 177 if (ret) 178 return ret; 179 180 pkt += packet->size; 181 } 182 183 return 0; 184 } 185 186 static int iris_hfi_gen2_handle_session_info(struct iris_inst *inst, 187 struct iris_hfi_packet *pkt) 188 { 189 struct iris_inst_hfi_gen2 *inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 190 struct iris_core *core = inst->core; 191 int ret = 0; 192 char *info; 193 194 switch (pkt->type) { 195 case HFI_INFO_UNSUPPORTED: 196 info = "unsupported"; 197 break; 198 case HFI_INFO_DATA_CORRUPT: 199 info = "data corrupt"; 200 inst_hfi_gen2->hfi_frame_info.data_corrupt = 1; 201 break; 202 case HFI_INFO_BUFFER_OVERFLOW: 203 info = "buffer overflow"; 204 inst_hfi_gen2->hfi_frame_info.overflow = 1; 205 break; 206 case HFI_INFO_HFI_FLAG_DRAIN_LAST: 207 info = "drain last flag"; 208 ret = iris_inst_sub_state_change_drain_last(inst); 209 break; 210 case HFI_INFO_HFI_FLAG_PSC_LAST: 211 info = "drc last flag"; 212 ret = iris_inst_sub_state_change_drc_last(inst); 213 break; 214 default: 215 info = "unknown"; 216 break; 217 } 218 219 dev_dbg(core->dev, "session info received %#x: %s\n", 220 pkt->type, info); 221 222 return ret; 223 } 224 225 static int iris_hfi_gen2_handle_session_error(struct iris_inst *inst, 226 struct iris_hfi_packet *pkt) 227 { 228 struct iris_core *core = inst->core; 229 char *error; 230 231 switch (pkt->type) { 232 case HFI_ERROR_MAX_SESSIONS: 233 error = "exceeded max sessions"; 234 break; 235 case HFI_ERROR_UNKNOWN_SESSION: 236 error = "unknown session id"; 237 break; 238 case HFI_ERROR_INVALID_STATE: 239 error = "invalid operation for current state"; 240 break; 241 case HFI_ERROR_INSUFFICIENT_RESOURCES: 242 error = "insufficient resources"; 243 break; 244 case HFI_ERROR_BUFFER_NOT_SET: 245 error = "internal buffers not set"; 246 break; 247 case HFI_ERROR_FATAL: 248 error = "fatal error"; 249 break; 250 case HFI_ERROR_STREAM_UNSUPPORTED: 251 error = "unsupported stream"; 252 break; 253 default: 254 error = "unknown"; 255 break; 256 } 257 258 dev_err(core->dev, "session error received %#x: %s\n", pkt->type, error); 259 iris_vb2_queue_error(inst); 260 iris_inst_change_state(inst, IRIS_INST_ERROR); 261 262 return 0; 263 } 264 265 static int iris_hfi_gen2_handle_system_error(struct iris_core *core, 266 struct iris_hfi_packet *pkt) 267 { 268 struct iris_inst *instance; 269 270 if (pkt) 271 dev_err(core->dev, "received system error of type %#x\n", pkt->type); 272 273 core->state = IRIS_CORE_ERROR; 274 275 mutex_lock(&core->lock); 276 list_for_each_entry(instance, &core->instances, list) 277 iris_inst_change_state(instance, IRIS_INST_ERROR); 278 mutex_unlock(&core->lock); 279 280 schedule_delayed_work(&core->sys_error_handler, msecs_to_jiffies(10)); 281 282 return 0; 283 } 284 285 static int iris_hfi_gen2_handle_system_init(struct iris_core *core, 286 struct iris_hfi_packet *pkt) 287 { 288 if (!(pkt->flags & HFI_FW_FLAGS_SUCCESS)) { 289 core->state = IRIS_CORE_ERROR; 290 return 0; 291 } 292 293 complete(&core->core_init_done); 294 295 return 0; 296 } 297 298 static void iris_hfi_gen2_handle_session_close(struct iris_inst *inst, 299 struct iris_hfi_packet *pkt) 300 { 301 if (!(pkt->flags & HFI_FW_FLAGS_SUCCESS)) { 302 iris_inst_change_state(inst, IRIS_INST_ERROR); 303 return; 304 } 305 306 complete(&inst->completion); 307 } 308 309 static int iris_hfi_gen2_handle_input_buffer(struct iris_inst *inst, 310 struct iris_hfi_buffer *buffer) 311 { 312 struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx; 313 struct v4l2_m2m_buffer *m2m_buffer, *n; 314 struct iris_buffer *buf; 315 bool found = false; 316 317 v4l2_m2m_for_each_src_buf_safe(m2m_ctx, m2m_buffer, n) { 318 buf = to_iris_buffer(&m2m_buffer->vb); 319 if (buf->index == buffer->index) { 320 found = true; 321 break; 322 } 323 } 324 if (!found) 325 return -EINVAL; 326 327 if (!(buf->attr & BUF_ATTR_QUEUED)) 328 return -EINVAL; 329 330 buf->attr &= ~BUF_ATTR_QUEUED; 331 buf->attr |= BUF_ATTR_DEQUEUED; 332 333 buf->flags = iris_hfi_gen2_get_driver_buffer_flags(inst, buffer->flags); 334 335 return 0; 336 } 337 338 static int iris_hfi_gen2_handle_output_buffer(struct iris_inst *inst, 339 struct iris_hfi_buffer *hfi_buffer) 340 { 341 struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx; 342 struct v4l2_m2m_buffer *m2m_buffer, *n; 343 struct iris_buffer *buf; 344 bool found = false; 345 int ret; 346 347 if (hfi_buffer->flags & HFI_BUF_FW_FLAG_LAST) { 348 ret = iris_inst_sub_state_change_drain_last(inst); 349 if (ret) 350 return ret; 351 } 352 353 if (hfi_buffer->flags & HFI_BUF_FW_FLAG_PSC_LAST) { 354 ret = iris_inst_sub_state_change_drc_last(inst); 355 if (ret) 356 return ret; 357 } 358 359 v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, m2m_buffer, n) { 360 buf = to_iris_buffer(&m2m_buffer->vb); 361 if (buf->index == hfi_buffer->index && 362 buf->device_addr == hfi_buffer->base_address && 363 buf->data_offset == hfi_buffer->data_offset) { 364 found = true; 365 break; 366 } 367 } 368 if (!found) 369 return -EINVAL; 370 371 if (!(buf->attr & BUF_ATTR_QUEUED)) 372 return -EINVAL; 373 374 buf->data_offset = hfi_buffer->data_offset; 375 buf->data_size = hfi_buffer->data_size; 376 buf->timestamp = hfi_buffer->timestamp; 377 378 buf->attr &= ~BUF_ATTR_QUEUED; 379 buf->attr |= BUF_ATTR_DEQUEUED; 380 381 buf->flags = iris_hfi_gen2_get_driver_buffer_flags(inst, hfi_buffer->flags); 382 383 if (!buf->data_size && inst->state == IRIS_INST_STREAMING && 384 !(hfi_buffer->flags & HFI_BUF_FW_FLAG_LAST)) { 385 buf->flags |= V4L2_BUF_FLAG_ERROR; 386 } 387 388 return 0; 389 } 390 391 static void iris_hfi_gen2_handle_dequeue_buffers(struct iris_inst *inst) 392 { 393 struct v4l2_m2m_ctx *m2m_ctx = inst->m2m_ctx; 394 struct v4l2_m2m_buffer *buffer, *n; 395 struct iris_buffer *buf = NULL; 396 397 v4l2_m2m_for_each_src_buf_safe(m2m_ctx, buffer, n) { 398 buf = to_iris_buffer(&buffer->vb); 399 if (buf->attr & BUF_ATTR_DEQUEUED) { 400 buf->attr &= ~BUF_ATTR_DEQUEUED; 401 if (!(buf->attr & BUF_ATTR_BUFFER_DONE)) { 402 buf->attr |= BUF_ATTR_BUFFER_DONE; 403 iris_vb2_buffer_done(inst, buf); 404 } 405 } 406 } 407 408 v4l2_m2m_for_each_dst_buf_safe(m2m_ctx, buffer, n) { 409 buf = to_iris_buffer(&buffer->vb); 410 if (buf->attr & BUF_ATTR_DEQUEUED) { 411 buf->attr &= ~BUF_ATTR_DEQUEUED; 412 if (!(buf->attr & BUF_ATTR_BUFFER_DONE)) { 413 buf->attr |= BUF_ATTR_BUFFER_DONE; 414 iris_vb2_buffer_done(inst, buf); 415 } 416 } 417 } 418 } 419 420 static int iris_hfi_gen2_handle_release_internal_buffer(struct iris_inst *inst, 421 struct iris_hfi_buffer *buffer) 422 { 423 u32 buf_type = iris_hfi_gen2_buf_type_to_driver(buffer->type); 424 struct iris_buffers *buffers = &inst->buffers[buf_type]; 425 struct iris_buffer *buf, *iter; 426 bool found = false; 427 int ret = 0; 428 429 list_for_each_entry(iter, &buffers->list, list) { 430 if (iter->device_addr == buffer->base_address) { 431 found = true; 432 buf = iter; 433 break; 434 } 435 } 436 if (!found) 437 return -EINVAL; 438 439 buf->attr &= ~BUF_ATTR_QUEUED; 440 if (buf->attr & BUF_ATTR_PENDING_RELEASE) 441 ret = iris_destroy_internal_buffer(inst, buf); 442 443 return ret; 444 } 445 446 static int iris_hfi_gen2_handle_session_stop(struct iris_inst *inst, 447 struct iris_hfi_packet *pkt) 448 { 449 int ret = 0; 450 451 if (pkt->port == HFI_PORT_RAW) 452 ret = iris_inst_sub_state_change_pause(inst, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE); 453 else if (pkt->port == HFI_PORT_BITSTREAM) 454 ret = iris_inst_sub_state_change_pause(inst, V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE); 455 456 complete(&inst->completion); 457 458 return ret; 459 } 460 461 static int iris_hfi_gen2_handle_session_buffer(struct iris_inst *inst, 462 struct iris_hfi_packet *pkt) 463 { 464 struct iris_hfi_buffer *buffer; 465 466 if (pkt->payload_info == HFI_PAYLOAD_NONE) 467 return 0; 468 469 if (!iris_hfi_gen2_validate_packet_payload(pkt)) { 470 iris_inst_change_state(inst, IRIS_INST_ERROR); 471 return 0; 472 } 473 474 buffer = (struct iris_hfi_buffer *)((u8 *)pkt + sizeof(*pkt)); 475 if (!iris_hfi_gen2_is_valid_hfi_buffer_type(buffer->type)) 476 return 0; 477 478 if (!iris_hfi_gen2_is_valid_hfi_port(pkt->port, buffer->type)) 479 return 0; 480 481 if (buffer->type == HFI_BUFFER_BITSTREAM) 482 return iris_hfi_gen2_handle_input_buffer(inst, buffer); 483 else if (buffer->type == HFI_BUFFER_RAW) 484 return iris_hfi_gen2_handle_output_buffer(inst, buffer); 485 else 486 return iris_hfi_gen2_handle_release_internal_buffer(inst, buffer); 487 } 488 489 static int iris_hfi_gen2_handle_session_drain(struct iris_inst *inst, 490 struct iris_hfi_packet *pkt) 491 { 492 int ret = 0; 493 494 if (!(pkt->flags & HFI_FW_FLAGS_SUCCESS)) { 495 iris_inst_change_state(inst, IRIS_INST_ERROR); 496 return 0; 497 } 498 499 if (inst->sub_state & IRIS_INST_SUB_DRAIN) 500 ret = iris_inst_change_sub_state(inst, 0, IRIS_INST_SUB_INPUT_PAUSE); 501 502 return ret; 503 } 504 505 static void iris_hfi_gen2_read_input_subcr_params(struct iris_inst *inst) 506 { 507 struct iris_inst_hfi_gen2 *inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 508 struct v4l2_pix_format_mplane *pixmp_ip = &inst->fmt_src->fmt.pix_mp; 509 struct v4l2_pix_format_mplane *pixmp_op = &inst->fmt_dst->fmt.pix_mp; 510 u32 primaries, matrix_coeff, transfer_char; 511 struct hfi_subscription_params subsc_params; 512 u32 colour_description_present_flag; 513 u32 video_signal_type_present_flag; 514 struct iris_core *core = inst->core; 515 u32 full_range, width, height; 516 struct vb2_queue *dst_q; 517 struct v4l2_ctrl *ctrl; 518 519 subsc_params = inst_hfi_gen2->src_subcr_params; 520 width = (subsc_params.bitstream_resolution & 521 HFI_BITMASK_BITSTREAM_WIDTH) >> 16; 522 height = subsc_params.bitstream_resolution & 523 HFI_BITMASK_BITSTREAM_HEIGHT; 524 525 pixmp_ip->width = width; 526 pixmp_ip->height = height; 527 528 pixmp_op->width = ALIGN(width, 128); 529 pixmp_op->height = ALIGN(height, 32); 530 pixmp_op->plane_fmt[0].bytesperline = ALIGN(width, 128); 531 pixmp_op->plane_fmt[0].sizeimage = iris_get_buffer_size(inst, BUF_OUTPUT); 532 533 matrix_coeff = subsc_params.color_info & 0xFF; 534 transfer_char = (subsc_params.color_info & 0xFF00) >> 8; 535 primaries = (subsc_params.color_info & 0xFF0000) >> 16; 536 colour_description_present_flag = 537 (subsc_params.color_info & 0x1000000) >> 24; 538 full_range = (subsc_params.color_info & 0x2000000) >> 25; 539 video_signal_type_present_flag = 540 (subsc_params.color_info & 0x20000000) >> 29; 541 542 pixmp_op->colorspace = V4L2_COLORSPACE_DEFAULT; 543 pixmp_op->xfer_func = V4L2_XFER_FUNC_DEFAULT; 544 pixmp_op->ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT; 545 pixmp_op->quantization = V4L2_QUANTIZATION_DEFAULT; 546 547 if (video_signal_type_present_flag) { 548 pixmp_op->quantization = 549 full_range ? 550 V4L2_QUANTIZATION_FULL_RANGE : 551 V4L2_QUANTIZATION_LIM_RANGE; 552 if (colour_description_present_flag) { 553 pixmp_op->colorspace = 554 iris_hfi_get_v4l2_color_primaries(primaries); 555 pixmp_op->xfer_func = 556 iris_hfi_get_v4l2_transfer_char(transfer_char); 557 pixmp_op->ycbcr_enc = 558 iris_hfi_get_v4l2_matrix_coefficients(matrix_coeff); 559 } 560 } 561 562 pixmp_ip->colorspace = pixmp_op->colorspace; 563 pixmp_ip->xfer_func = pixmp_op->xfer_func; 564 pixmp_ip->ycbcr_enc = pixmp_op->ycbcr_enc; 565 pixmp_ip->quantization = pixmp_op->quantization; 566 567 inst->crop.top = subsc_params.crop_offsets[0] & 0xFFFF; 568 inst->crop.left = (subsc_params.crop_offsets[0] >> 16) & 0xFFFF; 569 inst->crop.height = pixmp_ip->height - 570 (subsc_params.crop_offsets[1] & 0xFFFF) - inst->crop.top; 571 inst->crop.width = pixmp_ip->width - 572 ((subsc_params.crop_offsets[1] >> 16) & 0xFFFF) - inst->crop.left; 573 574 switch (inst->codec) { 575 case V4L2_PIX_FMT_HEVC: 576 inst->fw_caps[PROFILE_HEVC].value = subsc_params.profile; 577 inst->fw_caps[LEVEL_HEVC].value = subsc_params.level; 578 break; 579 case V4L2_PIX_FMT_VP9: 580 inst->fw_caps[PROFILE_VP9].value = subsc_params.profile; 581 inst->fw_caps[LEVEL_VP9].value = subsc_params.level; 582 break; 583 case V4L2_PIX_FMT_H264: 584 inst->fw_caps[PROFILE_H264].value = subsc_params.profile; 585 inst->fw_caps[LEVEL_H264].value = subsc_params.level; 586 break; 587 } 588 589 inst->fw_caps[POC].value = subsc_params.pic_order_cnt; 590 inst->fw_caps[TIER].value = subsc_params.tier; 591 592 if (subsc_params.bit_depth != BIT_DEPTH_8 || 593 !(subsc_params.coded_frames & HFI_BITMASK_FRAME_MBS_ONLY_FLAG)) { 594 dev_err(core->dev, "unsupported content, bit depth: %x, pic_struct = %x\n", 595 subsc_params.bit_depth, subsc_params.coded_frames); 596 iris_inst_change_state(inst, IRIS_INST_ERROR); 597 } 598 599 inst->fw_min_count = subsc_params.fw_min_count; 600 inst->buffers[BUF_OUTPUT].min_count = iris_vpu_buf_count(inst, BUF_OUTPUT); 601 inst->buffers[BUF_OUTPUT].size = pixmp_op->plane_fmt[0].sizeimage; 602 ctrl = v4l2_ctrl_find(&inst->ctrl_handler, V4L2_CID_MIN_BUFFERS_FOR_CAPTURE); 603 if (ctrl) 604 v4l2_ctrl_s_ctrl(ctrl, inst->buffers[BUF_OUTPUT].min_count); 605 606 dst_q = v4l2_m2m_get_dst_vq(inst->m2m_ctx); 607 dst_q->min_reqbufs_allocation = inst->buffers[BUF_OUTPUT].min_count; 608 } 609 610 static int iris_hfi_gen2_handle_src_change(struct iris_inst *inst, 611 struct iris_hfi_packet *pkt) 612 { 613 int ret; 614 615 if (pkt->port != HFI_PORT_BITSTREAM) 616 return 0; 617 618 ret = iris_inst_sub_state_change_drc(inst); 619 if (ret) 620 return ret; 621 622 iris_hfi_gen2_read_input_subcr_params(inst); 623 iris_vdec_src_change(inst); 624 625 return 0; 626 } 627 628 static int iris_hfi_gen2_handle_session_command(struct iris_inst *inst, 629 struct iris_hfi_packet *pkt) 630 { 631 int ret = 0; 632 633 switch (pkt->type) { 634 case HFI_CMD_CLOSE: 635 iris_hfi_gen2_handle_session_close(inst, pkt); 636 break; 637 case HFI_CMD_STOP: 638 iris_hfi_gen2_handle_session_stop(inst, pkt); 639 break; 640 case HFI_CMD_BUFFER: 641 ret = iris_hfi_gen2_handle_session_buffer(inst, pkt); 642 break; 643 case HFI_CMD_SETTINGS_CHANGE: 644 ret = iris_hfi_gen2_handle_src_change(inst, pkt); 645 break; 646 case HFI_CMD_DRAIN: 647 ret = iris_hfi_gen2_handle_session_drain(inst, pkt); 648 break; 649 default: 650 break; 651 } 652 653 return ret; 654 } 655 656 static int iris_hfi_gen2_handle_session_property(struct iris_inst *inst, 657 struct iris_hfi_packet *pkt) 658 { 659 struct iris_inst_hfi_gen2 *inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 660 661 if (pkt->flags & HFI_FW_FLAGS_INFORMATION) 662 return 0; 663 664 switch (pkt->type) { 665 case HFI_PROP_BITSTREAM_RESOLUTION: 666 inst_hfi_gen2->src_subcr_params.bitstream_resolution = pkt->payload[0]; 667 break; 668 case HFI_PROP_CROP_OFFSETS: 669 inst_hfi_gen2->src_subcr_params.crop_offsets[0] = pkt->payload[0]; 670 inst_hfi_gen2->src_subcr_params.crop_offsets[1] = pkt->payload[1]; 671 break; 672 case HFI_PROP_LUMA_CHROMA_BIT_DEPTH: 673 inst_hfi_gen2->src_subcr_params.bit_depth = pkt->payload[0]; 674 break; 675 case HFI_PROP_CODED_FRAMES: 676 inst_hfi_gen2->src_subcr_params.coded_frames = pkt->payload[0]; 677 break; 678 case HFI_PROP_BUFFER_FW_MIN_OUTPUT_COUNT: 679 inst_hfi_gen2->src_subcr_params.fw_min_count = pkt->payload[0]; 680 break; 681 case HFI_PROP_PIC_ORDER_CNT_TYPE: 682 inst_hfi_gen2->src_subcr_params.pic_order_cnt = pkt->payload[0]; 683 break; 684 case HFI_PROP_SIGNAL_COLOR_INFO: 685 inst_hfi_gen2->src_subcr_params.color_info = pkt->payload[0]; 686 break; 687 case HFI_PROP_PROFILE: 688 inst_hfi_gen2->src_subcr_params.profile = pkt->payload[0]; 689 break; 690 case HFI_PROP_LEVEL: 691 inst_hfi_gen2->src_subcr_params.level = pkt->payload[0]; 692 break; 693 case HFI_PROP_TIER: 694 inst_hfi_gen2->src_subcr_params.tier = pkt->payload[0]; 695 break; 696 case HFI_PROP_PICTURE_TYPE: 697 inst_hfi_gen2->hfi_frame_info.picture_type = pkt->payload[0]; 698 break; 699 case HFI_PROP_NO_OUTPUT: 700 inst_hfi_gen2->hfi_frame_info.no_output = 1; 701 break; 702 case HFI_PROP_QUALITY_MODE: 703 case HFI_PROP_STAGE: 704 case HFI_PROP_PIPE: 705 default: 706 break; 707 } 708 709 return 0; 710 } 711 712 static int iris_hfi_gen2_handle_image_version_property(struct iris_core *core, 713 struct iris_hfi_packet *pkt) 714 { 715 u8 *str_image_version = (u8 *)pkt + sizeof(*pkt); 716 u32 req_bytes = pkt->size - sizeof(*pkt); 717 char fw_version[IRIS_FW_VERSION_LENGTH]; 718 u32 i; 719 720 if (req_bytes < IRIS_FW_VERSION_LENGTH - 1) 721 return -EINVAL; 722 723 for (i = 0; i < IRIS_FW_VERSION_LENGTH - 1; i++) { 724 if (str_image_version[i] != '\0') 725 fw_version[i] = str_image_version[i]; 726 else 727 fw_version[i] = ' '; 728 } 729 fw_version[i] = '\0'; 730 dev_dbg(core->dev, "firmware version: %s\n", fw_version); 731 732 return 0; 733 } 734 735 static int iris_hfi_gen2_handle_system_property(struct iris_core *core, 736 struct iris_hfi_packet *pkt) 737 { 738 switch (pkt->type) { 739 case HFI_PROP_IMAGE_VERSION: 740 return iris_hfi_gen2_handle_image_version_property(core, pkt); 741 default: 742 return 0; 743 } 744 } 745 746 static int iris_hfi_gen2_handle_system_response(struct iris_core *core, 747 struct iris_hfi_header *hdr) 748 { 749 u8 *start_pkt = (u8 *)((u8 *)hdr + sizeof(*hdr)); 750 struct iris_hfi_packet *packet; 751 u32 i, j; 752 u8 *pkt; 753 int ret; 754 static const struct iris_hfi_gen2_core_hfi_range range[] = { 755 {HFI_SYSTEM_ERROR_BEGIN, HFI_SYSTEM_ERROR_END, iris_hfi_gen2_handle_system_error }, 756 {HFI_PROP_BEGIN, HFI_PROP_END, iris_hfi_gen2_handle_system_property }, 757 {HFI_CMD_BEGIN, HFI_CMD_END, iris_hfi_gen2_handle_system_init }, 758 }; 759 760 for (i = 0; i < ARRAY_SIZE(range); i++) { 761 pkt = start_pkt; 762 for (j = 0; j < hdr->num_packets; j++) { 763 packet = (struct iris_hfi_packet *)pkt; 764 if (packet->flags & HFI_FW_FLAGS_SYSTEM_ERROR) { 765 ret = iris_hfi_gen2_handle_system_error(core, packet); 766 return ret; 767 } 768 769 if (packet->type > range[i].begin && packet->type < range[i].end) { 770 ret = range[i].handle(core, packet); 771 if (ret) 772 return ret; 773 774 if (packet->type > HFI_SYSTEM_ERROR_BEGIN && 775 packet->type < HFI_SYSTEM_ERROR_END) 776 return 0; 777 } 778 pkt += packet->size; 779 } 780 } 781 782 return 0; 783 } 784 785 static void iris_hfi_gen2_init_src_change_param(struct iris_inst *inst) 786 { 787 struct iris_inst_hfi_gen2 *inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 788 struct v4l2_pix_format_mplane *pixmp_ip = &inst->fmt_src->fmt.pix_mp; 789 struct v4l2_pix_format_mplane *pixmp_op = &inst->fmt_dst->fmt.pix_mp; 790 u32 bottom_offset = (pixmp_ip->height - inst->crop.height); 791 u32 right_offset = (pixmp_ip->width - inst->crop.width); 792 struct hfi_subscription_params *subsc_params; 793 u32 primaries, matrix_coeff, transfer_char; 794 u32 colour_description_present_flag = 0; 795 u32 video_signal_type_present_flag = 0; 796 u32 full_range, video_format = 0; 797 u32 left_offset = inst->crop.left; 798 u32 top_offset = inst->crop.top; 799 800 subsc_params = &inst_hfi_gen2->src_subcr_params; 801 subsc_params->bitstream_resolution = 802 pixmp_ip->width << 16 | pixmp_ip->height; 803 subsc_params->crop_offsets[0] = 804 left_offset << 16 | top_offset; 805 subsc_params->crop_offsets[1] = 806 right_offset << 16 | bottom_offset; 807 subsc_params->fw_min_count = inst->buffers[BUF_OUTPUT].min_count; 808 809 primaries = iris_hfi_gen2_get_color_primaries(pixmp_op->colorspace); 810 matrix_coeff = iris_hfi_gen2_get_matrix_coefficients(pixmp_op->ycbcr_enc); 811 transfer_char = iris_hfi_gen2_get_transfer_char(pixmp_op->xfer_func); 812 full_range = pixmp_op->quantization == V4L2_QUANTIZATION_FULL_RANGE ? 1 : 0; 813 subsc_params->color_info = 814 iris_hfi_gen2_get_color_info(matrix_coeff, transfer_char, primaries, 815 colour_description_present_flag, 816 full_range, video_format, 817 video_signal_type_present_flag); 818 819 switch (inst->codec) { 820 case V4L2_PIX_FMT_HEVC: 821 subsc_params->profile = inst->fw_caps[PROFILE_HEVC].value; 822 subsc_params->level = inst->fw_caps[LEVEL_HEVC].value; 823 break; 824 case V4L2_PIX_FMT_VP9: 825 subsc_params->profile = inst->fw_caps[PROFILE_VP9].value; 826 subsc_params->level = inst->fw_caps[LEVEL_VP9].value; 827 break; 828 case V4L2_PIX_FMT_H264: 829 subsc_params->profile = inst->fw_caps[PROFILE_H264].value; 830 subsc_params->level = inst->fw_caps[LEVEL_H264].value; 831 break; 832 } 833 834 subsc_params->pic_order_cnt = inst->fw_caps[POC].value; 835 subsc_params->bit_depth = inst->fw_caps[BIT_DEPTH].value; 836 if (inst->fw_caps[CODED_FRAMES].value == 837 CODED_FRAMES_PROGRESSIVE) 838 subsc_params->coded_frames = HFI_BITMASK_FRAME_MBS_ONLY_FLAG; 839 else 840 subsc_params->coded_frames = 0; 841 } 842 843 static int iris_hfi_gen2_handle_session_response(struct iris_core *core, 844 struct iris_hfi_header *hdr) 845 { 846 u8 *pkt = (u8 *)((u8 *)hdr + sizeof(*hdr)); 847 struct iris_inst_hfi_gen2 *inst_hfi_gen2; 848 struct iris_hfi_packet *packet; 849 struct iris_inst *inst; 850 bool dequeue = false; 851 int ret = 0; 852 u32 i, j; 853 static const struct iris_hfi_gen2_inst_hfi_range range[] = { 854 {HFI_SESSION_ERROR_BEGIN, HFI_SESSION_ERROR_END, 855 iris_hfi_gen2_handle_session_error}, 856 {HFI_INFORMATION_BEGIN, HFI_INFORMATION_END, 857 iris_hfi_gen2_handle_session_info}, 858 {HFI_PROP_BEGIN, HFI_PROP_END, 859 iris_hfi_gen2_handle_session_property}, 860 {HFI_CMD_BEGIN, HFI_CMD_END, 861 iris_hfi_gen2_handle_session_command }, 862 }; 863 864 inst = iris_get_instance(core, hdr->session_id); 865 if (!inst) 866 return -EINVAL; 867 868 mutex_lock(&inst->lock); 869 inst_hfi_gen2 = to_iris_inst_hfi_gen2(inst); 870 memset(&inst_hfi_gen2->hfi_frame_info, 0, sizeof(struct iris_hfi_frame_info)); 871 872 for (i = 0; i < hdr->num_packets; i++) { 873 packet = (struct iris_hfi_packet *)pkt; 874 if (packet->type == HFI_CMD_SETTINGS_CHANGE) { 875 if (packet->port == HFI_PORT_BITSTREAM) { 876 iris_hfi_gen2_init_src_change_param(inst); 877 break; 878 } 879 } 880 pkt += packet->size; 881 } 882 883 pkt = (u8 *)((u8 *)hdr + sizeof(*hdr)); 884 for (i = 0; i < ARRAY_SIZE(range); i++) { 885 pkt = (u8 *)((u8 *)hdr + sizeof(*hdr)); 886 for (j = 0; j < hdr->num_packets; j++) { 887 packet = (struct iris_hfi_packet *)pkt; 888 if (packet->flags & HFI_FW_FLAGS_SESSION_ERROR) 889 iris_hfi_gen2_handle_session_error(inst, packet); 890 891 if (packet->type > range[i].begin && packet->type < range[i].end) { 892 dequeue |= (packet->type == HFI_CMD_BUFFER); 893 ret = range[i].handle(inst, packet); 894 if (ret) 895 iris_inst_change_state(inst, IRIS_INST_ERROR); 896 } 897 pkt += packet->size; 898 } 899 } 900 901 if (dequeue) 902 iris_hfi_gen2_handle_dequeue_buffers(inst); 903 904 mutex_unlock(&inst->lock); 905 906 return ret; 907 } 908 909 static int iris_hfi_gen2_handle_response(struct iris_core *core, void *response) 910 { 911 struct iris_hfi_header *hdr = (struct iris_hfi_header *)response; 912 int ret; 913 914 ret = iris_hfi_gen2_validate_hdr_packet(core, hdr); 915 if (ret) 916 return iris_hfi_gen2_handle_system_error(core, NULL); 917 918 if (!hdr->session_id) 919 return iris_hfi_gen2_handle_system_response(core, hdr); 920 else 921 return iris_hfi_gen2_handle_session_response(core, hdr); 922 } 923 924 static void iris_hfi_gen2_flush_debug_queue(struct iris_core *core, u8 *packet) 925 { 926 struct hfi_debug_header *pkt; 927 u8 *log; 928 929 while (!iris_hfi_queue_dbg_read(core, packet)) { 930 pkt = (struct hfi_debug_header *)packet; 931 932 if (pkt->size < sizeof(*pkt)) 933 continue; 934 935 if (pkt->size >= IFACEQ_CORE_PKT_SIZE) 936 continue; 937 938 packet[pkt->size] = '\0'; 939 log = (u8 *)packet + sizeof(*pkt) + 1; 940 dev_dbg(core->dev, "%s", log); 941 } 942 } 943 944 static void iris_hfi_gen2_response_handler(struct iris_core *core) 945 { 946 if (iris_vpu_watchdog(core, core->intr_status)) { 947 struct iris_hfi_packet pkt = {.type = HFI_SYS_ERROR_WD_TIMEOUT}; 948 949 dev_err(core->dev, "cpu watchdog error received\n"); 950 core->state = IRIS_CORE_ERROR; 951 iris_hfi_gen2_handle_system_error(core, &pkt); 952 953 return; 954 } 955 956 memset(core->response_packet, 0, sizeof(struct iris_hfi_header)); 957 while (!iris_hfi_queue_msg_read(core, core->response_packet)) { 958 iris_hfi_gen2_handle_response(core, core->response_packet); 959 memset(core->response_packet, 0, sizeof(struct iris_hfi_header)); 960 } 961 962 iris_hfi_gen2_flush_debug_queue(core, core->response_packet); 963 } 964 965 static const struct iris_hfi_response_ops iris_hfi_gen2_response_ops = { 966 .hfi_response_handler = iris_hfi_gen2_response_handler, 967 }; 968 969 void iris_hfi_gen2_response_ops_init(struct iris_core *core) 970 { 971 core->hfi_response_ops = &iris_hfi_gen2_response_ops; 972 } 973