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.
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/kthread.h>
24 #include <linux/freezer.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-event.h>
29 #include <media/videobuf2-dma-sg.h>
32 #include "solo6x10-tw28.h"
33 #include "solo6x10-jpeg.h"
35 #define MIN_VID_BUFFERS 2
36 #define FRAME_BUF_SIZE (196 * 1024)
38 #define DMA_ALIGN 4096
41 static unsigned char vop_6010_ntsc_d1
[] = {
42 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
43 0x02, 0x48, 0x1d, 0xc0, 0x00, 0x40, 0x00, 0x40,
44 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
45 0x1f, 0x4c, 0x58, 0x10, 0xf0, 0x71, 0x18, 0x3f,
48 static unsigned char vop_6010_ntsc_cif
[] = {
49 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
50 0x02, 0x48, 0x1d, 0xc0, 0x00, 0x40, 0x00, 0x40,
51 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
52 0x1f, 0x4c, 0x2c, 0x10, 0x78, 0x51, 0x18, 0x3f,
55 static unsigned char vop_6010_pal_d1
[] = {
56 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
57 0x02, 0x48, 0x15, 0xc0, 0x00, 0x40, 0x00, 0x40,
58 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
59 0x1f, 0x4c, 0x58, 0x11, 0x20, 0x71, 0x18, 0x3f,
62 static unsigned char vop_6010_pal_cif
[] = {
63 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x20,
64 0x02, 0x48, 0x15, 0xc0, 0x00, 0x40, 0x00, 0x40,
65 0x00, 0x40, 0x00, 0x80, 0x00, 0x97, 0x53, 0x04,
66 0x1f, 0x4c, 0x2c, 0x10, 0x90, 0x51, 0x18, 0x3f,
70 static unsigned char vop_6110_ntsc_d1
[] = {
71 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
72 0x9a, 0x74, 0x05, 0x81, 0xec, 0x80, 0x00, 0x00,
73 0x00, 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00,
76 static unsigned char vop_6110_ntsc_cif
[] = {
77 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
78 0x9a, 0x74, 0x0b, 0x0f, 0xc8, 0x00, 0x00, 0x00,
79 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00, 0x00,
82 static unsigned char vop_6110_pal_d1
[] = {
83 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
84 0x9a, 0x74, 0x05, 0x80, 0x93, 0x20, 0x00, 0x00,
85 0x00, 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00,
88 static unsigned char vop_6110_pal_cif
[] = {
89 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0x00, 0x1e,
90 0x9a, 0x74, 0x0b, 0x04, 0xb2, 0x00, 0x00, 0x00,
91 0x01, 0x68, 0xce, 0x32, 0x28, 0x00, 0x00, 0x00,
94 typedef __le32 vop_header
[16];
97 enum solo_enc_types type
;
102 static int solo_is_motion_on(struct solo_enc_dev
*solo_enc
)
104 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
106 return (solo_dev
->motion_mask
>> solo_enc
->ch
) & 1;
109 static int solo_motion_detected(struct solo_enc_dev
*solo_enc
)
111 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
113 u32 ch_mask
= 1 << solo_enc
->ch
;
116 spin_lock_irqsave(&solo_enc
->motion_lock
, flags
);
117 if (solo_reg_read(solo_dev
, SOLO_VI_MOT_STATUS
) & ch_mask
) {
118 solo_reg_write(solo_dev
, SOLO_VI_MOT_CLEAR
, ch_mask
);
121 spin_unlock_irqrestore(&solo_enc
->motion_lock
, flags
);
126 static void solo_motion_toggle(struct solo_enc_dev
*solo_enc
, int on
)
128 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
129 u32 mask
= 1 << solo_enc
->ch
;
132 spin_lock_irqsave(&solo_enc
->motion_lock
, flags
);
135 solo_dev
->motion_mask
|= mask
;
137 solo_dev
->motion_mask
&= ~mask
;
139 solo_reg_write(solo_dev
, SOLO_VI_MOT_CLEAR
, mask
);
141 solo_reg_write(solo_dev
, SOLO_VI_MOT_ADR
,
142 SOLO_VI_MOTION_EN(solo_dev
->motion_mask
) |
143 (SOLO_MOTION_EXT_ADDR(solo_dev
) >> 16));
145 spin_unlock_irqrestore(&solo_enc
->motion_lock
, flags
);
148 void solo_update_mode(struct solo_enc_dev
*solo_enc
)
150 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
154 solo_enc
->interlaced
= (solo_enc
->mode
& 0x08) ? 1 : 0;
155 solo_enc
->bw_weight
= max(solo_dev
->fps
/ solo_enc
->interval
, 1);
157 if (solo_enc
->mode
== SOLO_ENC_MODE_CIF
) {
158 solo_enc
->width
= solo_dev
->video_hsize
>> 1;
159 solo_enc
->height
= solo_dev
->video_vsize
;
160 if (solo_dev
->type
== SOLO_DEV_6110
) {
161 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
162 vop
= vop_6110_ntsc_cif
;
163 vop_len
= sizeof(vop_6110_ntsc_cif
);
165 vop
= vop_6110_pal_cif
;
166 vop_len
= sizeof(vop_6110_pal_cif
);
169 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
170 vop
= vop_6010_ntsc_cif
;
171 vop_len
= sizeof(vop_6010_ntsc_cif
);
173 vop
= vop_6010_pal_cif
;
174 vop_len
= sizeof(vop_6010_pal_cif
);
178 solo_enc
->width
= solo_dev
->video_hsize
;
179 solo_enc
->height
= solo_dev
->video_vsize
<< 1;
180 solo_enc
->bw_weight
<<= 2;
181 if (solo_dev
->type
== SOLO_DEV_6110
) {
182 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
183 vop
= vop_6110_ntsc_d1
;
184 vop_len
= sizeof(vop_6110_ntsc_d1
);
186 vop
= vop_6110_pal_d1
;
187 vop_len
= sizeof(vop_6110_pal_d1
);
190 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
) {
191 vop
= vop_6010_ntsc_d1
;
192 vop_len
= sizeof(vop_6010_ntsc_d1
);
194 vop
= vop_6010_pal_d1
;
195 vop_len
= sizeof(vop_6010_pal_d1
);
200 memcpy(solo_enc
->vop
, vop
, vop_len
);
202 /* Some fixups for 6010/M4V */
203 if (solo_dev
->type
== SOLO_DEV_6010
) {
204 u16 fps
= solo_dev
->fps
* 1000;
205 u16 interval
= solo_enc
->interval
* 1000;
209 /* Frame rate and interval */
211 vop
[23] = ((fps
<< 4) & 0xf0) | 0x0c
212 | ((interval
>> 13) & 0x3);
213 vop
[24] = (interval
>> 5) & 0xff;
214 vop
[25] = ((interval
<< 3) & 0xf8) | 0x04;
217 solo_enc
->vop_len
= vop_len
;
219 /* Now handle the jpeg header */
220 vop
= solo_enc
->jpeg_header
;
221 vop
[SOF0_START
+ 5] = 0xff & (solo_enc
->height
>> 8);
222 vop
[SOF0_START
+ 6] = 0xff & solo_enc
->height
;
223 vop
[SOF0_START
+ 7] = 0xff & (solo_enc
->width
>> 8);
224 vop
[SOF0_START
+ 8] = 0xff & solo_enc
->width
;
226 memcpy(vop
+ DQT_START
,
227 jpeg_dqt
[solo_g_jpeg_qp(solo_dev
, solo_enc
->ch
)], DQT_LEN
);
230 static int solo_enc_on(struct solo_enc_dev
*solo_enc
)
232 u8 ch
= solo_enc
->ch
;
233 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
236 solo_update_mode(solo_enc
);
238 /* Make sure to do a bandwidth check */
239 if (solo_enc
->bw_weight
> solo_dev
->enc_bw_remain
)
241 solo_enc
->sequence
= 0;
242 solo_enc
->motion_last_state
= false;
243 solo_enc
->frames_since_last_motion
= 0;
244 solo_dev
->enc_bw_remain
-= solo_enc
->bw_weight
;
246 if (solo_enc
->type
== SOLO_ENC_TYPE_EXT
)
247 solo_reg_write(solo_dev
, SOLO_CAP_CH_COMP_ENA_E(ch
), 1);
249 /* Disable all encoding for this channel */
250 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(ch
), 0);
252 /* Common for both std and ext encoding */
253 solo_reg_write(solo_dev
, SOLO_VE_CH_INTL(ch
),
254 solo_enc
->interlaced
? 1 : 0);
256 if (solo_enc
->interlaced
)
257 interval
= solo_enc
->interval
- 1;
259 interval
= solo_enc
->interval
;
261 /* Standard encoding only */
262 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP(ch
), solo_enc
->gop
);
263 solo_reg_write(solo_dev
, SOLO_VE_CH_QP(ch
), solo_enc
->qp
);
264 solo_reg_write(solo_dev
, SOLO_CAP_CH_INTV(ch
), interval
);
266 /* Extended encoding only */
267 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP_E(ch
), solo_enc
->gop
);
268 solo_reg_write(solo_dev
, SOLO_VE_CH_QP_E(ch
), solo_enc
->qp
);
269 solo_reg_write(solo_dev
, SOLO_CAP_CH_INTV_E(ch
), interval
);
271 /* Enables the standard encoder */
272 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(ch
), solo_enc
->mode
);
277 static void solo_enc_off(struct solo_enc_dev
*solo_enc
)
279 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
281 solo_dev
->enc_bw_remain
+= solo_enc
->bw_weight
;
283 solo_reg_write(solo_dev
, SOLO_CAP_CH_SCALE(solo_enc
->ch
), 0);
284 solo_reg_write(solo_dev
, SOLO_CAP_CH_COMP_ENA_E(solo_enc
->ch
), 0);
287 static int enc_get_mpeg_dma(struct solo_dev
*solo_dev
, dma_addr_t dma
,
288 unsigned int off
, unsigned int size
)
292 if (off
> SOLO_MP4E_EXT_SIZE(solo_dev
))
296 if (off
+ size
<= SOLO_MP4E_EXT_SIZE(solo_dev
)) {
297 return solo_p2m_dma_t(solo_dev
, 0, dma
,
298 SOLO_MP4E_EXT_ADDR(solo_dev
) + off
, size
,
303 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
,
304 SOLO_MP4E_EXT_ADDR(solo_dev
) + off
,
305 SOLO_MP4E_EXT_SIZE(solo_dev
) - off
, 0, 0);
308 ret
= solo_p2m_dma_t(solo_dev
, 0,
309 dma
+ SOLO_MP4E_EXT_SIZE(solo_dev
) - off
,
310 SOLO_MP4E_EXT_ADDR(solo_dev
),
311 size
+ off
- SOLO_MP4E_EXT_SIZE(solo_dev
), 0, 0);
317 /* Build a descriptor queue out of an SG list and send it to the P2M for
319 static int solo_send_desc(struct solo_enc_dev
*solo_enc
, int skip
,
320 struct sg_table
*vbuf
, int off
, int size
,
321 unsigned int base
, unsigned int base_size
)
323 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
324 struct scatterlist
*sg
;
328 if (WARN_ON_ONCE(size
> FRAME_BUF_SIZE
))
331 solo_enc
->desc_count
= 1;
333 for_each_sg(vbuf
->sgl
, sg
, vbuf
->nents
, i
) {
334 struct solo_p2m_desc
*desc
;
337 int left
= base_size
- off
;
339 desc
= &solo_enc
->desc_items
[solo_enc
->desc_count
++];
340 dma
= sg_dma_address(sg
);
341 len
= sg_dma_len(sg
);
343 /* We assume this is smaller than the scatter size */
352 len
= min(len
, size
);
355 /* Single descriptor */
356 solo_p2m_fill_desc(desc
, 0, dma
, base
+ off
,
360 /* XXX: Do these as separate DMA requests, to avoid
361 timeout errors triggered by awkwardly sized
363 <https://github.com/bluecherrydvr/solo6x10/issues/8>
365 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
, base
+ off
,
370 ret
= solo_p2m_dma_t(solo_dev
, 0, dma
+ left
, base
,
375 solo_enc
->desc_count
--;
383 if (off
>= base_size
)
386 /* Because we may use two descriptors per loop */
387 if (solo_enc
->desc_count
>= (solo_enc
->desc_nelts
- 1)) {
388 ret
= solo_p2m_dma_desc(solo_dev
, solo_enc
->desc_items
,
390 solo_enc
->desc_count
- 1);
393 solo_enc
->desc_count
= 1;
397 if (solo_enc
->desc_count
<= 1)
400 return solo_p2m_dma_desc(solo_dev
, solo_enc
->desc_items
,
401 solo_enc
->desc_dma
, solo_enc
->desc_count
- 1);
404 /* Extract values from VOP header - VE_STATUSxx */
405 static inline int vop_interlaced(const vop_header
*vh
)
407 return (__le32_to_cpu((*vh
)[0]) >> 30) & 1;
410 static inline u8
vop_channel(const vop_header
*vh
)
412 return (__le32_to_cpu((*vh
)[0]) >> 24) & 0x1F;
415 static inline u8
vop_type(const vop_header
*vh
)
417 return (__le32_to_cpu((*vh
)[0]) >> 22) & 3;
420 static inline u32
vop_mpeg_size(const vop_header
*vh
)
422 return __le32_to_cpu((*vh
)[0]) & 0xFFFFF;
425 static inline u8
vop_hsize(const vop_header
*vh
)
427 return (__le32_to_cpu((*vh
)[1]) >> 8) & 0xFF;
430 static inline u8
vop_vsize(const vop_header
*vh
)
432 return __le32_to_cpu((*vh
)[1]) & 0xFF;
435 static inline u32
vop_mpeg_offset(const vop_header
*vh
)
437 return __le32_to_cpu((*vh
)[2]);
440 static inline u32
vop_jpeg_offset(const vop_header
*vh
)
442 return __le32_to_cpu((*vh
)[3]);
445 static inline u32
vop_jpeg_size(const vop_header
*vh
)
447 return __le32_to_cpu((*vh
)[4]) & 0xFFFFF;
450 static inline u32
vop_sec(const vop_header
*vh
)
452 return __le32_to_cpu((*vh
)[5]);
455 static inline u32
vop_usec(const vop_header
*vh
)
457 return __le32_to_cpu((*vh
)[6]);
460 static int solo_fill_jpeg(struct solo_enc_dev
*solo_enc
,
461 struct vb2_buffer
*vb
, const vop_header
*vh
)
463 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
464 struct sg_table
*vbuf
= vb2_dma_sg_plane_desc(vb
, 0);
468 vb
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_KEYFRAME
;
470 if (vb2_plane_size(vb
, 0) < vop_jpeg_size(vh
) + solo_enc
->jpeg_len
)
473 frame_size
= ALIGN(vop_jpeg_size(vh
) + solo_enc
->jpeg_len
, DMA_ALIGN
);
474 vb2_set_plane_payload(vb
, 0, vop_jpeg_size(vh
) + solo_enc
->jpeg_len
);
476 /* may discard all previous data in vbuf->sgl */
477 if (!dma_map_sg(&solo_dev
->pdev
->dev
, vbuf
->sgl
, vbuf
->nents
,
480 ret
= solo_send_desc(solo_enc
, solo_enc
->jpeg_len
, vbuf
,
481 vop_jpeg_offset(vh
) - SOLO_JPEG_EXT_ADDR(solo_dev
),
482 frame_size
, SOLO_JPEG_EXT_ADDR(solo_dev
),
483 SOLO_JPEG_EXT_SIZE(solo_dev
));
484 dma_unmap_sg(&solo_dev
->pdev
->dev
, vbuf
->sgl
, vbuf
->nents
,
487 /* add the header only after dma_unmap_sg() */
488 sg_copy_from_buffer(vbuf
->sgl
, vbuf
->nents
,
489 solo_enc
->jpeg_header
, solo_enc
->jpeg_len
);
494 static int solo_fill_mpeg(struct solo_enc_dev
*solo_enc
,
495 struct vb2_buffer
*vb
, const vop_header
*vh
)
497 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
498 struct sg_table
*vbuf
= vb2_dma_sg_plane_desc(vb
, 0);
499 int frame_off
, frame_size
;
503 if (vb2_plane_size(vb
, 0) < vop_mpeg_size(vh
))
506 /* If this is a key frame, add extra header */
507 vb
->v4l2_buf
.flags
&= ~(V4L2_BUF_FLAG_KEYFRAME
| V4L2_BUF_FLAG_PFRAME
|
508 V4L2_BUF_FLAG_BFRAME
);
510 skip
= solo_enc
->vop_len
;
511 vb
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_KEYFRAME
;
512 vb2_set_plane_payload(vb
, 0, vop_mpeg_size(vh
) +
515 vb
->v4l2_buf
.flags
|= V4L2_BUF_FLAG_PFRAME
;
516 vb2_set_plane_payload(vb
, 0, vop_mpeg_size(vh
));
519 /* Now get the actual mpeg payload */
520 frame_off
= (vop_mpeg_offset(vh
) - SOLO_MP4E_EXT_ADDR(solo_dev
) +
521 sizeof(*vh
)) % SOLO_MP4E_EXT_SIZE(solo_dev
);
522 frame_size
= ALIGN(vop_mpeg_size(vh
) + skip
, DMA_ALIGN
);
524 /* may discard all previous data in vbuf->sgl */
525 if (!dma_map_sg(&solo_dev
->pdev
->dev
, vbuf
->sgl
, vbuf
->nents
,
528 ret
= solo_send_desc(solo_enc
, skip
, vbuf
, frame_off
, frame_size
,
529 SOLO_MP4E_EXT_ADDR(solo_dev
),
530 SOLO_MP4E_EXT_SIZE(solo_dev
));
531 dma_unmap_sg(&solo_dev
->pdev
->dev
, vbuf
->sgl
, vbuf
->nents
,
534 /* add the header only after dma_unmap_sg() */
536 sg_copy_from_buffer(vbuf
->sgl
, vbuf
->nents
,
537 solo_enc
->vop
, solo_enc
->vop_len
);
541 static int solo_enc_fillbuf(struct solo_enc_dev
*solo_enc
,
542 struct vb2_buffer
*vb
, struct solo_enc_buf
*enc_buf
)
544 const vop_header
*vh
= enc_buf
->vh
;
547 switch (solo_enc
->fmt
) {
548 case V4L2_PIX_FMT_MPEG4
:
549 case V4L2_PIX_FMT_H264
:
550 ret
= solo_fill_mpeg(solo_enc
, vb
, vh
);
552 default: /* V4L2_PIX_FMT_MJPEG */
553 ret
= solo_fill_jpeg(solo_enc
, vb
, vh
);
558 bool send_event
= false;
560 vb
->v4l2_buf
.sequence
= solo_enc
->sequence
++;
561 vb
->v4l2_buf
.timestamp
.tv_sec
= vop_sec(vh
);
562 vb
->v4l2_buf
.timestamp
.tv_usec
= vop_usec(vh
);
564 /* Check for motion flags */
565 if (solo_is_motion_on(solo_enc
)) {
566 /* It takes a few frames for the hardware to detect
567 * motion. Once it does it clears the motion detection
568 * register and it takes again a few frames before
569 * motion is seen. This means in practice that when the
570 * motion field is 1, it will go back to 0 for the next
571 * frame. This leads to motion detection event being
572 * sent all the time, which is not what we want.
573 * Instead wait a few frames before deciding that the
574 * motion has halted. After some experimentation it
575 * turns out that waiting for 5 frames works well.
577 if (enc_buf
->motion
== 0 &&
578 solo_enc
->motion_last_state
&&
579 solo_enc
->frames_since_last_motion
++ > 5)
581 else if (enc_buf
->motion
) {
582 solo_enc
->frames_since_last_motion
= 0;
583 send_event
= !solo_enc
->motion_last_state
;
588 struct v4l2_event ev
= {
589 .type
= V4L2_EVENT_MOTION_DET
,
591 .flags
= V4L2_EVENT_MD_FL_HAVE_FRAME_SEQ
,
592 .frame_sequence
= vb
->v4l2_buf
.sequence
,
593 .region_mask
= enc_buf
->motion
? 1 : 0,
597 solo_enc
->motion_last_state
= enc_buf
->motion
;
598 solo_enc
->frames_since_last_motion
= 0;
599 v4l2_event_queue(solo_enc
->vfd
, &ev
);
603 vb2_buffer_done(vb
, ret
? VB2_BUF_STATE_ERROR
: VB2_BUF_STATE_DONE
);
608 static void solo_enc_handle_one(struct solo_enc_dev
*solo_enc
,
609 struct solo_enc_buf
*enc_buf
)
611 struct solo_vb2_buf
*vb
;
614 mutex_lock(&solo_enc
->lock
);
615 if (solo_enc
->type
!= enc_buf
->type
)
618 spin_lock_irqsave(&solo_enc
->av_lock
, flags
);
619 if (list_empty(&solo_enc
->vidq_active
)) {
620 spin_unlock_irqrestore(&solo_enc
->av_lock
, flags
);
623 vb
= list_first_entry(&solo_enc
->vidq_active
, struct solo_vb2_buf
,
626 spin_unlock_irqrestore(&solo_enc
->av_lock
, flags
);
628 solo_enc_fillbuf(solo_enc
, &vb
->vb
, enc_buf
);
630 mutex_unlock(&solo_enc
->lock
);
633 void solo_enc_v4l2_isr(struct solo_dev
*solo_dev
)
635 wake_up_interruptible_all(&solo_dev
->ring_thread_wait
);
638 static void solo_handle_ring(struct solo_dev
*solo_dev
)
641 struct solo_enc_dev
*solo_enc
;
642 struct solo_enc_buf enc_buf
;
643 u32 mpeg_current
, off
;
647 /* Check if the hardware has any new ones in the queue */
648 cur_q
= solo_reg_read(solo_dev
, SOLO_VE_STATE(11)) & 0xff;
649 if (cur_q
== solo_dev
->enc_idx
)
652 mpeg_current
= solo_reg_read(solo_dev
,
653 SOLO_VE_MPEG4_QUE(solo_dev
->enc_idx
));
654 solo_dev
->enc_idx
= (solo_dev
->enc_idx
+ 1) % MP4_QS
;
656 ch
= (mpeg_current
>> 24) & 0x1f;
657 off
= mpeg_current
& 0x00ffffff;
659 if (ch
>= SOLO_MAX_CHANNELS
) {
660 ch
-= SOLO_MAX_CHANNELS
;
661 enc_buf
.type
= SOLO_ENC_TYPE_EXT
;
663 enc_buf
.type
= SOLO_ENC_TYPE_STD
;
665 solo_enc
= solo_dev
->v4l2_enc
[ch
];
666 if (solo_enc
== NULL
) {
667 dev_err(&solo_dev
->pdev
->dev
,
668 "Got spurious packet for channel %d\n", ch
);
673 if (enc_get_mpeg_dma(solo_dev
, solo_dev
->vh_dma
, off
,
677 enc_buf
.vh
= solo_dev
->vh_buf
;
680 if (vop_mpeg_offset(enc_buf
.vh
) !=
681 SOLO_MP4E_EXT_ADDR(solo_dev
) + off
)
684 if (solo_motion_detected(solo_enc
))
689 solo_enc_handle_one(solo_enc
, &enc_buf
);
693 static int solo_ring_thread(void *data
)
695 struct solo_dev
*solo_dev
= data
;
696 DECLARE_WAITQUEUE(wait
, current
);
699 add_wait_queue(&solo_dev
->ring_thread_wait
, &wait
);
702 long timeout
= schedule_timeout_interruptible(HZ
);
704 if (timeout
== -ERESTARTSYS
|| kthread_should_stop())
706 solo_irq_off(solo_dev
, SOLO_IRQ_ENCODER
);
707 solo_handle_ring(solo_dev
);
708 solo_irq_on(solo_dev
, SOLO_IRQ_ENCODER
);
712 remove_wait_queue(&solo_dev
->ring_thread_wait
, &wait
);
717 static int solo_enc_queue_setup(struct vb2_queue
*q
,
718 const struct v4l2_format
*fmt
,
719 unsigned int *num_buffers
,
720 unsigned int *num_planes
, unsigned int sizes
[],
723 sizes
[0] = FRAME_BUF_SIZE
;
726 if (*num_buffers
< MIN_VID_BUFFERS
)
727 *num_buffers
= MIN_VID_BUFFERS
;
732 static void solo_enc_buf_queue(struct vb2_buffer
*vb
)
734 struct vb2_queue
*vq
= vb
->vb2_queue
;
735 struct solo_enc_dev
*solo_enc
= vb2_get_drv_priv(vq
);
736 struct solo_vb2_buf
*solo_vb
=
737 container_of(vb
, struct solo_vb2_buf
, vb
);
739 spin_lock(&solo_enc
->av_lock
);
740 list_add_tail(&solo_vb
->list
, &solo_enc
->vidq_active
);
741 spin_unlock(&solo_enc
->av_lock
);
744 static int solo_ring_start(struct solo_dev
*solo_dev
)
746 solo_dev
->ring_thread
= kthread_run(solo_ring_thread
, solo_dev
,
747 SOLO6X10_NAME
"_ring");
748 if (IS_ERR(solo_dev
->ring_thread
)) {
749 int err
= PTR_ERR(solo_dev
->ring_thread
);
751 solo_dev
->ring_thread
= NULL
;
755 solo_irq_on(solo_dev
, SOLO_IRQ_ENCODER
);
760 static void solo_ring_stop(struct solo_dev
*solo_dev
)
762 if (solo_dev
->ring_thread
) {
763 kthread_stop(solo_dev
->ring_thread
);
764 solo_dev
->ring_thread
= NULL
;
767 solo_irq_off(solo_dev
, SOLO_IRQ_ENCODER
);
770 static int solo_enc_start_streaming(struct vb2_queue
*q
, unsigned int count
)
772 struct solo_enc_dev
*solo_enc
= vb2_get_drv_priv(q
);
775 ret
= solo_enc_on(solo_enc
);
778 return solo_ring_start(solo_enc
->solo_dev
);
781 static void solo_enc_stop_streaming(struct vb2_queue
*q
)
783 struct solo_enc_dev
*solo_enc
= vb2_get_drv_priv(q
);
785 solo_enc_off(solo_enc
);
786 INIT_LIST_HEAD(&solo_enc
->vidq_active
);
787 solo_ring_stop(solo_enc
->solo_dev
);
790 static struct vb2_ops solo_enc_video_qops
= {
791 .queue_setup
= solo_enc_queue_setup
,
792 .buf_queue
= solo_enc_buf_queue
,
793 .start_streaming
= solo_enc_start_streaming
,
794 .stop_streaming
= solo_enc_stop_streaming
,
795 .wait_prepare
= vb2_ops_wait_prepare
,
796 .wait_finish
= vb2_ops_wait_finish
,
799 static int solo_enc_querycap(struct file
*file
, void *priv
,
800 struct v4l2_capability
*cap
)
802 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
803 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
805 strcpy(cap
->driver
, SOLO6X10_NAME
);
806 snprintf(cap
->card
, sizeof(cap
->card
), "Softlogic 6x10 Enc %d",
808 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
), "PCI:%s",
809 pci_name(solo_dev
->pdev
));
810 cap
->device_caps
= V4L2_CAP_VIDEO_CAPTURE
|
811 V4L2_CAP_READWRITE
| V4L2_CAP_STREAMING
;
812 cap
->capabilities
= cap
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
816 static int solo_enc_enum_input(struct file
*file
, void *priv
,
817 struct v4l2_input
*input
)
819 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
820 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
825 snprintf(input
->name
, sizeof(input
->name
), "Encoder %d",
827 input
->type
= V4L2_INPUT_TYPE_CAMERA
;
828 input
->std
= solo_enc
->vfd
->tvnorms
;
830 if (!tw28_get_video_status(solo_dev
, solo_enc
->ch
))
831 input
->status
= V4L2_IN_ST_NO_SIGNAL
;
836 static int solo_enc_set_input(struct file
*file
, void *priv
,
845 static int solo_enc_get_input(struct file
*file
, void *priv
,
853 static int solo_enc_enum_fmt_cap(struct file
*file
, void *priv
,
854 struct v4l2_fmtdesc
*f
)
856 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
857 int dev_type
= solo_enc
->solo_dev
->type
;
863 f
->pixelformat
= V4L2_PIX_FMT_MPEG4
;
864 strcpy(f
->description
, "MPEG-4 part 2");
867 f
->pixelformat
= V4L2_PIX_FMT_H264
;
868 strcpy(f
->description
, "H.264");
873 f
->pixelformat
= V4L2_PIX_FMT_MJPEG
;
874 strcpy(f
->description
, "MJPEG");
880 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
885 static inline int solo_valid_pixfmt(u32 pixfmt
, int dev_type
)
887 return (pixfmt
== V4L2_PIX_FMT_H264
&& dev_type
== SOLO_DEV_6110
)
888 || (pixfmt
== V4L2_PIX_FMT_MPEG4
&& dev_type
== SOLO_DEV_6010
)
889 || pixfmt
== V4L2_PIX_FMT_MJPEG
? 0 : -EINVAL
;
892 static int solo_enc_try_fmt_cap(struct file
*file
, void *priv
,
893 struct v4l2_format
*f
)
895 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
896 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
897 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
899 if (solo_valid_pixfmt(pix
->pixelformat
, solo_dev
->type
))
902 if (pix
->width
< solo_dev
->video_hsize
||
903 pix
->height
< solo_dev
->video_vsize
<< 1) {
904 /* Default to CIF 1/2 size */
905 pix
->width
= solo_dev
->video_hsize
>> 1;
906 pix
->height
= solo_dev
->video_vsize
;
909 pix
->width
= solo_dev
->video_hsize
;
910 pix
->height
= solo_dev
->video_vsize
<< 1;
913 switch (pix
->field
) {
914 case V4L2_FIELD_NONE
:
915 case V4L2_FIELD_INTERLACED
:
919 pix
->field
= V4L2_FIELD_INTERLACED
;
924 pix
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
925 pix
->sizeimage
= FRAME_BUF_SIZE
;
926 pix
->bytesperline
= 0;
932 static int solo_enc_set_fmt_cap(struct file
*file
, void *priv
,
933 struct v4l2_format
*f
)
935 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
936 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
937 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
940 if (vb2_is_busy(&solo_enc
->vidq
))
943 ret
= solo_enc_try_fmt_cap(file
, priv
, f
);
947 if (pix
->width
== solo_dev
->video_hsize
)
948 solo_enc
->mode
= SOLO_ENC_MODE_D1
;
950 solo_enc
->mode
= SOLO_ENC_MODE_CIF
;
952 /* This does not change the encoder at all */
953 solo_enc
->fmt
= pix
->pixelformat
;
956 * More information is needed about these 'extended' types. As far
957 * as I can tell these are basically additional video streams with
958 * different MPEG encoding attributes that can run in parallel with
959 * the main stream. If so, then this should be implemented as a
960 * second video node. Abusing priv like this is certainly not the
963 solo_enc->type = SOLO_ENC_TYPE_EXT;
965 solo_update_mode(solo_enc
);
969 static int solo_enc_get_fmt_cap(struct file
*file
, void *priv
,
970 struct v4l2_format
*f
)
972 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
973 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
975 pix
->width
= solo_enc
->width
;
976 pix
->height
= solo_enc
->height
;
977 pix
->pixelformat
= solo_enc
->fmt
;
978 pix
->field
= solo_enc
->interlaced
? V4L2_FIELD_INTERLACED
:
980 pix
->sizeimage
= FRAME_BUF_SIZE
;
981 pix
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
987 static int solo_enc_g_std(struct file
*file
, void *priv
, v4l2_std_id
*i
)
989 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
990 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
992 if (solo_dev
->video_type
== SOLO_VO_FMT_TYPE_NTSC
)
993 *i
= V4L2_STD_NTSC_M
;
999 static int solo_enc_s_std(struct file
*file
, void *priv
, v4l2_std_id std
)
1001 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1003 return solo_set_video_type(solo_enc
->solo_dev
, std
& V4L2_STD_625_50
);
1006 static int solo_enum_framesizes(struct file
*file
, void *priv
,
1007 struct v4l2_frmsizeenum
*fsize
)
1009 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1010 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1012 if (solo_valid_pixfmt(fsize
->pixel_format
, solo_dev
->type
))
1015 switch (fsize
->index
) {
1017 fsize
->discrete
.width
= solo_dev
->video_hsize
>> 1;
1018 fsize
->discrete
.height
= solo_dev
->video_vsize
;
1021 fsize
->discrete
.width
= solo_dev
->video_hsize
;
1022 fsize
->discrete
.height
= solo_dev
->video_vsize
<< 1;
1028 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1033 static int solo_enum_frameintervals(struct file
*file
, void *priv
,
1034 struct v4l2_frmivalenum
*fintv
)
1036 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1037 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1039 if (solo_valid_pixfmt(fintv
->pixel_format
, solo_dev
->type
))
1043 if ((fintv
->width
!= solo_dev
->video_hsize
>> 1 ||
1044 fintv
->height
!= solo_dev
->video_vsize
) &&
1045 (fintv
->width
!= solo_dev
->video_hsize
||
1046 fintv
->height
!= solo_dev
->video_vsize
<< 1))
1049 fintv
->type
= V4L2_FRMIVAL_TYPE_STEPWISE
;
1051 fintv
->stepwise
.min
.numerator
= 1;
1052 fintv
->stepwise
.min
.denominator
= solo_dev
->fps
;
1054 fintv
->stepwise
.max
.numerator
= 15;
1055 fintv
->stepwise
.max
.denominator
= solo_dev
->fps
;
1057 fintv
->stepwise
.step
.numerator
= 1;
1058 fintv
->stepwise
.step
.denominator
= solo_dev
->fps
;
1063 static int solo_g_parm(struct file
*file
, void *priv
,
1064 struct v4l2_streamparm
*sp
)
1066 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1067 struct v4l2_captureparm
*cp
= &sp
->parm
.capture
;
1069 cp
->capability
= V4L2_CAP_TIMEPERFRAME
;
1070 cp
->timeperframe
.numerator
= solo_enc
->interval
;
1071 cp
->timeperframe
.denominator
= solo_enc
->solo_dev
->fps
;
1072 cp
->capturemode
= 0;
1073 /* XXX: Shouldn't we be able to get/set this from videobuf? */
1074 cp
->readbuffers
= 2;
1079 static inline int calc_interval(u8 fps
, u32 n
, u32 d
)
1086 return min(15U, n
/ d
+ (n
% d
>= (fps
>> 1)));
1089 static int solo_s_parm(struct file
*file
, void *priv
,
1090 struct v4l2_streamparm
*sp
)
1092 struct solo_enc_dev
*solo_enc
= video_drvdata(file
);
1093 struct v4l2_fract
*t
= &sp
->parm
.capture
.timeperframe
;
1094 u8 fps
= solo_enc
->solo_dev
->fps
;
1096 if (vb2_is_streaming(&solo_enc
->vidq
))
1099 solo_enc
->interval
= calc_interval(fps
, t
->numerator
, t
->denominator
);
1100 solo_update_mode(solo_enc
);
1101 return solo_g_parm(file
, priv
, sp
);
1104 static int solo_s_ctrl(struct v4l2_ctrl
*ctrl
)
1106 struct solo_enc_dev
*solo_enc
=
1107 container_of(ctrl
->handler
, struct solo_enc_dev
, hdl
);
1108 struct solo_dev
*solo_dev
= solo_enc
->solo_dev
;
1112 case V4L2_CID_BRIGHTNESS
:
1113 case V4L2_CID_CONTRAST
:
1114 case V4L2_CID_SATURATION
:
1116 case V4L2_CID_SHARPNESS
:
1117 return tw28_set_ctrl_val(solo_dev
, ctrl
->id
, solo_enc
->ch
,
1119 case V4L2_CID_MPEG_VIDEO_GOP_SIZE
:
1120 solo_enc
->gop
= ctrl
->val
;
1121 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP(solo_enc
->ch
), solo_enc
->gop
);
1122 solo_reg_write(solo_dev
, SOLO_VE_CH_GOP_E(solo_enc
->ch
), solo_enc
->gop
);
1124 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP
:
1125 solo_enc
->qp
= ctrl
->val
;
1126 solo_reg_write(solo_dev
, SOLO_VE_CH_QP(solo_enc
->ch
), solo_enc
->qp
);
1127 solo_reg_write(solo_dev
, SOLO_VE_CH_QP_E(solo_enc
->ch
), solo_enc
->qp
);
1129 case V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD
:
1130 solo_enc
->motion_thresh
= ctrl
->val
<< 8;
1131 if (!solo_enc
->motion_global
|| !solo_enc
->motion_enabled
)
1133 return solo_set_motion_threshold(solo_dev
, solo_enc
->ch
,
1134 solo_enc
->motion_thresh
);
1135 case V4L2_CID_DETECT_MD_MODE
:
1136 solo_enc
->motion_global
= ctrl
->val
== V4L2_DETECT_MD_MODE_GLOBAL
;
1137 solo_enc
->motion_enabled
= ctrl
->val
> V4L2_DETECT_MD_MODE_DISABLED
;
1139 if (solo_enc
->motion_global
)
1140 err
= solo_set_motion_threshold(solo_dev
, solo_enc
->ch
,
1141 solo_enc
->motion_thresh
);
1143 err
= solo_set_motion_block(solo_dev
, solo_enc
->ch
,
1144 solo_enc
->md_thresholds
->p_cur
.p_u16
);
1148 solo_motion_toggle(solo_enc
, ctrl
->val
);
1150 case V4L2_CID_DETECT_MD_THRESHOLD_GRID
:
1151 if (solo_enc
->motion_enabled
&& !solo_enc
->motion_global
)
1152 return solo_set_motion_block(solo_dev
, solo_enc
->ch
,
1153 solo_enc
->md_thresholds
->p_new
.p_u16
);
1155 case V4L2_CID_OSD_TEXT
:
1156 strcpy(solo_enc
->osd_text
, ctrl
->p_new
.p_char
);
1157 return solo_osd_print(solo_enc
);
1165 static int solo_subscribe_event(struct v4l2_fh
*fh
,
1166 const struct v4l2_event_subscription
*sub
)
1169 switch (sub
->type
) {
1170 case V4L2_EVENT_CTRL
:
1171 return v4l2_ctrl_subscribe_event(fh
, sub
);
1172 case V4L2_EVENT_MOTION_DET
:
1173 /* Allow for up to 30 events (1 second for NTSC) to be
1175 return v4l2_event_subscribe(fh
, sub
, 30, NULL
);
1180 static const struct v4l2_file_operations solo_enc_fops
= {
1181 .owner
= THIS_MODULE
,
1182 .open
= v4l2_fh_open
,
1183 .release
= vb2_fop_release
,
1184 .read
= vb2_fop_read
,
1185 .poll
= vb2_fop_poll
,
1186 .mmap
= vb2_fop_mmap
,
1187 .unlocked_ioctl
= video_ioctl2
,
1190 static const struct v4l2_ioctl_ops solo_enc_ioctl_ops
= {
1191 .vidioc_querycap
= solo_enc_querycap
,
1192 .vidioc_s_std
= solo_enc_s_std
,
1193 .vidioc_g_std
= solo_enc_g_std
,
1194 /* Input callbacks */
1195 .vidioc_enum_input
= solo_enc_enum_input
,
1196 .vidioc_s_input
= solo_enc_set_input
,
1197 .vidioc_g_input
= solo_enc_get_input
,
1198 /* Video capture format callbacks */
1199 .vidioc_enum_fmt_vid_cap
= solo_enc_enum_fmt_cap
,
1200 .vidioc_try_fmt_vid_cap
= solo_enc_try_fmt_cap
,
1201 .vidioc_s_fmt_vid_cap
= solo_enc_set_fmt_cap
,
1202 .vidioc_g_fmt_vid_cap
= solo_enc_get_fmt_cap
,
1204 .vidioc_reqbufs
= vb2_ioctl_reqbufs
,
1205 .vidioc_querybuf
= vb2_ioctl_querybuf
,
1206 .vidioc_qbuf
= vb2_ioctl_qbuf
,
1207 .vidioc_dqbuf
= vb2_ioctl_dqbuf
,
1208 .vidioc_streamon
= vb2_ioctl_streamon
,
1209 .vidioc_streamoff
= vb2_ioctl_streamoff
,
1210 /* Frame size and interval */
1211 .vidioc_enum_framesizes
= solo_enum_framesizes
,
1212 .vidioc_enum_frameintervals
= solo_enum_frameintervals
,
1213 /* Video capture parameters */
1214 .vidioc_s_parm
= solo_s_parm
,
1215 .vidioc_g_parm
= solo_g_parm
,
1216 /* Logging and events */
1217 .vidioc_log_status
= v4l2_ctrl_log_status
,
1218 .vidioc_subscribe_event
= solo_subscribe_event
,
1219 .vidioc_unsubscribe_event
= v4l2_event_unsubscribe
,
1222 static const struct video_device solo_enc_template
= {
1223 .name
= SOLO6X10_NAME
,
1224 .fops
= &solo_enc_fops
,
1225 .ioctl_ops
= &solo_enc_ioctl_ops
,
1227 .release
= video_device_release
,
1228 .tvnorms
= V4L2_STD_NTSC_M
| V4L2_STD_PAL
,
1231 static const struct v4l2_ctrl_ops solo_ctrl_ops
= {
1232 .s_ctrl
= solo_s_ctrl
,
1235 static const struct v4l2_ctrl_config solo_osd_text_ctrl
= {
1236 .ops
= &solo_ctrl_ops
,
1237 .id
= V4L2_CID_OSD_TEXT
,
1239 .type
= V4L2_CTRL_TYPE_STRING
,
1240 .max
= OSD_TEXT_MAX
,
1244 /* Motion Detection Threshold matrix */
1245 static const struct v4l2_ctrl_config solo_md_thresholds
= {
1246 .ops
= &solo_ctrl_ops
,
1247 .id
= V4L2_CID_DETECT_MD_THRESHOLD_GRID
,
1248 .dims
= { SOLO_MOTION_SZ
, SOLO_MOTION_SZ
},
1249 .def
= SOLO_DEF_MOT_THRESH
,
1254 static struct solo_enc_dev
*solo_enc_alloc(struct solo_dev
*solo_dev
,
1257 struct solo_enc_dev
*solo_enc
;
1258 struct v4l2_ctrl_handler
*hdl
;
1261 solo_enc
= kzalloc(sizeof(*solo_enc
), GFP_KERNEL
);
1263 return ERR_PTR(-ENOMEM
);
1265 hdl
= &solo_enc
->hdl
;
1266 v4l2_ctrl_handler_init(hdl
, 10);
1267 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1268 V4L2_CID_BRIGHTNESS
, 0, 255, 1, 128);
1269 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1270 V4L2_CID_CONTRAST
, 0, 255, 1, 128);
1271 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1272 V4L2_CID_SATURATION
, 0, 255, 1, 128);
1273 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1274 V4L2_CID_HUE
, 0, 255, 1, 128);
1275 if (tw28_has_sharpness(solo_dev
, ch
))
1276 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1277 V4L2_CID_SHARPNESS
, 0, 15, 1, 0);
1278 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1279 V4L2_CID_MPEG_VIDEO_GOP_SIZE
, 1, 255, 1, solo_dev
->fps
);
1280 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1281 V4L2_CID_MPEG_VIDEO_H264_MIN_QP
, 0, 31, 1, SOLO_DEFAULT_QP
);
1282 v4l2_ctrl_new_std_menu(hdl
, &solo_ctrl_ops
,
1283 V4L2_CID_DETECT_MD_MODE
,
1284 V4L2_DETECT_MD_MODE_THRESHOLD_GRID
, 0,
1285 V4L2_DETECT_MD_MODE_DISABLED
);
1286 v4l2_ctrl_new_std(hdl
, &solo_ctrl_ops
,
1287 V4L2_CID_DETECT_MD_GLOBAL_THRESHOLD
, 0, 0xff, 1,
1288 SOLO_DEF_MOT_THRESH
>> 8);
1289 v4l2_ctrl_new_custom(hdl
, &solo_osd_text_ctrl
, NULL
);
1290 solo_enc
->md_thresholds
=
1291 v4l2_ctrl_new_custom(hdl
, &solo_md_thresholds
, NULL
);
1297 solo_enc
->solo_dev
= solo_dev
;
1299 mutex_init(&solo_enc
->lock
);
1300 spin_lock_init(&solo_enc
->av_lock
);
1301 INIT_LIST_HEAD(&solo_enc
->vidq_active
);
1302 solo_enc
->fmt
= (solo_dev
->type
== SOLO_DEV_6010
) ?
1303 V4L2_PIX_FMT_MPEG4
: V4L2_PIX_FMT_H264
;
1304 solo_enc
->type
= SOLO_ENC_TYPE_STD
;
1306 solo_enc
->qp
= SOLO_DEFAULT_QP
;
1307 solo_enc
->gop
= solo_dev
->fps
;
1308 solo_enc
->interval
= 1;
1309 solo_enc
->mode
= SOLO_ENC_MODE_CIF
;
1310 solo_enc
->motion_global
= true;
1311 solo_enc
->motion_thresh
= SOLO_DEF_MOT_THRESH
;
1312 solo_enc
->vidq
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
1313 solo_enc
->vidq
.io_modes
= VB2_MMAP
| VB2_USERPTR
| VB2_READ
;
1314 solo_enc
->vidq
.ops
= &solo_enc_video_qops
;
1315 solo_enc
->vidq
.mem_ops
= &vb2_dma_sg_memops
;
1316 solo_enc
->vidq
.drv_priv
= solo_enc
;
1317 solo_enc
->vidq
.gfp_flags
= __GFP_DMA32
;
1318 solo_enc
->vidq
.timestamp_flags
= V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC
;
1319 solo_enc
->vidq
.buf_struct_size
= sizeof(struct solo_vb2_buf
);
1320 solo_enc
->vidq
.lock
= &solo_enc
->lock
;
1321 ret
= vb2_queue_init(&solo_enc
->vidq
);
1324 solo_update_mode(solo_enc
);
1326 spin_lock_init(&solo_enc
->motion_lock
);
1328 /* Initialize this per encoder */
1329 solo_enc
->jpeg_len
= sizeof(jpeg_header
);
1330 memcpy(solo_enc
->jpeg_header
, jpeg_header
, solo_enc
->jpeg_len
);
1332 solo_enc
->desc_nelts
= 32;
1333 solo_enc
->desc_items
= pci_alloc_consistent(solo_dev
->pdev
,
1334 sizeof(struct solo_p2m_desc
) *
1335 solo_enc
->desc_nelts
,
1336 &solo_enc
->desc_dma
);
1338 if (solo_enc
->desc_items
== NULL
)
1341 solo_enc
->vfd
= video_device_alloc();
1345 *solo_enc
->vfd
= solo_enc_template
;
1346 solo_enc
->vfd
->v4l2_dev
= &solo_dev
->v4l2_dev
;
1347 solo_enc
->vfd
->ctrl_handler
= hdl
;
1348 solo_enc
->vfd
->queue
= &solo_enc
->vidq
;
1349 solo_enc
->vfd
->lock
= &solo_enc
->lock
;
1350 video_set_drvdata(solo_enc
->vfd
, solo_enc
);
1351 ret
= video_register_device(solo_enc
->vfd
, VFL_TYPE_GRABBER
, nr
);
1355 snprintf(solo_enc
->vfd
->name
, sizeof(solo_enc
->vfd
->name
),
1356 "%s-enc (%i/%i)", SOLO6X10_NAME
, solo_dev
->vfd
->num
,
1357 solo_enc
->vfd
->num
);
1362 video_device_release(solo_enc
->vfd
);
1364 pci_free_consistent(solo_enc
->solo_dev
->pdev
,
1365 sizeof(struct solo_p2m_desc
) * solo_enc
->desc_nelts
,
1366 solo_enc
->desc_items
, solo_enc
->desc_dma
);
1368 v4l2_ctrl_handler_free(hdl
);
1370 return ERR_PTR(ret
);
1373 static void solo_enc_free(struct solo_enc_dev
*solo_enc
)
1375 if (solo_enc
== NULL
)
1378 video_unregister_device(solo_enc
->vfd
);
1379 v4l2_ctrl_handler_free(&solo_enc
->hdl
);
1383 int solo_enc_v4l2_init(struct solo_dev
*solo_dev
, unsigned nr
)
1387 init_waitqueue_head(&solo_dev
->ring_thread_wait
);
1389 solo_dev
->vh_size
= sizeof(vop_header
);
1390 solo_dev
->vh_buf
= pci_alloc_consistent(solo_dev
->pdev
,
1393 if (solo_dev
->vh_buf
== NULL
)
1396 for (i
= 0; i
< solo_dev
->nr_chans
; i
++) {
1397 solo_dev
->v4l2_enc
[i
] = solo_enc_alloc(solo_dev
, i
, nr
);
1398 if (IS_ERR(solo_dev
->v4l2_enc
[i
]))
1402 if (i
!= solo_dev
->nr_chans
) {
1403 int ret
= PTR_ERR(solo_dev
->v4l2_enc
[i
]);
1406 solo_enc_free(solo_dev
->v4l2_enc
[i
]);
1407 pci_free_consistent(solo_dev
->pdev
, solo_dev
->vh_size
,
1408 solo_dev
->vh_buf
, solo_dev
->vh_dma
);
1409 solo_dev
->vh_buf
= NULL
;
1413 if (solo_dev
->type
== SOLO_DEV_6010
)
1414 solo_dev
->enc_bw_remain
= solo_dev
->fps
* 4 * 4;
1416 solo_dev
->enc_bw_remain
= solo_dev
->fps
* 4 * 5;
1418 dev_info(&solo_dev
->pdev
->dev
, "Encoders as /dev/video%d-%d\n",
1419 solo_dev
->v4l2_enc
[0]->vfd
->num
,
1420 solo_dev
->v4l2_enc
[solo_dev
->nr_chans
- 1]->vfd
->num
);
1425 void solo_enc_v4l2_exit(struct solo_dev
*solo_dev
)
1429 for (i
= 0; i
< solo_dev
->nr_chans
; i
++)
1430 solo_enc_free(solo_dev
->v4l2_enc
[i
]);
1432 if (solo_dev
->vh_buf
)
1433 pci_free_consistent(solo_dev
->pdev
, solo_dev
->vh_size
,
1434 solo_dev
->vh_buf
, solo_dev
->vh_dma
);