1
2
3
4
5
6
7
8
9
10#include <linux/module.h>
11#include <linux/uaccess.h>
12#include <linux/delay.h>
13#include <linux/device.h>
14#include <linux/dma-mapping.h>
15#include <linux/mm.h>
16#include <linux/sched.h>
17
18#include "iss.h"
19#include "iss_regs.h"
20#include "iss_ipipeif.h"
21
22static const unsigned int ipipeif_fmts[] = {
23 MEDIA_BUS_FMT_SGRBG10_1X10,
24 MEDIA_BUS_FMT_SRGGB10_1X10,
25 MEDIA_BUS_FMT_SBGGR10_1X10,
26 MEDIA_BUS_FMT_SGBRG10_1X10,
27 MEDIA_BUS_FMT_UYVY8_1X16,
28 MEDIA_BUS_FMT_YUYV8_1X16,
29};
30
31
32
33
34
35
36
37#define IPIPEIF_PRINT_REGISTER(iss, name)\
38 dev_dbg(iss->dev, "###IPIPEIF " #name "=0x%08x\n", \
39 iss_reg_read(iss, OMAP4_ISS_MEM_ISP_IPIPEIF, IPIPEIF_##name))
40
41#define ISIF_PRINT_REGISTER(iss, name)\
42 dev_dbg(iss->dev, "###ISIF " #name "=0x%08x\n", \
43 iss_reg_read(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_##name))
44
45#define ISP5_PRINT_REGISTER(iss, name)\
46 dev_dbg(iss->dev, "###ISP5 " #name "=0x%08x\n", \
47 iss_reg_read(iss, OMAP4_ISS_MEM_ISP_SYS1, ISP5_##name))
48
49static void ipipeif_print_status(struct iss_ipipeif_device *ipipeif)
50{
51 struct iss_device *iss = to_iss_device(ipipeif);
52
53 dev_dbg(iss->dev, "-------------IPIPEIF Register dump-------------\n");
54
55 IPIPEIF_PRINT_REGISTER(iss, CFG1);
56 IPIPEIF_PRINT_REGISTER(iss, CFG2);
57
58 ISIF_PRINT_REGISTER(iss, SYNCEN);
59 ISIF_PRINT_REGISTER(iss, CADU);
60 ISIF_PRINT_REGISTER(iss, CADL);
61 ISIF_PRINT_REGISTER(iss, MODESET);
62 ISIF_PRINT_REGISTER(iss, CCOLP);
63 ISIF_PRINT_REGISTER(iss, SPH);
64 ISIF_PRINT_REGISTER(iss, LNH);
65 ISIF_PRINT_REGISTER(iss, LNV);
66 ISIF_PRINT_REGISTER(iss, VDINT(0));
67 ISIF_PRINT_REGISTER(iss, HSIZE);
68
69 ISP5_PRINT_REGISTER(iss, SYSCONFIG);
70 ISP5_PRINT_REGISTER(iss, CTRL);
71 ISP5_PRINT_REGISTER(iss, IRQSTATUS(0));
72 ISP5_PRINT_REGISTER(iss, IRQENABLE_SET(0));
73 ISP5_PRINT_REGISTER(iss, IRQENABLE_CLR(0));
74
75 dev_dbg(iss->dev, "-----------------------------------------------\n");
76}
77
78static void ipipeif_write_enable(struct iss_ipipeif_device *ipipeif, u8 enable)
79{
80 struct iss_device *iss = to_iss_device(ipipeif);
81
82 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_SYNCEN,
83 ISIF_SYNCEN_DWEN, enable ? ISIF_SYNCEN_DWEN : 0);
84}
85
86
87
88
89
90
91static void ipipeif_enable(struct iss_ipipeif_device *ipipeif, u8 enable)
92{
93 struct iss_device *iss = to_iss_device(ipipeif);
94
95 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_SYNCEN,
96 ISIF_SYNCEN_SYEN, enable ? ISIF_SYNCEN_SYEN : 0);
97}
98
99
100
101
102
103
104
105
106
107
108
109
110static void ipipeif_set_outaddr(struct iss_ipipeif_device *ipipeif, u32 addr)
111{
112 struct iss_device *iss = to_iss_device(ipipeif);
113
114
115 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_CADU,
116 (addr >> (16 + 5)) & ISIF_CADU_MASK);
117 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_CADL,
118 (addr >> 5) & ISIF_CADL_MASK);
119}
120
121static void ipipeif_configure(struct iss_ipipeif_device *ipipeif)
122{
123 struct iss_device *iss = to_iss_device(ipipeif);
124 const struct iss_format_info *info;
125 struct v4l2_mbus_framefmt *format;
126 u32 isif_ccolp = 0;
127
128 omap4iss_configure_bridge(iss, ipipeif->input);
129
130
131 format = &ipipeif->formats[IPIPEIF_PAD_SINK];
132
133
134 iss_reg_clr(iss, OMAP4_ISS_MEM_ISP_IPIPEIF, IPIPEIF_CFG1,
135 IPIPEIF_CFG1_INPSRC1_MASK | IPIPEIF_CFG1_INPSRC2_MASK);
136
137
138 switch (format->code) {
139 case MEDIA_BUS_FMT_UYVY8_1X16:
140 case MEDIA_BUS_FMT_YUYV8_1X16:
141 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_MODESET,
142 ISIF_MODESET_CCDMD | ISIF_MODESET_INPMOD_MASK |
143 ISIF_MODESET_CCDW_MASK,
144 ISIF_MODESET_INPMOD_YCBCR16);
145
146 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_IPIPEIF, IPIPEIF_CFG2,
147 IPIPEIF_CFG2_YUV8, IPIPEIF_CFG2_YUV16);
148
149 break;
150 case MEDIA_BUS_FMT_SGRBG10_1X10:
151 isif_ccolp = ISIF_CCOLP_CP0_F0_GR |
152 ISIF_CCOLP_CP1_F0_R |
153 ISIF_CCOLP_CP2_F0_B |
154 ISIF_CCOLP_CP3_F0_GB;
155 goto cont_raw;
156 case MEDIA_BUS_FMT_SRGGB10_1X10:
157 isif_ccolp = ISIF_CCOLP_CP0_F0_R |
158 ISIF_CCOLP_CP1_F0_GR |
159 ISIF_CCOLP_CP2_F0_GB |
160 ISIF_CCOLP_CP3_F0_B;
161 goto cont_raw;
162 case MEDIA_BUS_FMT_SBGGR10_1X10:
163 isif_ccolp = ISIF_CCOLP_CP0_F0_B |
164 ISIF_CCOLP_CP1_F0_GB |
165 ISIF_CCOLP_CP2_F0_GR |
166 ISIF_CCOLP_CP3_F0_R;
167 goto cont_raw;
168 case MEDIA_BUS_FMT_SGBRG10_1X10:
169 isif_ccolp = ISIF_CCOLP_CP0_F0_GB |
170 ISIF_CCOLP_CP1_F0_B |
171 ISIF_CCOLP_CP2_F0_R |
172 ISIF_CCOLP_CP3_F0_GR;
173cont_raw:
174 iss_reg_clr(iss, OMAP4_ISS_MEM_ISP_IPIPEIF, IPIPEIF_CFG2,
175 IPIPEIF_CFG2_YUV16);
176
177 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_MODESET,
178 ISIF_MODESET_CCDMD | ISIF_MODESET_INPMOD_MASK |
179 ISIF_MODESET_CCDW_MASK, ISIF_MODESET_INPMOD_RAW |
180 ISIF_MODESET_CCDW_2BIT);
181
182 info = omap4iss_video_format_info(format->code);
183 iss_reg_update(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_CGAMMAWD,
184 ISIF_CGAMMAWD_GWDI_MASK,
185 ISIF_CGAMMAWD_GWDI(info->bpp));
186
187
188 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_CCOLP,
189 isif_ccolp);
190 break;
191 }
192
193 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_SPH, 0 & ISIF_SPH_MASK);
194 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_LNH,
195 (format->width - 1) & ISIF_LNH_MASK);
196 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_LNV,
197 (format->height - 1) & ISIF_LNV_MASK);
198
199
200 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_VDINT(0),
201 format->height - 1);
202
203
204 format = &ipipeif->formats[IPIPEIF_PAD_SOURCE_ISIF_SF];
205
206 iss_reg_write(iss, OMAP4_ISS_MEM_ISP_ISIF, ISIF_HSIZE,
207 (ipipeif->video_out.bpl_value >> 5) &
208 ISIF_HSIZE_HSIZE_MASK);
209
210
211
212}
213
214
215
216
217
218static void ipipeif_isr_buffer(struct iss_ipipeif_device *ipipeif)
219{
220 struct iss_buffer *buffer;
221
222
223
224
225
226 if (list_empty(&ipipeif->video_out.dmaqueue))
227 return;
228
229 ipipeif_write_enable(ipipeif, 0);
230
231 buffer = omap4iss_video_buffer_next(&ipipeif->video_out);
232 if (!buffer)
233 return;
234
235 ipipeif_set_outaddr(ipipeif, buffer->iss_addr);
236
237 ipipeif_write_enable(ipipeif, 1);
238}
239
240
241
242
243
244
245void omap4iss_ipipeif_isr(struct iss_ipipeif_device *ipipeif, u32 events)
246{
247 if (omap4iss_module_sync_is_stopping(&ipipeif->wait,
248 &ipipeif->stopping))
249 return;
250
251 if ((events & ISP5_IRQ_ISIF_INT(0)) &&
252 (ipipeif->output & IPIPEIF_OUTPUT_MEMORY))
253 ipipeif_isr_buffer(ipipeif);
254}
255
256
257
258
259
260static int ipipeif_video_queue(struct iss_video *video,
261 struct iss_buffer *buffer)
262{
263 struct iss_ipipeif_device *ipipeif = container_of(video,
264 struct iss_ipipeif_device, video_out);
265
266 if (!(ipipeif->output & IPIPEIF_OUTPUT_MEMORY))
267 return -ENODEV;
268
269 ipipeif_set_outaddr(ipipeif, buffer->iss_addr);
270
271
272
273
274
275
276
277 if (video->dmaqueue_flags & ISS_VIDEO_DMAQUEUE_UNDERRUN) {
278 if (ipipeif->output & IPIPEIF_OUTPUT_MEMORY)
279 ipipeif_write_enable(ipipeif, 1);
280 ipipeif_enable(ipipeif, 1);
281 iss_video_dmaqueue_flags_clr(video);
282 }
283
284 return 0;
285}
286
287static const struct iss_video_operations ipipeif_video_ops = {
288 .queue = ipipeif_video_queue,
289};
290
291
292
293
294
295#define IPIPEIF_DRV_SUBCLK_MASK (OMAP4_ISS_ISP_SUBCLK_IPIPEIF |\
296 OMAP4_ISS_ISP_SUBCLK_ISIF)
297
298
299
300
301
302static int ipipeif_set_stream(struct v4l2_subdev *sd, int enable)
303{
304 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
305 struct iss_device *iss = to_iss_device(ipipeif);
306 struct iss_video *video_out = &ipipeif->video_out;
307 int ret = 0;
308
309 if (ipipeif->state == ISS_PIPELINE_STREAM_STOPPED) {
310 if (enable == ISS_PIPELINE_STREAM_STOPPED)
311 return 0;
312
313 omap4iss_isp_subclk_enable(iss, IPIPEIF_DRV_SUBCLK_MASK);
314 }
315
316 switch (enable) {
317 case ISS_PIPELINE_STREAM_CONTINUOUS:
318
319 ipipeif_configure(ipipeif);
320 ipipeif_print_status(ipipeif);
321
322
323
324
325
326
327
328 if (ipipeif->output & IPIPEIF_OUTPUT_MEMORY &&
329 !(video_out->dmaqueue_flags & ISS_VIDEO_DMAQUEUE_QUEUED))
330 break;
331
332 atomic_set(&ipipeif->stopping, 0);
333 if (ipipeif->output & IPIPEIF_OUTPUT_MEMORY)
334 ipipeif_write_enable(ipipeif, 1);
335 ipipeif_enable(ipipeif, 1);
336 iss_video_dmaqueue_flags_clr(video_out);
337 break;
338
339 case ISS_PIPELINE_STREAM_STOPPED:
340 if (ipipeif->state == ISS_PIPELINE_STREAM_STOPPED)
341 return 0;
342 if (omap4iss_module_sync_idle(&sd->entity, &ipipeif->wait,
343 &ipipeif->stopping))
344 ret = -ETIMEDOUT;
345
346 if (ipipeif->output & IPIPEIF_OUTPUT_MEMORY)
347 ipipeif_write_enable(ipipeif, 0);
348 ipipeif_enable(ipipeif, 0);
349 omap4iss_isp_subclk_disable(iss, IPIPEIF_DRV_SUBCLK_MASK);
350 iss_video_dmaqueue_flags_clr(video_out);
351 break;
352 }
353
354 ipipeif->state = enable;
355 return ret;
356}
357
358static struct v4l2_mbus_framefmt *
359__ipipeif_get_format(struct iss_ipipeif_device *ipipeif,
360 struct v4l2_subdev_state *sd_state, unsigned int pad,
361 enum v4l2_subdev_format_whence which)
362{
363 if (which == V4L2_SUBDEV_FORMAT_TRY)
364 return v4l2_subdev_get_try_format(&ipipeif->subdev, sd_state,
365 pad);
366 return &ipipeif->formats[pad];
367}
368
369
370
371
372
373
374
375
376static void
377ipipeif_try_format(struct iss_ipipeif_device *ipipeif,
378 struct v4l2_subdev_state *sd_state, unsigned int pad,
379 struct v4l2_mbus_framefmt *fmt,
380 enum v4l2_subdev_format_whence which)
381{
382 struct v4l2_mbus_framefmt *format;
383 unsigned int width = fmt->width;
384 unsigned int height = fmt->height;
385 unsigned int i;
386
387 switch (pad) {
388 case IPIPEIF_PAD_SINK:
389
390
391
392 for (i = 0; i < ARRAY_SIZE(ipipeif_fmts); i++) {
393 if (fmt->code == ipipeif_fmts[i])
394 break;
395 }
396
397
398 if (i >= ARRAY_SIZE(ipipeif_fmts))
399 fmt->code = MEDIA_BUS_FMT_SGRBG10_1X10;
400
401
402 fmt->width = clamp_t(u32, width, 1, 8192);
403 fmt->height = clamp_t(u32, height, 1, 8192);
404 break;
405
406 case IPIPEIF_PAD_SOURCE_ISIF_SF:
407 format = __ipipeif_get_format(ipipeif, sd_state,
408 IPIPEIF_PAD_SINK,
409 which);
410 memcpy(fmt, format, sizeof(*fmt));
411
412
413
414
415
416
417 fmt->width = clamp_t(u32, width, 32, (fmt->width + 15) & ~15);
418 fmt->width &= ~15;
419 fmt->height = clamp_t(u32, height, 32, fmt->height);
420 break;
421
422 case IPIPEIF_PAD_SOURCE_VP:
423 format = __ipipeif_get_format(ipipeif, sd_state,
424 IPIPEIF_PAD_SINK,
425 which);
426 memcpy(fmt, format, sizeof(*fmt));
427
428 fmt->width = clamp_t(u32, width, 32, fmt->width);
429 fmt->height = clamp_t(u32, height, 32, fmt->height);
430 break;
431 }
432
433
434
435
436 fmt->colorspace = V4L2_COLORSPACE_SRGB;
437 fmt->field = V4L2_FIELD_NONE;
438}
439
440
441
442
443
444
445
446
447static int ipipeif_enum_mbus_code(struct v4l2_subdev *sd,
448 struct v4l2_subdev_state *sd_state,
449 struct v4l2_subdev_mbus_code_enum *code)
450{
451 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
452 struct v4l2_mbus_framefmt *format;
453
454 switch (code->pad) {
455 case IPIPEIF_PAD_SINK:
456 if (code->index >= ARRAY_SIZE(ipipeif_fmts))
457 return -EINVAL;
458
459 code->code = ipipeif_fmts[code->index];
460 break;
461
462 case IPIPEIF_PAD_SOURCE_ISIF_SF:
463 case IPIPEIF_PAD_SOURCE_VP:
464
465 if (code->index != 0)
466 return -EINVAL;
467
468 format = __ipipeif_get_format(ipipeif, sd_state,
469 IPIPEIF_PAD_SINK,
470 code->which);
471
472 code->code = format->code;
473 break;
474
475 default:
476 return -EINVAL;
477 }
478
479 return 0;
480}
481
482static int ipipeif_enum_frame_size(struct v4l2_subdev *sd,
483 struct v4l2_subdev_state *sd_state,
484 struct v4l2_subdev_frame_size_enum *fse)
485{
486 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
487 struct v4l2_mbus_framefmt format;
488
489 if (fse->index != 0)
490 return -EINVAL;
491
492 format.code = fse->code;
493 format.width = 1;
494 format.height = 1;
495 ipipeif_try_format(ipipeif, sd_state, fse->pad, &format, fse->which);
496 fse->min_width = format.width;
497 fse->min_height = format.height;
498
499 if (format.code != fse->code)
500 return -EINVAL;
501
502 format.code = fse->code;
503 format.width = -1;
504 format.height = -1;
505 ipipeif_try_format(ipipeif, sd_state, fse->pad, &format, fse->which);
506 fse->max_width = format.width;
507 fse->max_height = format.height;
508
509 return 0;
510}
511
512
513
514
515
516
517
518
519
520
521static int ipipeif_get_format(struct v4l2_subdev *sd,
522 struct v4l2_subdev_state *sd_state,
523 struct v4l2_subdev_format *fmt)
524{
525 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
526 struct v4l2_mbus_framefmt *format;
527
528 format = __ipipeif_get_format(ipipeif, sd_state, fmt->pad, fmt->which);
529 if (!format)
530 return -EINVAL;
531
532 fmt->format = *format;
533 return 0;
534}
535
536
537
538
539
540
541
542
543
544
545static int ipipeif_set_format(struct v4l2_subdev *sd,
546 struct v4l2_subdev_state *sd_state,
547 struct v4l2_subdev_format *fmt)
548{
549 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
550 struct v4l2_mbus_framefmt *format;
551
552 format = __ipipeif_get_format(ipipeif, sd_state, fmt->pad, fmt->which);
553 if (!format)
554 return -EINVAL;
555
556 ipipeif_try_format(ipipeif, sd_state, fmt->pad, &fmt->format,
557 fmt->which);
558 *format = fmt->format;
559
560
561 if (fmt->pad == IPIPEIF_PAD_SINK) {
562 format = __ipipeif_get_format(ipipeif, sd_state,
563 IPIPEIF_PAD_SOURCE_ISIF_SF,
564 fmt->which);
565 *format = fmt->format;
566 ipipeif_try_format(ipipeif, sd_state,
567 IPIPEIF_PAD_SOURCE_ISIF_SF,
568 format, fmt->which);
569
570 format = __ipipeif_get_format(ipipeif, sd_state,
571 IPIPEIF_PAD_SOURCE_VP,
572 fmt->which);
573 *format = fmt->format;
574 ipipeif_try_format(ipipeif, sd_state, IPIPEIF_PAD_SOURCE_VP,
575 format,
576 fmt->which);
577 }
578
579 return 0;
580}
581
582static int ipipeif_link_validate(struct v4l2_subdev *sd,
583 struct media_link *link,
584 struct v4l2_subdev_format *source_fmt,
585 struct v4l2_subdev_format *sink_fmt)
586{
587
588 if (source_fmt->format.width != sink_fmt->format.width ||
589 source_fmt->format.height != sink_fmt->format.height)
590 return -EPIPE;
591
592 if (source_fmt->format.code != sink_fmt->format.code)
593 return -EPIPE;
594
595 return 0;
596}
597
598
599
600
601
602
603
604
605
606
607static int ipipeif_init_formats(struct v4l2_subdev *sd,
608 struct v4l2_subdev_fh *fh)
609{
610 struct v4l2_subdev_format format;
611
612 memset(&format, 0, sizeof(format));
613 format.pad = IPIPEIF_PAD_SINK;
614 format.which = fh ? V4L2_SUBDEV_FORMAT_TRY : V4L2_SUBDEV_FORMAT_ACTIVE;
615 format.format.code = MEDIA_BUS_FMT_SGRBG10_1X10;
616 format.format.width = 4096;
617 format.format.height = 4096;
618 ipipeif_set_format(sd, fh ? fh->state : NULL, &format);
619
620 return 0;
621}
622
623
624static const struct v4l2_subdev_video_ops ipipeif_v4l2_video_ops = {
625 .s_stream = ipipeif_set_stream,
626};
627
628
629static const struct v4l2_subdev_pad_ops ipipeif_v4l2_pad_ops = {
630 .enum_mbus_code = ipipeif_enum_mbus_code,
631 .enum_frame_size = ipipeif_enum_frame_size,
632 .get_fmt = ipipeif_get_format,
633 .set_fmt = ipipeif_set_format,
634 .link_validate = ipipeif_link_validate,
635};
636
637
638static const struct v4l2_subdev_ops ipipeif_v4l2_ops = {
639 .video = &ipipeif_v4l2_video_ops,
640 .pad = &ipipeif_v4l2_pad_ops,
641};
642
643
644static const struct v4l2_subdev_internal_ops ipipeif_v4l2_internal_ops = {
645 .open = ipipeif_init_formats,
646};
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661static int ipipeif_link_setup(struct media_entity *entity,
662 const struct media_pad *local,
663 const struct media_pad *remote, u32 flags)
664{
665 struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
666 struct iss_ipipeif_device *ipipeif = v4l2_get_subdevdata(sd);
667 struct iss_device *iss = to_iss_device(ipipeif);
668 unsigned int index = local->index;
669
670
671 if (is_media_entity_v4l2_subdev(remote->entity))
672 index |= 2 << 16;
673
674 switch (index) {
675 case IPIPEIF_PAD_SINK | 2 << 16:
676
677 if (!(flags & MEDIA_LNK_FL_ENABLED)) {
678 ipipeif->input = IPIPEIF_INPUT_NONE;
679 break;
680 }
681
682 if (ipipeif->input != IPIPEIF_INPUT_NONE)
683 return -EBUSY;
684
685 if (remote->entity == &iss->csi2a.subdev.entity)
686 ipipeif->input = IPIPEIF_INPUT_CSI2A;
687 else if (remote->entity == &iss->csi2b.subdev.entity)
688 ipipeif->input = IPIPEIF_INPUT_CSI2B;
689
690 break;
691
692 case IPIPEIF_PAD_SOURCE_ISIF_SF:
693
694 if (flags & MEDIA_LNK_FL_ENABLED) {
695 if (ipipeif->output & ~IPIPEIF_OUTPUT_MEMORY)
696 return -EBUSY;
697 ipipeif->output |= IPIPEIF_OUTPUT_MEMORY;
698 } else {
699 ipipeif->output &= ~IPIPEIF_OUTPUT_MEMORY;
700 }
701 break;
702
703 case IPIPEIF_PAD_SOURCE_VP | 2 << 16:
704
705 if (flags & MEDIA_LNK_FL_ENABLED) {
706 if (ipipeif->output & ~IPIPEIF_OUTPUT_VP)
707 return -EBUSY;
708 ipipeif->output |= IPIPEIF_OUTPUT_VP;
709 } else {
710 ipipeif->output &= ~IPIPEIF_OUTPUT_VP;
711 }
712 break;
713
714 default:
715 return -EINVAL;
716 }
717
718 return 0;
719}
720
721
722static const struct media_entity_operations ipipeif_media_ops = {
723 .link_setup = ipipeif_link_setup,
724 .link_validate = v4l2_subdev_link_validate,
725};
726
727
728
729
730
731
732
733static int ipipeif_init_entities(struct iss_ipipeif_device *ipipeif)
734{
735 struct v4l2_subdev *sd = &ipipeif->subdev;
736 struct media_pad *pads = ipipeif->pads;
737 struct media_entity *me = &sd->entity;
738 int ret;
739
740 ipipeif->input = IPIPEIF_INPUT_NONE;
741
742 v4l2_subdev_init(sd, &ipipeif_v4l2_ops);
743 sd->internal_ops = &ipipeif_v4l2_internal_ops;
744 strscpy(sd->name, "OMAP4 ISS ISP IPIPEIF", sizeof(sd->name));
745 sd->grp_id = BIT(16);
746 v4l2_set_subdevdata(sd, ipipeif);
747 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
748
749 pads[IPIPEIF_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
750 pads[IPIPEIF_PAD_SOURCE_ISIF_SF].flags = MEDIA_PAD_FL_SOURCE;
751 pads[IPIPEIF_PAD_SOURCE_VP].flags = MEDIA_PAD_FL_SOURCE;
752
753 me->ops = &ipipeif_media_ops;
754 ret = media_entity_pads_init(me, IPIPEIF_PADS_NUM, pads);
755 if (ret < 0)
756 return ret;
757
758 ipipeif_init_formats(sd, NULL);
759
760 ipipeif->video_out.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
761 ipipeif->video_out.ops = &ipipeif_video_ops;
762 ipipeif->video_out.iss = to_iss_device(ipipeif);
763 ipipeif->video_out.capture_mem = PAGE_ALIGN(4096 * 4096) * 3;
764 ipipeif->video_out.bpl_alignment = 32;
765 ipipeif->video_out.bpl_zero_padding = 1;
766 ipipeif->video_out.bpl_max = 0x1ffe0;
767
768 return omap4iss_video_init(&ipipeif->video_out, "ISP IPIPEIF");
769}
770
771void omap4iss_ipipeif_unregister_entities(struct iss_ipipeif_device *ipipeif)
772{
773 v4l2_device_unregister_subdev(&ipipeif->subdev);
774 omap4iss_video_unregister(&ipipeif->video_out);
775}
776
777int omap4iss_ipipeif_register_entities(struct iss_ipipeif_device *ipipeif,
778 struct v4l2_device *vdev)
779{
780 int ret;
781
782
783 ret = v4l2_device_register_subdev(vdev, &ipipeif->subdev);
784 if (ret < 0)
785 goto error;
786
787 ret = omap4iss_video_register(&ipipeif->video_out, vdev);
788 if (ret < 0)
789 goto error;
790
791 return 0;
792
793error:
794 omap4iss_ipipeif_unregister_entities(ipipeif);
795 return ret;
796}
797
798
799
800
801
802
803
804
805
806
807
808
809
810int omap4iss_ipipeif_init(struct iss_device *iss)
811{
812 struct iss_ipipeif_device *ipipeif = &iss->ipipeif;
813
814 ipipeif->state = ISS_PIPELINE_STREAM_STOPPED;
815 init_waitqueue_head(&ipipeif->wait);
816
817 return ipipeif_init_entities(ipipeif);
818}
819
820
821
822
823
824
825
826int omap4iss_ipipeif_create_links(struct iss_device *iss)
827{
828 struct iss_ipipeif_device *ipipeif = &iss->ipipeif;
829
830
831 return media_create_pad_link(&ipipeif->subdev.entity,
832 IPIPEIF_PAD_SOURCE_ISIF_SF,
833 &ipipeif->video_out.video.entity, 0, 0);
834}
835
836
837
838
839
840void omap4iss_ipipeif_cleanup(struct iss_device *iss)
841{
842 struct iss_ipipeif_device *ipipeif = &iss->ipipeif;
843
844 media_entity_cleanup(&ipipeif->subdev.entity);
845}
846