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