2 * Copyright (C) 2010-2013 Bluecherry, LLC <http://www.bluecherrydvr.com>
5 * Ben Collins <bcollins@ubuntu.com>
8 * John Brooks <john.brooks@bluecherry.net>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 #include <linux/kernel.h>
26 #include <linux/module.h>
27 #include <linux/kthread.h>
28 #include <linux/freezer.h>
30 #include <media/v4l2-ioctl.h>
31 #include <media/v4l2-common.h>
32 #include <media/v4l2-event.h>
33 #include <media/videobuf-dma-sg.h>
37 #include "solo6x10-jpeg.h"
39 #define MIN_VID_BUFFERS 2
40 #define FRAME_BUF_SIZE (196 * 1024)
42 #define DMA_ALIGN 4096
44 struct solo_videobuf
{
45 struct videobuf_buffer vb
;
50 static unsigned char vop_6010_ntsc_d1
[] = {
51 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
52 0x02, 0x48, 0x1d, 0xc0, 0x00, 0x40, 0x00, 0x40,
53 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
54 0x1f, 0x4c, 0x58, 0x10, 0xf0, 0x71, 0x18, 0x3f,
57 static unsigned char vop_6010_ntsc_cif
[] = {
58 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
59 0x02, 0x48, 0x1d, 0xc0, 0x00, 0x40, 0x00, 0x40,
60 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
61 0x1f, 0x4c, 0x2c, 0x10, 0x78, 0x51, 0x18, 0x3f,
64 static unsigned char vop_6010_pal_d1
[] = {
65 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
66 0x02, 0x48, 0x15, 0xc0, 0x00, 0x40, 0x00, 0x40,
67 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
68 0x1f, 0x4c, 0x58, 0x11, 0x20, 0x71, 0x18, 0x3f,
71 static unsigned char vop_6010_pal_cif
[] = {
72 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
73 0x02, 0x48, 0x15, 0xc0, 0x00, 0x40, 0x00, 0x40,
74 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
75 0x1f, 0x4c, 0x2c, 0x10, 0x90, 0x51, 0x18, 0x3f,
79 static unsigned char vop_6110_ntsc_d1
[] = {
80 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
81 0x9a, 0x74, 0x05, 0x81, 0xec, 0x80, 0x00, 0x00,
82 0x00, 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00,
85 static unsigned char vop_6110_ntsc_cif
[] = {
86 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
87 0x9a, 0x74, 0x0b, 0x0f, 0xc8, 0x00, 0x00, 0x00,
88 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00, 0x00,
91 static unsigned char vop_6110_pal_d1
[] = {
92 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
93 0x9a, 0x74, 0x05, 0x80, 0x93, 0x20, 0x00, 0x00,
94 0x00, 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00,
97 static unsigned char vop_6110_pal_cif
[] = {
98 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
99 0x9a, 0x74, 0x0b, 0x04, 0xb2, 0x00, 0x00, 0x00,
100 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00, 0x00,
105 u32 mpeg_size
:20, sad_motion_flag
:1, video_motion_flag
:1, vop_type
:2,
106 channel
:5, source_fl
:1, interlace
:1, progressive
:1;
109 u32 vsize
:8, hsize
:8, last_queue
:4, nop0
:8, scale
:4;
118 u32 jpeg_size
:20, interval
:10, nop1
:2;
127 u32 mpeg_size_alt
:20, nop3
:12;
132 struct solo_enc_buf
{
133 enum solo_enc_types type
;
134 struct vop_header
*vh
;
138 static int solo_is_motion_on(struct solo_enc_dev
*solo_enc
)
140 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
142 return (solo_dev
->motion_mask
>> solo_enc
->ch
) & 1;
145 static int solo_motion_detected(struct solo_enc_dev
*solo_enc
)
147 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
149 u32 ch_mask
= 1 << solo_enc
->ch
;
152 spin_lock_irqsave(&solo_enc
->motion_lock
, flags
);
153 if (solo_reg_read(solo_dev
, SOLO_VI_MOT_STATUS
) & ch_mask
) {
154 solo_reg_write(solo_dev
, SOLO_VI_MOT_CLEAR
, ch_mask
);
157 spin_unlock_irqrestore(&solo_enc
->motion_lock
, flags
);
162 static void solo_motion_toggle(struct solo_enc_dev
*solo_enc
, int on
)
164 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
165 u32 mask
= 1 << solo_enc
->ch
;
168 spin_lock_irqsave(&solo_enc
->motion_lock
, flags
);
171 solo_dev
->motion_mask
|= mask
;
173 solo_dev
->motion_mask
&= ~mask
;
175 solo_reg_write(solo_dev
, SOLO_VI_MOT_CLEAR
, mask
);
177 solo_reg_write(solo_dev
, SOLO_VI_MOT_ADR
,
178 SOLO_VI_MOTION_EN(solo_dev
->motion_mask
) |
179 (SOLO_MOTION_EXT_ADDR(solo_dev
) >> 16));
181 spin_unlock_irqrestore(&solo_enc
->motion_lock
, flags
);
184 /* MUST be called with solo_enc->enable_lock held */
185 static void solo_update_mode(struct solo_enc_dev
*solo_enc
)
187 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
191 solo_enc
->interlaced
= (solo_enc
->mode
& 0x08) ? 1 : 0;
192 solo_enc
->bw_weight
= max(solo_dev
->fps
/ solo_enc
->interval
, 1);
194 if (solo_enc
->mode
== SOLO_ENC_MODE_CIF
) {
195 solo_enc
->width
= solo_dev
->video_hsize
>> 1;
196 solo_enc
->height
= solo_dev
->video_vsize
;
197 if (solo_dev
->type
== SOLO_DEV_6110
) {
198 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
199 vop
= vop_6110_ntsc_cif
;
200 vop_len
= sizeof(vop_6110_ntsc_cif
);
202 vop
= vop_6110_pal_cif
;
203 vop_len
= sizeof(vop_6110_pal_cif
);
206 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
207 vop
= vop_6010_ntsc_cif
;
208 vop_len
= sizeof(vop_6010_ntsc_cif
);
210 vop
= vop_6010_pal_cif
;
211 vop_len
= sizeof(vop_6010_pal_cif
);
215 solo_enc
->width
= solo_dev
->video_hsize
;
216 solo_enc
->height
= solo_dev
->video_vsize
<< 1;
217 solo_enc
->bw_weight
<<= 2;
218 if (solo_dev
->type
== SOLO_DEV_6110
) {
219 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
220 vop
= vop_6110_ntsc_d1
;
221 vop_len
= sizeof(vop_6110_ntsc_d1
);
223 vop
= vop_6110_pal_d1
;
224 vop_len
= sizeof(vop_6110_pal_d1
);
227 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
228 vop
= vop_6010_ntsc_d1
;
229 vop_len
= sizeof(vop_6010_ntsc_d1
);
231 vop
= vop_6010_pal_d1
;
232 vop_len
= sizeof(vop_6010_pal_d1
);
237 memcpy(solo_enc
->vop
, vop
, vop_len
);
239 /* Some fixups for 6010/M4V */
240 if (solo_dev
->type
== SOLO_DEV_6010
) {
241 u16 fps
= solo_dev
->fps
* 1000;
242 u16 interval
= solo_enc
->interval
* 1000;
246 /* Frame rate and interval */
248 vop
[23] = ((fps
<< 4) & 0xf0) | 0x0c
249 | ((interval
>> 13) & 0x3);
250 vop
[24] = (interval
>> 5) & 0xff;
251 vop
[25] = ((interval
<< 3) & 0xf8) | 0x04;
254 solo_enc
->vop_len
= vop_len
;
256 /* Now handle the jpeg header */
257 vop
= solo_enc
->jpeg_header
;
258 vop
[SOF0_START
+ 5] = 0xff & (solo_enc
->height
>> 8);
259 vop
[SOF0_START
+ 6] = 0xff & solo_enc
->height
;
260 vop
[SOF0_START
+ 7] = 0xff & (solo_enc
->width
>> 8);
261 vop
[SOF0_START
+ 8] = 0xff & solo_enc
->width
;
263 memcpy(vop
+ DQT_START
,
264 jpeg_dqt
[solo_g_jpeg_qp(solo_dev
, solo_enc
->ch
)], DQT_LEN
);
267 /* MUST be called with solo_enc->enable_lock held */
268 static int __solo_enc_on(struct solo_enc_dev
*solo_enc
)
270 u8 ch
= solo_enc
->ch
;
271 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
274 BUG_ON(!mutex_is_locked(&solo_enc
->enable_lock
));
276 if (solo_enc
->enc_on
)
279 solo_update_mode(solo_enc
);
281 /* Make sure to bw check on first reader */
282 if (!atomic_read(&solo_enc
->readers
)) {
283 if (solo_enc
->bw_weight
> solo_dev
->enc_bw_remain
)
286 solo_dev
->enc_bw_remain
-= solo_enc
->bw_weight
;
289 solo_enc
->enc_on
= 1;
291 if (solo_enc
->type
== SOLO_ENC_TYPE_EXT
)
292 solo_reg_write(solo_dev
, SOLO_CAP_CH_COMP_ENA_E(ch
), 1);
294 /* Reset the encoder if we are the first mpeg reader, else only reset
295 * on the first mjpeg reader. */
296 if (solo_enc
->fmt
== V4L2_PIX_FMT_MPEG
) {
297 atomic_inc(&solo_enc
->readers
);
298 if (atomic_inc_return(&solo_enc
->mpeg_readers
) > 1)
300 } else if (atomic_inc_return(&solo_enc
->readers
) > 1) {
304 /* Disable all encoding for this channel */
305 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(ch
), 0);
307 /* Common for both std and ext encoding */
308 solo_reg_write(solo_dev
, SOLO_VE_CH_INTL(ch
),
309 solo_enc
->interlaced
? 1 : 0);
311 if (solo_enc
->interlaced
)
312 interval
= solo_enc
->interval
- 1;
314 interval
= solo_enc
->interval
;
316 /* Standard encoding only */
317 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP(ch
), solo_enc
->gop
);
318 solo_reg_write(solo_dev
, SOLO_VE_CH_QP(ch
), solo_enc
->qp
);
319 solo_reg_write(solo_dev
, SOLO_CAP_CH_INTV(ch
), interval
);
321 /* Extended encoding only */
322 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP_E(ch
), solo_enc
->gop
);
323 solo_reg_write(solo_dev
, SOLO_VE_CH_QP_E(ch
), solo_enc
->qp
);
324 solo_reg_write(solo_dev
, SOLO_CAP_CH_INTV_E(ch
), interval
);
326 /* Enables the standard encoder */
327 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(ch
), solo_enc
->mode
);
332 static int solo_enc_on(struct solo_enc_dev
*solo_enc
)
336 mutex_lock(&solo_enc
->enable_lock
);
337 ret
= __solo_enc_on(solo_enc
);
338 mutex_unlock(&solo_enc
->enable_lock
);
343 static void __solo_enc_off(struct solo_enc_dev
*solo_enc
)
345 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
347 BUG_ON(!mutex_is_locked(&solo_enc
->enable_lock
));
349 if (!solo_enc
->enc_on
)
352 solo_enc
->enc_on
= 0;
354 if (solo_enc
->fmt
== V4L2_PIX_FMT_MPEG
)
355 atomic_dec(&solo_enc
->mpeg_readers
);
357 if (atomic_dec_return(&solo_enc
->readers
) > 0)
360 solo_dev
->enc_bw_remain
+= solo_enc
->bw_weight
;
362 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(solo_enc
->ch
), 0);
363 solo_reg_write(solo_dev
, SOLO_CAP_CH_COMP_ENA_E(solo_enc
->ch
), 0);
366 static void solo_enc_off(struct solo_enc_dev
*solo_enc
)
368 mutex_lock(&solo_enc
->enable_lock
);
369 __solo_enc_off(solo_enc
);
370 mutex_unlock(&solo_enc
->enable_lock
);
373 static int enc_get_mpeg_dma(struct solo_dev
*solo_dev
, dma_addr_t dma
,
374 unsigned int off
, unsigned int size
)
378 if (off
> SOLO_MP4E_EXT_SIZE(solo_dev
))
382 if (off
+ size
<= SOLO_MP4E_EXT_SIZE(solo_dev
)) {
383 return solo_p2m_dma_t(solo_dev
, 0, dma
,
384 SOLO_MP4E_EXT_ADDR(solo_dev
) + off
, size
,
389 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
,
390 SOLO_MP4E_EXT_ADDR(solo_dev
) + off
,
391 SOLO_MP4E_EXT_SIZE(solo_dev
) - off
, 0, 0);
394 ret
= solo_p2m_dma_t(solo_dev
, 0,
395 dma
+ SOLO_MP4E_EXT_SIZE(solo_dev
) - off
,
396 SOLO_MP4E_EXT_ADDR(solo_dev
),
397 size
+ off
- SOLO_MP4E_EXT_SIZE(solo_dev
), 0, 0);
403 /* Build a descriptor queue out of an SG list and send it to the P2M for
405 static int solo_send_desc(struct solo_enc_dev
*solo_enc
, int skip
,
406 struct videobuf_dmabuf
*vbuf
, int off
, int size
,
407 unsigned int base
, unsigned int base_size
)
409 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
410 struct scatterlist
*sg
;
414 if (WARN_ON_ONCE(size
> FRAME_BUF_SIZE
))
417 solo_enc
->desc_count
= 1;
419 for_each_sg(vbuf
->sglist
, sg
, vbuf
->sglen
, i
) {
420 struct solo_p2m_desc
*desc
;
423 int left
= base_size
- off
;
425 desc
= &solo_enc
->desc_items
[solo_enc
->desc_count
++];
426 dma
= sg_dma_address(sg
);
427 len
= sg_dma_len(sg
);
429 /* We assume this is smaller than the scatter size */
438 len
= min(len
, size
);
441 /* Single descriptor */
442 solo_p2m_fill_desc(desc
, 0, dma
, base
+ off
,
446 /* XXX: Do these as separate DMA requests, to avoid
447 timeout errors triggered by awkwardly sized
449 <https://github.com/bluecherrydvr/solo6x10/issues/8>
451 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
, base
+ off
,
456 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
+ left
, base
,
461 solo_enc
->desc_count
--;
469 if (off
>= base_size
)
472 /* Because we may use two descriptors per loop */
473 if (solo_enc
->desc_count
>= (solo_enc
->desc_nelts
- 1)) {
474 ret
= solo_p2m_dma_desc(solo_dev
, solo_enc
->desc_items
,
476 solo_enc
->desc_count
- 1);
479 solo_enc
->desc_count
= 1;
483 if (solo_enc
->desc_count
<= 1)
486 return solo_p2m_dma_desc(solo_dev
, solo_enc
->desc_items
, solo_enc
->desc_dma
,
487 solo_enc
->desc_count
- 1);
490 static int solo_fill_jpeg(struct solo_enc_dev
*solo_enc
, struct videobuf_buffer
*vb
,
491 struct videobuf_dmabuf
*vbuf
, struct vop_header
*vh
)
493 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
494 struct solo_videobuf
*svb
= (struct solo_videobuf
*)vb
;
497 svb
->flags
|= V4L2_BUF_FLAG_KEYFRAME
;
499 if (vb
->bsize
< (vh
->jpeg_size
+ solo_enc
->jpeg_len
))
502 vb
->width
= solo_enc
->width
;
503 vb
->height
= solo_enc
->height
;
504 vb
->size
= vh
->jpeg_size
+ solo_enc
->jpeg_len
;
506 sg_copy_from_buffer(vbuf
->sglist
, vbuf
->sglen
,
507 solo_enc
->jpeg_header
,
510 frame_size
= (vh
->jpeg_size
+ solo_enc
->jpeg_len
+ (DMA_ALIGN
- 1))
513 return solo_send_desc(solo_enc
, solo_enc
->jpeg_len
, vbuf
, vh
->jpeg_off
,
514 frame_size
, SOLO_JPEG_EXT_ADDR(solo_dev
),
515 SOLO_JPEG_EXT_SIZE(solo_dev
));
518 static int solo_fill_mpeg(struct solo_enc_dev
*solo_enc
, struct videobuf_buffer
*vb
,
519 struct videobuf_dmabuf
*vbuf
, struct vop_header
*vh
)
521 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
522 struct solo_videobuf
*svb
= (struct solo_videobuf
*)vb
;
523 int frame_off
, frame_size
;
526 if (vb
->bsize
< vh
->mpeg_size
)
529 vb
->width
= vh
->hsize
<< 4;
530 vb
->height
= vh
->vsize
<< 4;
531 vb
->size
= vh
->mpeg_size
;
533 /* If this is a key frame, add extra header */
535 sg_copy_from_buffer(vbuf
->sglist
, vbuf
->sglen
,
539 skip
= solo_enc
->vop_len
;
540 vb
->size
+= solo_enc
->vop_len
;
542 svb
->flags
|= V4L2_BUF_FLAG_KEYFRAME
;
544 svb
->flags
|= V4L2_BUF_FLAG_PFRAME
;
547 /* Now get the actual mpeg payload */
548 frame_off
= (vh
->mpeg_off
+ sizeof(*vh
))
549 % SOLO_MP4E_EXT_SIZE(solo_dev
);
550 frame_size
= (vh
->mpeg_size
+ skip
+ (DMA_ALIGN
- 1))
553 return solo_send_desc(solo_enc
, skip
, vbuf
, frame_off
, frame_size
,
554 SOLO_MP4E_EXT_ADDR(solo_dev
),
555 SOLO_MP4E_EXT_SIZE(solo_dev
));
558 static int solo_enc_fillbuf(struct solo_enc_dev
*solo_enc
,
559 struct videobuf_buffer
*vb
,
560 struct solo_enc_buf
*enc_buf
)
562 struct solo_videobuf
*svb
= (struct solo_videobuf
*)vb
;
563 struct videobuf_dmabuf
*vbuf
= NULL
;
564 struct vop_header
*vh
= enc_buf
->vh
;
567 vbuf
= videobuf_to_dma(vb
);
568 if (WARN_ON_ONCE(!vbuf
)) {
573 /* Setup some common flags for both types */
574 svb
->flags
= V4L2_BUF_FLAG_TIMECODE
;
575 vb
->ts
.tv_sec
= vh
->sec
;
576 vb
->ts
.tv_usec
= vh
->usec
;
578 /* Check for motion flags */
579 if (solo_is_motion_on(solo_enc
)) {
580 svb
->flags
|= V4L2_BUF_FLAG_MOTION_ON
;
582 svb
->flags
|= V4L2_BUF_FLAG_MOTION_DETECTED
;
585 if (solo_enc
->fmt
== V4L2_PIX_FMT_MPEG
)
586 ret
= solo_fill_mpeg(solo_enc
, vb
, vbuf
, vh
);
588 ret
= solo_fill_jpeg(solo_enc
, vb
, vbuf
, vh
);
591 /* On error, we push this buffer back into the queue. The
592 * videobuf-core doesn't handle error packets very well. Plus
593 * we recover nicely internally anyway. */
597 spin_lock_irqsave(&solo_enc
->av_lock
, flags
);
598 list_add(&vb
->queue
, &solo_enc
->vidq_active
);
599 vb
->state
= VIDEOBUF_QUEUED
;
600 spin_unlock_irqrestore(&solo_enc
->av_lock
, flags
);
602 vb
->state
= VIDEOBUF_DONE
;
604 vb
->width
= solo_enc
->width
;
605 vb
->height
= solo_enc
->height
;
613 static void solo_enc_handle_one(struct solo_enc_dev
*solo_enc
,
614 struct solo_enc_buf
*enc_buf
)
616 struct videobuf_buffer
*vb
;
619 mutex_lock(&solo_enc
->enable_lock
);
621 if (solo_enc
->type
!= enc_buf
->type
)
624 if (list_empty(&solo_enc
->vidq_active
))
627 spin_lock_irqsave(&solo_enc
->av_lock
, flags
);
629 vb
= list_first_entry(&solo_enc
->vidq_active
,
630 struct videobuf_buffer
, queue
);
632 list_del(&vb
->queue
);
633 vb
->state
= VIDEOBUF_ACTIVE
;
635 spin_unlock_irqrestore(&solo_enc
->av_lock
, flags
);
637 solo_enc_fillbuf(solo_enc
, vb
, enc_buf
);
639 mutex_unlock(&solo_enc
->enable_lock
);
642 void solo_enc_v4l2_isr(struct solo_dev
*solo_dev
)
644 wake_up_interruptible_all(&solo_dev
->ring_thread_wait
);
647 static void solo_handle_ring(struct solo_dev
*solo_dev
)
650 struct solo_enc_dev
*solo_enc
;
651 struct solo_enc_buf enc_buf
;
652 u32 mpeg_current
, off
;
656 /* Check if the hardware has any new ones in the queue */
657 cur_q
= solo_reg_read(solo_dev
, SOLO_VE_STATE(11)) & 0xff;
658 if (cur_q
== solo_dev
->enc_idx
)
661 mpeg_current
= solo_reg_read(solo_dev
,
662 SOLO_VE_MPEG4_QUE(solo_dev
->enc_idx
));
663 solo_dev
->enc_idx
= (solo_dev
->enc_idx
+ 1) % MP4_QS
;
665 ch
= (mpeg_current
>> 24) & 0x1f;
666 off
= mpeg_current
& 0x00ffffff;
668 if (ch
>= SOLO_MAX_CHANNELS
) {
669 ch
-= SOLO_MAX_CHANNELS
;
670 enc_buf
.type
= SOLO_ENC_TYPE_EXT
;
672 enc_buf
.type
= SOLO_ENC_TYPE_STD
;
674 solo_enc
= solo_dev
->v4l2_enc
[ch
];
675 if (solo_enc
== NULL
) {
676 dev_err(&solo_dev
->pdev
->dev
,
677 "Got spurious packet for channel %d\n", ch
);
682 if (enc_get_mpeg_dma(solo_dev
, solo_dev
->vh_dma
, off
,
683 sizeof(struct vop_header
)))
686 enc_buf
.vh
= (struct vop_header
*)solo_dev
->vh_buf
;
687 enc_buf
.vh
->mpeg_off
-= SOLO_MP4E_EXT_ADDR(solo_dev
);
688 enc_buf
.vh
->jpeg_off
-= SOLO_JPEG_EXT_ADDR(solo_dev
);
691 if (enc_buf
.vh
->mpeg_off
!= off
)
694 if (solo_motion_detected(solo_enc
))
699 solo_enc_handle_one(solo_enc
, &enc_buf
);
703 static int solo_ring_thread(void *data
)
705 struct solo_dev
*solo_dev
= data
;
706 DECLARE_WAITQUEUE(wait
, current
);
709 add_wait_queue(&solo_dev
->ring_thread_wait
, &wait
);
712 long timeout
= schedule_timeout_interruptible(HZ
);
713 if (timeout
== -ERESTARTSYS
|| kthread_should_stop())
715 solo_irq_off(solo_dev
, SOLO_IRQ_ENCODER
);
716 solo_handle_ring(solo_dev
);
717 solo_irq_on(solo_dev
, SOLO_IRQ_ENCODER
);
721 remove_wait_queue(&solo_dev
->ring_thread_wait
, &wait
);
726 static int solo_enc_buf_setup(struct videobuf_queue
*vq
, unsigned int *count
,
729 *size
= FRAME_BUF_SIZE
;
731 if (*count
< MIN_VID_BUFFERS
)
732 *count
= MIN_VID_BUFFERS
;
737 static int solo_enc_buf_prepare(struct videobuf_queue
*vq
,
738 struct videobuf_buffer
*vb
,
739 enum v4l2_field field
)
741 vb
->size
= FRAME_BUF_SIZE
;
742 if (vb
->baddr
!= 0 && vb
->bsize
< vb
->size
)
745 /* This property only change when queue is idle */
748 if (vb
->state
== VIDEOBUF_NEEDS_INIT
) {
749 int rc
= videobuf_iolock(vq
, vb
, NULL
);
751 struct videobuf_dmabuf
*dma
= videobuf_to_dma(vb
);
752 videobuf_dma_unmap(vq
->dev
, dma
);
753 videobuf_dma_free(dma
);
758 vb
->state
= VIDEOBUF_PREPARED
;
763 static void solo_enc_buf_queue(struct videobuf_queue
*vq
,
764 struct videobuf_buffer
*vb
)
766 struct solo_enc_dev
*solo_enc
= vq
->priv_data
;
768 vb
->state
= VIDEOBUF_QUEUED
;
769 list_add_tail(&vb
->queue
, &solo_enc
->vidq_active
);
772 static void solo_enc_buf_release(struct videobuf_queue
*vq
,
773 struct videobuf_buffer
*vb
)
775 struct videobuf_dmabuf
*dma
= videobuf_to_dma(vb
);
776 videobuf_dma_unmap(vq
->dev
, dma
);
777 videobuf_dma_free(dma
);
778 vb
->state
= VIDEOBUF_NEEDS_INIT
;
781 static const struct videobuf_queue_ops solo_enc_video_qops
= {
782 .buf_setup
= solo_enc_buf_setup
,
783 .buf_prepare
= solo_enc_buf_prepare
,
784 .buf_queue
= solo_enc_buf_queue
,
785 .buf_release
= solo_enc_buf_release
,
788 static unsigned int solo_enc_poll(struct file
*file
,
789 struct poll_table_struct
*wait
)
791 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
792 unsigned long req_events
= poll_requested_events(wait
);
793 unsigned res
= v4l2_ctrl_poll(file
, wait
);
795 if (!(req_events
& (POLLIN
| POLLRDNORM
)))
797 return videobuf_poll_stream(file
, &solo_enc
->vidq
, wait
);
800 static int solo_enc_mmap(struct file
*file
, struct vm_area_struct
*vma
)
802 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
804 return videobuf_mmap_mapper(&solo_enc
->vidq
, vma
);
807 static int solo_ring_start(struct solo_dev
*solo_dev
)
809 if (atomic_inc_return(&solo_dev
->enc_users
) > 1)
812 solo_dev
->ring_thread
= kthread_run(solo_ring_thread
, solo_dev
,
813 SOLO6X10_NAME
"_ring");
814 if (IS_ERR(solo_dev
->ring_thread
)) {
815 int err
= PTR_ERR(solo_dev
->ring_thread
);
816 solo_dev
->ring_thread
= NULL
;
820 solo_irq_on(solo_dev
, SOLO_IRQ_ENCODER
);
825 static void solo_ring_stop(struct solo_dev
*solo_dev
)
827 if (atomic_dec_return(&solo_dev
->enc_users
) > 0)
830 if (solo_dev
->ring_thread
) {
831 kthread_stop(solo_dev
->ring_thread
);
832 solo_dev
->ring_thread
= NULL
;
835 solo_irq_off(solo_dev
, SOLO_IRQ_ENCODER
);
838 static int solo_enc_open(struct file
*file
)
840 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
841 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
842 int ret
= v4l2_fh_open(file
);
846 ret
= solo_ring_start(solo_dev
);
848 v4l2_fh_release(file
);
854 static ssize_t
solo_enc_read(struct file
*file
, char __user
*data
,
855 size_t count
, loff_t
*ppos
)
857 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
860 /* Make sure the encoder is on */
861 ret
= solo_enc_on(solo_enc
);
865 return videobuf_read_stream(&solo_enc
->vidq
, data
, count
, ppos
, 0,
866 file
->f_flags
& O_NONBLOCK
);
869 static int solo_enc_release(struct file
*file
)
871 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
872 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
874 solo_enc_off(solo_enc
);
875 videobuf_stop(&solo_enc
->vidq
);
876 videobuf_mmap_free(&solo_enc
->vidq
);
877 solo_ring_stop(solo_dev
);
879 return v4l2_fh_release(file
);
882 static int solo_enc_querycap(struct file
*file
, void *priv
,
883 struct v4l2_capability
*cap
)
885 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
886 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
888 strcpy(cap
->driver
, SOLO6X10_NAME
);
889 snprintf(cap
->card
, sizeof(cap
->card
), "Softlogic 6x10 Enc %d",
891 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
892 pci_name(solo_dev
->pdev
));
893 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
|
894 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
895 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
899 static int solo_enc_enum_input(struct file
*file
, void *priv
,
900 struct v4l2_input
*input
)
902 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
903 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
908 snprintf(input
->name
, sizeof(input
->name
), "Encoder %d",
910 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
912 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
)
913 input
->std
= V4L2_STD_NTSC_M
;
915 input
->std
= V4L2_STD_PAL_B
;
917 if (!tw28_get_video_status(solo_dev
, solo_enc
->ch
))
918 input
->status
= V4L2_IN_ST_NO_SIGNAL
;
923 static int solo_enc_set_input(struct file
*file
, void *priv
,
932 static int solo_enc_get_input(struct file
*file
, void *priv
,
940 static int solo_enc_enum_fmt_cap(struct file
*file
, void *priv
,
941 struct v4l2_fmtdesc
*f
)
945 f
->pixelformat
= V4L2_PIX_FMT_MPEG
;
946 strcpy(f
->description
, "MPEG-4 AVC");
949 f
->pixelformat
= V4L2_PIX_FMT_MJPEG
;
950 strcpy(f
->description
, "MJPEG");
956 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
961 static int solo_enc_try_fmt_cap(struct file
*file
, void *priv
,
962 struct v4l2_format
*f
)
964 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
965 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
966 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
968 if (pix
->pixelformat
!= V4L2_PIX_FMT_MPEG
&&
969 pix
->pixelformat
!= V4L2_PIX_FMT_MJPEG
)
972 if (pix
->width
< solo_dev
->video_hsize
||
973 pix
->height
< solo_dev
->video_vsize
<< 1) {
974 /* Default to CIF 1/2 size */
975 pix
->width
= solo_dev
->video_hsize
>> 1;
976 pix
->height
= solo_dev
->video_vsize
;
979 pix
->width
= solo_dev
->video_hsize
;
980 pix
->height
= solo_dev
->video_vsize
<< 1;
983 switch (pix
->field
) {
984 case V4L2_FIELD_NONE
:
985 case V4L2_FIELD_INTERLACED
:
989 pix
->field
= V4L2_FIELD_INTERLACED
;
994 pix
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
995 pix
->sizeimage
= FRAME_BUF_SIZE
;
996 pix
->bytesperline
= 0;
1002 static int solo_enc_set_fmt_cap(struct file
*file
, void *priv
,
1003 struct v4l2_format
*f
)
1005 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1006 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1007 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
1010 mutex_lock(&solo_enc
->enable_lock
);
1012 ret
= solo_enc_try_fmt_cap(file
, priv
, f
);
1016 /* We cannot change width/height in mid read */
1017 if (!ret
&& atomic_read(&solo_enc
->readers
) > 0) {
1018 if (pix
->width
!= solo_enc
->width
||
1019 pix
->height
!= solo_enc
->height
)
1023 mutex_unlock(&solo_enc
->enable_lock
);
1027 if (pix
->width
== solo_dev
->video_hsize
)
1028 solo_enc
->mode
= SOLO_ENC_MODE_D1
;
1030 solo_enc
->mode
= SOLO_ENC_MODE_CIF
;
1032 /* This does not change the encoder at all */
1033 solo_enc
->fmt
= pix
->pixelformat
;
1036 solo_enc
->type
= SOLO_ENC_TYPE_EXT
;
1038 mutex_unlock(&solo_enc
->enable_lock
);
1043 static int solo_enc_get_fmt_cap(struct file
*file
, void *priv
,
1044 struct v4l2_format
*f
)
1046 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1047 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
1049 pix
->width
= solo_enc
->width
;
1050 pix
->height
= solo_enc
->height
;
1051 pix
->pixelformat
= solo_enc
->fmt
;
1052 pix
->field
= solo_enc
->interlaced
? V4L2_FIELD_INTERLACED
:
1054 pix
->sizeimage
= FRAME_BUF_SIZE
;
1055 pix
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
1061 static int solo_enc_reqbufs(struct file
*file
, void *priv
,
1062 struct v4l2_requestbuffers
*req
)
1064 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1066 return videobuf_reqbufs(&solo_enc
->vidq
, req
);
1069 static int solo_enc_querybuf(struct file
*file
, void *priv
,
1070 struct v4l2_buffer
*buf
)
1072 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1074 return videobuf_querybuf(&solo_enc
->vidq
, buf
);
1077 static int solo_enc_qbuf(struct file
*file
, void *priv
,
1078 struct v4l2_buffer
*buf
)
1080 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1082 return videobuf_qbuf(&solo_enc
->vidq
, buf
);
1085 static int solo_enc_dqbuf(struct file
*file
, void *priv
,
1086 struct v4l2_buffer
*buf
)
1088 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1089 struct solo_videobuf
*svb
;
1092 /* Make sure the encoder is on */
1093 ret
= solo_enc_on(solo_enc
);
1097 ret
= videobuf_dqbuf(&solo_enc
->vidq
, buf
, file
->f_flags
& O_NONBLOCK
);
1101 /* Copy over the flags */
1102 svb
= (struct solo_videobuf
*)solo_enc
->vidq
.bufs
[buf
->index
];
1103 buf
->flags
|= svb
->flags
;
1108 static int solo_enc_streamon(struct file
*file
, void *priv
,
1109 enum v4l2_buf_type i
)
1111 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1113 if (i
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1116 return videobuf_streamon(&solo_enc
->vidq
);
1119 static int solo_enc_streamoff(struct file
*file
, void *priv
,
1120 enum v4l2_buf_type i
)
1122 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1125 if (i
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
1128 ret
= videobuf_streamoff(&solo_enc
->vidq
);
1130 solo_enc_off(solo_enc
);
1135 static int solo_enc_s_std(struct file
*file
, void *priv
, v4l2_std_id i
)
1140 static int solo_enum_framesizes(struct file
*file
, void *priv
,
1141 struct v4l2_frmsizeenum
*fsize
)
1143 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1144 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1146 if (fsize
->pixel_format
!= V4L2_PIX_FMT_MPEG
&&
1147 fsize
->pixel_format
!= V4L2_PIX_FMT_MJPEG
)
1150 switch (fsize
->index
) {
1152 fsize
->discrete
.width
= solo_dev
->video_hsize
>> 1;
1153 fsize
->discrete
.height
= solo_dev
->video_vsize
;
1156 fsize
->discrete
.width
= solo_dev
->video_hsize
;
1157 fsize
->discrete
.height
= solo_dev
->video_vsize
<< 1;
1163 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1168 static int solo_enum_frameintervals(struct file
*file
, void *priv
,
1169 struct v4l2_frmivalenum
*fintv
)
1171 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1172 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1174 if (fintv
->pixel_format
!= V4L2_PIX_FMT_MPEG
&&
1175 fintv
->pixel_format
!= V4L2_PIX_FMT_MJPEG
)
1179 if ((fintv
->width
!= solo_dev
->video_hsize
>> 1 ||
1180 fintv
->height
!= solo_dev
->video_vsize
) &&
1181 (fintv
->width
!= solo_dev
->video_hsize
||
1182 fintv
->height
!= solo_dev
->video_vsize
<< 1))
1185 fintv
->type
= V4L2_FRMIVAL_TYPE_STEPWISE
;
1187 fintv
->stepwise
.min
.denominator
= solo_dev
->fps
;
1188 fintv
->stepwise
.min
.numerator
= 15;
1190 fintv
->stepwise
.max
.denominator
= solo_dev
->fps
;
1191 fintv
->stepwise
.max
.numerator
= 1;
1193 fintv
->stepwise
.step
.numerator
= 1;
1194 fintv
->stepwise
.step
.denominator
= 1;
1199 static int solo_g_parm(struct file
*file
, void *priv
,
1200 struct v4l2_streamparm
*sp
)
1202 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1203 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1204 struct v4l2_captureparm
*cp
= &sp
->parm
.capture
;
1206 cp
->capability
= V4L2_CAP_TIMEPERFRAME
;
1207 cp
->timeperframe
.numerator
= solo_enc
->interval
;
1208 cp
->timeperframe
.denominator
= solo_dev
->fps
;
1209 cp
->capturemode
= 0;
1210 /* XXX: Shouldn't we be able to get/set this from videobuf? */
1211 cp
->readbuffers
= 2;
1216 static int solo_s_parm(struct file
*file
, void *priv
,
1217 struct v4l2_streamparm
*sp
)
1219 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1220 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1221 struct v4l2_captureparm
*cp
= &sp
->parm
.capture
;
1223 mutex_lock(&solo_enc
->enable_lock
);
1225 if (atomic_read(&solo_enc
->mpeg_readers
) > 0) {
1226 mutex_unlock(&solo_enc
->enable_lock
);
1230 if ((cp
->timeperframe
.numerator
== 0) ||
1231 (cp
->timeperframe
.denominator
== 0)) {
1232 /* reset framerate */
1233 cp
->timeperframe
.numerator
= 1;
1234 cp
->timeperframe
.denominator
= solo_dev
->fps
;
1237 if (cp
->timeperframe
.denominator
!= solo_dev
->fps
)
1238 cp
->timeperframe
.denominator
= solo_dev
->fps
;
1240 if (cp
->timeperframe
.numerator
> 15)
1241 cp
->timeperframe
.numerator
= 15;
1243 solo_enc
->interval
= cp
->timeperframe
.numerator
;
1245 cp
->capability
= V4L2_CAP_TIMEPERFRAME
;
1246 cp
->readbuffers
= 2;
1248 solo_update_mode(solo_enc
);
1250 mutex_unlock(&solo_enc
->enable_lock
);
1255 static int solo_s_ctrl(struct v4l2_ctrl
*ctrl
)
1257 struct solo_enc_dev
*solo_enc
=
1258 container_of(ctrl
->handler
, struct solo_enc_dev
, hdl
);
1259 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1263 case V4L2_CID_BRIGHTNESS
:
1264 case V4L2_CID_CONTRAST
:
1265 case V4L2_CID_SATURATION
:
1267 case V4L2_CID_SHARPNESS
:
1268 return tw28_set_ctrl_val(solo_dev
, ctrl
->id
, solo_enc
->ch
,
1270 case V4L2_CID_MPEG_VIDEO_ENCODING
:
1272 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1273 solo_enc
->gop
= ctrl
->val
;
1275 case V4L2_CID_MOTION_THRESHOLD
: {
1276 u16 block
= (ctrl
->val
>> 16) & 0xffff;
1277 u16 value
= ctrl
->val
& 0xffff;
1279 /* Motion thresholds are in a table of 64x64 samples, with
1280 * each sample representing 16x16 pixels of the source. In
1281 * effect, 44x30 samples are used for NTSC, and 44x36 for PAL.
1282 * The 5th sample on the 10th row is (10*64)+5 = 645.
1284 * Block is 0 to set the threshold globally, or any positive
1285 * number under 2049 to set block-1 individually. */
1286 /* Currently we limit support to block 0 only. A later patch
1287 * will add a new ioctl to set all other blocks. */
1289 solo_enc
->motion_thresh
= value
;
1290 return solo_set_motion_threshold(solo_dev
,
1291 solo_enc
->ch
, value
);
1293 return solo_set_motion_block(solo_dev
, solo_enc
->ch
,
1296 case V4L2_CID_MOTION_ENABLE
:
1297 solo_motion_toggle(solo_enc
, ctrl
->val
);
1299 case V4L2_CID_OSD_TEXT
:
1300 mutex_lock(&solo_enc
->enable_lock
);
1301 strcpy(solo_enc
->osd_text
, ctrl
->string
);
1302 err
= solo_osd_print(solo_enc
);
1303 mutex_unlock(&solo_enc
->enable_lock
);
1312 static const struct v4l2_file_operations solo_enc_fops
= {
1313 .owner
= THIS_MODULE
,
1314 .open
= solo_enc_open
,
1315 .release
= solo_enc_release
,
1316 .read
= solo_enc_read
,
1317 .poll
= solo_enc_poll
,
1318 .mmap
= solo_enc_mmap
,
1319 .ioctl
= video_ioctl2
,
1322 static const struct v4l2_ioctl_ops solo_enc_ioctl_ops
= {
1323 .vidioc_querycap
= solo_enc_querycap
,
1324 .vidioc_s_std
= solo_enc_s_std
,
1325 /* Input callbacks */
1326 .vidioc_enum_input
= solo_enc_enum_input
,
1327 .vidioc_s_input
= solo_enc_set_input
,
1328 .vidioc_g_input
= solo_enc_get_input
,
1329 /* Video capture format callbacks */
1330 .vidioc_enum_fmt_vid_cap
= solo_enc_enum_fmt_cap
,
1331 .vidioc_try_fmt_vid_cap
= solo_enc_try_fmt_cap
,
1332 .vidioc_s_fmt_vid_cap
= solo_enc_set_fmt_cap
,
1333 .vidioc_g_fmt_vid_cap
= solo_enc_get_fmt_cap
,
1335 .vidioc_reqbufs
= solo_enc_reqbufs
,
1336 .vidioc_querybuf
= solo_enc_querybuf
,
1337 .vidioc_qbuf
= solo_enc_qbuf
,
1338 .vidioc_dqbuf
= solo_enc_dqbuf
,
1339 .vidioc_streamon
= solo_enc_streamon
,
1340 .vidioc_streamoff
= solo_enc_streamoff
,
1341 /* Frame size and interval */
1342 .vidioc_enum_framesizes
= solo_enum_framesizes
,
1343 .vidioc_enum_frameintervals
= solo_enum_frameintervals
,
1344 /* Video capture parameters */
1345 .vidioc_s_parm
= solo_s_parm
,
1346 .vidioc_g_parm
= solo_g_parm
,
1347 /* Logging and events */
1348 .vidioc_log_status
= v4l2_ctrl_log_status
,
1349 .vidioc_subscribe_event
= v4l2_ctrl_subscribe_event
,
1350 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1353 static const struct video_device solo_enc_template
= {
1354 .name
= SOLO6X10_NAME
,
1355 .fops
= &solo_enc_fops
,
1356 .ioctl_ops
= &solo_enc_ioctl_ops
,
1358 .release
= video_device_release
,
1360 .tvnorms
= V4L2_STD_NTSC_M
| V4L2_STD_PAL_B
,
1361 .current_norm
= V4L2_STD_NTSC_M
,
1364 static const struct v4l2_ctrl_ops solo_ctrl_ops
= {
1365 .s_ctrl
= solo_s_ctrl
,
1368 static const struct v4l2_ctrl_config solo_motion_threshold_ctrl
= {
1369 .ops
= &solo_ctrl_ops
,
1370 .id
= V4L2_CID_MOTION_THRESHOLD
,
1371 .name
= "Motion Detection Threshold",
1372 .type
= V4L2_CTRL_TYPE_INTEGER
,
1374 .def
= SOLO_DEF_MOT_THRESH
,
1376 .flags
= V4L2_CTRL_FLAG_SLIDER
,
1379 static const struct v4l2_ctrl_config solo_motion_enable_ctrl
= {
1380 .ops
= &solo_ctrl_ops
,
1381 .id
= V4L2_CID_MOTION_ENABLE
,
1382 .name
= "Motion Detection Enable",
1383 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
1388 static const struct v4l2_ctrl_config solo_osd_text_ctrl
= {
1389 .ops
= &solo_ctrl_ops
,
1390 .id
= V4L2_CID_OSD_TEXT
,
1392 .type
= V4L2_CTRL_TYPE_STRING
,
1393 .max
= OSD_TEXT_MAX
,
1397 static struct solo_enc_dev
*solo_enc_alloc(struct solo_dev
*solo_dev
,
1400 struct solo_enc_dev
*solo_enc
;
1401 struct v4l2_ctrl_handler
*hdl
;
1404 solo_enc
= kzalloc(sizeof(*solo_enc
), GFP_KERNEL
);
1406 return ERR_PTR(-ENOMEM
);
1408 hdl
= &solo_enc
->hdl
;
1409 v4l2_ctrl_handler_init(hdl
, 10);
1410 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1411 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 128);
1412 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1413 V4L2_CID_CONTRAST
, 0, 255, 1, 128);
1414 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1415 V4L2_CID_SATURATION
, 0, 255, 1, 128);
1416 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1417 V4L2_CID_HUE
, 0, 255, 1, 128);
1418 if (tw28_has_sharpness(solo_dev
, ch
))
1419 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1420 V4L2_CID_SHARPNESS
, 0, 15, 1, 0);
1421 v4l2_ctrl_new_std_menu(hdl
, &solo_ctrl_ops
,
1422 V4L2_CID_MPEG_VIDEO_ENCODING
,
1423 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC
, 3,
1424 V4L2_MPEG_VIDEO_ENCODING_MPEG_4_AVC
);
1425 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1426 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 255, 1, solo_dev
->fps
);
1427 v4l2_ctrl_new_custom(hdl
, &solo_motion_threshold_ctrl
, NULL
);
1428 v4l2_ctrl_new_custom(hdl
, &solo_motion_enable_ctrl
, NULL
);
1429 v4l2_ctrl_new_custom(hdl
, &solo_osd_text_ctrl
, NULL
);
1435 solo_enc
->solo_dev
= solo_dev
;
1437 spin_lock_init(&solo_enc
->av_lock
);
1438 INIT_LIST_HEAD(&solo_enc
->vidq_active
);
1439 solo_enc
->fmt
= V4L2_PIX_FMT_MPEG
;
1440 solo_enc
->type
= SOLO_ENC_TYPE_STD
;
1442 atomic_set(&solo_enc
->readers
, 0);
1444 solo_enc
->qp
= SOLO_DEFAULT_QP
;
1445 solo_enc
->gop
= solo_dev
->fps
;
1446 solo_enc
->interval
= 1;
1447 solo_enc
->mode
= SOLO_ENC_MODE_CIF
;
1448 solo_enc
->motion_thresh
= SOLO_DEF_MOT_THRESH
;
1450 spin_lock(&solo_enc
->av_lock
);
1451 solo_update_mode(solo_enc
);
1452 spin_unlock(&solo_enc
->av_lock
);
1454 mutex_init(&solo_enc
->enable_lock
);
1455 spin_lock_init(&solo_enc
->motion_lock
);
1457 atomic_set(&solo_enc
->readers
, 0);
1458 atomic_set(&solo_enc
->mpeg_readers
, 0);
1460 /* Initialize this per encoder */
1461 solo_enc
->jpeg_len
= sizeof(jpeg_header
);
1462 memcpy(solo_enc
->jpeg_header
, jpeg_header
, solo_enc
->jpeg_len
);
1464 solo_enc
->desc_nelts
= 32;
1465 solo_enc
->desc_items
= pci_alloc_consistent(solo_dev
->pdev
,
1466 sizeof(struct solo_p2m_desc
) *
1467 solo_enc
->desc_nelts
, &solo_enc
->desc_dma
);
1469 if (solo_enc
->desc_items
== NULL
)
1472 videobuf_queue_sg_init(&solo_enc
->vidq
, &solo_enc_video_qops
,
1473 &solo_dev
->pdev
->dev
,
1475 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
1476 V4L2_FIELD_INTERLACED
,
1477 sizeof(struct solo_videobuf
),
1480 solo_enc
->vfd
= video_device_alloc();
1484 *solo_enc
->vfd
= solo_enc_template
;
1485 solo_enc
->vfd
->v4l2_dev
= &solo_dev
->v4l2_dev
;
1486 solo_enc
->vfd
->ctrl_handler
= hdl
;
1487 set_bit(V4L2_FL_USE_FH_PRIO
, &solo_enc
->vfd
->flags
);
1488 video_set_drvdata(solo_enc
->vfd
, solo_enc
);
1489 ret
= video_register_device(solo_enc
->vfd
, VFL_TYPE_GRABBER
, nr
);
1493 snprintf(solo_enc
->vfd
->name
, sizeof(solo_enc
->vfd
->name
),
1494 "%s-enc (%i/%i)", SOLO6X10_NAME
, solo_dev
->vfd
->num
,
1495 solo_enc
->vfd
->num
);
1500 video_device_release(solo_enc
->vfd
);
1502 pci_free_consistent(solo_enc
->solo_dev
->pdev
,
1503 sizeof(struct solo_p2m_desc
) * solo_enc
->desc_nelts
,
1504 solo_enc
->desc_items
, solo_enc
->desc_dma
);
1506 v4l2_ctrl_handler_free(hdl
);
1508 return ERR_PTR(ret
);
1511 static void solo_enc_free(struct solo_enc_dev
*solo_enc
)
1513 if (solo_enc
== NULL
)
1516 video_unregister_device(solo_enc
->vfd
);
1517 v4l2_ctrl_handler_free(&solo_enc
->hdl
);
1521 int solo_enc_v4l2_init(struct solo_dev
*solo_dev
, unsigned nr
)
1525 atomic_set(&solo_dev
->enc_users
, 0);
1526 init_waitqueue_head(&solo_dev
->ring_thread_wait
);
1528 solo_dev
->vh_size
= sizeof(struct vop_header
);
1529 solo_dev
->vh_buf
= pci_alloc_consistent(solo_dev
->pdev
,
1532 if (solo_dev
->vh_buf
== NULL
)
1535 for (i
= 0; i
< solo_dev
->nr_chans
; i
++) {
1536 solo_dev
->v4l2_enc
[i
] = solo_enc_alloc(solo_dev
, i
, nr
);
1537 if (IS_ERR(solo_dev
->v4l2_enc
[i
]))
1541 if (i
!= solo_dev
->nr_chans
) {
1542 int ret
= PTR_ERR(solo_dev
->v4l2_enc
[i
]);
1544 solo_enc_free(solo_dev
->v4l2_enc
[i
]);
1545 pci_free_consistent(solo_dev
->pdev
, solo_dev
->vh_size
,
1546 solo_dev
->vh_buf
, solo_dev
->vh_dma
);
1547 solo_dev
->vh_buf
= NULL
;
1551 if (solo_dev
->type
== SOLO_DEV_6010
)
1552 solo_dev
->enc_bw_remain
= solo_dev
->fps
* 4 * 4;
1554 solo_dev
->enc_bw_remain
= solo_dev
->fps
* 4 * 5;
1556 dev_info(&solo_dev
->pdev
->dev
, "Encoders as /dev/video%d-%d\n",
1557 solo_dev
->v4l2_enc
[0]->vfd
->num
,
1558 solo_dev
->v4l2_enc
[solo_dev
->nr_chans
- 1]->vfd
->num
);
1563 void solo_enc_v4l2_exit(struct solo_dev
*solo_dev
)
1567 for (i
= 0; i
< solo_dev
->nr_chans
; i
++)
1568 solo_enc_free(solo_dev
->v4l2_enc
[i
]);
1570 if (solo_dev
->vh_buf
)
1571 pci_free_consistent(solo_dev
->pdev
, solo_dev
->vh_size
,
1572 solo_dev
->vh_buf
, solo_dev
->vh_dma
);