1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/kernel.h>
21#include <linux/module.h>
22#include <linux/kthread.h>
23#include <linux/freezer.h>
24
25#include <media/v4l2-ioctl.h>
26#include <media/v4l2-common.h>
27#include <media/videobuf-dma-sg.h>
28
29#include "solo6010.h"
30#include "solo6010-tw28.h"
31#include "solo6010-jpeg.h"
32
33#define MIN_VID_BUFFERS 4
34#define FRAME_BUF_SIZE (128 * 1024)
35#define MP4_QS 16
36
37static int solo_enc_thread(void *data);
38
39extern unsigned video_nr;
40
41struct solo_enc_fh {
42 struct solo_enc_dev *enc;
43 u32 fmt;
44 u16 rd_idx;
45 u8 enc_on;
46 enum solo_enc_types type;
47 struct videobuf_queue vidq;
48 struct list_head vidq_active;
49 struct task_struct *kthread;
50 struct p2m_desc desc[SOLO_NR_P2M_DESC];
51};
52
53static unsigned char vid_vop_header[] = {
54 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
55 0x02, 0x48, 0x05, 0xc0, 0x00, 0x40, 0x00, 0x40,
56 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
57 0x1f, 0x4c, 0x58, 0x10, 0x78, 0x51, 0x18, 0x3f,
58};
59
60
61
62
63
64
65
66
67
68
69
70
71
72#define XVID_PAR_43_PAL 2
73#define XVID_PAR_43_NTSC 3
74
75static const u32 solo_user_ctrls[] = {
76 V4L2_CID_BRIGHTNESS,
77 V4L2_CID_CONTRAST,
78 V4L2_CID_SATURATION,
79 V4L2_CID_HUE,
80 V4L2_CID_SHARPNESS,
81 0
82};
83
84static const u32 solo_mpeg_ctrls[] = {
85 V4L2_CID_MPEG_VIDEO_ENCODING,
86 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
87 0
88};
89
90static const u32 solo_private_ctrls[] = {
91 V4L2_CID_MOTION_ENABLE,
92 V4L2_CID_MOTION_THRESHOLD,
93 0
94};
95
96static const u32 solo_fmtx_ctrls[] = {
97 V4L2_CID_RDS_TX_RADIO_TEXT,
98 0
99};
100
101static const u32 *solo_ctrl_classes[] = {
102 solo_user_ctrls,
103 solo_mpeg_ctrls,
104 solo_fmtx_ctrls,
105 solo_private_ctrls,
106 NULL
107};
108
109struct vop_header {
110
111 u32 size:20, sync_start:1, page_stop:1, vop_type:2, channel:4,
112 nop0:1, source_fl:1, interlace:1, progressive:1;
113
114
115 u32 vsize:8, hsize:8, frame_interop:1, nop1:7, win_id:4, scale:4;
116
117
118 u32 base_addr:16, nop2:15, hoff:1;
119
120
121 u32 sy:12, sx:12, nop3:1, hzoom:1, read_interop:1, write_interlace:1,
122 scale_mode:4;
123
124
125 u32 write_page:8, nop4:24;
126
127
128 u32 next_code_addr;
129
130 u32 end_nops[10];
131} __attribute__((packed));
132
133static int solo_is_motion_on(struct solo_enc_dev *solo_enc)
134{
135 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
136 u8 ch = solo_enc->ch;
137
138 if (solo_dev->motion_mask & (1 << ch))
139 return 1;
140 return 0;
141}
142
143static void solo_motion_toggle(struct solo_enc_dev *solo_enc, int on)
144{
145 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
146 u8 ch = solo_enc->ch;
147
148 spin_lock(&solo_enc->lock);
149
150 if (on)
151 solo_dev->motion_mask |= (1 << ch);
152 else
153 solo_dev->motion_mask &= ~(1 << ch);
154
155
156 solo_reg_write(solo_enc->solo_dev, SOLO_VI_MOT_CLEAR,
157 1 << solo_enc->ch);
158 solo_enc->motion_detected = 0;
159
160 solo_reg_write(solo_dev, SOLO_VI_MOT_ADR,
161 SOLO_VI_MOTION_EN(solo_dev->motion_mask) |
162 (SOLO_MOTION_EXT_ADDR(solo_dev) >> 16));
163
164 if (solo_dev->motion_mask)
165 solo6010_irq_on(solo_dev, SOLO_IRQ_MOTION);
166 else
167 solo6010_irq_off(solo_dev, SOLO_IRQ_MOTION);
168
169 spin_unlock(&solo_enc->lock);
170}
171
172
173static void solo_update_mode(struct solo_enc_dev *solo_enc)
174{
175 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
176
177 assert_spin_locked(&solo_enc->lock);
178
179 solo_enc->interlaced = (solo_enc->mode & 0x08) ? 1 : 0;
180 solo_enc->bw_weight = max(solo_dev->fps / solo_enc->interval, 1);
181
182 switch (solo_enc->mode) {
183 case SOLO_ENC_MODE_CIF:
184 solo_enc->width = solo_dev->video_hsize >> 1;
185 solo_enc->height = solo_dev->video_vsize;
186 break;
187 case SOLO_ENC_MODE_D1:
188 solo_enc->width = solo_dev->video_hsize;
189 solo_enc->height = solo_dev->video_vsize << 1;
190 solo_enc->bw_weight <<= 2;
191 break;
192 default:
193 WARN(1, "mode is unknown\n");
194 }
195}
196
197
198static int solo_enc_on(struct solo_enc_fh *fh)
199{
200 struct solo_enc_dev *solo_enc = fh->enc;
201 u8 ch = solo_enc->ch;
202 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
203 u8 interval;
204
205 assert_spin_locked(&solo_enc->lock);
206
207 if (fh->enc_on)
208 return 0;
209
210 solo_update_mode(solo_enc);
211
212
213 if (!atomic_read(&solo_enc->readers)) {
214 if (solo_enc->bw_weight > solo_dev->enc_bw_remain)
215 return -EBUSY;
216 else
217 solo_dev->enc_bw_remain -= solo_enc->bw_weight;
218 }
219
220 fh->enc_on = 1;
221 fh->rd_idx = solo_enc->solo_dev->enc_wr_idx;
222
223 if (fh->type == SOLO_ENC_TYPE_EXT)
224 solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(ch), 1);
225
226 if (atomic_inc_return(&solo_enc->readers) > 1)
227 return 0;
228
229
230 solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), 0);
231
232
233 solo_reg_write(solo_dev, SOLO_VE_CH_INTL(ch),
234 solo_enc->interlaced ? 1 : 0);
235
236 if (solo_enc->interlaced)
237 interval = solo_enc->interval - 1;
238 else
239 interval = solo_enc->interval;
240
241
242 solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch), solo_enc->gop);
243 solo_reg_write(solo_dev, SOLO_VE_CH_QP(ch), solo_enc->qp);
244 solo_reg_write(solo_dev, SOLO_CAP_CH_INTV(ch), interval);
245
246
247 solo_reg_write(solo_dev, SOLO_VE_CH_GOP_E(ch), solo_enc->gop);
248 solo_reg_write(solo_dev, SOLO_VE_CH_QP_E(ch), solo_enc->qp);
249 solo_reg_write(solo_dev, SOLO_CAP_CH_INTV_E(ch), interval);
250
251
252 solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(ch), solo_enc->mode);
253
254
255 mdelay(10);
256
257 return 0;
258}
259
260static void solo_enc_off(struct solo_enc_fh *fh)
261{
262 struct solo_enc_dev *solo_enc = fh->enc;
263 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
264
265 if (!fh->enc_on)
266 return;
267
268 if (fh->kthread) {
269 kthread_stop(fh->kthread);
270 fh->kthread = NULL;
271 }
272
273 solo_dev->enc_bw_remain += solo_enc->bw_weight;
274 fh->enc_on = 0;
275
276 if (atomic_dec_return(&solo_enc->readers) > 0)
277 return;
278
279 solo_reg_write(solo_dev, SOLO_CAP_CH_SCALE(solo_enc->ch), 0);
280 solo_reg_write(solo_dev, SOLO_CAP_CH_COMP_ENA_E(solo_enc->ch), 0);
281}
282
283static int solo_start_fh_thread(struct solo_enc_fh *fh)
284{
285 struct solo_enc_dev *solo_enc = fh->enc;
286
287 fh->kthread = kthread_run(solo_enc_thread, fh, SOLO6010_NAME "_enc");
288
289
290 if (IS_ERR(fh->kthread)) {
291 spin_lock(&solo_enc->lock);
292 solo_enc_off(fh);
293 spin_unlock(&solo_enc->lock);
294
295 return PTR_ERR(fh->kthread);
296 }
297
298 return 0;
299}
300
301static void enc_reset_gop(struct solo6010_dev *solo_dev, u8 ch)
302{
303 BUG_ON(ch >= solo_dev->nr_chans);
304 solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch), 1);
305 solo_dev->v4l2_enc[ch]->reset_gop = 1;
306}
307
308static int enc_gop_reset(struct solo6010_dev *solo_dev, u8 ch, u8 vop)
309{
310 BUG_ON(ch >= solo_dev->nr_chans);
311 if (!solo_dev->v4l2_enc[ch]->reset_gop)
312 return 0;
313 if (vop)
314 return 1;
315 solo_dev->v4l2_enc[ch]->reset_gop = 0;
316 solo_reg_write(solo_dev, SOLO_VE_CH_GOP(ch),
317 solo_dev->v4l2_enc[ch]->gop);
318 return 0;
319}
320
321static void enc_write_sg(struct scatterlist *sglist, void *buf, int size)
322{
323 struct scatterlist *sg;
324 u8 *src = buf;
325
326 for (sg = sglist; sg && size > 0; sg = sg_next(sg)) {
327 u8 *p = sg_virt(sg);
328 size_t len = sg_dma_len(sg);
329 int i;
330
331 for (i = 0; i < len && size; i++)
332 p[i] = *(src++);
333 }
334}
335
336static int enc_get_mpeg_dma_sg(struct solo6010_dev *solo_dev,
337 struct p2m_desc *desc,
338 struct scatterlist *sglist, int skip,
339 unsigned int off, unsigned int size)
340{
341 int ret;
342
343 if (off > SOLO_MP4E_EXT_SIZE(solo_dev))
344 return -EINVAL;
345
346 if (off + size <= SOLO_MP4E_EXT_SIZE(solo_dev)) {
347 return solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_MP4E,
348 desc, 0, sglist, skip,
349 SOLO_MP4E_EXT_ADDR(solo_dev) + off, size);
350 }
351
352
353 ret = solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_MP4E, desc, 0,
354 sglist, skip, SOLO_MP4E_EXT_ADDR(solo_dev) + off,
355 SOLO_MP4E_EXT_SIZE(solo_dev) - off);
356
357 ret |= solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_MP4E, desc, 0,
358 sglist, skip + SOLO_MP4E_EXT_SIZE(solo_dev) - off,
359 SOLO_MP4E_EXT_ADDR(solo_dev),
360 size + off - SOLO_MP4E_EXT_SIZE(solo_dev));
361
362 return ret;
363}
364
365static int enc_get_mpeg_dma_t(struct solo6010_dev *solo_dev,
366 dma_addr_t buf, unsigned int off,
367 unsigned int size)
368{
369 int ret;
370
371 if (off > SOLO_MP4E_EXT_SIZE(solo_dev))
372 return -EINVAL;
373
374 if (off + size <= SOLO_MP4E_EXT_SIZE(solo_dev)) {
375 return solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0, buf,
376 SOLO_MP4E_EXT_ADDR(solo_dev) + off, size);
377 }
378
379
380 ret = solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0, buf,
381 SOLO_MP4E_EXT_ADDR(solo_dev) + off,
382 SOLO_MP4E_EXT_SIZE(solo_dev) - off);
383
384 ret |= solo_p2m_dma_t(solo_dev, SOLO_P2M_DMA_ID_MP4E, 0,
385 buf + SOLO_MP4E_EXT_SIZE(solo_dev) - off,
386 SOLO_MP4E_EXT_ADDR(solo_dev),
387 size + off - SOLO_MP4E_EXT_SIZE(solo_dev));
388
389 return ret;
390}
391
392static int enc_get_mpeg_dma(struct solo6010_dev *solo_dev, void *buf,
393 unsigned int off, unsigned int size)
394{
395 int ret;
396
397 dma_addr_t dma_addr = pci_map_single(solo_dev->pdev, buf, size,
398 PCI_DMA_FROMDEVICE);
399 ret = enc_get_mpeg_dma_t(solo_dev, dma_addr, off, size);
400 pci_unmap_single(solo_dev->pdev, dma_addr, size, PCI_DMA_FROMDEVICE);
401
402 return ret;
403}
404
405static int enc_get_jpeg_dma_sg(struct solo6010_dev *solo_dev,
406 struct p2m_desc *desc,
407 struct scatterlist *sglist, int skip,
408 unsigned int off, unsigned int size)
409{
410 int ret;
411
412 if (off > SOLO_JPEG_EXT_SIZE(solo_dev))
413 return -EINVAL;
414
415 if (off + size <= SOLO_JPEG_EXT_SIZE(solo_dev)) {
416 return solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_JPEG,
417 desc, 0, sglist, skip,
418 SOLO_JPEG_EXT_ADDR(solo_dev) + off, size);
419 }
420
421
422 ret = solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_JPEG, desc, 0,
423 sglist, skip, SOLO_JPEG_EXT_ADDR(solo_dev) + off,
424 SOLO_JPEG_EXT_SIZE(solo_dev) - off);
425
426 ret |= solo_p2m_dma_sg(solo_dev, SOLO_P2M_DMA_ID_JPEG, desc, 0,
427 sglist, skip + SOLO_JPEG_EXT_SIZE(solo_dev) - off,
428 SOLO_JPEG_EXT_ADDR(solo_dev),
429 size + off - SOLO_JPEG_EXT_SIZE(solo_dev));
430
431 return ret;
432}
433
434
435#define OFF_IN_RANGE(__off, __range, __chk) \
436 ((__off <= __chk) && ((__off + __range) >= __chk))
437
438static void solo_jpeg_header(struct solo_enc_dev *solo_enc,
439 struct videobuf_dmabuf *vbuf)
440{
441 struct scatterlist *sg;
442 void *src = jpeg_header;
443 size_t copied = 0;
444 size_t to_copy = sizeof(jpeg_header);
445
446 for (sg = vbuf->sglist; sg && copied < to_copy; sg = sg_next(sg)) {
447 size_t this_copy = min(sg_dma_len(sg),
448 (unsigned int)(to_copy - copied));
449 u8 *p = sg_virt(sg);
450
451 memcpy(p, src + copied, this_copy);
452
453 if (OFF_IN_RANGE(copied, this_copy, SOF0_START + 5))
454 p[(SOF0_START + 5) - copied] =
455 0xff & (solo_enc->height >> 8);
456 if (OFF_IN_RANGE(copied, this_copy, SOF0_START + 6))
457 p[(SOF0_START + 6) - copied] = 0xff & solo_enc->height;
458 if (OFF_IN_RANGE(copied, this_copy, SOF0_START + 7))
459 p[(SOF0_START + 7) - copied] =
460 0xff & (solo_enc->width >> 8);
461 if (OFF_IN_RANGE(copied, this_copy, SOF0_START + 8))
462 p[(SOF0_START + 8) - copied] = 0xff & solo_enc->width;
463
464 copied += this_copy;
465 }
466}
467
468static int solo_fill_jpeg(struct solo_enc_fh *fh, struct solo_enc_buf *enc_buf,
469 struct videobuf_buffer *vb,
470 struct videobuf_dmabuf *vbuf)
471{
472 struct solo6010_dev *solo_dev = fh->enc->solo_dev;
473 int size = enc_buf->jpeg_size;
474
475
476 solo_jpeg_header(fh->enc, vbuf);
477
478 vb->size = size + sizeof(jpeg_header);
479
480
481 return enc_get_jpeg_dma_sg(solo_dev, fh->desc, vbuf->sglist,
482 sizeof(jpeg_header),
483 enc_buf->jpeg_off, size);
484}
485
486static int solo_fill_mpeg(struct solo_enc_fh *fh, struct solo_enc_buf *enc_buf,
487 struct videobuf_buffer *vb,
488 struct videobuf_dmabuf *vbuf)
489{
490 struct solo_enc_dev *solo_enc = fh->enc;
491 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
492 struct vop_header vh;
493 int ret;
494 int frame_size, frame_off;
495 int skip = 0;
496
497 if (WARN_ON_ONCE(enc_buf->size <= sizeof(vh)))
498 return -EINVAL;
499
500
501 ret = enc_get_mpeg_dma(solo_dev, &vh, enc_buf->off, sizeof(vh));
502 if (WARN_ON_ONCE(ret))
503 return ret;
504
505 if (WARN_ON_ONCE(vh.size > enc_buf->size))
506 return -EINVAL;
507
508 vb->width = vh.hsize << 4;
509 vb->height = vh.vsize << 4;
510 vb->size = vh.size;
511
512
513 if (!enc_buf->vop) {
514 u16 fps = solo_dev->fps * 1000;
515 u16 interval = solo_enc->interval * 1000;
516 u8 p[sizeof(vid_vop_header)];
517
518 memcpy(p, vid_vop_header, sizeof(p));
519
520 if (solo_dev->video_type == SOLO_VO_FMT_TYPE_NTSC)
521 p[10] |= ((XVID_PAR_43_NTSC << 3) & 0x78);
522 else
523 p[10] |= ((XVID_PAR_43_PAL << 3) & 0x78);
524
525
526 p[22] = fps >> 4;
527 p[23] = ((fps << 4) & 0xf0) | 0x0c | ((interval >> 13) & 0x3);
528 p[24] = (interval >> 5) & 0xff;
529 p[25] = ((interval << 3) & 0xf8) | 0x04;
530
531
532 p[26] = (vb->width >> 3) & 0xff;
533 p[27] = ((vb->height >> 9) & 0x0f) | 0x10;
534 p[28] = (vb->height >> 1) & 0xff;
535
536
537 if (vh.interlace)
538 p[29] |= 0x20;
539
540 enc_write_sg(vbuf->sglist, p, sizeof(p));
541
542
543 vb->size += sizeof(vid_vop_header);
544 skip = sizeof(vid_vop_header);
545 }
546
547
548 frame_off = (enc_buf->off + sizeof(vh)) % SOLO_MP4E_EXT_SIZE(solo_dev);
549 frame_size = enc_buf->size - sizeof(vh);
550
551 ret = enc_get_mpeg_dma_sg(solo_dev, fh->desc, vbuf->sglist,
552 skip, frame_off, frame_size);
553 WARN_ON_ONCE(ret);
554
555 return ret;
556}
557
558static void solo_enc_fillbuf(struct solo_enc_fh *fh,
559 struct videobuf_buffer *vb)
560{
561 struct solo_enc_dev *solo_enc = fh->enc;
562 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
563 struct solo_enc_buf *enc_buf = NULL;
564 struct videobuf_dmabuf *vbuf;
565 int ret;
566 int error = 1;
567 u16 idx = fh->rd_idx;
568
569 while (idx != solo_dev->enc_wr_idx) {
570 struct solo_enc_buf *ebuf = &solo_dev->enc_buf[idx];
571
572 idx = (idx + 1) % SOLO_NR_RING_BUFS;
573
574 if (ebuf->ch != solo_enc->ch)
575 continue;
576
577 if (fh->fmt == V4L2_PIX_FMT_MPEG) {
578 if (fh->type == ebuf->type) {
579 enc_buf = ebuf;
580 break;
581 }
582 } else {
583
584 enc_buf = ebuf;
585 }
586 }
587
588 fh->rd_idx = idx;
589
590 if (WARN_ON_ONCE(!enc_buf))
591 goto buf_err;
592
593 if ((fh->fmt == V4L2_PIX_FMT_MPEG &&
594 vb->bsize < enc_buf->size) ||
595 (fh->fmt == V4L2_PIX_FMT_MJPEG &&
596 vb->bsize < (enc_buf->jpeg_size + sizeof(jpeg_header)))) {
597 WARN_ON_ONCE(1);
598 goto buf_err;
599 }
600
601 vbuf = videobuf_to_dma(vb);
602 if (WARN_ON_ONCE(!vbuf))
603 goto buf_err;
604
605 if (fh->fmt == V4L2_PIX_FMT_MPEG)
606 ret = solo_fill_mpeg(fh, enc_buf, vb, vbuf);
607 else
608 ret = solo_fill_jpeg(fh, enc_buf, vb, vbuf);
609
610 if (!ret)
611 error = 0;
612
613buf_err:
614 if (error) {
615 vb->state = VIDEOBUF_ERROR;
616 } else {
617 vb->field_count++;
618 vb->ts = enc_buf->ts;
619 vb->state = VIDEOBUF_DONE;
620 }
621
622 wake_up(&vb->done);
623
624 return;
625}
626
627static void solo_enc_thread_try(struct solo_enc_fh *fh)
628{
629 struct solo_enc_dev *solo_enc = fh->enc;
630 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
631 struct videobuf_buffer *vb;
632
633 for (;;) {
634 spin_lock(&solo_enc->lock);
635
636 if (fh->rd_idx == solo_dev->enc_wr_idx)
637 break;
638
639 if (list_empty(&fh->vidq_active))
640 break;
641
642 vb = list_first_entry(&fh->vidq_active,
643 struct videobuf_buffer, queue);
644
645 if (!waitqueue_active(&vb->done))
646 break;
647
648 list_del(&vb->queue);
649
650 spin_unlock(&solo_enc->lock);
651
652 solo_enc_fillbuf(fh, vb);
653 }
654
655 assert_spin_locked(&solo_enc->lock);
656 spin_unlock(&solo_enc->lock);
657}
658
659static int solo_enc_thread(void *data)
660{
661 struct solo_enc_fh *fh = data;
662 struct solo_enc_dev *solo_enc = fh->enc;
663 DECLARE_WAITQUEUE(wait, current);
664
665 set_freezable();
666 add_wait_queue(&solo_enc->thread_wait, &wait);
667
668 for (;;) {
669 long timeout = schedule_timeout_interruptible(HZ);
670 if (timeout == -ERESTARTSYS || kthread_should_stop())
671 break;
672 solo_enc_thread_try(fh);
673 try_to_freeze();
674 }
675
676 remove_wait_queue(&solo_enc->thread_wait, &wait);
677
678 return 0;
679}
680
681void solo_motion_isr(struct solo6010_dev *solo_dev)
682{
683 u32 status;
684 int i;
685
686 solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_MOTION);
687
688 status = solo_reg_read(solo_dev, SOLO_VI_MOT_STATUS);
689
690 for (i = 0; i < solo_dev->nr_chans; i++) {
691 struct solo_enc_dev *solo_enc = solo_dev->v4l2_enc[i];
692
693 BUG_ON(solo_enc == NULL);
694
695 if (solo_enc->motion_detected)
696 continue;
697 if (!(status & (1 << i)))
698 continue;
699
700 solo_enc->motion_detected = 1;
701 }
702}
703
704void solo_enc_v4l2_isr(struct solo6010_dev *solo_dev)
705{
706 struct solo_enc_buf *enc_buf;
707 struct videnc_status vstatus;
708 u32 mpeg_current, mpeg_next, mpeg_size;
709 u32 jpeg_current, jpeg_next, jpeg_size;
710 u32 reg_mpeg_size;
711 u8 cur_q, vop_type;
712 u8 ch;
713 enum solo_enc_types enc_type;
714
715 solo_reg_write(solo_dev, SOLO_IRQ_STAT, SOLO_IRQ_ENCODER);
716
717 vstatus.status11 = solo_reg_read(solo_dev, SOLO_VE_STATE(11));
718 cur_q = (vstatus.status11_st.last_queue + 1) % MP4_QS;
719
720 vstatus.status0 = solo_reg_read(solo_dev, SOLO_VE_STATE(0));
721 reg_mpeg_size = (vstatus.status0_st.mp4_enc_code_size + 64 + 32) &
722 (~31);
723
724 while (solo_dev->enc_idx != cur_q) {
725 mpeg_current = solo_reg_read(solo_dev,
726 SOLO_VE_MPEG4_QUE(solo_dev->enc_idx));
727 jpeg_current = solo_reg_read(solo_dev,
728 SOLO_VE_JPEG_QUE(solo_dev->enc_idx));
729 solo_dev->enc_idx = (solo_dev->enc_idx + 1) % MP4_QS;
730 mpeg_next = solo_reg_read(solo_dev,
731 SOLO_VE_MPEG4_QUE(solo_dev->enc_idx));
732 jpeg_next = solo_reg_read(solo_dev,
733 SOLO_VE_JPEG_QUE(solo_dev->enc_idx));
734
735 ch = (mpeg_current >> 24) & 0x1f;
736 if (ch >= SOLO_MAX_CHANNELS) {
737 ch -= SOLO_MAX_CHANNELS;
738 enc_type = SOLO_ENC_TYPE_EXT;
739 } else
740 enc_type = SOLO_ENC_TYPE_STD;
741
742 vop_type = (mpeg_current >> 29) & 3;
743
744 mpeg_current &= 0x00ffffff;
745 mpeg_next &= 0x00ffffff;
746 jpeg_current &= 0x00ffffff;
747 jpeg_next &= 0x00ffffff;
748
749 mpeg_size = (SOLO_MP4E_EXT_SIZE(solo_dev) +
750 mpeg_next - mpeg_current) %
751 SOLO_MP4E_EXT_SIZE(solo_dev);
752
753 jpeg_size = (SOLO_JPEG_EXT_SIZE(solo_dev) +
754 jpeg_next - jpeg_current) %
755 SOLO_JPEG_EXT_SIZE(solo_dev);
756
757
758 if (mpeg_current > mpeg_next && mpeg_size != reg_mpeg_size) {
759 enc_reset_gop(solo_dev, ch);
760 continue;
761 }
762
763
764 if (enc_gop_reset(solo_dev, ch, vop_type))
765 continue;
766
767 enc_buf = &solo_dev->enc_buf[solo_dev->enc_wr_idx];
768
769 enc_buf->vop = vop_type;
770 enc_buf->ch = ch;
771 enc_buf->off = mpeg_current;
772 enc_buf->size = mpeg_size;
773 enc_buf->jpeg_off = jpeg_current;
774 enc_buf->jpeg_size = jpeg_size;
775 enc_buf->type = enc_type;
776
777 do_gettimeofday(&enc_buf->ts);
778
779 solo_dev->enc_wr_idx = (solo_dev->enc_wr_idx + 1) %
780 SOLO_NR_RING_BUFS;
781
782 wake_up_interruptible(&solo_dev->v4l2_enc[ch]->thread_wait);
783 }
784
785 return;
786}
787
788static int solo_enc_buf_setup(struct videobuf_queue *vq, unsigned int *count,
789 unsigned int *size)
790{
791 *size = FRAME_BUF_SIZE;
792
793 if (*count < MIN_VID_BUFFERS)
794 *count = MIN_VID_BUFFERS;
795
796 return 0;
797}
798
799static int solo_enc_buf_prepare(struct videobuf_queue *vq,
800 struct videobuf_buffer *vb,
801 enum v4l2_field field)
802{
803 struct solo_enc_fh *fh = vq->priv_data;
804 struct solo_enc_dev *solo_enc = fh->enc;
805
806 vb->size = FRAME_BUF_SIZE;
807 if (vb->baddr != 0 && vb->bsize < vb->size)
808 return -EINVAL;
809
810
811 vb->width = solo_enc->width;
812 vb->height = solo_enc->height;
813 vb->field = field;
814
815 if (vb->state == VIDEOBUF_NEEDS_INIT) {
816 int rc = videobuf_iolock(vq, vb, NULL);
817 if (rc < 0) {
818 struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
819 videobuf_dma_unmap(vq->dev, dma);
820 videobuf_dma_free(dma);
821 vb->state = VIDEOBUF_NEEDS_INIT;
822 return rc;
823 }
824 }
825 vb->state = VIDEOBUF_PREPARED;
826
827 return 0;
828}
829
830static void solo_enc_buf_queue(struct videobuf_queue *vq,
831 struct videobuf_buffer *vb)
832{
833 struct solo_enc_fh *fh = vq->priv_data;
834
835 vb->state = VIDEOBUF_QUEUED;
836 list_add_tail(&vb->queue, &fh->vidq_active);
837 wake_up_interruptible(&fh->enc->thread_wait);
838}
839
840static void solo_enc_buf_release(struct videobuf_queue *vq,
841 struct videobuf_buffer *vb)
842{
843 struct videobuf_dmabuf *dma = videobuf_to_dma(vb);
844
845 videobuf_dma_unmap(vq->dev, dma);
846 videobuf_dma_free(dma);
847 vb->state = VIDEOBUF_NEEDS_INIT;
848}
849
850static struct videobuf_queue_ops solo_enc_video_qops = {
851 .buf_setup = solo_enc_buf_setup,
852 .buf_prepare = solo_enc_buf_prepare,
853 .buf_queue = solo_enc_buf_queue,
854 .buf_release = solo_enc_buf_release,
855};
856
857static unsigned int solo_enc_poll(struct file *file,
858 struct poll_table_struct *wait)
859{
860 struct solo_enc_fh *fh = file->private_data;
861
862 return videobuf_poll_stream(file, &fh->vidq, wait);
863}
864
865static int solo_enc_mmap(struct file *file, struct vm_area_struct *vma)
866{
867 struct solo_enc_fh *fh = file->private_data;
868
869 return videobuf_mmap_mapper(&fh->vidq, vma);
870}
871
872static int solo_enc_open(struct file *file)
873{
874 struct solo_enc_dev *solo_enc = video_drvdata(file);
875 struct solo_enc_fh *fh;
876
877 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
878 if (fh == NULL)
879 return -ENOMEM;
880
881 fh->enc = solo_enc;
882 file->private_data = fh;
883 INIT_LIST_HEAD(&fh->vidq_active);
884 fh->fmt = V4L2_PIX_FMT_MPEG;
885 fh->type = SOLO_ENC_TYPE_STD;
886
887 videobuf_queue_sg_init(&fh->vidq, &solo_enc_video_qops,
888 &solo_enc->solo_dev->pdev->dev,
889 &solo_enc->lock,
890 V4L2_BUF_TYPE_VIDEO_CAPTURE,
891 V4L2_FIELD_INTERLACED,
892 sizeof(struct videobuf_buffer), fh, NULL);
893
894 return 0;
895}
896
897static ssize_t solo_enc_read(struct file *file, char __user *data,
898 size_t count, loff_t *ppos)
899{
900 struct solo_enc_fh *fh = file->private_data;
901 struct solo_enc_dev *solo_enc = fh->enc;
902
903
904 if (!fh->enc_on) {
905 int ret;
906
907 spin_lock(&solo_enc->lock);
908 ret = solo_enc_on(fh);
909 spin_unlock(&solo_enc->lock);
910 if (ret)
911 return ret;
912
913 ret = solo_start_fh_thread(fh);
914 if (ret)
915 return ret;
916 }
917
918 return videobuf_read_stream(&fh->vidq, data, count, ppos, 0,
919 file->f_flags & O_NONBLOCK);
920}
921
922static int solo_enc_release(struct file *file)
923{
924 struct solo_enc_fh *fh = file->private_data;
925 struct solo_enc_dev *solo_enc = fh->enc;
926
927 videobuf_stop(&fh->vidq);
928 videobuf_mmap_free(&fh->vidq);
929
930 spin_lock(&solo_enc->lock);
931 solo_enc_off(fh);
932 spin_unlock(&solo_enc->lock);
933
934 kfree(fh);
935
936 return 0;
937}
938
939static int solo_enc_querycap(struct file *file, void *priv,
940 struct v4l2_capability *cap)
941{
942 struct solo_enc_fh *fh = priv;
943 struct solo_enc_dev *solo_enc = fh->enc;
944 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
945
946 strcpy(cap->driver, SOLO6010_NAME);
947 snprintf(cap->card, sizeof(cap->card), "Softlogic 6010 Enc %d",
948 solo_enc->ch);
949 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI %s",
950 pci_name(solo_dev->pdev));
951 cap->version = SOLO6010_VER_NUM;
952 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
953 V4L2_CAP_READWRITE |
954 V4L2_CAP_STREAMING;
955 return 0;
956}
957
958static int solo_enc_enum_input(struct file *file, void *priv,
959 struct v4l2_input *input)
960{
961 struct solo_enc_fh *fh = priv;
962 struct solo_enc_dev *solo_enc = fh->enc;
963 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
964
965 if (input->index)
966 return -EINVAL;
967
968 snprintf(input->name, sizeof(input->name), "Encoder %d",
969 solo_enc->ch + 1);
970 input->type = V4L2_INPUT_TYPE_CAMERA;
971
972 if (solo_dev->video_type == SOLO_VO_FMT_TYPE_NTSC)
973 input->std = V4L2_STD_NTSC_M;
974 else
975 input->std = V4L2_STD_PAL_B;
976
977 if (!tw28_get_video_status(solo_dev, solo_enc->ch))
978 input->status = V4L2_IN_ST_NO_SIGNAL;
979
980 return 0;
981}
982
983static int solo_enc_set_input(struct file *file, void *priv, unsigned int index)
984{
985 if (index)
986 return -EINVAL;
987
988 return 0;
989}
990
991static int solo_enc_get_input(struct file *file, void *priv,
992 unsigned int *index)
993{
994 *index = 0;
995
996 return 0;
997}
998
999static int solo_enc_enum_fmt_cap(struct file *file, void *priv,
1000 struct v4l2_fmtdesc *f)
1001{
1002 switch (f->index) {
1003 case 0:
1004 f->pixelformat = V4L2_PIX_FMT_MPEG;
1005 strcpy(f->description, "MPEG-4 AVC");
1006 break;
1007 case 1:
1008 f->pixelformat = V4L2_PIX_FMT_MJPEG;
1009 strcpy(f->description, "MJPEG");
1010 break;
1011 default:
1012 return -EINVAL;
1013 }
1014
1015 f->flags = V4L2_FMT_FLAG_COMPRESSED;
1016
1017 return 0;
1018}
1019
1020static int solo_enc_try_fmt_cap(struct file *file, void *priv,
1021 struct v4l2_format *f)
1022{
1023 struct solo_enc_fh *fh = priv;
1024 struct solo_enc_dev *solo_enc = fh->enc;
1025 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1026 struct v4l2_pix_format *pix = &f->fmt.pix;
1027
1028 if (pix->pixelformat != V4L2_PIX_FMT_MPEG &&
1029 pix->pixelformat != V4L2_PIX_FMT_MJPEG)
1030 return -EINVAL;
1031
1032
1033 if (atomic_read(&solo_enc->readers) > 0) {
1034 if (pix->width != solo_enc->width ||
1035 pix->height != solo_enc->height)
1036 return -EBUSY;
1037 } else if (!(pix->width == solo_dev->video_hsize &&
1038 pix->height == solo_dev->video_vsize << 1) &&
1039 !(pix->width == solo_dev->video_hsize >> 1 &&
1040 pix->height == solo_dev->video_vsize)) {
1041
1042 pix->width = solo_dev->video_hsize >> 1;
1043 pix->height = solo_dev->video_vsize;
1044 }
1045
1046 if (pix->field == V4L2_FIELD_ANY)
1047 pix->field = V4L2_FIELD_INTERLACED;
1048 else if (pix->field != V4L2_FIELD_INTERLACED)
1049 pix->field = V4L2_FIELD_INTERLACED;
1050
1051
1052 pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1053 pix->sizeimage = FRAME_BUF_SIZE;
1054
1055 return 0;
1056}
1057
1058static int solo_enc_set_fmt_cap(struct file *file, void *priv,
1059 struct v4l2_format *f)
1060{
1061 struct solo_enc_fh *fh = priv;
1062 struct solo_enc_dev *solo_enc = fh->enc;
1063 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1064 struct v4l2_pix_format *pix = &f->fmt.pix;
1065 int ret;
1066
1067 spin_lock(&solo_enc->lock);
1068
1069 ret = solo_enc_try_fmt_cap(file, priv, f);
1070 if (ret) {
1071 spin_unlock(&solo_enc->lock);
1072 return ret;
1073 }
1074
1075 if (pix->width == solo_dev->video_hsize)
1076 solo_enc->mode = SOLO_ENC_MODE_D1;
1077 else
1078 solo_enc->mode = SOLO_ENC_MODE_CIF;
1079
1080
1081 fh->fmt = pix->pixelformat;
1082
1083 if (pix->priv)
1084 fh->type = SOLO_ENC_TYPE_EXT;
1085 ret = solo_enc_on(fh);
1086
1087 spin_unlock(&solo_enc->lock);
1088
1089 if (ret)
1090 return ret;
1091
1092 return solo_start_fh_thread(fh);
1093}
1094
1095static int solo_enc_get_fmt_cap(struct file *file, void *priv,
1096 struct v4l2_format *f)
1097{
1098 struct solo_enc_fh *fh = priv;
1099 struct solo_enc_dev *solo_enc = fh->enc;
1100 struct v4l2_pix_format *pix = &f->fmt.pix;
1101
1102 pix->width = solo_enc->width;
1103 pix->height = solo_enc->height;
1104 pix->pixelformat = fh->fmt;
1105 pix->field = solo_enc->interlaced ? V4L2_FIELD_INTERLACED :
1106 V4L2_FIELD_NONE;
1107 pix->sizeimage = FRAME_BUF_SIZE;
1108 pix->colorspace = V4L2_COLORSPACE_SMPTE170M;
1109
1110 return 0;
1111}
1112
1113static int solo_enc_reqbufs(struct file *file, void *priv,
1114 struct v4l2_requestbuffers *req)
1115{
1116 struct solo_enc_fh *fh = priv;
1117
1118 return videobuf_reqbufs(&fh->vidq, req);
1119}
1120
1121static int solo_enc_querybuf(struct file *file, void *priv,
1122 struct v4l2_buffer *buf)
1123{
1124 struct solo_enc_fh *fh = priv;
1125
1126 return videobuf_querybuf(&fh->vidq, buf);
1127}
1128
1129static int solo_enc_qbuf(struct file *file, void *priv, struct v4l2_buffer *buf)
1130{
1131 struct solo_enc_fh *fh = priv;
1132
1133 return videobuf_qbuf(&fh->vidq, buf);
1134}
1135
1136static int solo_enc_dqbuf(struct file *file, void *priv,
1137 struct v4l2_buffer *buf)
1138{
1139 struct solo_enc_fh *fh = priv;
1140 struct solo_enc_dev *solo_enc = fh->enc;
1141 int ret;
1142
1143
1144 if (!fh->enc_on) {
1145 spin_lock(&solo_enc->lock);
1146 ret = solo_enc_on(fh);
1147 spin_unlock(&solo_enc->lock);
1148 if (ret)
1149 return ret;
1150
1151 ret = solo_start_fh_thread(fh);
1152 if (ret)
1153 return ret;
1154 }
1155
1156 ret = videobuf_dqbuf(&fh->vidq, buf, file->f_flags & O_NONBLOCK);
1157 if (ret)
1158 return ret;
1159
1160
1161 if (solo_is_motion_on(solo_enc)) {
1162 buf->flags |= V4L2_BUF_FLAG_MOTION_ON;
1163 if (solo_enc->motion_detected) {
1164 buf->flags |= V4L2_BUF_FLAG_MOTION_DETECTED;
1165 solo_reg_write(solo_enc->solo_dev, SOLO_VI_MOT_CLEAR,
1166 1 << solo_enc->ch);
1167 solo_enc->motion_detected = 0;
1168 }
1169 }
1170
1171
1172 if (fh->fmt == V4L2_PIX_FMT_MPEG) {
1173 struct videobuf_dmabuf *vbuf =
1174 videobuf_to_dma(fh->vidq.bufs[buf->index]);
1175
1176 if (vbuf) {
1177 u8 *p = sg_virt(vbuf->sglist);
1178 if (p[3] == 0x00)
1179 buf->flags |= V4L2_BUF_FLAG_KEYFRAME;
1180 else
1181 buf->flags |= V4L2_BUF_FLAG_PFRAME;
1182 }
1183 }
1184
1185 return 0;
1186}
1187
1188static int solo_enc_streamon(struct file *file, void *priv,
1189 enum v4l2_buf_type i)
1190{
1191 struct solo_enc_fh *fh = priv;
1192
1193 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1194 return -EINVAL;
1195
1196 return videobuf_streamon(&fh->vidq);
1197}
1198
1199static int solo_enc_streamoff(struct file *file, void *priv,
1200 enum v4l2_buf_type i)
1201{
1202 struct solo_enc_fh *fh = priv;
1203
1204 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1205 return -EINVAL;
1206
1207 return videobuf_streamoff(&fh->vidq);
1208}
1209
1210static int solo_enc_s_std(struct file *file, void *priv, v4l2_std_id *i)
1211{
1212 return 0;
1213}
1214
1215static int solo_enum_framesizes(struct file *file, void *priv,
1216 struct v4l2_frmsizeenum *fsize)
1217{
1218 struct solo_enc_fh *fh = priv;
1219 struct solo6010_dev *solo_dev = fh->enc->solo_dev;
1220
1221 if (fsize->pixel_format != V4L2_PIX_FMT_MPEG)
1222 return -EINVAL;
1223
1224 switch (fsize->index) {
1225 case 0:
1226 fsize->discrete.width = solo_dev->video_hsize >> 1;
1227 fsize->discrete.height = solo_dev->video_vsize;
1228 break;
1229 case 1:
1230 fsize->discrete.width = solo_dev->video_hsize;
1231 fsize->discrete.height = solo_dev->video_vsize << 1;
1232 break;
1233 default:
1234 return -EINVAL;
1235 }
1236
1237 fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1238
1239 return 0;
1240}
1241
1242static int solo_enum_frameintervals(struct file *file, void *priv,
1243 struct v4l2_frmivalenum *fintv)
1244{
1245 struct solo_enc_fh *fh = priv;
1246 struct solo6010_dev *solo_dev = fh->enc->solo_dev;
1247
1248 if (fintv->pixel_format != V4L2_PIX_FMT_MPEG || fintv->index)
1249 return -EINVAL;
1250
1251 fintv->type = V4L2_FRMIVAL_TYPE_STEPWISE;
1252
1253 fintv->stepwise.min.numerator = solo_dev->fps;
1254 fintv->stepwise.min.denominator = 1;
1255
1256 fintv->stepwise.max.numerator = solo_dev->fps;
1257 fintv->stepwise.max.denominator = 15;
1258
1259 fintv->stepwise.step.numerator = 1;
1260 fintv->stepwise.step.denominator = 1;
1261
1262 return 0;
1263}
1264
1265static int solo_g_parm(struct file *file, void *priv,
1266 struct v4l2_streamparm *sp)
1267{
1268 struct solo_enc_fh *fh = priv;
1269 struct solo_enc_dev *solo_enc = fh->enc;
1270 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1271 struct v4l2_captureparm *cp = &sp->parm.capture;
1272
1273 cp->capability = V4L2_CAP_TIMEPERFRAME;
1274 cp->timeperframe.numerator = solo_enc->interval;
1275 cp->timeperframe.denominator = solo_dev->fps;
1276 cp->capturemode = 0;
1277
1278 cp->readbuffers = 2;
1279
1280 return 0;
1281}
1282
1283static int solo_s_parm(struct file *file, void *priv,
1284 struct v4l2_streamparm *sp)
1285{
1286 struct solo_enc_fh *fh = priv;
1287 struct solo_enc_dev *solo_enc = fh->enc;
1288 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1289 struct v4l2_captureparm *cp = &sp->parm.capture;
1290
1291 spin_lock(&solo_enc->lock);
1292
1293 if (atomic_read(&solo_enc->readers) > 0) {
1294 spin_unlock(&solo_enc->lock);
1295 return -EBUSY;
1296 }
1297
1298 if ((cp->timeperframe.numerator == 0) ||
1299 (cp->timeperframe.denominator == 0)) {
1300
1301 cp->timeperframe.numerator = 1;
1302 cp->timeperframe.denominator = solo_dev->fps;
1303 }
1304
1305 if (cp->timeperframe.denominator != solo_dev->fps)
1306 cp->timeperframe.denominator = solo_dev->fps;
1307
1308 if (cp->timeperframe.numerator > 15)
1309 cp->timeperframe.numerator = 15;
1310
1311 solo_enc->interval = cp->timeperframe.numerator;
1312
1313 cp->capability = V4L2_CAP_TIMEPERFRAME;
1314
1315 solo_enc->gop = max(solo_dev->fps / solo_enc->interval, 1);
1316 solo_update_mode(solo_enc);
1317
1318 spin_unlock(&solo_enc->lock);
1319
1320 return 0;
1321}
1322
1323static int solo_queryctrl(struct file *file, void *priv,
1324 struct v4l2_queryctrl *qc)
1325{
1326 struct solo_enc_fh *fh = priv;
1327 struct solo_enc_dev *solo_enc = fh->enc;
1328 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1329
1330 qc->id = v4l2_ctrl_next(solo_ctrl_classes, qc->id);
1331 if (!qc->id)
1332 return -EINVAL;
1333
1334 switch (qc->id) {
1335 case V4L2_CID_BRIGHTNESS:
1336 case V4L2_CID_CONTRAST:
1337 case V4L2_CID_SATURATION:
1338 case V4L2_CID_HUE:
1339 return v4l2_ctrl_query_fill(qc, 0x00, 0xff, 1, 0x80);
1340 case V4L2_CID_SHARPNESS:
1341 return v4l2_ctrl_query_fill(qc, 0x00, 0x0f, 1, 0x00);
1342 case V4L2_CID_MPEG_VIDEO_ENCODING:
1343 return v4l2_ctrl_query_fill(
1344 qc, V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1345 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC, 1,
1346 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC);
1347 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1348 return v4l2_ctrl_query_fill(qc, 1, 255, 1, solo_dev->fps);
1349#ifdef PRIVATE_CIDS
1350 case V4L2_CID_MOTION_THRESHOLD:
1351 qc->flags |= V4L2_CTRL_FLAG_SLIDER;
1352 qc->type = V4L2_CTRL_TYPE_INTEGER;
1353 qc->minimum = 0;
1354 qc->maximum = 0xffff;
1355 qc->step = 1;
1356 qc->default_value = SOLO_DEF_MOT_THRESH;
1357 strlcpy(qc->name, "Motion Detection Threshold",
1358 sizeof(qc->name));
1359 return 0;
1360 case V4L2_CID_MOTION_ENABLE:
1361 qc->type = V4L2_CTRL_TYPE_BOOLEAN;
1362 qc->minimum = 0;
1363 qc->maximum = qc->step = 1;
1364 qc->default_value = 0;
1365 strlcpy(qc->name, "Motion Detection Enable", sizeof(qc->name));
1366 return 0;
1367#else
1368 case V4L2_CID_MOTION_THRESHOLD:
1369 return v4l2_ctrl_query_fill(qc, 0, 0xffff, 1,
1370 SOLO_DEF_MOT_THRESH);
1371 case V4L2_CID_MOTION_ENABLE:
1372 return v4l2_ctrl_query_fill(qc, 0, 1, 1, 0);
1373#endif
1374 case V4L2_CID_RDS_TX_RADIO_TEXT:
1375 qc->type = V4L2_CTRL_TYPE_STRING;
1376 qc->minimum = 0;
1377 qc->maximum = OSD_TEXT_MAX;
1378 qc->step = 1;
1379 qc->default_value = 0;
1380 strlcpy(qc->name, "OSD Text", sizeof(qc->name));
1381 return 0;
1382 }
1383
1384 return -EINVAL;
1385}
1386
1387static int solo_querymenu(struct file *file, void *priv,
1388 struct v4l2_querymenu *qmenu)
1389{
1390 struct v4l2_queryctrl qctrl;
1391 int err;
1392
1393 qctrl.id = qmenu->id;
1394 err = solo_queryctrl(file, priv, &qctrl);
1395 if (err)
1396 return err;
1397
1398 return v4l2_ctrl_query_menu(qmenu, &qctrl, NULL);
1399}
1400
1401static int solo_g_ctrl(struct file *file, void *priv,
1402 struct v4l2_control *ctrl)
1403{
1404 struct solo_enc_fh *fh = priv;
1405 struct solo_enc_dev *solo_enc = fh->enc;
1406 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1407
1408 switch (ctrl->id) {
1409 case V4L2_CID_BRIGHTNESS:
1410 case V4L2_CID_CONTRAST:
1411 case V4L2_CID_SATURATION:
1412 case V4L2_CID_HUE:
1413 case V4L2_CID_SHARPNESS:
1414 return tw28_get_ctrl_val(solo_dev, ctrl->id, solo_enc->ch,
1415 &ctrl->value);
1416 case V4L2_CID_MPEG_VIDEO_ENCODING:
1417 ctrl->value = V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC;
1418 break;
1419 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1420 ctrl->value = solo_enc->gop;
1421 break;
1422 case V4L2_CID_MOTION_THRESHOLD:
1423 ctrl->value = solo_enc->motion_thresh;
1424 break;
1425 case V4L2_CID_MOTION_ENABLE:
1426 ctrl->value = solo_is_motion_on(solo_enc);
1427 break;
1428 default:
1429 return -EINVAL;
1430 }
1431
1432 return 0;
1433}
1434
1435static int solo_s_ctrl(struct file *file, void *priv,
1436 struct v4l2_control *ctrl)
1437{
1438 struct solo_enc_fh *fh = priv;
1439 struct solo_enc_dev *solo_enc = fh->enc;
1440 struct solo6010_dev *solo_dev = solo_enc->solo_dev;
1441
1442 switch (ctrl->id) {
1443 case V4L2_CID_BRIGHTNESS:
1444 case V4L2_CID_CONTRAST:
1445 case V4L2_CID_SATURATION:
1446 case V4L2_CID_HUE:
1447 case V4L2_CID_SHARPNESS:
1448 return tw28_set_ctrl_val(solo_dev, ctrl->id, solo_enc->ch,
1449 ctrl->value);
1450 case V4L2_CID_MPEG_VIDEO_ENCODING:
1451 if (ctrl->value != V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC)
1452 return -ERANGE;
1453 break;
1454 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1455 if (ctrl->value < 1 || ctrl->value > 255)
1456 return -ERANGE;
1457 solo_enc->gop = ctrl->value;
1458 solo_reg_write(solo_dev, SOLO_VE_CH_GOP(solo_enc->ch),
1459 solo_enc->gop);
1460 solo_reg_write(solo_dev, SOLO_VE_CH_GOP_E(solo_enc->ch),
1461 solo_enc->gop);
1462 break;
1463 case V4L2_CID_MOTION_THRESHOLD:
1464
1465
1466 if (ctrl->value < 0 || ctrl->value > 0xffff)
1467 return -ERANGE;
1468 solo_enc->motion_thresh = ctrl->value;
1469 solo_set_motion_threshold(solo_dev, solo_enc->ch, ctrl->value);
1470 break;
1471 case V4L2_CID_MOTION_ENABLE:
1472 solo_motion_toggle(solo_enc, ctrl->value);
1473 break;
1474 default:
1475 return -EINVAL;
1476 }
1477
1478 return 0;
1479}
1480
1481static int solo_s_ext_ctrls(struct file *file, void *priv,
1482 struct v4l2_ext_controls *ctrls)
1483{
1484 struct solo_enc_fh *fh = priv;
1485 struct solo_enc_dev *solo_enc = fh->enc;
1486 int i;
1487
1488 for (i = 0; i < ctrls->count; i++) {
1489 struct v4l2_ext_control *ctrl = (ctrls->controls + i);
1490 int err;
1491
1492 switch (ctrl->id) {
1493 case V4L2_CID_RDS_TX_RADIO_TEXT:
1494 if (ctrl->size - 1 > OSD_TEXT_MAX)
1495 err = -ERANGE;
1496 else {
1497 err = copy_from_user(solo_enc->osd_text,
1498 ctrl->string,
1499 OSD_TEXT_MAX);
1500 solo_enc->osd_text[OSD_TEXT_MAX] = '\0';
1501 if (!err)
1502 err = solo_osd_print(solo_enc);
1503 }
1504 break;
1505 default:
1506 err = -EINVAL;
1507 }
1508
1509 if (err < 0) {
1510 ctrls->error_idx = i;
1511 return err;
1512 }
1513 }
1514
1515 return 0;
1516}
1517
1518static int solo_g_ext_ctrls(struct file *file, void *priv,
1519 struct v4l2_ext_controls *ctrls)
1520{
1521 struct solo_enc_fh *fh = priv;
1522 struct solo_enc_dev *solo_enc = fh->enc;
1523 int i;
1524
1525 for (i = 0; i < ctrls->count; i++) {
1526 struct v4l2_ext_control *ctrl = (ctrls->controls + i);
1527 int err;
1528
1529 switch (ctrl->id) {
1530 case V4L2_CID_RDS_TX_RADIO_TEXT:
1531 if (ctrl->size < OSD_TEXT_MAX) {
1532 ctrl->size = OSD_TEXT_MAX;
1533 err = -ENOSPC;
1534 } else {
1535 err = copy_to_user(ctrl->string,
1536 solo_enc->osd_text,
1537 OSD_TEXT_MAX);
1538 }
1539 break;
1540 default:
1541 err = -EINVAL;
1542 }
1543
1544 if (err < 0) {
1545 ctrls->error_idx = i;
1546 return err;
1547 }
1548 }
1549
1550 return 0;
1551}
1552
1553static const struct v4l2_file_operations solo_enc_fops = {
1554 .owner = THIS_MODULE,
1555 .open = solo_enc_open,
1556 .release = solo_enc_release,
1557 .read = solo_enc_read,
1558 .poll = solo_enc_poll,
1559 .mmap = solo_enc_mmap,
1560 .ioctl = video_ioctl2,
1561};
1562
1563static const struct v4l2_ioctl_ops solo_enc_ioctl_ops = {
1564 .vidioc_querycap = solo_enc_querycap,
1565 .vidioc_s_std = solo_enc_s_std,
1566
1567 .vidioc_enum_input = solo_enc_enum_input,
1568 .vidioc_s_input = solo_enc_set_input,
1569 .vidioc_g_input = solo_enc_get_input,
1570
1571 .vidioc_enum_fmt_vid_cap = solo_enc_enum_fmt_cap,
1572 .vidioc_try_fmt_vid_cap = solo_enc_try_fmt_cap,
1573 .vidioc_s_fmt_vid_cap = solo_enc_set_fmt_cap,
1574 .vidioc_g_fmt_vid_cap = solo_enc_get_fmt_cap,
1575
1576 .vidioc_reqbufs = solo_enc_reqbufs,
1577 .vidioc_querybuf = solo_enc_querybuf,
1578 .vidioc_qbuf = solo_enc_qbuf,
1579 .vidioc_dqbuf = solo_enc_dqbuf,
1580 .vidioc_streamon = solo_enc_streamon,
1581 .vidioc_streamoff = solo_enc_streamoff,
1582
1583 .vidioc_enum_framesizes = solo_enum_framesizes,
1584 .vidioc_enum_frameintervals = solo_enum_frameintervals,
1585
1586 .vidioc_s_parm = solo_s_parm,
1587 .vidioc_g_parm = solo_g_parm,
1588
1589 .vidioc_queryctrl = solo_queryctrl,
1590 .vidioc_querymenu = solo_querymenu,
1591 .vidioc_g_ctrl = solo_g_ctrl,
1592 .vidioc_s_ctrl = solo_s_ctrl,
1593 .vidioc_g_ext_ctrls = solo_g_ext_ctrls,
1594 .vidioc_s_ext_ctrls = solo_s_ext_ctrls,
1595};
1596
1597static struct video_device solo_enc_template = {
1598 .name = SOLO6010_NAME,
1599 .fops = &solo_enc_fops,
1600 .ioctl_ops = &solo_enc_ioctl_ops,
1601 .minor = -1,
1602 .release = video_device_release,
1603
1604 .tvnorms = V4L2_STD_NTSC_M | V4L2_STD_PAL_B,
1605 .current_norm = V4L2_STD_NTSC_M,
1606};
1607
1608static struct solo_enc_dev *solo_enc_alloc(struct solo6010_dev *solo_dev, u8 ch)
1609{
1610 struct solo_enc_dev *solo_enc;
1611 int ret;
1612
1613 solo_enc = kzalloc(sizeof(*solo_enc), GFP_KERNEL);
1614 if (!solo_enc)
1615 return ERR_PTR(-ENOMEM);
1616
1617 solo_enc->vfd = video_device_alloc();
1618 if (!solo_enc->vfd) {
1619 kfree(solo_enc);
1620 return ERR_PTR(-ENOMEM);
1621 }
1622
1623 solo_enc->solo_dev = solo_dev;
1624 solo_enc->ch = ch;
1625
1626 *solo_enc->vfd = solo_enc_template;
1627 solo_enc->vfd->parent = &solo_dev->pdev->dev;
1628 ret = video_register_device(solo_enc->vfd, VFL_TYPE_GRABBER,
1629 video_nr);
1630 if (ret < 0) {
1631 video_device_release(solo_enc->vfd);
1632 kfree(solo_enc);
1633 return ERR_PTR(ret);
1634 }
1635
1636 video_set_drvdata(solo_enc->vfd, solo_enc);
1637
1638 snprintf(solo_enc->vfd->name, sizeof(solo_enc->vfd->name),
1639 "%s-enc (%i/%i)", SOLO6010_NAME, solo_dev->vfd->num,
1640 solo_enc->vfd->num);
1641
1642 if (video_nr != -1)
1643 video_nr++;
1644
1645 spin_lock_init(&solo_enc->lock);
1646 init_waitqueue_head(&solo_enc->thread_wait);
1647 atomic_set(&solo_enc->readers, 0);
1648
1649 solo_enc->qp = SOLO_DEFAULT_QP;
1650 solo_enc->gop = solo_dev->fps;
1651 solo_enc->interval = 1;
1652 solo_enc->mode = SOLO_ENC_MODE_CIF;
1653 solo_enc->motion_thresh = SOLO_DEF_MOT_THRESH;
1654
1655 spin_lock(&solo_enc->lock);
1656 solo_update_mode(solo_enc);
1657 spin_unlock(&solo_enc->lock);
1658
1659 return solo_enc;
1660}
1661
1662static void solo_enc_free(struct solo_enc_dev *solo_enc)
1663{
1664 if (solo_enc == NULL)
1665 return;
1666
1667 video_unregister_device(solo_enc->vfd);
1668 kfree(solo_enc);
1669}
1670
1671int solo_enc_v4l2_init(struct solo6010_dev *solo_dev)
1672{
1673 int i;
1674
1675 for (i = 0; i < solo_dev->nr_chans; i++) {
1676 solo_dev->v4l2_enc[i] = solo_enc_alloc(solo_dev, i);
1677 if (IS_ERR(solo_dev->v4l2_enc[i]))
1678 break;
1679 }
1680
1681 if (i != solo_dev->nr_chans) {
1682 int ret = PTR_ERR(solo_dev->v4l2_enc[i]);
1683 while (i--)
1684 solo_enc_free(solo_dev->v4l2_enc[i]);
1685 return ret;
1686 }
1687
1688
1689 solo_dev->enc_bw_remain = solo_dev->fps * 4 * 4;
1690
1691 dev_info(&solo_dev->pdev->dev, "Encoders as /dev/video%d-%d\n",
1692 solo_dev->v4l2_enc[0]->vfd->num,
1693 solo_dev->v4l2_enc[solo_dev->nr_chans - 1]->vfd->num);
1694
1695 return 0;
1696}
1697
1698void solo_enc_v4l2_exit(struct solo6010_dev *solo_dev)
1699{
1700 int i;
1701
1702 solo6010_irq_off(solo_dev, SOLO_IRQ_MOTION);
1703
1704 for (i = 0; i < solo_dev->nr_chans; i++)
1705 solo_enc_free(solo_dev->v4l2_enc[i]);
1706}
1707
