1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * camss-vfe.c 4 * 5 * Qualcomm MSM Camera Subsystem - VFE (Video Front End) Module 6 * 7 * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. 8 * Copyright (C) 2015-2018 Linaro Ltd. 9 */ 10 #include <linux/clk.h> 11 #include <linux/completion.h> 12 #include <linux/interrupt.h> 13 #include <linux/iommu.h> 14 #include <linux/mutex.h> 15 #include <linux/of.h> 16 #include <linux/platform_device.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/spinlock_types.h> 19 #include <linux/spinlock.h> 20 #include <media/media-entity.h> 21 #include <media/v4l2-device.h> 22 #include <media/v4l2-subdev.h> 23 24 #include "camss-vfe.h" 25 #include "camss.h" 26 27 #define MSM_VFE_NAME "msm_vfe" 28 29 /* VFE reset timeout */ 30 #define VFE_RESET_TIMEOUT_MS 50 31 32 #define SCALER_RATIO_MAX 16 33 34 struct vfe_format { 35 u32 code; 36 u8 bpp; 37 }; 38 39 static const struct vfe_format formats_rdi_8x16[] = { 40 { MEDIA_BUS_FMT_UYVY8_2X8, 8 }, 41 { MEDIA_BUS_FMT_VYUY8_2X8, 8 }, 42 { MEDIA_BUS_FMT_YUYV8_2X8, 8 }, 43 { MEDIA_BUS_FMT_YVYU8_2X8, 8 }, 44 { MEDIA_BUS_FMT_SBGGR8_1X8, 8 }, 45 { MEDIA_BUS_FMT_SGBRG8_1X8, 8 }, 46 { MEDIA_BUS_FMT_SGRBG8_1X8, 8 }, 47 { MEDIA_BUS_FMT_SRGGB8_1X8, 8 }, 48 { MEDIA_BUS_FMT_SBGGR10_1X10, 10 }, 49 { MEDIA_BUS_FMT_SGBRG10_1X10, 10 }, 50 { MEDIA_BUS_FMT_SGRBG10_1X10, 10 }, 51 { MEDIA_BUS_FMT_SRGGB10_1X10, 10 }, 52 { MEDIA_BUS_FMT_SBGGR12_1X12, 12 }, 53 { MEDIA_BUS_FMT_SGBRG12_1X12, 12 }, 54 { MEDIA_BUS_FMT_SGRBG12_1X12, 12 }, 55 { MEDIA_BUS_FMT_SRGGB12_1X12, 12 }, 56 { MEDIA_BUS_FMT_Y10_1X10, 10 }, 57 }; 58 59 static const struct vfe_format formats_pix_8x16[] = { 60 { MEDIA_BUS_FMT_UYVY8_2X8, 8 }, 61 { MEDIA_BUS_FMT_VYUY8_2X8, 8 }, 62 { MEDIA_BUS_FMT_YUYV8_2X8, 8 }, 63 { MEDIA_BUS_FMT_YVYU8_2X8, 8 }, 64 }; 65 66 static const struct vfe_format formats_rdi_8x96[] = { 67 { MEDIA_BUS_FMT_UYVY8_2X8, 8 }, 68 { MEDIA_BUS_FMT_VYUY8_2X8, 8 }, 69 { MEDIA_BUS_FMT_YUYV8_2X8, 8 }, 70 { MEDIA_BUS_FMT_YVYU8_2X8, 8 }, 71 { MEDIA_BUS_FMT_SBGGR8_1X8, 8 }, 72 { MEDIA_BUS_FMT_SGBRG8_1X8, 8 }, 73 { MEDIA_BUS_FMT_SGRBG8_1X8, 8 }, 74 { MEDIA_BUS_FMT_SRGGB8_1X8, 8 }, 75 { MEDIA_BUS_FMT_SBGGR10_1X10, 10 }, 76 { MEDIA_BUS_FMT_SGBRG10_1X10, 10 }, 77 { MEDIA_BUS_FMT_SGRBG10_1X10, 10 }, 78 { MEDIA_BUS_FMT_SRGGB10_1X10, 10 }, 79 { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, 16 }, 80 { MEDIA_BUS_FMT_SBGGR12_1X12, 12 }, 81 { MEDIA_BUS_FMT_SGBRG12_1X12, 12 }, 82 { MEDIA_BUS_FMT_SGRBG12_1X12, 12 }, 83 { MEDIA_BUS_FMT_SRGGB12_1X12, 12 }, 84 { MEDIA_BUS_FMT_SBGGR14_1X14, 14 }, 85 { MEDIA_BUS_FMT_SGBRG14_1X14, 14 }, 86 { MEDIA_BUS_FMT_SGRBG14_1X14, 14 }, 87 { MEDIA_BUS_FMT_SRGGB14_1X14, 14 }, 88 { MEDIA_BUS_FMT_Y10_1X10, 10 }, 89 { MEDIA_BUS_FMT_Y10_2X8_PADHI_LE, 16 }, 90 }; 91 92 static const struct vfe_format formats_pix_8x96[] = { 93 { MEDIA_BUS_FMT_UYVY8_2X8, 8 }, 94 { MEDIA_BUS_FMT_VYUY8_2X8, 8 }, 95 { MEDIA_BUS_FMT_YUYV8_2X8, 8 }, 96 { MEDIA_BUS_FMT_YVYU8_2X8, 8 }, 97 }; 98 99 static const struct vfe_format formats_rdi_845[] = { 100 { MEDIA_BUS_FMT_UYVY8_2X8, 8 }, 101 { MEDIA_BUS_FMT_VYUY8_2X8, 8 }, 102 { MEDIA_BUS_FMT_YUYV8_2X8, 8 }, 103 { MEDIA_BUS_FMT_YVYU8_2X8, 8 }, 104 { MEDIA_BUS_FMT_SBGGR8_1X8, 8 }, 105 { MEDIA_BUS_FMT_SGBRG8_1X8, 8 }, 106 { MEDIA_BUS_FMT_SGRBG8_1X8, 8 }, 107 { MEDIA_BUS_FMT_SRGGB8_1X8, 8 }, 108 { MEDIA_BUS_FMT_SBGGR10_1X10, 10 }, 109 { MEDIA_BUS_FMT_SGBRG10_1X10, 10 }, 110 { MEDIA_BUS_FMT_SGRBG10_1X10, 10 }, 111 { MEDIA_BUS_FMT_SRGGB10_1X10, 10 }, 112 { MEDIA_BUS_FMT_SBGGR10_2X8_PADHI_LE, 16 }, 113 { MEDIA_BUS_FMT_SBGGR12_1X12, 12 }, 114 { MEDIA_BUS_FMT_SGBRG12_1X12, 12 }, 115 { MEDIA_BUS_FMT_SGRBG12_1X12, 12 }, 116 { MEDIA_BUS_FMT_SRGGB12_1X12, 12 }, 117 { MEDIA_BUS_FMT_SBGGR14_1X14, 14 }, 118 { MEDIA_BUS_FMT_SGBRG14_1X14, 14 }, 119 { MEDIA_BUS_FMT_SGRBG14_1X14, 14 }, 120 { MEDIA_BUS_FMT_SRGGB14_1X14, 14 }, 121 { MEDIA_BUS_FMT_Y8_1X8, 8 }, 122 { MEDIA_BUS_FMT_Y10_1X10, 10 }, 123 { MEDIA_BUS_FMT_Y10_2X8_PADHI_LE, 16 }, 124 }; 125 126 /* 127 * vfe_get_bpp - map media bus format to bits per pixel 128 * @formats: supported media bus formats array 129 * @nformats: size of @formats array 130 * @code: media bus format code 131 * 132 * Return number of bits per pixel 133 */ 134 static u8 vfe_get_bpp(const struct vfe_format *formats, 135 unsigned int nformats, u32 code) 136 { 137 unsigned int i; 138 139 for (i = 0; i < nformats; i++) 140 if (code == formats[i].code) 141 return formats[i].bpp; 142 143 WARN(1, "Unknown format\n"); 144 145 return formats[0].bpp; 146 } 147 148 static u32 vfe_find_code(u32 *code, unsigned int n_code, 149 unsigned int index, u32 req_code) 150 { 151 int i; 152 153 if (!req_code && (index >= n_code)) 154 return 0; 155 156 for (i = 0; i < n_code; i++) 157 if (req_code) { 158 if (req_code == code[i]) 159 return req_code; 160 } else { 161 if (i == index) 162 return code[i]; 163 } 164 165 return code[0]; 166 } 167 168 static u32 vfe_src_pad_code(struct vfe_line *line, u32 sink_code, 169 unsigned int index, u32 src_req_code) 170 { 171 struct vfe_device *vfe = to_vfe(line); 172 173 if (vfe->camss->version == CAMSS_8x16) 174 switch (sink_code) { 175 case MEDIA_BUS_FMT_YUYV8_2X8: 176 { 177 u32 src_code[] = { 178 MEDIA_BUS_FMT_YUYV8_2X8, 179 MEDIA_BUS_FMT_YUYV8_1_5X8, 180 }; 181 182 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 183 index, src_req_code); 184 } 185 case MEDIA_BUS_FMT_YVYU8_2X8: 186 { 187 u32 src_code[] = { 188 MEDIA_BUS_FMT_YVYU8_2X8, 189 MEDIA_BUS_FMT_YVYU8_1_5X8, 190 }; 191 192 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 193 index, src_req_code); 194 } 195 case MEDIA_BUS_FMT_UYVY8_2X8: 196 { 197 u32 src_code[] = { 198 MEDIA_BUS_FMT_UYVY8_2X8, 199 MEDIA_BUS_FMT_UYVY8_1_5X8, 200 }; 201 202 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 203 index, src_req_code); 204 } 205 case MEDIA_BUS_FMT_VYUY8_2X8: 206 { 207 u32 src_code[] = { 208 MEDIA_BUS_FMT_VYUY8_2X8, 209 MEDIA_BUS_FMT_VYUY8_1_5X8, 210 }; 211 212 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 213 index, src_req_code); 214 } 215 default: 216 if (index > 0) 217 return 0; 218 219 return sink_code; 220 } 221 else if (vfe->camss->version == CAMSS_8x96 || 222 vfe->camss->version == CAMSS_660 || 223 vfe->camss->version == CAMSS_845 || 224 vfe->camss->version == CAMSS_8250) 225 switch (sink_code) { 226 case MEDIA_BUS_FMT_YUYV8_2X8: 227 { 228 u32 src_code[] = { 229 MEDIA_BUS_FMT_YUYV8_2X8, 230 MEDIA_BUS_FMT_YVYU8_2X8, 231 MEDIA_BUS_FMT_UYVY8_2X8, 232 MEDIA_BUS_FMT_VYUY8_2X8, 233 MEDIA_BUS_FMT_YUYV8_1_5X8, 234 }; 235 236 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 237 index, src_req_code); 238 } 239 case MEDIA_BUS_FMT_YVYU8_2X8: 240 { 241 u32 src_code[] = { 242 MEDIA_BUS_FMT_YVYU8_2X8, 243 MEDIA_BUS_FMT_YUYV8_2X8, 244 MEDIA_BUS_FMT_UYVY8_2X8, 245 MEDIA_BUS_FMT_VYUY8_2X8, 246 MEDIA_BUS_FMT_YVYU8_1_5X8, 247 }; 248 249 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 250 index, src_req_code); 251 } 252 case MEDIA_BUS_FMT_UYVY8_2X8: 253 { 254 u32 src_code[] = { 255 MEDIA_BUS_FMT_UYVY8_2X8, 256 MEDIA_BUS_FMT_YUYV8_2X8, 257 MEDIA_BUS_FMT_YVYU8_2X8, 258 MEDIA_BUS_FMT_VYUY8_2X8, 259 MEDIA_BUS_FMT_UYVY8_1_5X8, 260 }; 261 262 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 263 index, src_req_code); 264 } 265 case MEDIA_BUS_FMT_VYUY8_2X8: 266 { 267 u32 src_code[] = { 268 MEDIA_BUS_FMT_VYUY8_2X8, 269 MEDIA_BUS_FMT_YUYV8_2X8, 270 MEDIA_BUS_FMT_YVYU8_2X8, 271 MEDIA_BUS_FMT_UYVY8_2X8, 272 MEDIA_BUS_FMT_VYUY8_1_5X8, 273 }; 274 275 return vfe_find_code(src_code, ARRAY_SIZE(src_code), 276 index, src_req_code); 277 } 278 default: 279 if (index > 0) 280 return 0; 281 282 return sink_code; 283 } 284 else 285 return 0; 286 } 287 288 int vfe_reset(struct vfe_device *vfe) 289 { 290 unsigned long time; 291 292 reinit_completion(&vfe->reset_complete); 293 294 vfe->ops->global_reset(vfe); 295 296 time = wait_for_completion_timeout(&vfe->reset_complete, 297 msecs_to_jiffies(VFE_RESET_TIMEOUT_MS)); 298 if (!time) { 299 dev_err(vfe->camss->dev, "VFE reset timeout\n"); 300 return -EIO; 301 } 302 303 return 0; 304 } 305 306 static void vfe_init_outputs(struct vfe_device *vfe) 307 { 308 int i; 309 310 for (i = 0; i < vfe->line_num; i++) { 311 struct vfe_output *output = &vfe->line[i].output; 312 313 output->state = VFE_OUTPUT_OFF; 314 output->buf[0] = NULL; 315 output->buf[1] = NULL; 316 INIT_LIST_HEAD(&output->pending_bufs); 317 } 318 } 319 320 static void vfe_reset_output_maps(struct vfe_device *vfe) 321 { 322 int i; 323 324 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++) 325 vfe->wm_output_map[i] = VFE_LINE_NONE; 326 } 327 328 int vfe_reserve_wm(struct vfe_device *vfe, enum vfe_line_id line_id) 329 { 330 int ret = -EBUSY; 331 int i; 332 333 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++) { 334 if (vfe->wm_output_map[i] == VFE_LINE_NONE) { 335 vfe->wm_output_map[i] = line_id; 336 ret = i; 337 break; 338 } 339 } 340 341 return ret; 342 } 343 344 int vfe_release_wm(struct vfe_device *vfe, u8 wm) 345 { 346 if (wm >= ARRAY_SIZE(vfe->wm_output_map)) 347 return -EINVAL; 348 349 vfe->wm_output_map[wm] = VFE_LINE_NONE; 350 351 return 0; 352 } 353 354 struct camss_buffer *vfe_buf_get_pending(struct vfe_output *output) 355 { 356 struct camss_buffer *buffer = NULL; 357 358 if (!list_empty(&output->pending_bufs)) { 359 buffer = list_first_entry(&output->pending_bufs, 360 struct camss_buffer, 361 queue); 362 list_del(&buffer->queue); 363 } 364 365 return buffer; 366 } 367 368 void vfe_buf_add_pending(struct vfe_output *output, 369 struct camss_buffer *buffer) 370 { 371 INIT_LIST_HEAD(&buffer->queue); 372 list_add_tail(&buffer->queue, &output->pending_bufs); 373 } 374 375 /* 376 * vfe_buf_flush_pending - Flush all pending buffers. 377 * @output: VFE output 378 * @state: vb2 buffer state 379 */ 380 static void vfe_buf_flush_pending(struct vfe_output *output, 381 enum vb2_buffer_state state) 382 { 383 struct camss_buffer *buf; 384 struct camss_buffer *t; 385 386 list_for_each_entry_safe(buf, t, &output->pending_bufs, queue) { 387 vb2_buffer_done(&buf->vb.vb2_buf, state); 388 list_del(&buf->queue); 389 } 390 } 391 392 int vfe_put_output(struct vfe_line *line) 393 { 394 struct vfe_device *vfe = to_vfe(line); 395 struct vfe_output *output = &line->output; 396 unsigned long flags; 397 unsigned int i; 398 399 spin_lock_irqsave(&vfe->output_lock, flags); 400 401 for (i = 0; i < output->wm_num; i++) 402 vfe_release_wm(vfe, output->wm_idx[i]); 403 404 output->state = VFE_OUTPUT_OFF; 405 406 spin_unlock_irqrestore(&vfe->output_lock, flags); 407 return 0; 408 } 409 410 /** 411 * vfe_isr_comp_done() - Process composite image done interrupt 412 * @vfe: VFE Device 413 * @comp: Composite image id 414 */ 415 void vfe_isr_comp_done(struct vfe_device *vfe, u8 comp) 416 { 417 unsigned int i; 418 419 for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++) 420 if (vfe->wm_output_map[i] == VFE_LINE_PIX) { 421 vfe->isr_ops.wm_done(vfe, i); 422 break; 423 } 424 } 425 426 void vfe_isr_reset_ack(struct vfe_device *vfe) 427 { 428 complete(&vfe->reset_complete); 429 } 430 431 /* 432 * vfe_set_clock_rates - Calculate and set clock rates on VFE module 433 * @vfe: VFE device 434 * 435 * Return 0 on success or a negative error code otherwise 436 */ 437 static int vfe_set_clock_rates(struct vfe_device *vfe) 438 { 439 struct device *dev = vfe->camss->dev; 440 u64 pixel_clock[VFE_LINE_NUM_MAX]; 441 int i, j; 442 int ret; 443 444 for (i = VFE_LINE_RDI0; i < vfe->line_num; i++) { 445 ret = camss_get_pixel_clock(&vfe->line[i].subdev.entity, 446 &pixel_clock[i]); 447 if (ret) 448 pixel_clock[i] = 0; 449 } 450 451 for (i = 0; i < vfe->nclocks; i++) { 452 struct camss_clock *clock = &vfe->clock[i]; 453 454 if (!strcmp(clock->name, "vfe0") || 455 !strcmp(clock->name, "vfe1") || 456 !strcmp(clock->name, "vfe_lite")) { 457 u64 min_rate = 0; 458 long rate; 459 460 for (j = VFE_LINE_RDI0; j < vfe->line_num; j++) { 461 u32 tmp; 462 u8 bpp; 463 464 if (j == VFE_LINE_PIX) { 465 tmp = pixel_clock[j]; 466 } else { 467 struct vfe_line *l = &vfe->line[j]; 468 469 bpp = vfe_get_bpp(l->formats, 470 l->nformats, 471 l->fmt[MSM_VFE_PAD_SINK].code); 472 tmp = pixel_clock[j] * bpp / 64; 473 } 474 475 if (min_rate < tmp) 476 min_rate = tmp; 477 } 478 479 camss_add_clock_margin(&min_rate); 480 481 for (j = 0; j < clock->nfreqs; j++) 482 if (min_rate < clock->freq[j]) 483 break; 484 485 if (j == clock->nfreqs) { 486 dev_err(dev, 487 "Pixel clock is too high for VFE"); 488 return -EINVAL; 489 } 490 491 /* if sensor pixel clock is not available */ 492 /* set highest possible VFE clock rate */ 493 if (min_rate == 0) 494 j = clock->nfreqs - 1; 495 496 rate = clk_round_rate(clock->clk, clock->freq[j]); 497 if (rate < 0) { 498 dev_err(dev, "clk round rate failed: %ld\n", 499 rate); 500 return -EINVAL; 501 } 502 503 ret = clk_set_rate(clock->clk, rate); 504 if (ret < 0) { 505 dev_err(dev, "clk set rate failed: %d\n", ret); 506 return ret; 507 } 508 } 509 } 510 511 return 0; 512 } 513 514 /* 515 * vfe_check_clock_rates - Check current clock rates on VFE module 516 * @vfe: VFE device 517 * 518 * Return 0 if current clock rates are suitable for a new pipeline 519 * or a negative error code otherwise 520 */ 521 static int vfe_check_clock_rates(struct vfe_device *vfe) 522 { 523 u64 pixel_clock[VFE_LINE_NUM_MAX]; 524 int i, j; 525 int ret; 526 527 for (i = VFE_LINE_RDI0; i < vfe->line_num; i++) { 528 ret = camss_get_pixel_clock(&vfe->line[i].subdev.entity, 529 &pixel_clock[i]); 530 if (ret) 531 pixel_clock[i] = 0; 532 } 533 534 for (i = 0; i < vfe->nclocks; i++) { 535 struct camss_clock *clock = &vfe->clock[i]; 536 537 if (!strcmp(clock->name, "vfe0") || 538 !strcmp(clock->name, "vfe1")) { 539 u64 min_rate = 0; 540 unsigned long rate; 541 542 for (j = VFE_LINE_RDI0; j < vfe->line_num; j++) { 543 u32 tmp; 544 u8 bpp; 545 546 if (j == VFE_LINE_PIX) { 547 tmp = pixel_clock[j]; 548 } else { 549 struct vfe_line *l = &vfe->line[j]; 550 551 bpp = vfe_get_bpp(l->formats, 552 l->nformats, 553 l->fmt[MSM_VFE_PAD_SINK].code); 554 tmp = pixel_clock[j] * bpp / 64; 555 } 556 557 if (min_rate < tmp) 558 min_rate = tmp; 559 } 560 561 camss_add_clock_margin(&min_rate); 562 563 rate = clk_get_rate(clock->clk); 564 if (rate < min_rate) 565 return -EBUSY; 566 } 567 } 568 569 return 0; 570 } 571 572 /* 573 * vfe_get - Power up and reset VFE module 574 * @vfe: VFE Device 575 * 576 * Return 0 on success or a negative error code otherwise 577 */ 578 int vfe_get(struct vfe_device *vfe) 579 { 580 int ret; 581 582 mutex_lock(&vfe->power_lock); 583 584 if (vfe->power_count == 0) { 585 ret = vfe->ops->pm_domain_on(vfe); 586 if (ret < 0) 587 goto error_pm_domain; 588 589 ret = pm_runtime_resume_and_get(vfe->camss->dev); 590 if (ret < 0) 591 goto error_domain_off; 592 593 ret = vfe_set_clock_rates(vfe); 594 if (ret < 0) 595 goto error_pm_runtime_get; 596 597 ret = camss_enable_clocks(vfe->nclocks, vfe->clock, 598 vfe->camss->dev); 599 if (ret < 0) 600 goto error_pm_runtime_get; 601 602 ret = vfe_reset(vfe); 603 if (ret < 0) 604 goto error_reset; 605 606 vfe_reset_output_maps(vfe); 607 608 vfe_init_outputs(vfe); 609 610 vfe->ops->hw_version(vfe); 611 } else { 612 ret = vfe_check_clock_rates(vfe); 613 if (ret < 0) 614 goto error_pm_runtime_get; 615 } 616 vfe->power_count++; 617 618 mutex_unlock(&vfe->power_lock); 619 620 return 0; 621 622 error_reset: 623 camss_disable_clocks(vfe->nclocks, vfe->clock); 624 625 error_pm_runtime_get: 626 pm_runtime_put_sync(vfe->camss->dev); 627 error_domain_off: 628 vfe->ops->pm_domain_off(vfe); 629 630 error_pm_domain: 631 mutex_unlock(&vfe->power_lock); 632 633 return ret; 634 } 635 636 /* 637 * vfe_put - Power down VFE module 638 * @vfe: VFE Device 639 */ 640 void vfe_put(struct vfe_device *vfe) 641 { 642 mutex_lock(&vfe->power_lock); 643 644 if (vfe->power_count == 0) { 645 dev_err(vfe->camss->dev, "vfe power off on power_count == 0\n"); 646 goto exit; 647 } else if (vfe->power_count == 1) { 648 if (vfe->was_streaming) { 649 vfe->was_streaming = 0; 650 vfe->ops->vfe_halt(vfe); 651 } 652 camss_disable_clocks(vfe->nclocks, vfe->clock); 653 pm_runtime_put_sync(vfe->camss->dev); 654 vfe->ops->pm_domain_off(vfe); 655 } 656 657 vfe->power_count--; 658 659 exit: 660 mutex_unlock(&vfe->power_lock); 661 } 662 663 /* 664 * vfe_flush_buffers - Return all vb2 buffers 665 * @vid: Video device structure 666 * @state: vb2 buffer state of the returned buffers 667 * 668 * Return all buffers to vb2. This includes queued pending buffers (still 669 * unused) and any buffers given to the hardware but again still not used. 670 * 671 * Return 0 on success or a negative error code otherwise 672 */ 673 int vfe_flush_buffers(struct camss_video *vid, 674 enum vb2_buffer_state state) 675 { 676 struct vfe_line *line = container_of(vid, struct vfe_line, video_out); 677 struct vfe_device *vfe = to_vfe(line); 678 struct vfe_output *output; 679 unsigned long flags; 680 681 output = &line->output; 682 683 spin_lock_irqsave(&vfe->output_lock, flags); 684 685 vfe_buf_flush_pending(output, state); 686 687 if (output->buf[0]) 688 vb2_buffer_done(&output->buf[0]->vb.vb2_buf, state); 689 690 if (output->buf[1]) 691 vb2_buffer_done(&output->buf[1]->vb.vb2_buf, state); 692 693 if (output->last_buffer) { 694 vb2_buffer_done(&output->last_buffer->vb.vb2_buf, state); 695 output->last_buffer = NULL; 696 } 697 698 spin_unlock_irqrestore(&vfe->output_lock, flags); 699 700 return 0; 701 } 702 703 /* 704 * vfe_set_power - Power on/off VFE module 705 * @sd: VFE V4L2 subdevice 706 * @on: Requested power state 707 * 708 * Return 0 on success or a negative error code otherwise 709 */ 710 static int vfe_set_power(struct v4l2_subdev *sd, int on) 711 { 712 struct vfe_line *line = v4l2_get_subdevdata(sd); 713 struct vfe_device *vfe = to_vfe(line); 714 int ret; 715 716 if (on) { 717 ret = vfe_get(vfe); 718 if (ret < 0) 719 return ret; 720 } else { 721 vfe_put(vfe); 722 } 723 724 return 0; 725 } 726 727 /* 728 * vfe_set_stream - Enable/disable streaming on VFE module 729 * @sd: VFE V4L2 subdevice 730 * @enable: Requested streaming state 731 * 732 * Main configuration of VFE module is triggered here. 733 * 734 * Return 0 on success or a negative error code otherwise 735 */ 736 static int vfe_set_stream(struct v4l2_subdev *sd, int enable) 737 { 738 struct vfe_line *line = v4l2_get_subdevdata(sd); 739 struct vfe_device *vfe = to_vfe(line); 740 int ret; 741 742 if (enable) { 743 ret = vfe->ops->vfe_enable(line); 744 if (ret < 0) 745 dev_err(vfe->camss->dev, 746 "Failed to enable vfe outputs\n"); 747 } else { 748 ret = vfe->ops->vfe_disable(line); 749 if (ret < 0) 750 dev_err(vfe->camss->dev, 751 "Failed to disable vfe outputs\n"); 752 } 753 754 return ret; 755 } 756 757 /* 758 * __vfe_get_format - Get pointer to format structure 759 * @line: VFE line 760 * @cfg: V4L2 subdev pad configuration 761 * @pad: pad from which format is requested 762 * @which: TRY or ACTIVE format 763 * 764 * Return pointer to TRY or ACTIVE format structure 765 */ 766 static struct v4l2_mbus_framefmt * 767 __vfe_get_format(struct vfe_line *line, 768 struct v4l2_subdev_state *sd_state, 769 unsigned int pad, 770 enum v4l2_subdev_format_whence which) 771 { 772 if (which == V4L2_SUBDEV_FORMAT_TRY) 773 return v4l2_subdev_get_try_format(&line->subdev, sd_state, 774 pad); 775 776 return &line->fmt[pad]; 777 } 778 779 /* 780 * __vfe_get_compose - Get pointer to compose selection structure 781 * @line: VFE line 782 * @cfg: V4L2 subdev pad configuration 783 * @which: TRY or ACTIVE format 784 * 785 * Return pointer to TRY or ACTIVE compose rectangle structure 786 */ 787 static struct v4l2_rect * 788 __vfe_get_compose(struct vfe_line *line, 789 struct v4l2_subdev_state *sd_state, 790 enum v4l2_subdev_format_whence which) 791 { 792 if (which == V4L2_SUBDEV_FORMAT_TRY) 793 return v4l2_subdev_get_try_compose(&line->subdev, sd_state, 794 MSM_VFE_PAD_SINK); 795 796 return &line->compose; 797 } 798 799 /* 800 * __vfe_get_crop - Get pointer to crop selection structure 801 * @line: VFE line 802 * @cfg: V4L2 subdev pad configuration 803 * @which: TRY or ACTIVE format 804 * 805 * Return pointer to TRY or ACTIVE crop rectangle structure 806 */ 807 static struct v4l2_rect * 808 __vfe_get_crop(struct vfe_line *line, 809 struct v4l2_subdev_state *sd_state, 810 enum v4l2_subdev_format_whence which) 811 { 812 if (which == V4L2_SUBDEV_FORMAT_TRY) 813 return v4l2_subdev_get_try_crop(&line->subdev, sd_state, 814 MSM_VFE_PAD_SRC); 815 816 return &line->crop; 817 } 818 819 /* 820 * vfe_try_format - Handle try format by pad subdev method 821 * @line: VFE line 822 * @cfg: V4L2 subdev pad configuration 823 * @pad: pad on which format is requested 824 * @fmt: pointer to v4l2 format structure 825 * @which: wanted subdev format 826 */ 827 static void vfe_try_format(struct vfe_line *line, 828 struct v4l2_subdev_state *sd_state, 829 unsigned int pad, 830 struct v4l2_mbus_framefmt *fmt, 831 enum v4l2_subdev_format_whence which) 832 { 833 unsigned int i; 834 u32 code; 835 836 switch (pad) { 837 case MSM_VFE_PAD_SINK: 838 /* Set format on sink pad */ 839 840 for (i = 0; i < line->nformats; i++) 841 if (fmt->code == line->formats[i].code) 842 break; 843 844 /* If not found, use UYVY as default */ 845 if (i >= line->nformats) 846 fmt->code = MEDIA_BUS_FMT_UYVY8_2X8; 847 848 fmt->width = clamp_t(u32, fmt->width, 1, 8191); 849 fmt->height = clamp_t(u32, fmt->height, 1, 8191); 850 851 fmt->field = V4L2_FIELD_NONE; 852 fmt->colorspace = V4L2_COLORSPACE_SRGB; 853 854 break; 855 856 case MSM_VFE_PAD_SRC: 857 /* Set and return a format same as sink pad */ 858 code = fmt->code; 859 860 *fmt = *__vfe_get_format(line, sd_state, MSM_VFE_PAD_SINK, 861 which); 862 863 fmt->code = vfe_src_pad_code(line, fmt->code, 0, code); 864 865 if (line->id == VFE_LINE_PIX) { 866 struct v4l2_rect *rect; 867 868 rect = __vfe_get_crop(line, sd_state, which); 869 870 fmt->width = rect->width; 871 fmt->height = rect->height; 872 } 873 874 break; 875 } 876 877 fmt->colorspace = V4L2_COLORSPACE_SRGB; 878 } 879 880 /* 881 * vfe_try_compose - Handle try compose selection by pad subdev method 882 * @line: VFE line 883 * @cfg: V4L2 subdev pad configuration 884 * @rect: pointer to v4l2 rect structure 885 * @which: wanted subdev format 886 */ 887 static void vfe_try_compose(struct vfe_line *line, 888 struct v4l2_subdev_state *sd_state, 889 struct v4l2_rect *rect, 890 enum v4l2_subdev_format_whence which) 891 { 892 struct v4l2_mbus_framefmt *fmt; 893 894 fmt = __vfe_get_format(line, sd_state, MSM_VFE_PAD_SINK, which); 895 896 if (rect->width > fmt->width) 897 rect->width = fmt->width; 898 899 if (rect->height > fmt->height) 900 rect->height = fmt->height; 901 902 if (fmt->width > rect->width * SCALER_RATIO_MAX) 903 rect->width = (fmt->width + SCALER_RATIO_MAX - 1) / 904 SCALER_RATIO_MAX; 905 906 rect->width &= ~0x1; 907 908 if (fmt->height > rect->height * SCALER_RATIO_MAX) 909 rect->height = (fmt->height + SCALER_RATIO_MAX - 1) / 910 SCALER_RATIO_MAX; 911 912 if (rect->width < 16) 913 rect->width = 16; 914 915 if (rect->height < 4) 916 rect->height = 4; 917 } 918 919 /* 920 * vfe_try_crop - Handle try crop selection by pad subdev method 921 * @line: VFE line 922 * @cfg: V4L2 subdev pad configuration 923 * @rect: pointer to v4l2 rect structure 924 * @which: wanted subdev format 925 */ 926 static void vfe_try_crop(struct vfe_line *line, 927 struct v4l2_subdev_state *sd_state, 928 struct v4l2_rect *rect, 929 enum v4l2_subdev_format_whence which) 930 { 931 struct v4l2_rect *compose; 932 933 compose = __vfe_get_compose(line, sd_state, which); 934 935 if (rect->width > compose->width) 936 rect->width = compose->width; 937 938 if (rect->width + rect->left > compose->width) 939 rect->left = compose->width - rect->width; 940 941 if (rect->height > compose->height) 942 rect->height = compose->height; 943 944 if (rect->height + rect->top > compose->height) 945 rect->top = compose->height - rect->height; 946 947 /* wm in line based mode writes multiple of 16 horizontally */ 948 rect->left += (rect->width & 0xf) >> 1; 949 rect->width &= ~0xf; 950 951 if (rect->width < 16) { 952 rect->left = 0; 953 rect->width = 16; 954 } 955 956 if (rect->height < 4) { 957 rect->top = 0; 958 rect->height = 4; 959 } 960 } 961 962 /* 963 * vfe_enum_mbus_code - Handle pixel format enumeration 964 * @sd: VFE V4L2 subdevice 965 * @cfg: V4L2 subdev pad configuration 966 * @code: pointer to v4l2_subdev_mbus_code_enum structure 967 * 968 * return -EINVAL or zero on success 969 */ 970 static int vfe_enum_mbus_code(struct v4l2_subdev *sd, 971 struct v4l2_subdev_state *sd_state, 972 struct v4l2_subdev_mbus_code_enum *code) 973 { 974 struct vfe_line *line = v4l2_get_subdevdata(sd); 975 976 if (code->pad == MSM_VFE_PAD_SINK) { 977 if (code->index >= line->nformats) 978 return -EINVAL; 979 980 code->code = line->formats[code->index].code; 981 } else { 982 struct v4l2_mbus_framefmt *sink_fmt; 983 984 sink_fmt = __vfe_get_format(line, sd_state, MSM_VFE_PAD_SINK, 985 code->which); 986 987 code->code = vfe_src_pad_code(line, sink_fmt->code, 988 code->index, 0); 989 if (!code->code) 990 return -EINVAL; 991 } 992 993 return 0; 994 } 995 996 /* 997 * vfe_enum_frame_size - Handle frame size enumeration 998 * @sd: VFE V4L2 subdevice 999 * @cfg: V4L2 subdev pad configuration 1000 * @fse: pointer to v4l2_subdev_frame_size_enum structure 1001 * 1002 * Return -EINVAL or zero on success 1003 */ 1004 static int vfe_enum_frame_size(struct v4l2_subdev *sd, 1005 struct v4l2_subdev_state *sd_state, 1006 struct v4l2_subdev_frame_size_enum *fse) 1007 { 1008 struct vfe_line *line = v4l2_get_subdevdata(sd); 1009 struct v4l2_mbus_framefmt format; 1010 1011 if (fse->index != 0) 1012 return -EINVAL; 1013 1014 format.code = fse->code; 1015 format.width = 1; 1016 format.height = 1; 1017 vfe_try_format(line, sd_state, fse->pad, &format, fse->which); 1018 fse->min_width = format.width; 1019 fse->min_height = format.height; 1020 1021 if (format.code != fse->code) 1022 return -EINVAL; 1023 1024 format.code = fse->code; 1025 format.width = -1; 1026 format.height = -1; 1027 vfe_try_format(line, sd_state, fse->pad, &format, fse->which); 1028 fse->max_width = format.width; 1029 fse->max_height = format.height; 1030 1031 return 0; 1032 } 1033 1034 /* 1035 * vfe_get_format - Handle get format by pads subdev method 1036 * @sd: VFE V4L2 subdevice 1037 * @cfg: V4L2 subdev pad configuration 1038 * @fmt: pointer to v4l2 subdev format structure 1039 * 1040 * Return -EINVAL or zero on success 1041 */ 1042 static int vfe_get_format(struct v4l2_subdev *sd, 1043 struct v4l2_subdev_state *sd_state, 1044 struct v4l2_subdev_format *fmt) 1045 { 1046 struct vfe_line *line = v4l2_get_subdevdata(sd); 1047 struct v4l2_mbus_framefmt *format; 1048 1049 format = __vfe_get_format(line, sd_state, fmt->pad, fmt->which); 1050 if (format == NULL) 1051 return -EINVAL; 1052 1053 fmt->format = *format; 1054 1055 return 0; 1056 } 1057 1058 static int vfe_set_selection(struct v4l2_subdev *sd, 1059 struct v4l2_subdev_state *sd_state, 1060 struct v4l2_subdev_selection *sel); 1061 1062 /* 1063 * vfe_set_format - Handle set format by pads subdev method 1064 * @sd: VFE V4L2 subdevice 1065 * @cfg: V4L2 subdev pad configuration 1066 * @fmt: pointer to v4l2 subdev format structure 1067 * 1068 * Return -EINVAL or zero on success 1069 */ 1070 static int vfe_set_format(struct v4l2_subdev *sd, 1071 struct v4l2_subdev_state *sd_state, 1072 struct v4l2_subdev_format *fmt) 1073 { 1074 struct vfe_line *line = v4l2_get_subdevdata(sd); 1075 struct v4l2_mbus_framefmt *format; 1076 1077 format = __vfe_get_format(line, sd_state, fmt->pad, fmt->which); 1078 if (format == NULL) 1079 return -EINVAL; 1080 1081 vfe_try_format(line, sd_state, fmt->pad, &fmt->format, fmt->which); 1082 *format = fmt->format; 1083 1084 if (fmt->pad == MSM_VFE_PAD_SINK) { 1085 struct v4l2_subdev_selection sel = { 0 }; 1086 int ret; 1087 1088 /* Propagate the format from sink to source */ 1089 format = __vfe_get_format(line, sd_state, MSM_VFE_PAD_SRC, 1090 fmt->which); 1091 1092 *format = fmt->format; 1093 vfe_try_format(line, sd_state, MSM_VFE_PAD_SRC, format, 1094 fmt->which); 1095 1096 if (line->id != VFE_LINE_PIX) 1097 return 0; 1098 1099 /* Reset sink pad compose selection */ 1100 sel.which = fmt->which; 1101 sel.pad = MSM_VFE_PAD_SINK; 1102 sel.target = V4L2_SEL_TGT_COMPOSE; 1103 sel.r.width = fmt->format.width; 1104 sel.r.height = fmt->format.height; 1105 ret = vfe_set_selection(sd, sd_state, &sel); 1106 if (ret < 0) 1107 return ret; 1108 } 1109 1110 return 0; 1111 } 1112 1113 /* 1114 * vfe_get_selection - Handle get selection by pads subdev method 1115 * @sd: VFE V4L2 subdevice 1116 * @cfg: V4L2 subdev pad configuration 1117 * @sel: pointer to v4l2 subdev selection structure 1118 * 1119 * Return -EINVAL or zero on success 1120 */ 1121 static int vfe_get_selection(struct v4l2_subdev *sd, 1122 struct v4l2_subdev_state *sd_state, 1123 struct v4l2_subdev_selection *sel) 1124 { 1125 struct vfe_line *line = v4l2_get_subdevdata(sd); 1126 struct v4l2_subdev_format fmt = { 0 }; 1127 struct v4l2_rect *rect; 1128 int ret; 1129 1130 if (line->id != VFE_LINE_PIX) 1131 return -EINVAL; 1132 1133 if (sel->pad == MSM_VFE_PAD_SINK) 1134 switch (sel->target) { 1135 case V4L2_SEL_TGT_COMPOSE_BOUNDS: 1136 fmt.pad = sel->pad; 1137 fmt.which = sel->which; 1138 ret = vfe_get_format(sd, sd_state, &fmt); 1139 if (ret < 0) 1140 return ret; 1141 1142 sel->r.left = 0; 1143 sel->r.top = 0; 1144 sel->r.width = fmt.format.width; 1145 sel->r.height = fmt.format.height; 1146 break; 1147 case V4L2_SEL_TGT_COMPOSE: 1148 rect = __vfe_get_compose(line, sd_state, sel->which); 1149 if (rect == NULL) 1150 return -EINVAL; 1151 1152 sel->r = *rect; 1153 break; 1154 default: 1155 return -EINVAL; 1156 } 1157 else if (sel->pad == MSM_VFE_PAD_SRC) 1158 switch (sel->target) { 1159 case V4L2_SEL_TGT_CROP_BOUNDS: 1160 rect = __vfe_get_compose(line, sd_state, sel->which); 1161 if (rect == NULL) 1162 return -EINVAL; 1163 1164 sel->r.left = rect->left; 1165 sel->r.top = rect->top; 1166 sel->r.width = rect->width; 1167 sel->r.height = rect->height; 1168 break; 1169 case V4L2_SEL_TGT_CROP: 1170 rect = __vfe_get_crop(line, sd_state, sel->which); 1171 if (rect == NULL) 1172 return -EINVAL; 1173 1174 sel->r = *rect; 1175 break; 1176 default: 1177 return -EINVAL; 1178 } 1179 1180 return 0; 1181 } 1182 1183 /* 1184 * vfe_set_selection - Handle set selection by pads subdev method 1185 * @sd: VFE V4L2 subdevice 1186 * @cfg: V4L2 subdev pad configuration 1187 * @sel: pointer to v4l2 subdev selection structure 1188 * 1189 * Return -EINVAL or zero on success 1190 */ 1191 static int vfe_set_selection(struct v4l2_subdev *sd, 1192 struct v4l2_subdev_state *sd_state, 1193 struct v4l2_subdev_selection *sel) 1194 { 1195 struct vfe_line *line = v4l2_get_subdevdata(sd); 1196 struct v4l2_rect *rect; 1197 int ret; 1198 1199 if (line->id != VFE_LINE_PIX) 1200 return -EINVAL; 1201 1202 if (sel->target == V4L2_SEL_TGT_COMPOSE && 1203 sel->pad == MSM_VFE_PAD_SINK) { 1204 struct v4l2_subdev_selection crop = { 0 }; 1205 1206 rect = __vfe_get_compose(line, sd_state, sel->which); 1207 if (rect == NULL) 1208 return -EINVAL; 1209 1210 vfe_try_compose(line, sd_state, &sel->r, sel->which); 1211 *rect = sel->r; 1212 1213 /* Reset source crop selection */ 1214 crop.which = sel->which; 1215 crop.pad = MSM_VFE_PAD_SRC; 1216 crop.target = V4L2_SEL_TGT_CROP; 1217 crop.r = *rect; 1218 ret = vfe_set_selection(sd, sd_state, &crop); 1219 } else if (sel->target == V4L2_SEL_TGT_CROP && 1220 sel->pad == MSM_VFE_PAD_SRC) { 1221 struct v4l2_subdev_format fmt = { 0 }; 1222 1223 rect = __vfe_get_crop(line, sd_state, sel->which); 1224 if (rect == NULL) 1225 return -EINVAL; 1226 1227 vfe_try_crop(line, sd_state, &sel->r, sel->which); 1228 *rect = sel->r; 1229 1230 /* Reset source pad format width and height */ 1231 fmt.which = sel->which; 1232 fmt.pad = MSM_VFE_PAD_SRC; 1233 ret = vfe_get_format(sd, sd_state, &fmt); 1234 if (ret < 0) 1235 return ret; 1236 1237 fmt.format.width = rect->width; 1238 fmt.format.height = rect->height; 1239 ret = vfe_set_format(sd, sd_state, &fmt); 1240 } else { 1241 ret = -EINVAL; 1242 } 1243 1244 return ret; 1245 } 1246 1247 /* 1248 * vfe_init_formats - Initialize formats on all pads 1249 * @sd: VFE V4L2 subdevice 1250 * @fh: V4L2 subdev file handle 1251 * 1252 * Initialize all pad formats with default values. 1253 * 1254 * Return 0 on success or a negative error code otherwise 1255 */ 1256 static int vfe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh) 1257 { 1258 struct v4l2_subdev_format format = { 1259 .pad = MSM_VFE_PAD_SINK, 1260 .which = fh ? V4L2_SUBDEV_FORMAT_TRY : 1261 V4L2_SUBDEV_FORMAT_ACTIVE, 1262 .format = { 1263 .code = MEDIA_BUS_FMT_UYVY8_2X8, 1264 .width = 1920, 1265 .height = 1080 1266 } 1267 }; 1268 1269 return vfe_set_format(sd, fh ? fh->state : NULL, &format); 1270 } 1271 1272 /* 1273 * msm_vfe_subdev_init - Initialize VFE device structure and resources 1274 * @vfe: VFE device 1275 * @res: VFE module resources table 1276 * 1277 * Return 0 on success or a negative error code otherwise 1278 */ 1279 int msm_vfe_subdev_init(struct camss *camss, struct vfe_device *vfe, 1280 const struct resources *res, u8 id) 1281 { 1282 struct device *dev = camss->dev; 1283 struct platform_device *pdev = to_platform_device(dev); 1284 int i, j; 1285 int ret; 1286 1287 switch (camss->version) { 1288 case CAMSS_8x16: 1289 vfe->ops = &vfe_ops_4_1; 1290 break; 1291 case CAMSS_8x96: 1292 vfe->ops = &vfe_ops_4_7; 1293 break; 1294 case CAMSS_660: 1295 vfe->ops = &vfe_ops_4_8; 1296 break; 1297 case CAMSS_845: 1298 vfe->ops = &vfe_ops_170; 1299 break; 1300 case CAMSS_8250: 1301 vfe->ops = &vfe_ops_480; 1302 break; 1303 default: 1304 return -EINVAL; 1305 } 1306 vfe->ops->subdev_init(dev, vfe); 1307 1308 /* Memory */ 1309 1310 vfe->base = devm_platform_ioremap_resource_byname(pdev, res->reg[0]); 1311 if (IS_ERR(vfe->base)) { 1312 dev_err(dev, "could not map memory\n"); 1313 return PTR_ERR(vfe->base); 1314 } 1315 1316 /* Interrupt */ 1317 1318 ret = platform_get_irq_byname(pdev, res->interrupt[0]); 1319 if (ret < 0) 1320 return ret; 1321 1322 vfe->irq = ret; 1323 snprintf(vfe->irq_name, sizeof(vfe->irq_name), "%s_%s%d", 1324 dev_name(dev), MSM_VFE_NAME, id); 1325 ret = devm_request_irq(dev, vfe->irq, vfe->ops->isr, 1326 IRQF_TRIGGER_RISING, vfe->irq_name, vfe); 1327 if (ret < 0) { 1328 dev_err(dev, "request_irq failed: %d\n", ret); 1329 return ret; 1330 } 1331 1332 /* Clocks */ 1333 1334 vfe->nclocks = 0; 1335 while (res->clock[vfe->nclocks]) 1336 vfe->nclocks++; 1337 1338 vfe->clock = devm_kcalloc(dev, vfe->nclocks, sizeof(*vfe->clock), 1339 GFP_KERNEL); 1340 if (!vfe->clock) 1341 return -ENOMEM; 1342 1343 for (i = 0; i < vfe->nclocks; i++) { 1344 struct camss_clock *clock = &vfe->clock[i]; 1345 1346 clock->clk = devm_clk_get(dev, res->clock[i]); 1347 if (IS_ERR(clock->clk)) 1348 return PTR_ERR(clock->clk); 1349 1350 clock->name = res->clock[i]; 1351 1352 clock->nfreqs = 0; 1353 while (res->clock_rate[i][clock->nfreqs]) 1354 clock->nfreqs++; 1355 1356 if (!clock->nfreqs) { 1357 clock->freq = NULL; 1358 continue; 1359 } 1360 1361 clock->freq = devm_kcalloc(dev, 1362 clock->nfreqs, 1363 sizeof(*clock->freq), 1364 GFP_KERNEL); 1365 if (!clock->freq) 1366 return -ENOMEM; 1367 1368 for (j = 0; j < clock->nfreqs; j++) 1369 clock->freq[j] = res->clock_rate[i][j]; 1370 } 1371 1372 mutex_init(&vfe->power_lock); 1373 vfe->power_count = 0; 1374 1375 mutex_init(&vfe->stream_lock); 1376 vfe->stream_count = 0; 1377 1378 spin_lock_init(&vfe->output_lock); 1379 1380 vfe->camss = camss; 1381 vfe->id = id; 1382 vfe->reg_update = 0; 1383 1384 for (i = VFE_LINE_RDI0; i < vfe->line_num; i++) { 1385 struct vfe_line *l = &vfe->line[i]; 1386 1387 l->video_out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1388 l->video_out.camss = camss; 1389 l->id = i; 1390 init_completion(&l->output.sof); 1391 init_completion(&l->output.reg_update); 1392 1393 if (camss->version == CAMSS_8x16) { 1394 if (i == VFE_LINE_PIX) { 1395 l->formats = formats_pix_8x16; 1396 l->nformats = ARRAY_SIZE(formats_pix_8x16); 1397 } else { 1398 l->formats = formats_rdi_8x16; 1399 l->nformats = ARRAY_SIZE(formats_rdi_8x16); 1400 } 1401 } else if (camss->version == CAMSS_8x96 || 1402 camss->version == CAMSS_660) { 1403 if (i == VFE_LINE_PIX) { 1404 l->formats = formats_pix_8x96; 1405 l->nformats = ARRAY_SIZE(formats_pix_8x96); 1406 } else { 1407 l->formats = formats_rdi_8x96; 1408 l->nformats = ARRAY_SIZE(formats_rdi_8x96); 1409 } 1410 } else if (camss->version == CAMSS_845 || 1411 camss->version == CAMSS_8250) { 1412 l->formats = formats_rdi_845; 1413 l->nformats = ARRAY_SIZE(formats_rdi_845); 1414 } else { 1415 return -EINVAL; 1416 } 1417 } 1418 1419 init_completion(&vfe->reset_complete); 1420 init_completion(&vfe->halt_complete); 1421 1422 return 0; 1423 } 1424 1425 /* 1426 * vfe_link_setup - Setup VFE connections 1427 * @entity: Pointer to media entity structure 1428 * @local: Pointer to local pad 1429 * @remote: Pointer to remote pad 1430 * @flags: Link flags 1431 * 1432 * Return 0 on success 1433 */ 1434 static int vfe_link_setup(struct media_entity *entity, 1435 const struct media_pad *local, 1436 const struct media_pad *remote, u32 flags) 1437 { 1438 if (flags & MEDIA_LNK_FL_ENABLED) 1439 if (media_pad_remote_pad_first(local)) 1440 return -EBUSY; 1441 1442 return 0; 1443 } 1444 1445 static const struct v4l2_subdev_core_ops vfe_core_ops = { 1446 .s_power = vfe_set_power, 1447 }; 1448 1449 static const struct v4l2_subdev_video_ops vfe_video_ops = { 1450 .s_stream = vfe_set_stream, 1451 }; 1452 1453 static const struct v4l2_subdev_pad_ops vfe_pad_ops = { 1454 .enum_mbus_code = vfe_enum_mbus_code, 1455 .enum_frame_size = vfe_enum_frame_size, 1456 .get_fmt = vfe_get_format, 1457 .set_fmt = vfe_set_format, 1458 .get_selection = vfe_get_selection, 1459 .set_selection = vfe_set_selection, 1460 }; 1461 1462 static const struct v4l2_subdev_ops vfe_v4l2_ops = { 1463 .core = &vfe_core_ops, 1464 .video = &vfe_video_ops, 1465 .pad = &vfe_pad_ops, 1466 }; 1467 1468 static const struct v4l2_subdev_internal_ops vfe_v4l2_internal_ops = { 1469 .open = vfe_init_formats, 1470 }; 1471 1472 static const struct media_entity_operations vfe_media_ops = { 1473 .link_setup = vfe_link_setup, 1474 .link_validate = v4l2_subdev_link_validate, 1475 }; 1476 1477 /* 1478 * msm_vfe_register_entities - Register subdev node for VFE module 1479 * @vfe: VFE device 1480 * @v4l2_dev: V4L2 device 1481 * 1482 * Initialize and register a subdev node for the VFE module. Then 1483 * call msm_video_register() to register the video device node which 1484 * will be connected to this subdev node. Then actually create the 1485 * media link between them. 1486 * 1487 * Return 0 on success or a negative error code otherwise 1488 */ 1489 int msm_vfe_register_entities(struct vfe_device *vfe, 1490 struct v4l2_device *v4l2_dev) 1491 { 1492 struct device *dev = vfe->camss->dev; 1493 struct v4l2_subdev *sd; 1494 struct media_pad *pads; 1495 struct camss_video *video_out; 1496 int ret; 1497 int i; 1498 1499 for (i = 0; i < vfe->line_num; i++) { 1500 char name[32]; 1501 1502 sd = &vfe->line[i].subdev; 1503 pads = vfe->line[i].pads; 1504 video_out = &vfe->line[i].video_out; 1505 1506 v4l2_subdev_init(sd, &vfe_v4l2_ops); 1507 sd->internal_ops = &vfe_v4l2_internal_ops; 1508 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE; 1509 if (i == VFE_LINE_PIX) 1510 snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s", 1511 MSM_VFE_NAME, vfe->id, "pix"); 1512 else 1513 snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s%d", 1514 MSM_VFE_NAME, vfe->id, "rdi", i); 1515 1516 v4l2_set_subdevdata(sd, &vfe->line[i]); 1517 1518 ret = vfe_init_formats(sd, NULL); 1519 if (ret < 0) { 1520 dev_err(dev, "Failed to init format: %d\n", ret); 1521 goto error_init; 1522 } 1523 1524 pads[MSM_VFE_PAD_SINK].flags = MEDIA_PAD_FL_SINK; 1525 pads[MSM_VFE_PAD_SRC].flags = MEDIA_PAD_FL_SOURCE; 1526 1527 sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER; 1528 sd->entity.ops = &vfe_media_ops; 1529 ret = media_entity_pads_init(&sd->entity, MSM_VFE_PADS_NUM, 1530 pads); 1531 if (ret < 0) { 1532 dev_err(dev, "Failed to init media entity: %d\n", ret); 1533 goto error_init; 1534 } 1535 1536 ret = v4l2_device_register_subdev(v4l2_dev, sd); 1537 if (ret < 0) { 1538 dev_err(dev, "Failed to register subdev: %d\n", ret); 1539 goto error_reg_subdev; 1540 } 1541 1542 video_out->ops = &vfe->video_ops; 1543 video_out->bpl_alignment = 8; 1544 video_out->line_based = 0; 1545 if (i == VFE_LINE_PIX) { 1546 video_out->bpl_alignment = 16; 1547 video_out->line_based = 1; 1548 } 1549 snprintf(name, ARRAY_SIZE(name), "%s%d_%s%d", 1550 MSM_VFE_NAME, vfe->id, "video", i); 1551 ret = msm_video_register(video_out, v4l2_dev, name, 1552 i == VFE_LINE_PIX ? 1 : 0); 1553 if (ret < 0) { 1554 dev_err(dev, "Failed to register video node: %d\n", 1555 ret); 1556 goto error_reg_video; 1557 } 1558 1559 ret = media_create_pad_link( 1560 &sd->entity, MSM_VFE_PAD_SRC, 1561 &video_out->vdev.entity, 0, 1562 MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED); 1563 if (ret < 0) { 1564 dev_err(dev, "Failed to link %s->%s entities: %d\n", 1565 sd->entity.name, video_out->vdev.entity.name, 1566 ret); 1567 goto error_link; 1568 } 1569 } 1570 1571 return 0; 1572 1573 error_link: 1574 msm_video_unregister(video_out); 1575 1576 error_reg_video: 1577 v4l2_device_unregister_subdev(sd); 1578 1579 error_reg_subdev: 1580 media_entity_cleanup(&sd->entity); 1581 1582 error_init: 1583 for (i--; i >= 0; i--) { 1584 sd = &vfe->line[i].subdev; 1585 video_out = &vfe->line[i].video_out; 1586 1587 msm_video_unregister(video_out); 1588 v4l2_device_unregister_subdev(sd); 1589 media_entity_cleanup(&sd->entity); 1590 } 1591 1592 return ret; 1593 } 1594 1595 /* 1596 * msm_vfe_unregister_entities - Unregister VFE module subdev node 1597 * @vfe: VFE device 1598 */ 1599 void msm_vfe_unregister_entities(struct vfe_device *vfe) 1600 { 1601 int i; 1602 1603 mutex_destroy(&vfe->power_lock); 1604 mutex_destroy(&vfe->stream_lock); 1605 1606 for (i = 0; i < vfe->line_num; i++) { 1607 struct v4l2_subdev *sd = &vfe->line[i].subdev; 1608 struct camss_video *video_out = &vfe->line[i].video_out; 1609 1610 msm_video_unregister(video_out); 1611 v4l2_device_unregister_subdev(sd); 1612 media_entity_cleanup(&sd->entity); 1613 } 1614 } 1615