开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
v4l2cap.c
资源名称：dvd-munitions.tar.gz　[点击查看]
上传用户：aoeyumen
上传日期：2007-01-06
资源大小：3329k
文件大小：87k
源码类别：

DVD

开发平台：

Unix_Linux

v4l2cap.c：源码内容
  1. /*        Video for Linux Two
  2.  *        Video Capture Driver
  3.  *        -- example code --
  4.  *
  5.  *        This software is in the public domain.
  6.  *        Written by Bill Dirks
  7.  *
  8.  *        This module is an example implementation of the Video for Linux Two
  9.  *        video capture API specification. The purposes of this software are
  10.  *        1) Serve as a starting point for a new V4L2 capture driver
  11.  *        2) Serve as a dummy driver for an application developer
  12.  *        3) Supplement the V4L2 API documentation 
  13.  *
  14.  *        gcc -c -O2 -Wall v4l2cap.c
  15.  */
  17. #ifndef __KERNEL__
  18. #define __KERNEL__
  19. #endif
  20. #ifndef MODULE
  21. #define MODULE
  22. #endif
  23. #include <linux/module.h>
  24. #include <linux/errno.h>
  25. #include <linux/kernel.h>
  26. #include <linux/malloc.h>
  27. #include <linux/mm.h>
  28. #include <linux/poll.h>
  29. #include <linux/ioport.h>
  30. #include <asm/io.h>
  31. #include <linux/videodev2.h>
  32. #include <linux/version.h>
  33. #include <asm/uaccess.h>
  34. #include <asm/pgtable.h>
  35. #include <asm/page.h>
  37. #include <linux/i2c.h>
  38. #include "mgavideo.h"
  39. #include "ks0127.h"
  40. #include "tuner.h"
  41. #include "msp3400.h"
  42. #include "zr36060.h"
  44. #define PKMOD "cap: "
  45. #if 0
  46. #define debug_msg(fmt,arg...) printk(KERN_DEBUG PKMOD fmt,##arg)
  47. #else
  48. #define debug_msg(fmt,arg...)
  49. #endif
  50. #if 1
  51. #define err_msg(fmt,arg...) printk(KERN_ERR PKMOD fmt,##arg)
  52. #else
  53. #define err_msg(fmt,arg...)
  54. #endif
  55. #if 1
  56. #define info_msg(fmt,arg...) printk(KERN_INFO PKMOD fmt,##arg)
  57. #else
  58. #define info_msg(fmt,arg...)
  59. #endif
  62. /*  Video controls  */
  64. static struct v4l2_queryctrl capture_control[] =
  65. {
  66.  {V4L2_CID_BRIGHTNESS, "Brightness", -126, 126, 1, 0, V4L2_CTRL_TYPE_INTEGER},
  67.  {V4L2_CID_CONTRAST,   "Contrast",   -126, 126, 1, 0, V4L2_CTRL_TYPE_INTEGER},
  68.  {V4L2_CID_SATURATION, "Saturation", -126, 126, 1, 0, V4L2_CTRL_TYPE_INTEGER},
  69.  {V4L2_CID_HUE,        "Hue",        -126, 126, 1, 0, V4L2_CTRL_TYPE_INTEGER},
  70. #if 1 /* extra stuff used for testing vidpanel */
  71.  {V4L2_CID_EXPOSURE, "Exposure", 0,4,0,0, V4L2_CTRL_TYPE_MENU},
  72.  {V4L2_CID_AUTOGAIN, "Auto Gain", 0, 1, 0, 1, V4L2_CTRL_TYPE_BOOLEAN},
  73.  {V4L2_CID_DO_WHITE_BALANCE, "White Balance", 0,0,0,0, V4L2_CTRL_TYPE_BUTTON},
  74. #endif
  75. };
  76. #define MAXCONTROLS        (sizeof(capture_control)/sizeof(capture_control[0]))
  77. #define VCTRL_BRIGHTNESS   0
  78. #define VCTRL_CONTRAST     1
  79. #define VCTRL_SATURATION   2
  80. #define VCTRL_HUE          3
  81. static int
  82. find_vctrl(int id)
  83. {
  84.         int i;
  85.         if (id == V4L2_CID_PRIVATE_BASE ||
  86.             id <  V4L2_CID_BASE ||
  87.             id >  V4L2_CID_LASTP1)
  88.                 return -EDOM;
  89.         for (i = MAXCONTROLS - 1; i >= 0; i--)
  90.                 if (capture_control[i].id == id)
  91.                         break;
  92.         if (i < 0)
  93.                 i = -EINVAL;
  94.         return i;
  95. }
  96. static int
  97. vctrl_querymenu(struct v4l2_querymenu *qm)
  98. {
  99.         static char *expo_menu[] = {
  100.                 "1/60",
  101.                 "1/100",
  102.                 "1/250",
  103.                 "1/1000",
  104.                 "1/5000",
  105.         };
  106.         if (qm->id == V4L2_CID_EXPOSURE)
  107.         {
  108.                 if (qm->index < 0 ||
  109.                     qm->index >= sizeof(expo_menu)/sizeof(char *))
  110.                         return -EINVAL;
  111.                 {
  112.                         memcpy(qm->name, expo_menu[qm->index],
  113.                                sizeof(qm->name));
  114.                 }
  115.                 return 0;
  116.         }
  117.         return -EINVAL;
  118. }
  122. struct capture_device;/* forward reference */
  124. struct video_source
  125. {
  126.         struct v4l2_input        input;
  127.         int                      control[MAXCONTROLS];
  128.         struct v4l2_tuner        tuner;
  129.         int                      freq;
  130.         struct v4l2_audio        audio;
  131.         int                      vcrmode;
  132. };
  134. /*  Bus-master scatter list  */
  135. struct scatter_node
  136. {
  137.         __u32                    addr;
  138.         __u32                    len;
  139. };
  140. #define END_OF_SCATTER_LIST 0x80000000
  142. /*  Image translations  */
  143. struct lookup_rgb24
  144. {
  145.         __u32                    u_rgb[256];
  146.         __u32                    v_rgb[256];
  147.         __u32                    y_rgb[256];
  148.         __u8                     sat[1024];
  149. __u32  sat8[1024];
  150. __u32  sat16[1024];
  151. __u32  uv_rgb[256 * 256];
  152. };
  154. struct lookup
  155. {
  156.         int                      type;
  157.         int                      size;
  158.         union
  159.         {
  160.                 void                *base;        /* vmalloc() */
  161.                 __u16               *rgb16;
  162.                 struct lookup_rgb24 *rgb24;
  163.         } table;
  164. };
  165. #define LUT_NULL                 0
  166. #define LUT_RGB555               1
  167. #define LUT_RGB565               2
  168. #define LUT_RGB24                3
  170. struct translation
  171. {
  172.         int                      type;
  173.         int                      width;
  174.         int                      height;
  175.         __u8                     *in;
  176.         int                      in_stride;
  177.         __u8                     *out;
  178.         int                      out_stride;
  179.         int                      output_size;
  180.         int                      output_is_user;
  181.         struct lookup            lut;
  182. };
  183. #define XLAT_NULL                0
  184. #define XLAT_YUYV_TO_UYVY        1
  185. #define XLAT_YUYV_TO_YUV420      2
  186. #define XLAT_YUYV_TO_GREY        4
  187. #define XLAT_YUYV_TO_RGB555      6
  188. #define XLAT_YUYV_TO_RGB565      7
  189. #define XLAT_YUYV_TO_RGB24       8
  190. #define XLAT_YUYV_TO_RGB32       9
  192. /*  Per-open data for handling multiple opens on one device */
  193. struct device_open
  194. {
  195.         int                      isopen;
  196.         int                      noncapturing;
  197.         struct capture_device    *dev;
  198. };
  199. #define MAX_OPENS        3
  201. /*  Streaming data buffer  */
  202. struct stream_buffer
  203. {
  204.         struct v4l2_q_node       qnode;
  205.         struct v4l2_buffer       vidbuf;
  206.         int                      requested;
  207.         __u8                     *vaddress;  /* vmalloc() */
  208.         struct scatter_node      *dma_list;  /* get_free_page() */
  209. };
  210. #define MAX_CAPTURE_BUFFERS      30
  211. #define MAX_LOCKED_MEMORY        2000000
  213. /*
  214.  *        Capture device structure
  215.  *
  216.  *        One for each handled device in the system.
  217.  *        This structure holds all the global information the driver
  218.  *        needs about each device.
  219.  */
  220. struct capture_device
  221. {
  222.         struct v4l2_device       v;        /*  Must be first */
  223.         struct mga_dev*          mga;
  224.         char                     shortname[16];
  225.         int                      is_registered;
  226.         int                      open_count;
  227.         struct device_open       open_data[MAX_OPENS];
  228.         int                      capturing_opens;
  230. /*        Per-bus index number for each device        */
  231.         int                      index;
  232. /*        General type of device  */
  233.         int                      type;
  234. /*        Interrupts        */
  235.         int                      ints_enabled;
  236.         struct tq_struct         tqnode_dpc;/* for Bottom Half routine */
  237.         struct wait_queue        *new_video_frame;
  239. /*        Video decoder stuff                */
  240.         __u32                    standards;
  241.         __u32                    standard;
  242.         __u32                    frame_period;
  243.         struct video_source      source[KS_INPUT_COUNT];
  244.         int                      source_width;
  245.         int                      source_height;
  247. /*        Client capture format and capture modes        */
  248.         struct v4l2_format       clientfmt;
  249.         struct v4l2_captureparm  capture;
  250.         int                      input;/* which video source is selected */
  252. /*        Hardware capture format         */
  253.         int                      capture_bypp;
  254.         int                      capture_size;
  255.         struct scatter_node      *capture_dma_list;/* get_free_page() */
  257. /*        Capture state        */
  258.         int                      ready_to_capture;
  259.         int                      grabber_enabled;
  260.         int                      capture_completed;
  261.         unsigned long            time_acquired;/* millisecond time stamp */
  262.         int                      streaming;
  263.         struct stream_buffer     stream_buf[MAX_CAPTURE_BUFFERS];
  264.         int                      stream_buffers_requested;
  265.         int                      stream_buffers_mapped;
  266.         int                      stream_contig_map;
  267.         struct v4l2_queue        stream_q_capture;
  268.         struct v4l2_queue        stream_q_done;
  269.         struct timeval           stream_begin;
  270.         unsigned long            stream_last_frame;
  272. /*        Image format conversions        */
  273.         struct translation       translation;
  274.         __u8                     *xlat_temp;/* vmalloc() */
  276. /*        Performance statistics        */
  277.         struct v4l2_performance  perf;
  279.         /* frame counter for test images */
  280.         int                      h,m,s,f;
  282.         /* video preview stuff */
  283.         struct v4l2_framebuffer  fbuf;
  284.         struct v4l2_window       window;
  285. };
  286. /*        Values for type field        */
  287. #define DEVICE_TYPE_0            0
  288. /*        Extreme video dimensions        */
  289. #define MIN_WIDTH                32
  290. #define MIN_HEIGHT               24
  291. #define MAX_WIDTH                704
  292. #define MAX_HEIGHT               290
  293. #define MAX_FRAME_AGE            200 /* ms */
  299. /*
  300.  *        The Capture device structure array. This is the only global
  301.  *        variable in the module besides those used by the device probing
  302.  *        and enumeration routines (command line overrides)
  303.  */
  304. #define NBOARDS                  2
  305. static struct capture_device capture[NBOARDS];
  306. static int unit_video[NBOARDS] = { 0, 1, };
  307. MODULE_PARM(unit_video, "1-"__MODULE_STRING(NBOARDS)"i");
  309. static inline struct capture_device *
  310. capture_device_from_file(struct file *file)
  311. {
  312.         return (struct capture_device *)v4l2_device_from_file(file);
  313. }
  316. /*  These macros can be used to make device I/O operations atomic  */
  317. /* static spinlock_t device_lock = SPIN_LOCK_UNLOCKED; */
  318. /* #define BEGIN_CRITICAL_SECTION         */
  319. /*         do{unsigned long flags;spin_lock_irqsave(&wavi_lock,flags) */
  320. /* #define END_CRITICAL_SECTION         */
  321. /*         spin_unlock_irqrestore(&wavi_lock,flags);}while(0) */
  325. /*
  326.  *        D E V I C E   F U N C T I O N S
  327.  */
  329. static void
  330. device_initialize(struct capture_device *dev)
  331. {
  332.         int in;
  334.         /*  TODO: Put hardware into a sensible state and        */
  335.         /*        do the one-time startup things                */
  336.         mgavideo_decoder( dev->mga, KS0127_RESET, 0 );
  337.         in = KS_INPUT_COMPOSITE;
  338.         mgavideo_decoder( dev->mga, KS0127_SET_INPUT, &in );
  339.         in = KS_STD_NTSC;
  340.         mgavideo_decoder( dev->mga, KS0127_SET_STANDARD, &in );
  341.         in = KS_OUTPUT_YUV656E;
  342.         mgavideo_decoder( dev->mga, KS0127_SET_OUTPUT, &in );
  343.         in = -1;
  344.         mgavideo_tuner( dev->mga, TUNER_SET_TYPE, &in );
  346. mgavideo_zr36060_reset(dev->mga);
  347. }
  349. static void
  350. device_brightness(struct capture_device *dev, int x)
  351. {
  352.         mgavideo_decoder( dev->mga, KS0127_SET_BRIGHTNESS, &x);
  353. }
  355. static void
  356. device_contrast(struct capture_device *dev, int x)
  357. {
  358.         mgavideo_decoder( dev->mga, KS0127_SET_CONTRAST, &x);
  359. }
  361. static void
  362. device_saturation(struct capture_device *dev, int x)
  363. {
  364.         mgavideo_decoder( dev->mga, KS0127_SET_SATURATION, &x);
  365. }
  367. static void
  368. device_hue(struct capture_device *dev, int x)
  369. {
  370.         mgavideo_decoder( dev->mga, KS0127_SET_HUE, &x);
  371. }
  372.   
  374. static void
  375. device_tone_controls(struct capture_device *dev)
  376. {
  377.         int        *ctrl;
  378.         ctrl = dev->source[dev->input].control;
  379.         device_brightness(dev, ctrl[VCTRL_BRIGHTNESS]);
  380.         device_contrast(dev, ctrl[VCTRL_CONTRAST]);
  381.         device_saturation(dev, ctrl[VCTRL_SATURATION]);
  382.         device_hue(dev, ctrl[VCTRL_HUE]);
  383. }
  385. static void
  386. grabbing_enable(struct capture_device *dev, int x)
  387. {
  388. // XXX
  389. }
  391. static unsigned long
  392. current_time_ms(void)
  393. {
  394.         struct timeval now;
  396.         do_gettimeofday(&now);
  397.         return now.tv_sec * 1000 + now.tv_usec / 1000;
  398. }
  401. static void
  402. set_video_input(struct capture_device *dev, int i)
  403. {
  404.         if (i < 0 || i >= KS_INPUT_COUNT)
  405.                 return;
  407.         dev->input = i;
  408.         mgavideo_decoder( dev->mga, KS0127_SET_INPUT, &i );
  409.         device_tone_controls(dev);
  410. }
  412. static void
  413. set_video_standard(struct capture_device *dev, int x)
  414. {
  415.         int in;
  417.         dev->standard = x;
  419.         switch (x)
  420.         {
  421.         case V4L2_STD_NTSC:
  422.                 dev->frame_period = 333667;
  423.                 in = KS_STD_NTSC;
  424.                 break;
  425.         case V4L2_STD_PAL:
  426.                 dev->frame_period = 400000;
  427.                 in = KS_STD_PAL;
  428.                 break;
  429.         case V4L2_STD_SECAM:
  430.                 dev->frame_period = 400000;
  431.                 in = KS_STD_SECAM;
  432.                 break;
  433.         }
  435.         mgavideo_decoder( dev->mga, KS0127_SET_STANDARD, &in );
  436. }
  438. static void
  439. set_video_freq(struct capture_device *dev, int *freq)
  440. {
  441.         int norm = 0;
  443.         mgavideo_audio( dev->mga, MSP_SWITCH_MUTE, 0 );
  444.         mgavideo_tuner( dev->mga, TUNER_SET_TVFREQ, freq );
  445.         mgavideo_audio( dev->mga, MSP_SET_TVNORM, &norm );
  446.         mgavideo_audio( dev->mga, MSP_NEWCHANNEL, 0 );
  448.         dev->source[dev->input].freq = *freq;
  449. }
  453. /*
  454.  *
  455.  *        I M A G E   F O R M A T   T R A N S L A T I O N
  456.  *
  457.  */
  459. static int
  460. translate_yuyv_grey(struct translation *xlat)
  461. {
  462.         __u8        *esi, *edi;
  463.         __u32        eax, ebx, ecx, edx;
  464.         int        row;
  466.         esi = xlat->in;
  467.         edi = xlat->out;
  468.         eax = xlat->in_stride - xlat->width * 2;
  469.         ebx = xlat->out_stride - xlat->width;
  470.         for (row = xlat->height; row; esi += eax, edi += ebx, --row)
  471.         {
  472.                 for (ecx = xlat->width >> 2; ecx; --ecx)
  473.                 {
  474.                         edx = esi[4] | (esi[6] << 8);
  475.                         edx <<= 16;
  476.                         edx |= esi[0] | (esi[2] << 8);
  477.                         esi += 8;
  478.                         *(__u32 *)edi = edx;
  479.                         edi += 4;
  480.                 }
  481.         }
  482.         return 1;
  483. }
  485. static int
  486. translate_yuyv_yuv420(struct translation *xlat)
  487. {
  488.         __u8        *esi, *edi;
  489.         __u32        eax, ebx, ecx, edx;
  490.         __u8        dl;
  491.         int        row;
  493.         /* Y's */
  494.         esi = xlat->in;
  495.         edi = xlat->out;
  496.         eax = xlat->in_stride - xlat->width * 2;
  497.         ebx = xlat->out_stride - xlat->width;
  498.         for (row = xlat->height; row; esi += eax, edi += ebx, --row)
  499.         {
  500.                 for (ecx = xlat->width >> 2; ecx; --ecx)
  501.                 {
  502.                         edx = esi[4] | (esi[6] << 8);
  503.                         edx <<= 16;
  504.                         edx |= esi[0] | (esi[2] << 8);
  505.                         esi += 8;
  506.                         *(__u32 *)edi = edx;
  507.                         edi += 4;
  508.                 }
  509.         }
  510.         /* U's */
  511.         esi = xlat->in + xlat->in_stride;
  512.         eax = xlat->in_stride * 2 - xlat->width * 2;
  513.         ebx >>= 1;
  514.         for (row = xlat->height >> 1; row; esi += eax, edi += ebx, --row)
  515.         {
  516.                 for (ecx = xlat->width >> 1; ecx; ++edi, --ecx)
  517.                 {
  518.                         dl = esi[1];
  519.                         esi += 4;
  520.                         *edi = dl;
  521.                 }
  522.         }
  523.         /* V's */
  524.         esi = xlat->in + xlat->in_stride;
  525.         for (row = xlat->height >> 1; row; esi += eax, edi += ebx, --row)
  526.         {
  527.                 for (ecx = xlat->width >> 1; ecx; ++edi, --ecx)
  528.                 {
  529.                         dl = esi[3];
  530.                         esi += 4;
  531.                         *edi = dl;
  532.                 }
  533.         }
  534.         return 1;
  535. }
  537. #define K12_1         4096
  538. #define K12_S           12
  539. #define K12_GU        -1409
  540. #define K12_BU         7258
  541. #define K12_RV         5743
  542. #define K12_GV        -2925
  543. static int
  544. translate_expand_y(int y)
  545. {
  546.         y = (255 * y + 110) / 220;
  547.         if (y < 0) y = 0; else if (y > 255) y = 255;
  548.         return y;
  549. }
  550. static int
  551. translate_expand_c(int c)
  552. {
  553.         c = (127 * c + 56) / 112;
  554.         if (c < -128) c = -128; else if (c > 127) c = 127;
  555.         return c;
  556. }
  558. static int
  559. translate_make_rgb16_lut(struct translation *xlat)
  560. {
  561.         __u16        *lut;
  562.         long        gu[32], bu[32], rv[32], gv[32];
  563.         int        rscale[256], gscale[256], bscale[256];
  564.         int        rrange, grange, brange;
  565.         int        rshift, gshift, bshift;
  566.         long        x;
  567.         int        y, u, v;
  568.         int        r, g, b;
  569.         int        i, t;
  571.         if ((xlat->type == XLAT_YUYV_TO_RGB555 &&
  572.              xlat->lut.type == LUT_RGB555) ||
  573.             (xlat->type == XLAT_YUYV_TO_RGB565 &&
  574.              xlat->lut.type == LUT_RGB565))
  575.                 return 1;
  577.         if (xlat->lut.table.base)
  578.                 vfree(xlat->lut.table.base);
  579.         xlat->lut.table.base = vmalloc(1 << 17);
  580.         if (xlat->lut.table.base == NULL)
  581.         {
  582.                 err_msg("vmalloc() failed in make_rgb16_lutn");
  583.                 return 0;
  584.         }
  585.         lut = xlat->lut.table.rgb16;
  587.         //  Compute all different chroma components to 8-bit precision
  588.         for (i = 0, t = -128; t < 128; t += 8, ++i)
  589.         {
  590.                 x = translate_expand_c(t) + 2;
  591.                 gu[i] = (K12_GU * x + K12_1/2) >> K12_S;
  592.                 bu[i] = (K12_BU * x + K12_1/2) >> K12_S;
  593.                 rv[i] = (K12_RV * x + K12_1/2) >> K12_S;
  594.                 gv[i] = (K12_GV * x + K12_1/2) >> K12_S;
  595.         }
  596.         //  8-bit to ?-bit scaling tables
  597.         if (xlat->type == XLAT_YUYV_TO_RGB555)
  598.         {
  599.                 xlat->lut.type = LUT_RGB555;
  600.                 rrange = grange = brange = 31;
  601.                 rshift = 10; gshift = 5; bshift = 0;
  602.         }
  603.         else
  604.         {
  605.                 xlat->lut.type = LUT_RGB565;
  606.                 rrange = brange = 31;
  607.                 grange = 63;
  608.                 rshift = 11; gshift = 5; bshift = 0;
  609.         }
  610.         for (i = 0; i < 256; ++i)
  611.         {
  612.                 rscale[i] = ((i * rrange + 127) / 255) << rshift;
  613.                 gscale[i] = ((i * grange + 127) / 255) << gshift;
  614.                 bscale[i] = ((i * brange + 127) / 255) << bshift;
  615.         }
  617.         //  Fill in the RGB values for each combination of YUV
  618.         for (i = 0; i < 256; i += 4)
  619.         {
  620.                 y = translate_expand_y(i) + 2;
  621.                 if (y > 255) y = 255;
  622.                 for (u = 0; u < 32; ++u)
  623.                         for (v = 0; v < 32; ++v)
  624.                         {
  625.                                 //  Red, Green and Blue
  626.                                 r = y + rv[v];
  627.                                 g = y + gu[u] + gv[v];
  628.                                 b = y + bu[u];
  629.                                 //  Saturate
  630.                                 if (r < 0) r = 0; else if (r > 254) r = 254;
  631.                                 if (g < 0) g = 0; else if (g > 254) g = 254;
  632.                                 if (b < 0) b = 0; else if (b > 254) b = 254;
  633.                                 //  scale, shift and combine
  634.                                 *lut++ = rscale[r] + gscale[g] + bscale[b];
  635.                         }
  636.         }
  637.         return 1;
  638. }
  640. static int
  641. translate_yuyv_rgb16(struct translation *xlat)
  642. {
  643.         __u32        *src, *dst;
  644.         __u32        uv, yuv0, yuv1, dual;
  645.         __u16        *lut;
  646.         int        stride;
  647.         int        row, i;
  649.         if (!translate_make_rgb16_lut(xlat))
  650.                 return 0;
  651.         lut = xlat->lut.table.rgb16;
  652.         src = (__u32 *)xlat->in;
  653.         dst = (__u32 *)xlat->out;
  654.         if (src == NULL || dst == NULL)
  655.                 return 0;
  656.         stride = (xlat->out_stride - xlat->width * 2) >> 2;
  657.         for (row = xlat->height; row; --row)
  658.         {
  659.                 for (i = xlat->width >> 1; i; --i)
  660.                 {
  661.                         dual = *src++;
  662.                         uv   =    ((dual & 0x0000F800) >> 6)
  663.                                 + ((dual & 0xF8000000) >> 27);
  664.                         yuv1 =           ((dual & 0x00FC0000) >> 8) + uv;
  665.                         yuv0 =           ((dual & 0x000000FC) << 8) + uv;
  666.                         *dst++ = ((__u32)lut[yuv1] << 16) | lut[yuv0];
  667.                 }
  668.                 dst += stride;
  669.         }
  670.         return 1;
  671. }
  673. static int
  674. translate_make_rgb24_lut(struct translation *xlat)
  675. {
  676.         struct lookup_rgb24        *lut;
  677.         int                        r, g, b;
  678.         int                        i;
  679. int    j;
  680.         int                        x;
  682.         if (xlat->lut.type == LUT_RGB24)
  683.                 return 1;
  685.         if (xlat->lut.table.base)
  686.                 vfree(xlat->lut.table.base);
  687.         xlat->lut.table.base = vmalloc(sizeof(struct lookup_rgb24));
  688.         if (xlat->lut.table.base == NULL)
  689.         {
  690.                 err_msg("vmalloc() failed in make_rgb24_lutn");
  691.                 return 0;
  692.         }
  693.         xlat->lut.type = LUT_RGB24;
  694.         lut = xlat->lut.table.rgb24;
  696.         for (i = 0; i < 256; ++i)
  697.         {
  698.                 x = i;                // Value is in excess-128 format
  699.                 if (x < 128)
  700.                         ++x;        // Add 1 to negative values for noise rejection
  701.                 x -= 128;        // Convert to two's complement format
  702.                 x = translate_expand_c(x);
  704.                 g = (K12_GU * x + K12_1/2) >> K12_S;
  705.                 b = (K12_BU * x + K12_1/2) >> K12_S;
  706.                 lut->u_rgb[i] = ((g & 0x3FF) << 11) | (b & 0x3FF);
  708.                 r = (K12_RV * x + K12_1/2) >> K12_S;
  709.                 g = (K12_GV * x + K12_1/2) >> K12_S;
  710.                 lut->v_rgb[i] = (r << 22) | ((g & 0x3FF) << 11);
  711.                 
  712.                 x = translate_expand_y(i);
  713.                 lut->y_rgb[i] = (x << 22) | (x << 11) | x;
  714.         }
  715.         for (i = 0; i < 1024; ++i)
  716.         {
  717.                 x = (i > 511) ? 0 : ((i > 255) ? 255 : i);
  718.                 lut->sat[i] = x;
  719. lut->sat8[i] = x << 8;
  720. lut->sat16[i] = x << 16;
  721.         }
  722. for(i=0; i < 256; i++) {
  723. for(j = 0; j < 256; j++) {
  724. lut->uv_rgb[i*256 + j] = lut->u_rgb[i]  + lut->v_rgb[j];
  725. }
  726. }
  727.         return 1;
  728. }
  730. static int
  731. translate_yuyv_rgb24(struct translation *xlat)
  732. {
  733.         struct lookup_rgb24        *lut;
  734.         __u32                        *src;
  735.         __u32                        *dst;
  736. union pixel {
  737. __u32 yuyv;
  738. __u8 part[4];
  739. } pixel_data;
  740.         int                        i;
  741.         int                        row;
  742.         int                        stride;
  743.         __u32                        pela, pelb, pelc, peld;
  745.         if (!translate_make_rgb24_lut(xlat))
  746.                 return 0;
  747.         lut = xlat->lut.table.rgb24;
  748.         src = (__u32 *)xlat->in;
  749.         dst = (__u32 *)xlat->out;
  750.         if (src == NULL || dst == NULL)
  751.                 return 0;
  752.         stride = (xlat->out_stride - 3 * xlat->width) >> 2;
  753.         for (row = xlat->height; row; --row)        {
  754.                 for (i = xlat->width >> 2; i; --i)
  755.                 {
  756. pixel_data.yuyv = *src++;
  758.                         pelb  = lut->u_rgb[pixel_data.part[1]]
  759.                               + lut->v_rgb[pixel_data.part[3]];
  760.                         pela  = lut->y_rgb[pixel_data.part[0]] + pelb;
  761.                         pelb += lut->y_rgb[pixel_data.part[2]];
  762. pixel_data.yuyv = *src++;
  763.                         peld  = lut->u_rgb[pixel_data.part[1]]
  764.                               + lut->v_rgb[pixel_data.part[3]];
  765.                         pelc  = lut->y_rgb[pixel_data.part[0]] + peld;
  766.                         peld += lut->y_rgb[pixel_data.part[2]];
  769.                         dst[0] = ((u32)lut->sat[pela & 0x3FF])
  770.                                + ((u32)lut->sat[(pela >> 11) & 0x3FF] << 8)
  771.                                + ((u32)lut->sat[pela >> 22] << 16)
  772.                                + ((u32)lut->sat[pelb & 0x3FF] << 24);
  773.                         dst[1] = ((u32)lut->sat[(pelb >> 11) & 0x3FF])
  774.                                + ((u32)lut->sat[pelb >> 22] << 8)
  775.                                + ((u32)lut->sat[pelc & 0x3FF] << 16)
  776.                                + ((u32)lut->sat[(pelc >> 11) & 0x3FF] << 24);
  777.                         dst[2] = ((u32)lut->sat[pelc >> 22])
  778.                                + ((u32)lut->sat[peld & 0x3FF] << 8)
  779.                                + ((u32)lut->sat[(peld >> 11) & 0x3FF] << 16)
  780.                                + ((u32)lut->sat[peld >> 22] << 24);
  781.                         dst += 3;
  782.                 }
  783.                 dst += stride;
  784.         }
  786.         return 1;
  787. }
  789. static int
  790. translate_yuyv_rgb32(struct translation *xlat)
  791. {
  792.         struct lookup_rgb24        *lut;
  793.         __u32                        *src;
  794.         __u32                        *dst;
  795. union pixel {
  796. __u32 yuyv;
  797. __u8 part[4];
  798. } pixel_data;
  799.         int                        i;
  800.         int                        row;
  801.         int                        stride;
  802.         __u32                        pela, pelb;
  804.         if (!translate_make_rgb24_lut(xlat))
  805.                 return 0;
  807.         lut = xlat->lut.table.rgb24;
  808.         src = (__u32 *)xlat->in;
  809.         dst = (__u32 *)xlat->out;
  810.         if (src == NULL || dst == NULL)
  811.                 return 0;
  812.         stride = (xlat->out_stride - 4 * xlat->width) >> 2;
  813.         for (row = xlat->height; row; --row)
  814.         {
  815.                 for (i = xlat->width >> 1; i--;)
  816.                 {
  817. pixel_data.yuyv = *src++;
  818.                         pelb  = lut->u_rgb[pixel_data.part[1]] + 
  819. lut->v_rgb[pixel_data.part[3]];
  820.                         pela  = lut->y_rgb[pixel_data.part[0]] + pelb;
  821.                         pelb += lut->y_rgb[pixel_data.part[2]];
  823.                         dst[0] =  lut->sat[pela & 0x3FF]
  824.                                + (lut->sat8[(pela >> 11) & 0x3FF])
  825.                                + (lut->sat16[pela >> 22]);
  826.                         dst[1] =  lut->sat[pelb & 0x3FF]
  827.                                + (lut->sat8[(pelb >> 11) & 0x3FF])
  828.                                + (lut->sat16[pelb >> 22]);
  829.                         dst += 2;
  830.                 }
  831.                 dst += stride;
  832.         }
  834.         return 1;
  835. }
  838. static void
  839. translate_close(struct capture_device *dev)
  840. {
  841.         dev->translation.type = XLAT_NULL;
  842.         dev->translation.in = NULL;
  843.         dev->translation.out = NULL;
  844.         dev->translation.lut.type = LUT_NULL;
  845.         if (dev->translation.lut.table.base)
  846.                 vfree(dev->translation.lut.table.base);
  847.         dev->translation.lut.table.base = NULL;
  849.         if (dev->xlat_temp)
  850.                 vfree(dev->xlat_temp);
  851.         dev->xlat_temp = NULL;
  852. }
  854. static int
  855. translate_setup(struct capture_device *dev)
  856. {
  857.         int        npix2;
  858.         translate_close(dev);
  860.         /*  Translation: YUYV to client format */
  861.         dev->translation.width = dev->clientfmt.width;
  862.         dev->translation.height = dev->clientfmt.height;
  863.         dev->translation.in_stride = dev->translation.width * 2;
  864.         dev->translation.output_size = dev->clientfmt.sizeimage;
  866.         npix2 = dev->translation.width * dev->translation.height;
  867.         switch (dev->clientfmt.pixelformat)
  868.         {
  869.         case V4L2_PIX_FMT_YUYV:
  870.                 dev->translation.type = XLAT_NULL;
  871.                 break;
  872.         case V4L2_PIX_FMT_GREY:
  873.                 dev->translation.type = XLAT_YUYV_TO_GREY;
  874.                 dev->translation.out_stride = dev->translation.width;
  875.                 break;
  876.         case V4L2_PIX_FMT_YUV420:
  877.                 dev->translation.type = XLAT_YUYV_TO_YUV420;
  878.                 dev->translation.out_stride = dev->translation.width;
  879.                 break;
  880.         case V4L2_PIX_FMT_RGB555:
  881.         case V4L2_PIX_FMT_RGB565:
  882.                 dev->translation.type = (dev->clientfmt.pixelformat == 
  883.                         V4L2_PIX_FMT_RGB555) ? XLAT_YUYV_TO_RGB555 
  884.                         : XLAT_YUYV_TO_RGB565;
  885.                 dev->translation.out_stride = dev->translation.width * 2;
  886.                 if (!translate_make_rgb16_lut(&dev->translation))
  887.                         return 0;
  888.                 break;
  890.         case V4L2_PIX_FMT_BGR24:
  891.                 dev->translation.type = XLAT_YUYV_TO_RGB24;
  892.                 dev->translation.out_stride = dev->translation.width * 3;
  893.                 if (!translate_make_rgb24_lut(&dev->translation))
  894.                         return 0;
  895.                 break;
  897. #ifdef NEVER
  898.         case V4L2_PIX_FMT_BGR24:
  899.                 dev->translation.type = XLAT_NULL;
  900.                 break;
  901. #endif
  903.         case V4L2_PIX_FMT_BGR32:
  904.                 dev->translation.type = XLAT_YUYV_TO_RGB32;
  905.                 dev->translation.out_stride = dev->translation.width * 4;
  906.                 if (!translate_make_rgb24_lut(&dev->translation))
  907.                         return 0;
  908.                 break;
  909.         }
  910.         return 1;
  911. }
  913. static void
  914. translate_inandout(struct capture_device *dev,
  915.                    __u8 *input_buffer,
  916.                    __u8 *output_buffer,
  917.                    __u8 output_is_user_space)
  918. {
  919.         /*  Translation: YUYV to client format */
  920.         dev->translation.in = input_buffer;
  921.         dev->translation.out = output_buffer;
  922.         dev->translation.output_is_user = output_is_user_space;
  923. }
  925. static int /* length of output image or negative error */
  926. translate_image(struct capture_device *dev,
  927.                 __u8        *input_buffer,
  928.                 __u8        *output_buffer,
  929.                 int        len,
  930.                 int        output_is_user)
  931. {
  932.         int        err;
  934.         /* The buffer must be large enough for the whole image */
  935.         if (len < dev->translation.output_size)
  936.         {
  937.                 debug_msg("Read buffer too small, %d < %dn",
  938.                           len, dev->translation.output_size);
  939.                 return -EFAULT;
  940.         }
  941.         if (len > dev->translation.output_size)
  942.                 len = dev->translation.output_size;
  944.         translate_inandout(dev, input_buffer, output_buffer, output_is_user);
  946.         /*  Translation: YUYV to client format */
  947.         if (dev->translation.type == XLAT_NULL)
  948.         {
  949.                 if (dev->translation.in == dev->translation.out)
  950.                         return len;
  951.                 if (!output_is_user) 
  952. {
  953.                         memcpy(output_buffer, dev->translation.in, len);
  954. }
  955.                 else
  956.                 {
  957.                         err = copy_to_user(output_buffer, 
  958.                                            dev->translation.in, len);
  959.                         len = (err) ? -EFAULT : len;
  960.                 }
  961.                 return len;
  962.         }
  964.         if (output_is_user && !access_ok(VERIFY_WRITE, output_buffer, len))
  965.         {
  966.                 debug_msg("Buffer verify failed in translate_imagen");
  967.                 return -EFAULT;
  968.         }
  970.         switch (dev->translation.type)
  971.         {
  972.         case XLAT_YUYV_TO_GREY:
  973.                 translate_yuyv_grey(&dev->translation);
  974.                 break;
  975.         case XLAT_YUYV_TO_YUV420:
  976.                 translate_yuyv_yuv420(&dev->translation);
  977.                 break;
  978.         case XLAT_YUYV_TO_RGB555:
  979.         case XLAT_YUYV_TO_RGB565:
  980.                 translate_yuyv_rgb16(&dev->translation);
  981.                 break;
  982.         case XLAT_YUYV_TO_RGB24:
  983.                 translate_yuyv_rgb24(&dev->translation);
  984.                 break;
  985.         case XLAT_YUYV_TO_RGB32:
  986.                 translate_yuyv_rgb32(&dev->translation);
  987.                 break;
  988.         default:
  989.                 debug_msg("Unknown image translationn");
  990.                 break;
  991.         }
  992.         dev->translation.out = NULL;
  993.         return len;
  994. }
  996. /*
  997.  *
  998.  *        V I D E O   C A P T U R E   F U N C T I O N S
  999.  *
  1000.  */
  1002. /*
  1003.  *  Supported capture formats (for VIDIOC_ENUM_CAPFMT)
  1004.  */
  1005. static struct v4l2_fmtdesc capfmt[] = 
  1006. {
  1007.         {        0, {"RGB-16 (5-5-5)"},
  1008.                 V4L2_PIX_FMT_RGB555,  V4L2_FMT_FLAG_SWCONVERSION, 16, {0, 0},
  1009.         },
  1010.         {        1, {"RGB-16 (5-6-5)"},
  1011.                 V4L2_PIX_FMT_RGB565,  V4L2_FMT_FLAG_SWCONVERSION, 16, {0, 0},
  1012.         },
  1013.         {        2, {"RGB-24 (B-G-R)"},
  1014.                 V4L2_PIX_FMT_BGR24,   V4L2_FMT_FLAG_SWCONVERSION, 24, {0, 0},
  1015.         },
  1016.         {        3, {"RGB-32 (B-G-R-?)"},
  1017.                 V4L2_PIX_FMT_BGR32,   V4L2_FMT_FLAG_SWCONVERSION, 32, {0, 0},
  1018.         },
  1019.         {        4, {"Greyscale-8"},
  1020.                 V4L2_PIX_FMT_GREY,    V4L2_FMT_CS_601YUV | V4L2_FMT_FLAG_SWCONVERSION, 8, {0, 0},
  1021.         },
  1022.         {        5, {"YUV 4:2:2 (Y-U-Y-V)"},
  1023.                 V4L2_PIX_FMT_YUYV,    V4L2_FMT_CS_601YUV, 16, {0, 0},
  1024.         },
  1025.         {        6, {"YUV 4:2:0 (planar)"},
  1026.                 V4L2_PIX_FMT_YUV420,  V4L2_FMT_CS_601YUV | V4L2_FMT_FLAG_SWCONVERSION, 12, {0, 0},
  1027.         },
  1028. };
  1029. #define NUM_CAPFMT (sizeof(capfmt)/sizeof(capfmt[0]))
  1032. static void interrupt_enable(struct capture_device *dev);
  1034. /*  The image format has changed, width, height, pixel format.
  1035.  *  Decide if the format is ok or take the closest valid format.
  1036.  */
  1037. static int
  1038. capture_new_format(struct capture_device *dev)
  1039. {
  1040.         dev->ready_to_capture = 0;
  1042.         switch (dev->standard) {
  1044.                 case V4L2_STD_NTSC:
  1045.                         dev->source_width = 704;
  1046.                         dev->source_height = 240;
  1047.                         break;
  1049.                 case V4L2_STD_PAL:
  1050.                         dev->source_width = 704;
  1051.                         dev->source_height = 290;
  1052.                         break;
  1054.                 case V4L2_STD_SECAM:
  1055.                         dev->source_width = 704;
  1056.                         dev->source_height = 290;
  1057.                         break;
  1058.         }
  1061. dev->clientfmt.flags &= ~V4L2_FMT_CS_field;
  1062.         dev->clientfmt.flags |= V4L2_FMT_CS_601YUV;
  1064.         switch (dev->clientfmt.pixelformat)
  1065.         {
  1066.         case V4L2_PIX_FMT_GREY:
  1067.                 dev->clientfmt.depth = 8;
  1068.                 break;
  1069.         case V4L2_PIX_FMT_YUV420:
  1070.                 dev->clientfmt.depth = 12;
  1071.                 break;
  1072.         case V4L2_PIX_FMT_RGB555:
  1073.         case V4L2_PIX_FMT_RGB565:
  1074.                 dev->clientfmt.flags = 0;
  1075.                 /* fall thru */
  1076.         case V4L2_PIX_FMT_YUYV:
  1077.         case V4L2_PIX_FMT_UYVY:
  1078.                 dev->clientfmt.depth = 16;
  1079.                 break;
  1080.         case V4L2_PIX_FMT_BGR24:
  1081.                 dev->clientfmt.depth = 24;
  1082.                 dev->clientfmt.flags = 0;
  1083.                 break;
  1084.         case V4L2_PIX_FMT_BGR32:
  1085.                 dev->clientfmt.depth = 32;
  1086.                 dev->clientfmt.flags = 0;
  1087.                 break;
  1088.         default:
  1089.                 debug_msg("unknown format %4.4sn",
  1090.                           (char *)&dev->clientfmt.pixelformat);
  1091.                 dev->clientfmt.depth = 16;
  1092.                 dev->clientfmt.pixelformat = V4L2_PIX_FMT_YUYV;
  1093.                 dev->clientfmt.flags = 0;
  1094.                 break;
  1095.         }
  1097.         dev->capture_bypp = 2;
  1099. if (dev->clientfmt.height <= dev->source_height)
  1100. dev->clientfmt.flags &= ~V4L2_FMT_FLAG_INTERLACED;
  1103. if (dev->clientfmt.flags & V4L2_FMT_FLAG_INTERLACED) {
  1104. dev->clientfmt.flags |= V4L2_FMT_FLAG_TOPFIELD | 
  1105. V4L2_FMT_FLAG_BOTFIELD;
  1107. if (dev->clientfmt.height > dev->source_height * 2)
  1108. dev->clientfmt.height = dev->source_height * 2;
  1109. if (dev->clientfmt.height < 32)
  1110. dev->clientfmt.height = 32;
  1111. } else {
  1112. /* Make sure that at least 1 field is requested */
  1113. if ((dev->clientfmt.flags & 
  1114.      (V4L2_FMT_FLAG_TOPFIELD | V4L2_FMT_FLAG_BOTFIELD)) == 0) 
  1115. dev->clientfmt.flags |= V4L2_FMT_FLAG_TOPFIELD;
  1117. if (dev->clientfmt.height > dev->source_height)
  1118. dev->clientfmt.height = dev->source_height;
  1119. if (dev->clientfmt.height < 32)
  1120. dev->clientfmt.height = 32;
  1121. }
  1123. if (dev->clientfmt.width > dev->source_width)
  1124. dev->clientfmt.width = dev->source_width;
  1125. if (dev->clientfmt.width < 32)
  1126. dev->clientfmt.width = 32;
  1128. dev->clientfmt.width  &= ~3;
  1130. mgavideo_set_dims(dev->mga, dev->clientfmt.width, dev->clientfmt.height);
  1132. dev->clientfmt.sizeimage = (dev->clientfmt.width
  1133.                 * dev->clientfmt.height
  1134.                 * dev->clientfmt.depth)
  1135.                 / 8;
  1137. dev->clientfmt.flags |= V4L2_FMT_FLAG_BYTESPERLINE;
  1138. dev->clientfmt.bytesperline = (dev->clientfmt.width * 
  1139. dev->clientfmt.depth) / 8;
  1141.         dev->capture_size = dev->clientfmt.width
  1142.                 * dev->clientfmt.height
  1143.                 * dev->capture_bypp;
  1146.         /*  TODO: Any other driver state related to the image format  */
  1147.         return 1;
  1148. }
  1150. /*  Stop the music!
  1151.  */
  1152. static void
  1153. capture_abort(struct capture_device *dev)
  1154. {
  1155.         dev->grabber_enabled = 0;
  1156.         /*  Turn off the capture hardware  */
  1157.         grabbing_enable(dev, 0);
  1158. }
  1160. /*  Allocate buffers, and get everything ready to capture
  1161.  *  an image, but don't start capturing yet.
  1162.  */
  1163. static int
  1164. capture_begin(struct capture_device *dev)
  1165. {
  1166.         capture_abort(dev);
  1167.         if (dev->ready_to_capture)
  1168.                 return dev->ready_to_capture;
  1170.         if (!translate_setup(dev))
  1171.                 return dev->ready_to_capture;
  1173.         interrupt_enable(dev);
  1174.         return (dev->ready_to_capture = 1);
  1175. }
  1177. /*  Start an image capture
  1178.  */
  1179. static void
  1180. capture_grab_frame(struct capture_device *dev)
  1181. {
  1182.         if (dev->ready_to_capture && dev->grabber_enabled) {
  1183.                 return;
  1184. }
  1186.         capture_begin(dev);
  1187.         if (!dev->ready_to_capture) 
  1188.                 return;
  1190.         /*  TODO: Prepare the hardware for the next capture  */
  1192.         /*  Set up stream_capture_buffer to point to the buffer to  */
  1193.         /*  capture the next frame into  */
  1194.         if (dev->streaming)
  1195.         {
  1196.                 struct stream_buffer        *buf;
  1198.                 /* Go straight into streaming buffer? */
  1199.                 if (dev->translation.type == XLAT_NULL)
  1200.                 {
  1201.                         buf = v4l2_q_peek_head(&dev->stream_q_capture);
  1202.                         if (buf != NULL)
  1203.                         {
  1204.                                 //XXX no streaming yet dev->stream_capture_buffer = buf->vaddress;
  1205.                                 //list = buf->dma_list;
  1206.                         }
  1207.                 }
  1208.         }
  1210.         /*  Start the hardware  */
  1211.         grabbing_enable(dev, 1);
  1213.         dev->grabber_enabled = 1;
  1214.         dev->capture_completed = 0;
  1215. }
  1217. /*
  1218.  *        STREAMING CAPTURE
  1219.  */
  1221. static int/* 1 = success; 0 = failed */
  1222. capture_queuebuffer(struct capture_device *dev,
  1223.                     struct v4l2_buffer          *vidbuf)
  1224. {
  1225.         int                        i        = vidbuf->index;
  1226.         struct stream_buffer        *buf        = NULL;
  1228.         if (!dev->stream_buffers_mapped)
  1229.         {
  1230.                 debug_msg("QBUF no buffers mappedn");
  1231.                 return 0;
  1232.         }
  1233.         if (vidbuf->type != V4L2_BUF_TYPE_CAPTURE)
  1234.         {
  1235.                 debug_msg("QBUF wrong typen");
  1236.                 return 0;
  1237.         }
  1238.         if (i < 0 || i >= MAX_CAPTURE_BUFFERS || !dev->stream_buf[i].requested)
  1239.         {
  1240.                 debug_msg("QBUF buffer index %d is out of rangen", i);
  1241.                 return 0;
  1242.         }
  1244.         buf = &dev->stream_buf[i];
  1246.         if (!(buf->vidbuf.flags & V4L2_BUF_FLAG_MAPPED))
  1247.         {
  1248.                 debug_msg("QBUF buffer %d is not mappedn", i);
  1249.                 return 0;
  1250.         }
  1251.         if ((buf->vidbuf.flags & V4L2_BUF_FLAG_QUEUED))
  1252.         {
  1253.                 debug_msg("QBUF buffer %d is already queuedn", i);
  1254.                 return 0;
  1255.         }
  1257.         buf->vidbuf.flags &= ~V4L2_BUF_FLAG_DONE;
  1258.         v4l2_q_add_tail(&dev->stream_q_capture, &buf->qnode);
  1259.         buf->vidbuf.flags |= V4L2_BUF_FLAG_QUEUED;
  1260.         return 1;
  1261. }
  1263. static int/* 1 = got a buffer; 0 = no buffers */
  1264. capture_dequeuebuffer(struct capture_device *dev,
  1265.                       struct v4l2_buffer *buf)
  1266. {
  1267.         struct stream_buffer *newbuf;
  1269.         if (!dev->streaming || buf->type != V4L2_BUF_TYPE_CAPTURE)
  1270.         {
  1271.                 debug_msg("DQBUF not streaming or wrong buffer typen");
  1272.                 return 0;
  1273.         }
  1274.         newbuf = v4l2_q_del_head(&dev->stream_q_done);
  1275.         if (newbuf == NULL)
  1276.         {
  1277.                 debug_msg("DQBUF nothing on done queuen");
  1278.                 return 0;
  1279.         }
  1280.         newbuf->vidbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
  1282.         *buf = newbuf->vidbuf;
  1283.         return 1;
  1284. }
  1286. static int
  1287. capture_streamon(struct capture_device        *dev,
  1288.                  __u32                        type)
  1289. {
  1290.         struct stream_buffer *buf;
  1292.         if (dev->streaming)
  1293.                 return 1;
  1295.         if (type != V4L2_BUF_TYPE_CAPTURE)
  1296.         {
  1297.                 debug_msg("STREAMON wrong buffer typen");
  1298.                 return 0;
  1299.         }
  1301.         capture_abort(dev);/* cancel any capture that might be in progress */
  1303.         /*  -2 is a magic number that triggers start-of-stream logic in */
  1304.         /*    capture_interrupt()  */
  1305.         dev->stream_last_frame = -2;
  1307.         dev->perf.frames = 0;
  1308.         dev->perf.framesdropped = 0;
  1309.         dev->perf.bytesout = 0;
  1311.         /*  Can't capture frames faster than the video input  */
  1312.         if (dev->capture.timeperframe < dev->frame_period)
  1313.                 dev->capture.timeperframe = dev->frame_period;
  1315.         /*  Move any leftover DONE buffers to the free pool */
  1316.         while ((buf = v4l2_q_del_head(&dev->stream_q_done)))
  1317.                 buf->vidbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
  1319.         /*  Kick off the machine */
  1320.         dev->streaming = 1;
  1321.         capture_grab_frame(dev);
  1322.         return 1;
  1323. }
  1325. static void
  1326. capture_streamoff(struct capture_device        *dev,
  1327.                  __u32                        type)
  1328. {
  1329.         if (!dev->streaming)
  1330.                 return;
  1331.         if (type != V4L2_BUF_TYPE_CAPTURE)
  1332.         {
  1333.                 debug_msg("STREAMOFF wrong buffer typen");
  1334.                 return;
  1335.         }
  1336.         capture_abort(dev);
  1337.         dev->streaming = 0;
  1339.         /* Note: should really delay this till next capture */
  1340.         dev->perf.frames = 0;
  1341.         dev->perf.framesdropped = 0;
  1342.         dev->perf.bytesout = 0;
  1343. }
  1346. /*        Read out and convert the next frame
  1347.  */
  1348. static int /* returns length of data or negative for error */
  1349. capture_imagereadout(struct capture_device        *dev,
  1350.                      __u8                        *output_buffer,
  1351.                      int                        output_size,
  1352.                      int                        output_is_user)
  1353. {
  1354.         int        len;
  1355.         __u8*      input_buffer;
  1357.         dev->grabber_enabled = 0;
  1358.         grabbing_enable(dev, 0);
  1360. // XXX
  1361.         input_buffer = mgavideo_lock_video( dev->mga );
  1362.         len = translate_image(dev, input_buffer, output_buffer,
  1363.                               output_size, output_is_user);
  1364.         mgavideo_unlock_video( dev->mga );
  1366.         if (len < 0)
  1367.                 return len;
  1368.         ++dev->perf.frames;
  1369.         dev->perf.bytesout += len;
  1370.         return len;
  1371. }
  1373. /*  The hardware has issued the interrupt signal, do any post-capture
  1374.  *  processing that may be necessary.
  1375.  *  [This function is called indirectly through the immediate task queue;
  1376.  *  it executes at elevated IRQL, but it is interruptible. (It's a b.h.)]
  1377.  */
  1378. static void
  1379. capture_interrupt(void *v)
  1380. {
  1381.         struct capture_device        *dev = (struct capture_device *)v;
  1382.         struct stream_buffer        *buf;
  1383.         int                        len;
  1384.         struct timeval                timestamp_rough;
  1385.         unsigned long                raw_frame_num;
  1386.         unsigned long                next_raw_frame_to_keep;
  1387.         unsigned long                stream_frame_num;
  1388.         u64                        temp64;
  1390.         /*  TODO: Check for an interrupt pending on the device, and  */
  1391.         /*        return if there is no interrupt pending  */
  1392.         /*  (In this hardware-less demo I'll just check the completed flag) */
  1393.         if (!dev->grabber_enabled ||
  1394.             dev->capture_completed)
  1395.                 return;
  1397.         if (!dev->ints_enabled)
  1398.         {
  1399.                 err_msg("Can't process the interruptn");
  1400.                 return;
  1401.         }
  1402.         dev->capture_completed = 1;
  1404. {
  1405. struct timeval curr;
  1406. do_gettimeofday(&curr);
  1407. debug_msg("cap interrupt: time: %d:%dn", curr.tv_sec, curr.tv_usec);
  1408. }
  1410.         if (!dev->streaming)
  1411.         {
  1412.                 dev->time_acquired = current_time_ms();
  1413.                 /* DMA might not have finished, but we'll check in read() */
  1414.                 //debug_msg("New frame readyn");
  1415. debug_msg("interupt_cap: non_streaming wakup new_video_framen");
  1416.                 wake_up_interruptible(&dev->new_video_frame);
  1417.                 return;
  1418.         }
  1420.         /*  Only get here in streaming mode  */
  1422.         if (dev->stream_last_frame == -2)
  1423.         {/*        First frame of the stream  */
  1424.                 v4l2_masterclock_gettime(&dev->stream_begin);
  1425.                 dev->stream_last_frame = -1;
  1426.         }
  1428.         buf = v4l2_q_peek_head(&dev->stream_q_capture);
  1429.         if (buf == NULL)
  1430.         {/*        No available buffers. Skip this frame. This is not an  */
  1431.          /*        error, it's a normal way to throttle the capture rate  */
  1432.                 dev->grabber_enabled = 0;
  1433.                 grabbing_enable(dev, 0);
  1434.                 capture_grab_frame(dev);
  1435.                 return;
  1436.         }
  1438.         /*  Compute current stream time  */
  1439.         v4l2_masterclock_gettime(&timestamp_rough);
  1440.         v4l2_timeval_delta(&timestamp_rough,
  1441.                            &dev->stream_begin, &timestamp_rough);
  1443.         /*  Capture rate control  */
  1444.         raw_frame_num = v4l2_timeval_divide(
  1445.                 &timestamp_rough, dev->frame_period);
  1446.         temp64 = (u64)dev->capture.timeperframe
  1447.                 * (dev->stream_last_frame + 1)
  1448.                 + (dev->frame_period >> 1);
  1449.         next_raw_frame_to_keep = 
  1450.                 v4l2_math_div6432(temp64, dev->frame_period, NULL);
  1451. #if 0
  1452.         if (raw_frame_num < next_raw_frame_to_keep)
  1453.         {/*        Not time yet, don't keep this frame */
  1454.                 dev->grabber_enabled = 0;
  1455.                 grabbing_enable(dev, 0);
  1456.                 capture_grab_frame(dev);
  1457.                 return;
  1458.         }
  1459. #endif
  1460. {
  1461. struct timeval curr;
  1462. do_gettimeofday(&curr);
  1463. debug_msg("cap start: time: %d:%dn", curr.tv_sec, curr.tv_usec);
  1464. }
  1466.         /*  Want this frame  */
  1467.         len = capture_imagereadout(dev, buf->vaddress, buf->vidbuf.length, 0);
  1468. {
  1469. struct timeval curr;
  1470. do_gettimeofday(&curr);
  1471. debug_msg("cap end  : time: %d:%dn", curr.tv_sec, curr.tv_usec);
  1472. }
  1474.         if (len <= 0)
  1475.         {/*        Frame no good, DMA did not finish, etc. */
  1476.                 /*  Begin capturing the next frame now  */
  1477.                 capture_grab_frame(dev);
  1478.                 return;
  1479.         }
  1481.         /*  Fill in the buffer information fields  */
  1482.         buf->vidbuf.bytesused = len;
  1484. /* only mark as done if both frames for interlace have been
  1485.  * seen
  1486.  */
  1487.         buf->vidbuf.flags |= V4L2_BUF_FLAG_DONE | V4L2_BUF_FLAG_KEYFRAME;
  1488.         buf->vidbuf.timestamp = timestamp_rough;
  1489.         stream_frame_num = v4l2_timeval_correct(&buf->vidbuf.timestamp,
  1490.                                                 dev->capture.timeperframe);
  1491.         //debug_msg("Stream frame %4lu T= %lu.%06lun", stream_frame_num,
  1492.         //          buf->vidbuf.timestamp.tv_sec,buf->vidbuf.timestamp.tv_usec);
  1493.         if (stream_frame_num > dev->stream_last_frame + 1)
  1494.         {/*        We have missed one or more frames  */
  1495.                 dev->perf.framesdropped += stream_frame_num
  1496.                         - dev->stream_last_frame + 1;
  1497.         }
  1498.         dev->stream_last_frame = stream_frame_num;
  1500.         /*  Move buffer to done queue  */
  1501.         buf = v4l2_q_del_head(&dev->stream_q_capture);
  1502.         v4l2_q_add_tail(&dev->stream_q_done, &buf->qnode);
  1504.         /*  Begin capturing the next frame now  */
  1505.         capture_grab_frame(dev);
  1507.         /*  A new frame is ready!  */
  1508. debug_msg("interrupt_cap: waking up new_video_framen");
  1509.         wake_up_interruptible(&dev->new_video_frame);
  1510. }
  1513. /*  Read captured data into a user buffer.
  1514.  *  Return: negative = error
  1515.  *            0        = keep waiting
  1516.  *            positive = count of bytes read successfully
  1517.  */
  1518. static long
  1519. capture_read(struct capture_device *dev,
  1520.              __u8        *user_buffer,
  1521.              int        user_buffer_size)
  1522. {
  1523.         int                len = user_buffer_size;
  1524.         unsigned long        now;
  1526.         if (!dev->ints_enabled)
  1527.                 return -EIO;
  1529.         if (!dev->capture_completed)
  1530.         {/* No interrupt has occurred yet, or DMA didn't finish.  */
  1531.                 //debug_msg("No data ready.n");
  1532.                 if (!dev->grabber_enabled)
  1533.                         capture_grab_frame(dev);
  1534.                 return 0;/* caller should keep waiting */
  1535.         }
  1536.         
  1537.         now = current_time_ms();
  1538.         if (now - dev->time_acquired > MAX_FRAME_AGE)
  1539.         {/* Frame in buffer is stale, get a new one */
  1540.                 debug_msg("Stale frame, re-acquiring.n");
  1541.                 dev->grabber_enabled = 0;
  1542.                 grabbing_enable(dev, 0);
  1543.                 capture_grab_frame(dev);
  1544.                 return 0;/* caller should keep waiting */
  1545.         }
  1547.         len = capture_imagereadout(dev, user_buffer, user_buffer_size, 1);
  1548.         capture_grab_frame(dev);
  1549.         return len;
  1550. }
  1552. /*  Stop capturing and free all resources used for capture.
  1553.  */
  1554. static void
  1555. capture_close(struct capture_device *dev)
  1556. {
  1557.   //        int        i;
  1559.         if (dev->streaming)
  1560.                 capture_streamoff(dev, V4L2_BUF_TYPE_CAPTURE);
  1561.         capture_abort(dev);
  1562.         dev->ready_to_capture = 0;
  1563.         translate_close(dev);
  1564.         if (dev->capture_dma_list)
  1565.                 free_page((unsigned long)dev->capture_dma_list);
  1566.         dev->capture_dma_list = 0;
  1567. #if 0
  1568.         for (i = 0; i < MAX_CAPTURE_BUFFERS; ++i)
  1569.         {
  1570.                 dev->stream_buf[i].requested = 0;
  1571.                 if (dev->stream_buf[i].vaddress)
  1572.                         vfree(dev->stream_buf[i].vaddress);
  1573.                 dev->stream_buf[i].vaddress = NULL;
  1574.                 if (dev->stream_buf[i].dma_list)
  1575.                         free_page((unsigned long)dev->stream_buf[i].dma_list);
  1576.                 dev->stream_buf[i].dma_list = NULL;
  1577.         }
  1578. #endif
  1579. }
  1581. /*
  1582.  *
  1583.  *        I N T E R R U P T   R O U T I N E S
  1584.  *
  1585.  */
  1587. static void
  1588. interrupt_disable(struct capture_device *dev)
  1589. {
  1590.         if (!dev->ints_enabled)
  1591.                 return;
  1592.         dev->ints_enabled = 0;
  1594.         /*  TODO: Disable interrupts on the device  */
  1595.         mgavideo_ivsync_enable( dev->mga, 0 );
  1597.         /*  Wake up any processes that might be waiting for a frame  */
  1598.         /*  and let them return an error  */
  1599. debug_msg("interrupt_disable: waking up new_video_framen");
  1600.         wake_up_interruptible(&dev->new_video_frame);
  1601. }
  1603. static void
  1604. interrupt_enable(struct capture_device *dev)
  1605. {
  1606. int even_fields;
  1607. int odd_fields;
  1609.         if (dev->ints_enabled)
  1610.                 interrupt_disable(dev);
  1611.         dev->ints_enabled = 1;
  1613.         /*  TODO: Enable interrupts on the device  */
  1614. even_fields= (dev->clientfmt.flags & V4L2_FMT_FLAG_TOPFIELD) ? 1:0;
  1615. odd_fields = (dev->clientfmt.flags & V4L2_FMT_FLAG_BOTFIELD) ? 1:0;
  1617.         mgavideo_register_bh( dev->mga, even_fields, odd_fields,
  1618. capture_interrupt, dev );
  1620.         mgavideo_ivsync_enable( dev->mga, 1 );
  1621. }
  1623. /*
  1624.  *
  1625.  *        M E M O R Y   M A P P I N G
  1626.  *
  1627.  */
  1629. static struct stream_buffer *
  1630. mmap_stream_buffer_from_offset(struct capture_device *dev,
  1631.                                unsigned long offset)
  1632. {
  1633.         int        i;
  1634.         for (i = 0; i < MAX_CAPTURE_BUFFERS; ++i)
  1635.                 if (offset == dev->stream_buf[i].vidbuf.offset)
  1636.                         return &dev->stream_buf[i];
  1637.         return NULL;
  1638. }
  1640. static int
  1641. mmap_request_buffers(struct capture_device *dev,
  1642.                      struct v4l2_requestbuffers *req)
  1643. {
  1644.         int        i;
  1645.         u32        buflen;
  1646.         u32        type;
  1648.         if (dev->stream_buffers_mapped)
  1649.                 return 0;/* can't make requests if buffers are mapped */
  1650.         if (req->count < 1)
  1651.                 req->count = 1;
  1652.         if (req->count > MAX_CAPTURE_BUFFERS)
  1653.                 req->count = MAX_CAPTURE_BUFFERS;
  1654.         type = V4L2_BUF_TYPE_CAPTURE;
  1655.         dev->stream_contig_map = 0;
  1656.         if (req->type & V4L2_BUF_REQ_CONTIG)
  1657.         {
  1658.                 dev->stream_contig_map = 1;
  1659.                 req->type = type | V4L2_BUF_REQ_CONTIG;
  1660.                 /* note: _REQ_CONTIG is only used in v4l2_requestbuffers */
  1661.         }
  1663.         /*  The buffer length needs to be a multiple of the page size  */
  1664.         buflen = (dev->clientfmt.sizeimage + PAGE_SIZE - 1)
  1665.                 & ~(PAGE_SIZE - 1);
  1667.         debug_msg("Granting %d buffersn",req->count);
  1669.         /*  Now initialize the buffer structures. Don't allocate the */
  1670.         /*  buffers until they're mapped. */
  1671.         for (i = 0; i < req->count; ++i)
  1672.         {
  1673.                 dev->stream_buf[i].requested = 1;
  1674.                 dev->stream_buf[i].vidbuf.index = i;
  1675.                 dev->stream_buf[i].vidbuf.type = type;
  1676.                 dev->stream_buf[i].vidbuf.offset = 4*i;/* anything unique */
  1677.                 dev->stream_buf[i].vidbuf.length = buflen;
  1678.                 dev->stream_buf[i].vidbuf.bytesused = 0;
  1679.                 dev->stream_buf[i].vidbuf.timestamp.tv_sec = 0;
  1680.                 dev->stream_buf[i].vidbuf.timestamp.tv_usec = 0;
  1681.                 dev->stream_buf[i].vidbuf.flags = 0;
  1682.         }
  1683.         for (i = req->count; i < MAX_CAPTURE_BUFFERS; ++i)
  1684.                 dev->stream_buf[i].requested = 0;
  1685.         dev->stream_buffers_requested = req->count;
  1687.         return 1;
  1688. }
  1690. static void
  1691. mmap_unrequest_buffers(struct capture_device *dev)
  1692. {
  1693.         int        i;
  1695.         if (dev->stream_buffers_requested == 0 ||
  1696.             dev->stream_buffers_mapped)
  1697.                 return;
  1698.         for (i = 0; i < MAX_CAPTURE_BUFFERS; ++i)
  1699.                 dev->stream_buf[i].requested = 0;
  1700.         dev->stream_buffers_requested = 0;
  1701. }
  1703. static void
  1704. mmap_vma_open(struct vm_area_struct *vma)
  1705. {
  1706.         struct capture_device *dev =
  1707.                 capture_device_from_file(vma->vm_file);
  1708.         if (dev == NULL)
  1709.                 return;
  1710.         //debug_msg("vma_open calledn");
  1711.         //MOD_INC_USE_COUNT;
  1712. }
  1714. static void
  1715. mmap_vma_close(struct vm_area_struct *vma)
  1716. {
  1717.         struct capture_device *dev =
  1718.                 capture_device_from_file(vma->vm_file);
  1719.         struct stream_buffer *buf =
  1720.                 mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  1721.         int        i, n = 1;
  1723.         if (dev->stream_contig_map)
  1724.         {/*        Unmap all the buffers in one stroke  */
  1725.                 n = dev->stream_buffers_mapped;
  1726.                 buf = &dev->stream_buf[0];
  1727.         }
  1728.         for (i = 0; i < n; ++i)
  1729.         {
  1730.                 if (dev->streaming)
  1731.                 {
  1732.                         info_msg("Warning- munmap() called while streamingn");
  1733.                         capture_streamoff(dev, buf->vidbuf.type);
  1734.                 }
  1735.                 v4l2_q_yank_node(&dev->stream_q_capture, &buf->qnode);
  1736.                 v4l2_q_yank_node(&dev->stream_q_done, &buf->qnode);
  1738.                 if (buf->vaddress != NULL && i == 0)
  1739.                         vfree(buf->vaddress);
  1740.                 buf->vaddress = NULL;
  1741.                 if (buf->dma_list)
  1742.                         free_page((unsigned long)buf->dma_list);
  1743.                 buf->dma_list = NULL;
  1744.                 buf->vidbuf.flags = 0;
  1745.                 //debug_msg("Buffer %d deallocatedn",(int)vma->vm_offset/4);
  1746.                 ++buf;
  1747.                 if (dev->stream_buffers_mapped > 0)
  1748.                         --dev->stream_buffers_mapped;
  1749.         }
  1750.         //MOD_DEC_USE_COUNT;
  1751. }
  1753. static unsigned long
  1754. mmap_vma_nopage(struct vm_area_struct *vma,
  1755.                 unsigned long address, int write)
  1756. {
  1757.         struct capture_device        *dev;
  1758.         struct stream_buffer        *buf;
  1759.         unsigned long                offset_into_buffer;
  1760.         unsigned long                page;
  1761.         int                        n        = 1;
  1763.         dev = capture_device_from_file(vma->vm_file);
  1764.         if (dev == NULL)
  1765.                 return 0;
  1766.         if (dev->stream_contig_map)
  1767.         {
  1768.                 buf = &dev->stream_buf[0];
  1769.                 n = dev->stream_buffers_requested;
  1770.         }        
  1771.         else
  1772.                 buf = mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  1773.         if (buf == NULL)
  1774.                 return 0;
  1775.         offset_into_buffer = address - vma->vm_start;
  1776.         if (offset_into_buffer >= buf->vidbuf.length * n)
  1777.         {
  1778.                 err_msg("Attempt to read past end of mmap() buffern");
  1779.                 return 0;
  1780.         }
  1781.         page = v4l2_vmalloc_to_page(buf->vaddress + offset_into_buffer);
  1782.         if (page == 0)
  1783.                 return 0;
  1785.         atomic_inc(&mem_map[MAP_NR(page)].count);
  1786.         return page;
  1787. }
  1789. static struct vm_operations_struct capture_vma_operations =
  1790. {
  1791.         mmap_vma_open, mmap_vma_close, NULL, NULL, NULL, NULL,
  1792.         mmap_vma_nopage,
  1793. };
  1796. /*
  1797.  *
  1798.  *        V I D E O   F O R   L I N U X   I N T E R F A C I N G
  1799.  *
  1800.  */
  1802. static int
  1803. v4l2_open(struct v4l2_device *v, int flags, void **idptr)
  1804. {
  1805.         struct capture_device *dev = (struct capture_device *)v;
  1806.         int        i, n;
  1807.         int        cap;
  1809.         for (i = 0, n = -1, cap = 0; i < MAX_OPENS; ++i)
  1810.         {
  1811.                 if (!dev->open_data[i].isopen)
  1812.                         n = i;/* available open_data structure */
  1813.                 else if (!dev->open_data[i].noncapturing)
  1814.                         cap = 1;/* another open is already capturing */
  1815.         }
  1816.         if (n == -1)/* No available open_data structures */
  1817.         {
  1818.                 debug_msg("No more opens on this devicen");
  1819.                 return -EBUSY;
  1820.         }
  1822.         if (flags & O_NONCAP)/*  Non-capturing open */
  1823.                 dev->open_data[n].noncapturing = 1;
  1824.         else if (cap)
  1825.         {
  1826.                 debug_msg("No more capturing opens on this devicen");
  1827.                 return -EBUSY;
  1828.         }
  1829.         else
  1830.         {
  1831.                 dev->open_data[n].noncapturing = 0;
  1832.                 /*  Keep track of whether there is a capturing open  */
  1833.                 ++dev->capturing_opens;
  1834.                 dev->perf.frames = 0;
  1835.                 dev->perf.framesdropped = 0;
  1836.                 dev->perf.bytesout = 0;
  1837.         }
  1839.         //MOD_INC_USE_COUNT;
  1840.         ++dev->open_count;
  1841.         dev->open_data[n].isopen = 1;
  1842.         dev->open_data[n].dev = dev;
  1843.         *idptr = &dev->open_data[n];
  1845.         if (dev->open_count == 1)
  1846.         {
  1847.                 dev->ready_to_capture = 0;/* benchmark changes parameters! */
  1848.                 dev->capture_completed = 0;
  1849.                 dev->grabber_enabled = 0;
  1850.                 v4l2_q_init(&dev->stream_q_capture);
  1851.                 v4l2_q_init(&dev->stream_q_done);
  1852.         }
  1853.         debug_msg("Open succeededn");
  1855.         /* frame counter for test images only */
  1856.         if (!dev->open_data[n].noncapturing)
  1857.                 dev->h=dev->m=dev->s=dev->f=0;
  1858.         return 0;
  1859. }
  1861. static void
  1862. v4l2_close(void *id)
  1863. {
  1864.         struct device_open *o = (struct device_open *)id;
  1865.         struct capture_device *dev = o->dev;
  1867.         if (!o->noncapturing)
  1868.         {
  1869.                 --dev->capturing_opens;
  1870.                 debug_msg("Closen");
  1871.         }
  1872.         o->isopen = 0;
  1873.         --dev->open_count;
  1874.         if (dev->open_count == 0)
  1875.         {
  1876.                 interrupt_disable(dev);
  1877.                 capture_close(dev);
  1878.         }
  1879.         //MOD_DEC_USE_COUNT;
  1880. }
  1882. static long
  1883. v4l2_write(void                *id, 
  1884.              const char                *buf, 
  1885.              unsigned long        count, 
  1886.              int                noblock)
  1887. {
  1888.         debug_msg("Write() not handledn");
  1889.         return -EINVAL;
  1890. }
  1892. /*  The arguments are already copied into kernel memory, so don't use
  1893.     copy_from_user() or copy_to_user() on arg.  */
  1894. static int
  1895. v4l2_ioctl(void                *id,
  1896.            unsigned int        cmd,
  1897.            void                *arg)
  1898. {
  1899.         struct device_open *o = (struct device_open *)id;
  1900.         struct capture_device *dev = o->dev;
  1902. //debug_msg("ioctl %dn", _IOC_NR(cmd));
  1903.         switch(cmd)
  1904.         {
  1905.         case VIDIOC_QUERYCAP:
  1906.         {
  1907.                 struct v4l2_capability *b = arg;
  1908.                 strcpy(b->name, dev->v.name);
  1909.                 b->type = V4L2_TYPE_CAPTURE;
  1910.                 b->flags = V4L2_FLAG_READ |
  1911.                            V4L2_FLAG_STREAMING |
  1912.                            V4L2_FLAG_PREVIEW |
  1913.                            V4L2_FLAG_TUNER |
  1914.                            V4L2_FLAG_SELECT;
  1915.                 b->inputs = KS_INPUT_COUNT;
  1916.                 b->outputs = 0;
  1917.                 b->audios = 0;
  1918.                 b->maxwidth = MAX_WIDTH;
  1919.                 b->maxheight = MAX_HEIGHT;
  1920.                 b->minwidth = MIN_WIDTH;
  1921.                 b->minheight = MIN_HEIGHT;
  1922.                 b->maxframerate = 30;
  1923.                 return 0;
  1924.         }
  1926.         case VIDIOC_ENUM_CAPFMT:
  1927.         {
  1928.                 struct v4l2_fmtdesc *f = arg;
  1929.                 if (f->index < 0 || f->index >= NUM_CAPFMT)
  1930.                         return -EINVAL;
  1931.                 *f = capfmt[f->index];
  1932.                 return 0;
  1933.         }
  1935.         case VIDIOC_G_FMT:
  1936.         {
  1937.                 memcpy(arg, &dev->clientfmt, sizeof(dev->clientfmt));
  1938.                 return 0;
  1939.         }
  1941.         case VIDIOC_S_FMT:
  1942.         {
  1943.                 struct v4l2_format *fmt = arg;
  1944.                 if (o->noncapturing)
  1945.                 {
  1946.                         debug_msg("S_FMT illegal in non-capturing openn");
  1947.                         return -EPERM;
  1948.                 }
  1949.                 dev->clientfmt = *fmt;
  1950.                 if (!capture_new_format(dev))
  1951.                         return -EINVAL;
  1953.                 mmap_unrequest_buffers(dev);
  1954.                 *fmt = dev->clientfmt;
  1955.                 return 0;
  1956.         }
  1958.         case VIDIOC_G_COMP:        return -EINVAL;
  1959.         case VIDIOC_S_COMP:        return -EINVAL;
  1961.         case VIDIOC_REQBUFS:
  1962.         {
  1963.                 struct v4l2_requestbuffers *req = arg;
  1964.                 if (o->noncapturing)
  1965.                 {
  1966.                         debug_msg("REQBUFS illegal in non-capturing openn");
  1967.                         return -EPERM;
  1968.                 }
  1969.                 if (dev->stream_buffers_mapped)
  1970.                 {
  1971.                         debug_msg("Can't request buffers if buffers are "
  1972.                                   "already mappedn");
  1973.                         return -EPERM;
  1974.                 }
  1975.                 capture_begin(dev);
  1976.                 if (!mmap_request_buffers(dev, req))
  1977.                         return -EINVAL;
  1978.                 return 0;
  1979.         }
  1981.         case VIDIOC_QUERYBUF:
  1982.         {
  1983.                 struct v4l2_buffer *buf = arg;
  1984.                 int        i;
  1985.                 if (o->noncapturing)
  1986.                 {
  1987.                         debug_msg("QUERYBUF illegal in non-capturing openn");
  1988.                         return -EPERM;
  1989.                 }
  1990.                 i = buf->index;
  1991.                 if (i < 0 || i >= MAX_CAPTURE_BUFFERS ||
  1992.                     !dev->stream_buf[i].requested ||
  1993.                     (buf->type & V4L2_BUF_TYPE_field) != 
  1994.                      (dev->stream_buf[i].vidbuf.type & V4L2_BUF_TYPE_field))
  1995.                 {
  1996.                         debug_msg("QUERYBUF bad parametern");
  1997.                         return -EINVAL;
  1998.                 }
  1999.                 *buf = dev->stream_buf[i].vidbuf;
  2000.                 return 0;
  2001.         }
  2003.         case VIDIOC_QBUF:
  2004.         {
  2005.                 struct v4l2_buffer *buf = arg;
  2006.                 if (o->noncapturing)
  2007.                 {
  2008.                         debug_msg("QBUF illegal in non-capturing openn");
  2009.                         return -EPERM;
  2010.                 }
  2011.                 if (!dev->stream_buffers_mapped)
  2012.                 {
  2013.                         debug_msg("QBUF no buffers are mappedn");
  2014.                         return -EINVAL;
  2015.                 }
  2016.                 if (!capture_queuebuffer(dev, buf))
  2017.                         return -EINVAL;
  2018.                 return 0;
  2019.         }
  2021.         case VIDIOC_DQBUF:
  2022.         {
  2023.                 struct v4l2_buffer *buf = arg;
  2024.                 if (o->noncapturing)
  2025.                 {
  2026.                         debug_msg("DQBUF illegal in non-capturing openn");
  2027.                         return -EPERM;
  2028.                 }
  2029.                 if (!capture_dequeuebuffer(dev, buf))
  2030.                         return -EINVAL;
  2031.                 return 0;
  2032.         }
  2034.         case VIDIOC_STREAMON:
  2035.         {
  2036.                 __u32        type = (__u32)arg;
  2037.                 if (o->noncapturing)
  2038.                 {
  2039.                         debug_msg("STREAMON illegal in non-capturing openn");
  2040.                         return -EPERM;
  2041.                 }
  2042.                 if (!capture_streamon(dev, type))
  2043.                         return -EINVAL;
  2044.                 return 0;
  2045.         }
  2047.         case VIDIOC_STREAMOFF:
  2048.         {
  2049.                 __u32        type = (__u32)arg;
  2050.                 if (o->noncapturing)
  2051.                 {
  2052.                         debug_msg("STREAMOFF illegal in non-capturing openn");
  2053.                         return -EPERM;
  2054.                 }
  2055.                 capture_streamoff(dev, type);
  2056.                 return 0;
  2057.         }
  2059.         /* Video Preview support */
  2060.         case VIDIOC_ENUM_FBUFFMT:
  2061.         {
  2062.                 struct v4l2_fmtdesc* fmt = (struct v4l2_fmtdesc*)arg;
  2063.                 strcpy( fmt->description, "Video Overlay" );
  2064.                 fmt->pixelformat = 0;
  2065.                 fmt->flags = 0;
  2066.                 fmt->depth = 0;
  2067.                 return 0;
  2068.         }
  2070.         case VIDIOC_G_FBUF:
  2071.                 (struct v4l2_framebuffer*)arg = &dev->fbuf;
  2072.                 return 0;
  2074.         case VIDIOC_S_FBUF:                return -EINVAL;
  2075.         case VIDIOC_G_WIN:
  2076.                 (struct v4l2_window*)arg = &dev->window;
  2077.                 return 0;
  2079.         case VIDIOC_S_WIN:
  2080.         {
  2081.                 struct v4l2_window* win = (struct v4l2_window*)arg;
  2082.                 int red, green, blue;
  2084.                 if( ( win->clips != NULL ) || ( win->clipcount != 0 ) ) 
  2085.                         return -EINVAL;
  2087.                 memcpy( &dev->window, win, sizeof(dev->window) );
  2088.                 
  2089.                 /* set on hardware */
  2090.                 mgavideo_set_window( dev->mga, win->x, win->y,
  2091.                                      win->width, win->height );
  2093. if ((long)win->chromakey < 0) {
  2094. mgavideo_set_overlay(dev->mga);
  2095. } else {
  2096. red = (win->chromakey >> 16) & 0xff;
  2097. green = (win->chromakey >> 8) & 0xff;
  2098. blue = (win->chromakey >> 0) & 0xff;
  2099. mgavideo_set_colorkey( dev->mga, red, green, blue );
  2100. }
  2101.                 return 0;
  2102.         }
  2103.         
  2104.         case VIDIOC_PREVIEW:
  2105. mgavideo_ivsync_enable( dev->mga, *(int *)arg );
  2106.                 mgavideo_preview_enable( dev->mga, *(int*)arg );
  2107.                 return 0;
  2110.         case VIDIOC_G_PERF:
  2111.         {
  2112.                 memcpy(arg, &dev->perf, sizeof(dev->perf));
  2113.                 return 0;
  2114.         }
  2116.         case VIDIOC_G_INPUT:
  2117.         {
  2118.                 memcpy(arg, &dev->input, sizeof(dev->input));
  2119.                 return 0;
  2120.         }
  2122.         case VIDIOC_S_INPUT:
  2123.         {
  2124.                 int        input = (int)arg;
  2125.                 if (input < 0 || input >= KS_INPUT_COUNT)
  2126.                 {
  2127.                         debug_msg("Input out of range %dn", input);
  2128.                         return -EINVAL;
  2129.                 }
  2130.                 if (input != dev->input)
  2131.                 {
  2132.                         dev->input = input;
  2133.                         set_video_input(dev, input);
  2134.                 }
  2135.                 return 0;
  2136.         }
  2138.         case VIDIOC_G_PARM:
  2139.         {
  2140.                 memcpy(arg, &dev->capture, sizeof(dev->capture));
  2141.                 return 0;
  2142.         }
  2144.         case VIDIOC_S_PARM:
  2145.         {
  2146.                 struct v4l2_captureparm *vp = arg;
  2147.                 if (vp->capturemode & ~dev->capture.capability)
  2148.                 {
  2149.                         debug_msg("PARM unsupported capture capabilityn");
  2150.                         return -EINVAL;
  2151.                 }
  2152.                 if ((dev->capture.capability & V4L2_CAP_TIMEPERFRAME) &&
  2153.                     vp->timeperframe < 10000)
  2154.                 {
  2155.                         debug_msg("PARM time per frame out of range %ldn",
  2156.                                   vp->timeperframe);
  2157.                         return -EINVAL;
  2158.                 }
  2159.                 if (vp->capturemode != dev->capture.capturemode &&
  2160.                     !o->noncapturing && dev->streaming)
  2161.                         return -EINVAL;
  2163.                 if (o->noncapturing)
  2164.                         return 0;
  2165.                 if (vp->capturemode != dev->capture.capturemode)
  2166.                 {
  2167.                         dev->capture.capturemode = vp->capturemode;
  2168.                         capture_new_format(dev);
  2169.                 }
  2170.                 if ((vp->capturemode & V4L2_CAP_TIMEPERFRAME) &&
  2171.                     vp->timeperframe >= dev->frame_period)
  2172.                         dev->capture.timeperframe = vp->timeperframe;
  2173.                 else
  2174.                         dev->capture.timeperframe = dev->frame_period;
  2175.                 return 0;
  2176.         }
  2178.         case VIDIOC_G_STD:
  2179.         {
  2180.                 struct v4l2_standard *std = arg;
  2181.                 v4l2_video_std_construct(std, dev->standard, 0);
  2182.                 return 0;
  2183.         }
  2185.         case VIDIOC_S_STD:
  2186.         {
  2187.                 struct v4l2_standard        *std = arg;
  2188.                 int                        id;
  2189.                 if ((o->noncapturing && dev->capturing_opens) ||
  2190.                     dev->stream_buffers_mapped) {
  2191. printk("noncapturing=%d capturing_opens=%d mapped=%dn",
  2192. o->noncapturing, dev->capturing_opens, dev->stream_buffers_mapped);
  2193.                         return -EPERM;
  2194. }
  2195.                 id = v4l2_video_std_confirm(std);
  2196.                 if (!((1 << id) & dev->standards))
  2197.                 {
  2198. printk("Bad standard: %un", (unsigned)id);
  2199.                         debug_msg("Bad standard: %un", (unsigned)id);
  2200.                         return -EINVAL;
  2201.                 }
  2202.                 set_video_standard(dev, id);
  2203.                 return 0;
  2204.         }
  2206.         case VIDIOC_ENUMSTD:
  2207.         {
  2208.                 struct v4l2_enumstd *estd = arg;
  2209.                 __u32        b, i;
  2210.                 if (estd->index < 0 || estd->index > 30)
  2211.                         return -EINVAL;
  2212.                 for (b = 1, i = 0; b < 32; ++b)
  2213.                 {
  2214.                         if (((1 << b) & dev->standards) == 0)
  2215.                                 continue;
  2216.                         if (i == estd->index)
  2217.                         {
  2218.                                 v4l2_video_std_construct(&estd->std, b, 0);
  2219.                                 estd->inputs = (__u32)-1; /* all inputs */
  2220.                                 estd->outputs = 0;
  2221.                                 return 0;
  2222.                         }
  2223.                         ++i;
  2224.                 }
  2225.                 return -EINVAL;
  2226.         }
  2228.         case VIDIOC_ENUMINPUT:
  2229.         {
  2230.                 struct v4l2_input *vi = arg;
  2231.                 if (vi->index < 0 || vi->index >= KS_INPUT_COUNT)
  2232.                         return -EINVAL;
  2233.                 *vi = dev->source[vi->index].input;
  2234.                 return 0;
  2235.         }
  2237.         case VIDIOC_QUERYCTRL:
  2238.         {
  2239.                 struct v4l2_queryctrl        *qc = arg;
  2240.                 int                        i;
  2241.                 i = find_vctrl(qc->id);
  2242.                 if (i < 0)
  2243.                 {
  2244.                         return i;
  2245.                 }
  2246.                 /*  V4L2 filled in category and catname, preserve them */
  2247.                 capture_control[i].category = qc->category;
  2248.                 memcpy(capture_control[i].catname, qc->catname, 
  2249.                        sizeof(qc->catname));
  2250.                 *qc = capture_control[i];
  2251.                 return 0;
  2252.         }
  2254.         case VIDIOC_QUERYMENU:
  2255.         {
  2256.                 struct v4l2_querymenu        *qm = arg;
  2258.                 return vctrl_querymenu(qm);
  2259.         }
  2261.         case VIDIOC_G_CTRL:
  2262.         {
  2263.                 struct v4l2_control        *vc = arg;
  2264.                 int                        i;
  2265.                 i = find_vctrl(vc->id);
  2266.                 if (i < 0)
  2267.                         return i;
  2268.                 vc->value = dev->source[dev->input].control[i];
  2269.                 return 0;
  2270.         }
  2272.         case VIDIOC_S_CTRL:
  2273.         {
  2274.                 struct v4l2_control        *vc = arg;
  2275.                 int                        i;
  2276.                 i = find_vctrl(vc->id);
  2277.                 if (i < 0)
  2278.                         return i;
  2279.                 dev->source[dev->input].control[i] = vc->value;
  2280.                 device_tone_controls(dev);
  2281.                 return 0;
  2282.         }
  2284.         case VIDIOC_G_TUNER:
  2285.         {
  2286.                 struct v4l2_tuner* tuner = (struct v4l2_tuner*)arg;
  2287.                 if( dev->source[tuner->input].input.type !=
  2288.                                         V4L2_INPUT_TYPE_TUNER ) {
  2289.                         return -EINVAL;
  2290.                 }
  2292.                 memcpy( tuner, &dev->source[tuner->input].tuner,
  2293.                                         sizeof( *tuner ) );
  2294.                 break;
  2295.         }
  2297.         case VIDIOC_S_TUNER:        return -EINVAL;
  2298.         case VIDIOC_G_FREQ:
  2299.                 memcpy(arg, &dev->source[dev->input].freq, sizeof(int));
  2300.                 break;
  2301.         
  2302.         case VIDIOC_S_FREQ:
  2303.                 set_video_freq( dev, arg );
  2304.                 break;
  2306.         case VIDIOC_G_AUDIO:        return -EINVAL;
  2307.         {
  2308.                 struct v4l2_audio* audio = (struct v4l2_audio*)arg;
  2309.                 if( dev->source[audio->audio].input.capability &
  2310.                                         V4L2_INPUT_CAP_AUDIO ) {
  2311.                         return -EINVAL;
  2312.                 }
  2314.                 memcpy( audio, &dev->source[audio->audio].audio,
  2315.                                         sizeof( *audio ) );
  2316.                 break;
  2317.         }
  2319.         case VIDIOC_S_AUDIO:        return -EINVAL;
  2321.         default:
  2322.                 return -ENOIOCTLCMD;
  2323.         }
  2324.         return 0;
  2325. }
  2327. static int
  2328. v4l2_mmap(void                        *id,
  2329.           struct vm_area_struct *vma)
  2330. {
  2331.         struct device_open        *o   = (struct device_open *)id;
  2332.         struct capture_device        *dev = o->dev;
  2333.         struct stream_buffer        *buf;
  2334.         int                        i, n = 1;
  2336.         if (o->noncapturing)
  2337.         {
  2338.                 debug_msg("mmap() called on non-capturing openn");
  2339.                 return -ENODEV;
  2340.         }
  2341.         buf = mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  2342.         if (dev->stream_contig_map)
  2343.         {/*        N buffers in one contiguous map  */
  2344.                 buf = &dev->stream_buf[0];
  2345.                 n = dev->stream_buffers_requested;
  2346.         }
  2347.         if (buf == NULL)
  2348.         {
  2349.                 debug_msg("mmap() Invalid offset parametern");
  2350.                 return -EINVAL;/* no such buffer */
  2351.         }
  2352.         if (buf->vidbuf.length * n != vma->vm_end - vma->vm_start)
  2353.         {
  2354.                 debug_msg("mmap() Wrong length parametern");
  2355.                 return -EINVAL;/* wrong length */
  2356.         }
  2357.         for (i = 0; i < n; ++i)
  2358.         {
  2359.                 if (!buf->requested)
  2360.                 {
  2361.                         debug_msg("mmap() Buffer is not available for"
  2362.                                   " mappingn");
  2363.                         return -EINVAL;/* not requested */
  2364.                 }
  2365.                 if (buf->vidbuf.flags & V4L2_BUF_FLAG_MAPPED)
  2366.                 {
  2367.                         debug_msg("mmap() Buffer is already mappedn");
  2368.                         return -EINVAL;/* already mapped */
  2369.                 }
  2371.                 if (buf->vaddress != NULL)
  2372.                         vfree(buf->vaddress);
  2373.                 if (i == 0)
  2374.                         buf->vaddress = vmalloc(buf->vidbuf.length * n);
  2375.                 else
  2376.                         buf->vaddress = buf[-1].vaddress + buf->vidbuf.length;
  2377.                 if (buf->vaddress == NULL)
  2378.                 {
  2379.                         err_msg("Could not allocate mmap() buffern");
  2380.                         return -ENODEV;
  2381.                 }
  2382. #if 0                /*  TODO: build scatter list for buffer if using DMA  */
  2383.                 if ((using DMA) &&
  2384.                     !bm_build_scatter_list(dev, buf->vaddress, &buf->dma_list))
  2385.                         return -ENODEV;
  2386. #endif
  2387.                 buf->vidbuf.flags |= V4L2_BUF_FLAG_MAPPED;
  2388.                 ++dev->stream_buffers_mapped;
  2389.                 ++buf;
  2390.         }
  2392.         vma->vm_ops = &capture_vma_operations;
  2393.         if (vma->vm_ops->open)
  2394.                 vma->vm_ops->open(vma);
  2395.         /*  Note: vma->vm_file will be set up by V4L2  */
  2397.         return 0;
  2398. }
  2400. static int
  2401. v4l2_poll(void        *id,
  2402.             struct file        *file,
  2403.             poll_table        *table)
  2404. {
  2405.         struct device_open *o = (struct device_open *)id;
  2406.         struct capture_device *dev = o->dev;
  2408. debug_msg("starting pool: noncapturing=%d streaming=%dn", 
  2409. o->noncapturing, dev->streaming);
  2410.         if (o->noncapturing)
  2411.         {
  2412.                 debug_msg("poll() illegal in non-capturing openn");
  2413.                 return POLLERR;
  2414.         }
  2416.         if (dev->streaming)
  2417.         {
  2418.                 void        *node;
  2419.                 node = v4l2_q_peek_head(&dev->stream_q_done);
  2420. debug_msg("poll: check done queue: %xn", node);
  2421.                 if (node != NULL)
  2422.                         return (POLLIN | POLLRDNORM);/* data is ready now */
  2423.                 node = v4l2_q_peek_head(&dev->stream_q_capture);
  2424. debug_msg("poll: check capture queue: %xn", node);
  2425.                 if (node == NULL)
  2426.                         return POLLERR;  /* no frames queued */
  2427. {
  2428. struct timeval curr;
  2429. do_gettimeofday(&curr);
  2430. debug_msg("waiting on new_video_frame: time: %d:%dn", curr.tv_sec, curr.tv_usec);
  2431. }
  2432.                 poll_wait(file, &dev->new_video_frame, table);
  2433. {
  2434. struct timeval curr;
  2435. do_gettimeofday(&curr);
  2436. debug_msg("done waiting on new_video_frame: time: %d:%dn", curr.tv_sec, curr.tv_usec);
  2437. }
  2438.                 return 0;
  2439.         }
  2441.         /*  Capture is through read() call */
  2443.         if (dev->capture_completed)/* data is ready now */
  2444.                 return (POLLIN | POLLRDNORM);
  2445.         capture_grab_frame(dev);/* does nothing if capture is in progress */
  2446.         if (!dev->ready_to_capture)/* Can't grab frames! */
  2447.                 return POLLERR;
  2448.         poll_wait(file, &dev->new_video_frame, table);
  2449.         return 0;
  2450. }
  2452. static long
  2453. v4l2_read(void                *id,
  2454.             char                *buf,
  2455.             unsigned long        count,
  2456.             int                        noblock)
  2457. {
  2458.         struct device_open *o = (struct device_open *)id;
  2459.         struct capture_device *dev = o->dev;
  2460.         long        len = 0;
  2461.         long        my_timeout;
  2463.         if (o->noncapturing)
  2464.         {
  2465.                 debug_msg("read() illegal in non-capturing openn");
  2466.                 return -EPERM;
  2467.         }
  2468.         if (dev->streaming)
  2469.         {
  2470.                 debug_msg("Can't read() when streaming is onn");
  2471.                 return -EPERM;
  2472.         }
  2473.         capture_grab_frame(dev);/* does nothing if capture is in progress */
  2474.         if (!dev->ready_to_capture)
  2475.         {
  2476.                 debug_msg("Can't grab frames!n");
  2477.                 return 0;
  2478.         }
  2480.         my_timeout = HZ / 5;
  2481. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  2482.         current->timeout = jiffies + my_timeout;
  2483. #endif
  2484.         while (len == 0)
  2485.         {
  2486.                 if (noblock)
  2487.                 {
  2488.                         if (!dev->capture_completed)
  2489.                                 return -EAGAIN;
  2490.                 }
  2491.                 else
  2492.                 {
  2493.                         /* watch out for race condition going to sleep! */
  2494.                         cli();
  2495.                         if (!dev->capture_completed)
  2496.                         {
  2497. debug_msg("read: wainting on new_video_framen");
  2498. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  2499.                                 interruptible_sleep_on(&dev->new_video_frame);
  2500. #else
  2501.                                 my_timeout = interruptible_sleep_on_timeout(
  2502.                                         &dev->new_video_frame, my_timeout);
  2503. #endif
  2504. debug_msg("readL wakeup on new_video_timeoutn");
  2505.                         }
  2506.                         sti();
  2507.                 }
  2508. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  2509.                 if (current->timeout <= jiffies)
  2510. #else
  2511.                 if (my_timeout == 0)
  2512. #endif
  2513.                 {
  2514. printk("Timeout on readn");
  2515.                         debug_msg("Timeout on readn");
  2516.                         break;
  2517.                 }
  2518.                 len = capture_read(dev, buf, count);
  2519.         }
  2520. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  2521.         current->timeout = 0;
  2522. #endif
  2523.         //debug_msg("read %dn", (int)len);
  2524.         return len;
  2525. }
  2527. /*
  2528.  *        Remaining initialization of video decoder etc. This is only
  2529.  *        done when the device is successfully identified and registered.
  2530.  */
  2531. static int
  2532. v4l2_init_done(struct v4l2_device *v)
  2533. {
  2534.         struct capture_device *dev = (struct capture_device *)v;
  2535.         int        i;
  2537.         /*  Initialize video input array        */
  2538.         for (i = 0; i < KS_INPUT_COUNT; ++i)
  2539.         {
  2540.                 /*  Initialize video control properties        */
  2541.                 dev->source[i].control[VCTRL_BRIGHTNESS] =
  2542.                         capture_control[VCTRL_BRIGHTNESS].default_value;
  2543.                 dev->source[i].control[VCTRL_CONTRAST] =
  2544.                         capture_control[VCTRL_CONTRAST].default_value;
  2545.                 dev->source[i].control[VCTRL_SATURATION] =
  2546.                         capture_control[VCTRL_SATURATION].default_value;
  2547.                 dev->source[i].control[VCTRL_HUE] =
  2548.                         capture_control[VCTRL_HUE].default_value;
  2549.         }
  2550.         dev->source[KS_INPUT_COMPOSITE].input.index = KS_INPUT_COMPOSITE;
  2551.         strcpy(dev->source[KS_INPUT_COMPOSITE].input.name, "Composite");
  2552.         dev->source[KS_INPUT_COMPOSITE].input.type = V4L2_INPUT_TYPE_CAMERA;
  2553.         dev->source[KS_INPUT_COMPOSITE].input.capability = V4L2_INPUT_CAP_AUDIO;
  2554.         dev->source[KS_INPUT_COMPOSITE].input.assoc_audio = 0;
  2556.         dev->source[KS_INPUT_SVIDEO].input.index = KS_INPUT_SVIDEO;
  2557.         strcpy(dev->source[KS_INPUT_SVIDEO].input.name, "S-Video");
  2558.         dev->source[KS_INPUT_SVIDEO].input.type = V4L2_INPUT_TYPE_CAMERA;
  2559.         dev->source[KS_INPUT_SVIDEO].input.capability = 0;
  2560.         dev->source[KS_INPUT_SVIDEO].input.assoc_audio = 0;
  2562.         dev->source[KS_INPUT_TUNER].input.index = KS_INPUT_TUNER;
  2563.         strcpy(dev->source[KS_INPUT_TUNER].input.name, "Tuner");
  2564.         dev->source[KS_INPUT_TUNER].input.type = V4L2_INPUT_TYPE_TUNER;
  2565.         dev->source[KS_INPUT_TUNER].input.capability = V4L2_INPUT_CAP_AUDIO;
  2566.         dev->source[KS_INPUT_TUNER].input.assoc_audio = 0;
  2567.         dev->source[KS_INPUT_TUNER].tuner.input = KS_INPUT_TUNER;
  2568.         strcpy(dev->source[KS_INPUT_TUNER].tuner.name, "Tuner");
  2569.         dev->source[KS_INPUT_TUNER].tuner.capability = 0;
  2570.         dev->source[KS_INPUT_TUNER].tuner.rangelow = 552500 / 625;
  2571.         dev->source[KS_INPUT_TUNER].tuner.rangehigh = 8012500 / 625;
  2572.         dev->source[KS_INPUT_TUNER].tuner.rxsubchans = V4L2_TUNER_SUB_MONO;
  2573.         dev->source[KS_INPUT_TUNER].tuner.audmode = V4L2_TUNER_MODE_MONO;
  2574.         dev->source[KS_INPUT_TUNER].tuner.afc = 0;
  2575.         dev->source[KS_INPUT_TUNER].audio.audio = 0;
  2576.         strcpy(dev->source[KS_INPUT_TUNER].audio.name, "Audio");
  2577.         dev->source[KS_INPUT_TUNER].audio.capability = 0;
  2578.         dev->source[KS_INPUT_TUNER].audio.mode = 0;
  2580.         dev->source[KS_INPUT_YUV656_60HZ].input.index = KS_INPUT_YUV656_60HZ;
  2581.         strcpy(dev->source[KS_INPUT_YUV656_60HZ].input.name, "YUV656 60Hz");
  2582.         dev->source[KS_INPUT_YUV656_60HZ].input.type = V4L2_INPUT_TYPE_CAMERA;
  2583.         dev->source[KS_INPUT_YUV656_60HZ].input.capability = 0;
  2584.         dev->source[KS_INPUT_YUV656_60HZ].input.assoc_audio = 0;
  2586.         dev->source[KS_INPUT_YUV656_50HZ].input.index = KS_INPUT_YUV656_50HZ;
  2587.         strcpy(dev->source[KS_INPUT_YUV656_50HZ].input.name, "YUV656 50Hz");
  2588.         dev->source[KS_INPUT_YUV656_50HZ].input.type = V4L2_INPUT_TYPE_CAMERA;
  2589.         dev->source[KS_INPUT_YUV656_50HZ].input.capability = 0;
  2590.         dev->source[KS_INPUT_YUV656_50HZ].input.assoc_audio = 0;
  2591.         
  2593.         dev->standards = (1<<V4L2_STD_PAL)
  2594.                        | (1<<V4L2_STD_NTSC)
  2595.                        | (1<<V4L2_STD_SECAM);
  2596.         /*  BUG: get defaults from user somehow...  */
  2597.         set_video_input(dev, KS_INPUT_COMPOSITE);
  2598.         set_video_standard(dev, V4L2_STD_NTSC);
  2600.         /*  Capture parameters  */
  2601.         dev->capture.capability = V4L2_CAP_TIMEPERFRAME;
  2602.         dev->capture.capturemode = 0;
  2603.         dev->capture.extendedmode = 0;
  2604.         dev->capture.timeperframe = dev->frame_period;
  2606.         /*  Default capture dimensions        */
  2607.         dev->clientfmt.width = 704;
  2608.         dev->clientfmt.height = 240;
  2609.         dev->clientfmt.depth = 16;
  2610.         dev->clientfmt.pixelformat = V4L2_PIX_FMT_RGB565;
  2611.         dev->clientfmt.flags = 0;
  2612.         dev->clientfmt.bytesperline = 0;
  2613.         dev->clientfmt.sizeimage = 0;
  2614.         capture_new_format(dev);
  2616.         /* Default preview window */
  2617.         dev->window.x = 0;
  2618.         dev->window.y = 0;
  2619.         dev->window.width = 704;
  2620.         dev->window.height = 480;
  2621.         dev->window.chromakey = 0x000800;
  2622.         dev->window.clips = NULL;
  2623.         dev->window.clipcount = 0;
  2625.         /* Default preview framebuffer */
  2626.         dev->fbuf.capability = V4L2_FBUF_CAP_EXTERNOVERLAY
  2627.                              | V4L2_FBUF_CAP_CHROMAKEY
  2628.                              | V4L2_FBUF_CAP_SCALEUP
  2629.                              | V4L2_FBUF_CAP_SCALEDOWN;
  2630.         dev->fbuf.flags = V4L2_FBUF_FLAG_PRIMARY
  2631.                         | V4L2_FBUF_FLAG_OVERLAY
  2632.                         | V4L2_FBUF_FLAG_CHROMAKEY;
  2633.         dev->fbuf.base[0] = mgavideo_get_base( dev->mga );
  2634.         /* dev->fbuf.fmt = ? */
  2636.         return 0;
  2637. }
  2639. /*  =====================================================================
  2640.  *        The functions below this point are only called during loading
  2641.  *        and unloading of the driver.
  2642.  */
  2645. /*
  2646.  *        D E V I C E   I N I A L I Z A T I O N   R O U T I N E S
  2647.  *
  2648.  *        These routines locate and enable the hardware, and initialize
  2649.  *        the device structure. 
  2650.  */
  2653. static int
  2654. config_a_device(struct capture_device *dev)
  2655. {
  2656.         sprintf(dev->shortname, "capture%d", dev - capture);
  2658.         dev->mga = mgavideo_get();
  2659.         if( dev->mga == NULL )
  2660.                 return 0;
  2662.         device_initialize(dev);
  2664.         sprintf(dev->v.name, "V4L2 Video Capture Driver (%d)", dev-capture);
  2665.         dev->v.type = V4L2_TYPE_CAPTURE;
  2666.         dev->v.minor = unit_video[dev-capture];
  2668.         dev->v.open = v4l2_open;
  2669.         dev->v.close = v4l2_close;
  2670.         dev->v.read = v4l2_read;
  2671.         dev->v.write = v4l2_write;
  2672.         dev->v.ioctl = v4l2_ioctl;
  2673.         dev->v.mmap = v4l2_mmap;
  2674.         dev->v.poll = v4l2_poll;
  2675.         dev->v.initialize = v4l2_init_done;
  2676.         dev->v.priv = NULL;
  2678.         if(!( mgavideo_querycaps( dev->mga ) & MGAVIDEO_HAS_DECODER ))
  2679.         {
  2680.                 err_msg("Bad or unrecognized video decodern");
  2681. mgavideo_release(dev->mga);
  2682.                 return 0;/* failed */
  2683.         }
  2684.         return 1;
  2685. }
  2687. static void
  2688. unconfig_a_device(struct capture_device *dev)
  2689. {
  2690.         interrupt_disable(dev);
  2691.         capture_close(dev);
  2693.         /*  TODO: Unconfigure the device, free the I/O port, etc.  */
  2694.         mgavideo_release( dev->mga );
  2696.         if (dev->is_registered)
  2697.         {
  2698.                 v4l2_unregister_device((struct v4l2_device *)dev);
  2699.                 info_msg("Removed device %sn", dev->shortname);
  2700.         }
  2701.         memset(dev, 0, sizeof(capture[0]));
  2702. }
  2704. /*
  2705.  *        M O D U L E   I N I T   A N D   C L E A N U P
  2706.  */
  2708. int
  2709. init_module(void)
  2710. {
  2711.         int        i;
  2713.         for (i = 0; i < NBOARDS; ++i)
  2714.         {
  2715.                 memset(&capture[i], 0, sizeof(capture[0]));
  2716.                 if (!config_a_device(&capture[i]))
  2717.                 {
  2718.                         break;
  2719.                 }
  2720.                 if (v4l2_register_device(
  2721.                         (struct v4l2_device *)&capture[i]) != 0)
  2722.                 {
  2723.                         err_msg("Couldn't register the driver.n");
  2724.                         unconfig_a_device(&capture[i]);
  2725.                         return 0;
  2726.                 }
  2727.                 capture[i].is_registered = 1;
  2728.         }
  2729.         if (i == 0)
  2730.         {
  2731.                 err_msg("No devices found.n");
  2732.                 return -ENODEV;/* cleanup will not be called */
  2733.         }
  2734.         return 0;
  2735. }
  2737. void
  2738. cleanup_module(void)
  2739. {
  2740.         int        i;
  2742.         for (i = 0; i < NBOARDS; ++i)
  2743.                 unconfig_a_device(&capture[i]);
  2744. }