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

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

DVD

开发平台：

Unix_Linux

v4l2out.c：源码内容
  1. /* -*- linux-c -*- --------------------------------------------------------- *  
  2.  *
  3.  * Video for Linux Two
  4.  * Video Output Driver for Matrox Gx00 series
  5.  *       and Zoran DVD add-on module
  6.  *      (c) 1999 David Barth <dbarth@besancon.net>
  7.  *
  8.  * This software is in the public domain.
  9.  * Based mainly on the module example Written by Bill Dirks
  10.  */
  12. #ifndef __KERNEL__
  13. #define __KERNEL__
  14. #endif
  15. #ifndef MODULE
  16. #define MODULE
  17. #endif
  18. #include <linux/module.h>
  19. #include <linux/delay.h>
  20. #include <linux/errno.h>
  21. #include <linux/fs.h>
  22. #include <linux/kernel.h>
  23. #include <linux/malloc.h>
  24. #include <linux/mm.h>
  25. #include <linux/poll.h>
  26. #include <linux/ioport.h>
  27. #include <asm/io.h>
  28. #include <linux/sched.h>
  29. #include <linux/videodev2.h>
  30. #include <linux/version.h>
  31. #include <asm/uaccess.h>
  32. #include <linux/pci.h>
  33. #include <asm/pgtable.h>
  34. #include <asm/page.h>
  35. #include <linux/interrupt.h>
  37. #include "mgavideo.h"
  38. #include "i34.h"
  41. #define PKMOD "out: "
  42. #if 1
  43. #define debug_msg(fmt,arg...) printk(KERN_DEBUG PKMOD fmt,##arg)
  44. #else
  45. #define debug_msg(fmt,arg...)
  46. #endif
  47. #if 1
  48. #define err_msg(fmt,arg...) printk(KERN_ERR PKMOD fmt,##arg)
  49. #else
  50. #define err_msg(fmt,arg...)
  51. #endif
  52. #if 1
  53. #define info_msg(fmt,arg...) printk(KERN_INFO PKMOD fmt,##arg)
  54. #else
  55. #define info_msg(fmt,arg...)
  56. #endif
  59. /*  Video controls  */
  60. static struct v4l2_queryctrl output_control[] =
  61. {
  62. {V4L2_CID_BRIGHTNESS, "Brightness", 0, 63, 1, 32, V4L2_CTRL_TYPE_INTEGER},
  63. {V4L2_CID_CONTRAST,   "Contrast",   0, 63, 1, 32, V4L2_CTRL_TYPE_INTEGER},
  64. {V4L2_CID_SATURATION, "Saturation", 0, 63, 1, 32, V4L2_CTRL_TYPE_INTEGER},
  65. /*{V4L2_CID_HUE,        "Hue",        0, 63, 1, 32, V4L2_CTRL_TYPE_INTEGER},*/
  66. };
  67. #define MAXCONTROLS (sizeof(output_control)/sizeof(output_control[0]))
  68. #define VCTRL_BRIGHTNESS 0
  69. #define VCTRL_CONTRAST 1
  70. #define VCTRL_SATURATION 2
  71. #define VCTRL_HUE 3
  72. static int
  73. find_vctrl(int id)
  74. {
  75. int i = -1;
  76. if (id == V4L2_CID_PRIVATE_BASE ||
  77.     id <  V4L2_CID_BASE ||
  78.             id >  V4L2_CID_LASTP1)
  79. return -EDOM;
  80. #if 0
  81.         for (i = MAXCONTROLS - 1; i >= 0; i--)
  82.                 if (output_control[i].id == id)
  83.                         break;
  84. #endif
  85. if (i < 0)
  86. i = -EINVAL;
  87.         return i;
  88. }
  92. struct output_device;/* forward reference */
  94. struct video_encoder
  95. {
  96. int is_initialized;
  97. int num_outputs;
  98. int output;
  99. __u32 standards;
  100. __u32 standard;
  101. __u32 frame_period;
  103. /*  Changable method functions helps us support multiple */
  104. /*  different types of video encoders easily */
  105. int (*initialize)(struct output_device *dev);
  106. int (*set_output)(struct output_device *dev, int x);
  107. int (*set_standard)(struct output_device *dev, int x);
  108. };
  110. struct video_output
  111. {
  112. struct v4l2_output output;
  113. int control[MAXCONTROLS];
  114. struct v4l2_modulator modulator;
  115. };
  116. /*  Indices into the array of video_output's */
  117. #define VOUTPUT_COMP 0
  118. #define VOUTPUT_SVIDEO 1
  119. #define VOUTPUT_COUNT 2
  121. /*  Bus-master gather list  */
  122. struct gather_node
  123. {
  124. __u32 addr;
  125. __u32 len;
  126. };
  127. #define END_OF_GATHER_LIST 0x80000000
  130. /*  Per-open data for handling multiple opens on one device */
  131. struct device_open
  132. {
  133. int isopen;
  134. int noio;
  135. struct output_device *dev;
  136. };
  137. #define MAX_OPENS 3
  139. /*  Streaming data buffer  */
  140. struct stream_buffer
  141. {
  142. struct v4l2_q_node qnode;
  143. struct v4l2_buffer vidbuf;
  144. int requested;
  145. __u8 *vaddress;  /* vmalloc() */
  146. struct gather_node *dma_list;  /* get_free_page() */
  147. };
  148. #define MAX_OUTPUT_BUFFERS 10
  149. #define MAX_LOCKED_MEMORY 2000000
  151. /*
  152.  * Output device structure
  153.  *
  154.  * One for each handled device in the system.
  155.  * This structure holds all the global information the driver
  156.  * needs about each device.
  157.  */
  158. struct output_device
  159. {
  160. struct v4l2_device v; /*  Must be first */
  161. struct mga_dev         *mga;
  162. char shortname[16];
  163. int is_registered;
  164. int open_count;
  165. struct device_open open_data[MAX_OPENS];
  166. int io_opens;
  168. /* Per-bus index number for each device */
  169. int index;
  170. /* General type of device  */
  171. int type;
  172. /* Pointer to the pci_dev structure for this board */
  173. struct pci_dev *pci;
  174. /* I/O Base address for non-PCI devices */
  175. unsigned int iobase;
  176. /* Interrupts */
  177. int irq;
  178. int ints_enabled;
  179. struct tq_struct tqnode_dpc;/* for Bottom Half routine */
  180. struct timer_list tlnode;/* for polling interrupts */
  181. struct wait_queue *new_video_frame;
  183. /* Video output (and encoder) stuff */
  184. struct video_encoder viden;
  185. struct video_output voutput[VOUTPUT_COUNT];
  186. int hwoutput_width;
  187. int hwoutput_height;
  189. /* Client output image format */
  190. struct v4l2_format clientfmt;
  191. int output;/* which video output is selected */
  192. struct v4l2_outputparm outputparm;
  194. /* Hardware image format  */
  195. int hwoutput_bypp;
  196. int hwoutput_size;
  197. __u8 *hwoutput_buffer;/* vmalloc() */
  198. int hwoutput_buffer_size;
  199. struct gather_node *hwoutput_dma_list;/* get_free_page() */
  201. /* Hardware output state */
  202. int ready_to_output;
  203. int hwoutput_enabled;
  204. int hwoutput_completed;
  205. unsigned long time_acquired;/* millisecond time stamp */
  206. int streaming;
  207. struct stream_buffer stream_buf[MAX_OUTPUT_BUFFERS];
  208. int stream_buffers_mapped;
  209. struct v4l2_queue stream_q_output;
  210. struct v4l2_queue stream_q_done;
  211. struct timeval stream_begin;
  212. unsigned long stream_last_frame;
  213. __u8 *stream_hwoutput_buffer;
  215. /* Performance statistics */
  216. struct v4l2_performance perf;
  218.         /* video preview stuff */
  219.         struct v4l2_framebuffer  fbuf;
  220.         struct v4l2_window       window;
  221. };
  222. /* Values for type field */
  223. #define DEVICE_TYPE_0 0
  224. /* Extreme video dimensions */
  225. #define MIN_WIDTH 32
  226. #define MIN_HEIGHT 24
  227. #define MAX_WIDTH 720
  228. #define MAX_HEIGHT 576
  229. #define MAX_FRAME_AGE 200 /* ms */
  232. /*
  233.  * The Output device structure array. This is the only global
  234.  * variable in the module besides those used by the device probing
  235.  * and enumeration routines (command line overrides)
  236.  */
  237. #define NBOARDS 2
  238. static struct output_device outputdev[NBOARDS];
  239. static int unit_vout[NBOARDS] = { 16, 17, };
  240. MODULE_PARM(unit_vout, "1-"__MODULE_STRING(NBOARDS)"i");
  242. static inline struct output_device *
  243. output_device_from_file(struct file *file)
  244. {
  245. return (struct output_device *)v4l2_device_from_file(file);
  246. }
  249. /*  These macros can be used to make device I/O operations atomic  */
  250. /* static spinlock_t device_lock = SPIN_LOCK_UNLOCKED; */
  251. /* #define BEGIN_CRITICAL_SECTION  */
  252. /*         do{unsigned long flags;spin_lock_irqsave(&wavi_lock,flags) */
  253. /* #define END_CRITICAL_SECTION  */
  254. /*  spin_unlock_irqrestore(&wavi_lock,flags);}while(0) */
  258. /*
  259.  * D E V I C E   F U N C T I O N S
  260.  */
  262. static void
  263. device_initialize(struct output_device *dev)
  264. {
  265. /*  TODO: Put hardware into a sensible state and */
  266. /*        do the one-time startup things */
  267.         I34_Init(dev->mga);
  268. }
  270. static void
  271. device_brightness(struct output_device *dev, int x)
  272. {
  273. }
  275. static void
  276. device_contrast(struct output_device *dev, int x)
  277. {
  278. }
  280. static void
  281. device_saturation(struct output_device *dev, int x)
  282. {
  283. }
  285. static void
  286. device_tone_controls(struct output_device *dev)
  287. {
  288. int *ctrl;
  289. ctrl = dev->voutput[dev->output].control;
  290. device_brightness(dev, ctrl[VCTRL_BRIGHTNESS]);
  291. device_contrast(dev, ctrl[VCTRL_CONTRAST]);
  292. device_saturation(dev, ctrl[VCTRL_SATURATION]);
  293. /*  device_hue(dev, ctrl[VCTRL_HUE]); */
  294. }
  296. /*  Start or stop the DMA transfer  */
  297. static void
  298. hwoutput_enable(struct output_device *dev, int start)
  299. {
  300. /*  TODO: Start the transfer of the data  */
  301. // if (dev->streaming)
  302. // {
  303. // }
  304. // else
  305. // {
  306. // }
  307. }
  310. #if 0
  311. /*
  312.  *
  313.  * B U S   M A S T E R   F U N C T I O N S
  314.  *
  315.  */
  317. static int
  318. bm_build_gather_list(struct output_device *dev,
  319.      unsigned char    *buffer,
  320.      struct gather_node **plist)
  321. {
  322. struct gather_node *list;
  323. int i, n;
  324. unsigned char *a;
  326. if (buffer == NULL)
  327. return 0;
  328. list = *plist;
  329. if (list == NULL)
  330. {/* Assuming one page will be big enough. 4KB = 512 pieces */
  331. list = (struct gather_node *)get_free_page(GFP_KERNEL);
  332. if (list == NULL)
  333. return 0;
  334. }
  336. /*  Simple algorithm will just map the buffer contiguously by pages */
  337. /*  Note: hwoutput_buffer is vmalloc()ed, so it's page-aligned */
  339. n = (dev->hwoutput_size + PAGE_SIZE - 1) / PAGE_SIZE;
  340. a = buffer;
  341. for (i = 0; i < n; ++i)
  342. {
  343. list[i].addr = v4l2_vmalloc_to_bus(a);
  344. list[i].len = PAGE_SIZE;
  345. a += PAGE_SIZE;
  346. }
  347. /* Last page might not be full */
  348. if (dev->hwoutput_size < n * PAGE_SIZE)
  349. list[n - 1].len = dev->hwoutput_size - (n - 1) * PAGE_SIZE;
  351. list[n - 1].len |= END_OF_GATHER_LIST;
  353. #if 0
  354. debug_msg("Gather list %08lXn", virt_to_bus(list));
  355. for (i = 0; i < n; ++i)
  356. debug_msg("List %2d: A=%08X L=%08Xn",i,
  357.   list[i].addr,list[i].len);
  358. #endif
  359. *plist = list;
  360. return 1;/* ok */
  361. }
  362. #endif
  365. /*
  366.  *
  367.  * V I D E O   E N C O D E R S
  368.  *
  369.  */
  371. static int
  372. encoder_initialize(struct output_device *dev)
  373. {
  374. /*  Video encoder information fields */
  375. dev->viden.standards = (1 << V4L2_STD_NTSC) |
  376. (1 << V4L2_STD_PAL);
  378. dev->viden.num_outputs = 2;
  380. return 1;
  381. }
  383. static int
  384. encoder_set_output(struct output_device *dev, int i)
  385. {
  386. dev->output = i;
  387. /*  TODO: Switch the hardware to the new output  */
  388. return 1;
  389. }
  391. static int
  392. encoder_set_standard(struct output_device *dev, int x)
  393. {
  394. dev->viden.standard = x;
  395. /*  TODO: Switch the hardware to the new standard  */
  396. switch (x)
  397. {
  398. case V4L2_STD_NTSC:
  399. dev->viden.frame_period = 333667;
  400. break;
  401. case V4L2_STD_PAL:
  402. dev->viden.frame_period = 400000;
  403. break;
  404. case V4L2_STD_SECAM:
  405. dev->viden.frame_period = 400000;
  406. break;
  407. }
  408. return 1;
  409. }
  411. static int
  412. encoder_probe(struct output_device *dev)
  413. {
  414. /*  TODO: Probe I2C bus or whatever for the video encoder */
  416. /*  Fill in the method fields  */
  417. dev->viden.initialize = encoder_initialize;
  418. dev->viden.set_output = encoder_set_output;
  419. dev->viden.set_standard = encoder_set_standard;
  421. //info_msg("Found encoder chipn");
  422. return 1;/*  Found  */
  423. }
  426. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  427.  *
  428.  * Probe I2C bus for video encoder and fill in the device fields
  429.  */
  430. static int
  431. find_encoder(struct output_device *dev)
  432. {
  433. if (!encoder_probe(dev))
  434. return 0;/*  Failure  */
  435. return 1;
  436. }
  438. static void
  439. set_video_output(struct output_device *dev,
  440.  int i)
  441. {
  442. if (i < 0 || i >= dev->viden.num_outputs)
  443. return;
  444. dev->viden.set_output(dev, i);
  445. device_tone_controls(dev);
  446. }
  449. /*
  450.  *
  451.  * V I D E O   O U T P U T   F U N C T I O N S
  452.  *
  453.  */
  455. /*
  456.  *  Supported image formats
  457.  */
  458. static struct v4l2_fmtdesc outfmt[] = 
  459. {
  460. { 0, {"RGB-16 (5-5-5)"},
  461. V4L2_PIX_FMT_RGB555,  0, 16, {0, 0},
  462. },
  463. { 1, {"RGB-16 (5-6-5)"},
  464. V4L2_PIX_FMT_RGB565,  0, 16, {0, 0},
  465. },
  466. { 2, {"RGB-24 (B-G-R)"},
  467. V4L2_PIX_FMT_BGR24,   0, 24, {0, 0},
  468. },
  469. { 3, {"RGB-32 (B-G-R-?)"},
  470. V4L2_PIX_FMT_BGR32,   0, 32, {0, 0},
  471. },
  472. { 4, {"Greyscale-8"},
  473. V4L2_PIX_FMT_GREY,    V4L2_FMT_CS_601YUV, 8, {0, 0},
  474. },
  475. { 5, {"YUV 4:2:2 (Y-U-Y-V)"},
  476. V4L2_PIX_FMT_YUYV,    V4L2_FMT_CS_601YUV, 16, {0, 0},
  477. },
  478. { 6, {"YUV 4:2:0 (planar)"},
  479. V4L2_PIX_FMT_YUV420,  V4L2_FMT_CS_601YUV, 12, {0, 0},
  480. },
  481. };
  482. #define NUM_OUTFMT (sizeof(outfmt)/sizeof(outfmt[0]))
  485. static void interrupt_enable(struct output_device *dev);
  487. /*  The image format has changed, width, height, pixel format.
  488.  *  Decide if the format is ok or take the closest valid format.
  489.  */
  490. static void
  491. hwoutput_new_format(struct output_device *dev)
  492. {
  493. int ntsc;
  494. int max_height;
  495. int max_width;
  497. if (dev->stream_buffers_mapped)
  498. return;
  499. ntsc = (dev->viden.standard == V4L2_STD_NTSC);
  500. dev->ready_to_output = 0;
  502. dev->clientfmt.flags = V4L2_FMT_CS_601YUV;
  503. switch (dev->clientfmt.pixelformat)
  504. {
  505. case V4L2_PIX_FMT_GREY:
  506. dev->clientfmt.depth = 8;
  507. break;
  508. case V4L2_PIX_FMT_YUV420:
  509. dev->clientfmt.depth = 12;
  510. break;
  511. case V4L2_PIX_FMT_RGB555:
  512. case V4L2_PIX_FMT_RGB565:
  513. dev->clientfmt.flags = 0;
  514. /* fall thru */
  515. case V4L2_PIX_FMT_YUYV:
  516. case V4L2_PIX_FMT_UYVY:
  517. dev->clientfmt.depth = 16;
  518. break;
  519. case V4L2_PIX_FMT_BGR24:
  520. dev->clientfmt.depth = 24;
  521. dev->clientfmt.flags = 0;
  522. break;
  523. case V4L2_PIX_FMT_BGR32:
  524. dev->clientfmt.depth = 32;
  525. dev->clientfmt.flags = 0;
  526. break;
  527. default:
  528. //debug_msg("unknown format %08Xn", dev->clientfmt.pixelformat);
  529. dev->clientfmt.depth = 24;
  530. dev->clientfmt.flags = 0;
  531. break;
  532. }
  534. dev->hwoutput_bypp = 2;
  536. if (dev->clientfmt.width < MIN_WIDTH)
  537. dev->clientfmt.width = MIN_WIDTH;
  538. if (dev->clientfmt.height < MIN_HEIGHT)
  539. dev->clientfmt.height = MIN_HEIGHT;
  541. max_width = MAX_WIDTH;
  542. max_height = MAX_HEIGHT;
  543. if (dev->clientfmt.width > max_width)
  544. dev->clientfmt.width = max_width;
  545. if (dev->clientfmt.height > max_height)
  546. dev->clientfmt.height = max_height;
  548. dev->clientfmt.width &= ~3;
  549. dev->clientfmt.height &= ~3;
  550. dev->clientfmt.sizeimage = (dev->clientfmt.width
  551.     * dev->clientfmt.height
  552.     * dev->clientfmt.depth)
  553. / 8;
  555. dev->hwoutput_size = dev->clientfmt.width
  556. * dev->clientfmt.height
  557. * dev->hwoutput_bypp;
  559. /*  TODO: Any other driver state related to the image format  */
  560. }
  562. /*  Stop the music!
  563.  */
  564. static void
  565. hwoutput_abort(struct output_device *dev)
  566. {
  567. dev->hwoutput_enabled = 0;
  568. /*  Turn off the hardware  */
  569. hwoutput_enable(dev, 0);
  570. }
  572. /*  Allocate buffers, and get everything ready to go, but don't start yet.
  573.  */
  574. static int
  575. hwoutput_begin(struct output_device *dev)
  576. {
  577. hwoutput_abort(dev);
  578. if (dev->ready_to_output)
  579. return dev->ready_to_output;
  581. if (dev->hwoutput_buffer_size < dev->hwoutput_size)
  582. {
  583. if (dev->hwoutput_buffer != NULL)
  584. vfree(dev->hwoutput_buffer);
  585. dev->hwoutput_buffer_size = 
  586. (dev->hwoutput_size + PAGE_SIZE - 1)
  587. & ~(PAGE_SIZE - 1);
  588. dev->hwoutput_buffer = (__u8 *)
  589. vmalloc(dev->hwoutput_buffer_size);
  590. if (dev->hwoutput_buffer == NULL)
  591. {
  592. dev->hwoutput_buffer_size = 0;
  593. err_msg("Can't allocate buffer"
  594. " %d bytesn", dev->hwoutput_size);
  595. return dev->ready_to_output;
  596. }
  597. }
  599. #if 0
  600. if (dev->irq && (can use DMA))
  601. bm_build_gather_list(dev, dev->hwoutput_buffer, 
  602.      &dev->hwoutput_dma_list);
  603. #endif
  605. /*  TODO: other last-minute things to get the device ready */
  607. interrupt_enable(dev);
  608. debug_msg("Ready to go!n");
  609. return (dev->ready_to_output = 1);
  610. }
  612. /*  Start an image transfer out to the hardware
  613.  */
  614. static void
  615. hwoutput_send_frame(struct output_device *dev)
  616. {
  617. if (!dev->ready_to_output)
  618. return;/* shouldn't happen */
  619. if (dev->hwoutput_enabled)
  620. return;
  623. /*  TODO: Prepare the hardware for the next image transfer */
  625. //list = dev->hwoutput_dma_list;/* DMA list for hwoutput_buffer */
  627. /*  Set up stream_hwoutput_buffer to point to the buffer to  */
  628. /*  transfer the next frame from  */
  629. if (dev->streaming)
  630. {
  631. struct stream_buffer *buf;
  632. buf = v4l2_q_peek_head(&dev->stream_q_output);
  633. if (buf != NULL)
  634. {
  635. dev->stream_hwoutput_buffer = buf->vaddress;
  636. //list = buf->dma_list;
  637. }
  638. }
  640. /*  TODO: load the DMA gather list if needed */
  641. /*  Start the hardware taking the data */
  642. hwoutput_enable(dev, 1);
  644. dev->hwoutput_enabled = 1;
  645. dev->hwoutput_completed = 0;
  646. }
  648. /*
  649.  * STREAMING IMAGES
  650.  */
  652. static int/* 1 = success; 0 = failed */
  653. hwoutput_queuebuffer(struct output_device *dev,
  654.      struct v4l2_buffer   *vidbuf)
  655. {
  656. int i = vidbuf->index;
  657. struct stream_buffer *buf = NULL;
  659. if (!dev->stream_buffers_mapped)
  660. {
  661. debug_msg("QBUF no buffers mappedn");
  662. return 0;
  663. }
  664. if (vidbuf->type != V4L2_BUF_TYPE_VIDEOOUT)
  665. {
  666. debug_msg("QBUF wrong typen");
  667. return 0;
  668. }
  669. if (i < 0 || i >= MAX_OUTPUT_BUFFERS || !dev->stream_buf[i].requested)
  670. {
  671. debug_msg("QBUF buffer index %d is out of rangen", i);
  672. return 0;
  673. }
  675. buf = &dev->stream_buf[i];
  677. if (!(buf->vidbuf.flags & V4L2_BUF_FLAG_MAPPED))
  678. {
  679. debug_msg("QBUF buffer %d is not mappedn", i);
  680. return 0;
  681. }
  682. if ((buf->vidbuf.flags & V4L2_BUF_FLAG_QUEUED))
  683. {
  684. debug_msg("QBUF buffer %d is already queuedn", i);
  685. return 0;
  686. }
  688. buf->vidbuf.flags &= ~V4L2_BUF_FLAG_DONE;
  689. v4l2_q_add_tail(&dev->stream_q_output, &buf->qnode);
  690. buf->vidbuf.flags |= V4L2_BUF_FLAG_QUEUED;
  691. return 1;
  692. }
  694. static int/* 1 = got a buffer; 0 = no buffers */
  695. hwoutput_dequeuebuffer(struct output_device *dev,
  696.        struct v4l2_buffer *buf)
  697. {
  698. struct stream_buffer *newbuf;
  700. if (!dev->streaming || buf->type != V4L2_BUF_TYPE_VIDEOOUT)
  701. {
  702. debug_msg("DQBUF not streaming or wrong buffer typen");
  703. return 0;
  704. }
  705. newbuf = v4l2_q_del_head(&dev->stream_q_done);
  706. if (newbuf == NULL)
  707. {
  708. debug_msg("DQBUF nothing on done queuen");
  709. return 0;
  710. }
  711. newbuf->vidbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
  713. *buf = newbuf->vidbuf;
  714. return 1;
  715. }
  717. static int
  718. hwoutput_streamon(struct output_device *dev,
  719.   __u32 type)
  720. {
  721. struct stream_buffer *buf;
  723. if (dev->streaming || type != V4L2_BUF_TYPE_VIDEOOUT)
  724. {
  725. debug_msg("STREAMON wrong buffer type or already streamingn");
  726. return 0;
  727. }
  729. hwoutput_abort(dev);/* cancel any transfer that might be in progress */
  731. /*  -2 is a magic number that triggers start-of-stream logic in */
  732. /*    hwoutput_interrupt()  */
  733. dev->stream_last_frame = -2;
  735. dev->perf.frames = 0;
  736. dev->perf.framesdropped = 0;
  737. dev->perf.bytesout = 0;
  739. /*  Can't send frames faster than the video output rate  */
  740. if (dev->outputparm.timeperframe < dev->viden.frame_period)
  741. dev->outputparm.timeperframe = dev->viden.frame_period;
  743. /*  Move any leftover DONE buffers to the free pool */
  744. while ((buf = v4l2_q_del_head(&dev->stream_q_done)))
  745. buf->vidbuf.flags &= ~V4L2_BUF_FLAG_QUEUED;
  747. /*  Kick off the machine */
  748. dev->streaming = 1;
  749. hwoutput_send_frame(dev);
  750. return 1;
  751. }
  753. static void
  754. hwoutput_streamoff(struct output_device *dev,
  755.    __u32 type)
  756. {
  757. if (!dev->streaming || type != V4L2_BUF_TYPE_VIDEOOUT)
  758. {
  759. debug_msg("STREAMOFF wrong buffer type or not streamingn");
  760. return;
  761. }
  762. hwoutput_abort(dev);
  763. dev->streaming = 0;
  765. /* Note: should really delay this  */
  766. dev->perf.frames = 0;
  767. dev->perf.framesdropped = 0;
  768. dev->perf.bytesout = 0;
  769. }
  772. /* Called from write(). Copy the data to a driver internal buffer
  773.  * which the hardware can read directly or can DMA from or whatever
  774.  * makes sense for the hardware. You probably want to double-buffer
  775.  * somehow so that the output is continuous.
  776.  */
  777. static int /* returns length of data or negative for error */
  778. hwoutput_writeimage(struct output_device *dev,
  779.     __u8 *hwoutput_buffer,
  780.     const __u8 *source_buffer,
  781.     int output_size,
  782.     int output_is_user)
  783. {
  784. int len;
  786. /*  TODO: take data from the source buffer */
  787. /*  Check if more data can be accepted now, if not return 
  788.     zero if the application just needs to wait, or a negative 
  789.     error code if there is a problem. Otherwise return the
  790.     number of bytes taken  */
  792. len = dev->hwoutput_size;
  794. ++dev->perf.frames;
  795. dev->perf.bytesout += len;
  796. return len;
  797. }
  799. /*  The hardware has issued the interrupt signal, depending on the device,
  800.  *  this could mean a vertical sync or a DMA completion.
  801.  *  [This function is called indirectly through the immediate task queue;
  802.  *  it executes at elevated IRQL, but it is interruptible. (It's a b.h.)]
  803.  */
  804. static void
  805. hwoutput_interrupt(void *v)
  806. {
  807. struct output_device *dev = (struct output_device *)v;
  808. struct stream_buffer *buf;
  809. struct timeval timestamp_rough;
  810. unsigned long raw_frame_num;
  811. unsigned long next_raw_frame_to_keep;
  812. unsigned long stream_frame_num;
  813. u64 temp64;
  815. /*  TODO: Check for an interrupt pending on the device, and  */
  816. /*        return if there is no interrupt pending  */
  817. /*  (In this hardware-less demo I'll just check the completed flag) */
  818. if (!dev->hwoutput_enabled ||
  819.     dev->hwoutput_completed)
  820. return;
  822. if (!dev->ints_enabled /* || TODO: some other sanity checks? */)
  823. {
  824. err_msg("Can't process the interruptn");
  825. return;
  826. }
  827. dev->hwoutput_completed = 1;
  829. if (!dev->streaming)
  830. {
  831. /*  TODO: Interrupt processing when using write() instead  */
  832. /*  of streaming for outputting frames   */
  834. //debug_msg("Ready for new framen");
  835. /*  Ready for the next frame!  */
  836. /*  (If select() or write() is blocked, wake him up.) */
  837. wake_up_interruptible(&dev->new_video_frame);
  838. return;
  839. }
  841. /*  ...Only get here in streaming mode...  */
  843. if (dev->stream_last_frame == -2)
  844. {/* First frame of the stream  */
  845. v4l2_masterclock_gettime(&dev->stream_begin);
  846. dev->stream_last_frame = -1;
  847. }
  849. buf = v4l2_q_peek_head(&dev->stream_q_output);
  850. if (buf == NULL)
  851. {/* No available buffers. TODO: Maybe do nothing, maybe use  */
  852. /* previous frame again  */
  853. return;
  854. }
  856. /*  Compute current stream time  */
  857. v4l2_masterclock_gettime(&timestamp_rough);
  858. v4l2_timeval_delta(&timestamp_rough,
  859.    &dev->stream_begin, &timestamp_rough);
  861. /*  Output rate control  */
  862. raw_frame_num = v4l2_timeval_divide(
  863. &timestamp_rough, dev->viden.frame_period);
  864. temp64 = (u64)dev->outputparm.timeperframe
  865. * (dev->stream_last_frame + 1)
  866. + (dev->viden.frame_period >> 1);
  867. next_raw_frame_to_keep = 
  868. v4l2_math_div6432(temp64, dev->viden.frame_period, NULL);
  869. if (raw_frame_num < next_raw_frame_to_keep)
  870. {/* Not time yet according to desired output frame rate,     */
  871. /* wait some more. (Similar processing to no buffers case.) */
  872. return;
  873. }
  875. /*  Time to send out next frame  */
  876. //hwoutput_writeimage(dev, dev->stream_hwoutput_buffer,
  877. //       buf->vaddress, buf->vidbuf.length, 0);
  879. /*  Mark the buffer DONE  */
  880. buf->vidbuf.flags |= V4L2_BUF_FLAG_DONE;
  882. /*  For informational purposes to the app, figure if frames have  */
  883. /*  been missed.     */
  884. stream_frame_num = v4l2_timeval_correct(&buf->vidbuf.timestamp,
  885. dev->outputparm.timeperframe);
  886. //debug_msg("Stream frame %4lu T= %lu.%06lun", stream_frame_num,
  887. //   buf->vidbuf.timestamp.tv_sec,buf->vidbuf.timestamp.tv_usec);
  888. if (stream_frame_num > dev->stream_last_frame + 1)
  889. {/* We have missed one or more frames  */
  890. dev->perf.framesdropped += stream_frame_num
  891. - dev->stream_last_frame + 1;
  892. }
  893. dev->stream_last_frame = stream_frame_num;
  895. /*  Move buffer to done queue  */
  896. buf = v4l2_q_del_head(&dev->stream_q_output);
  897. v4l2_q_add_tail(&dev->stream_q_done, &buf->qnode);
  899. /*  Send out the next frame now  */
  900. hwoutput_send_frame(dev);
  902. /*  Ready for the next frame! (select() might be waiting) */
  903. wake_up_interruptible(&dev->new_video_frame);
  904. }
  907. /*  Send a frame from a user buffer to the device
  908.  *  Return: negative = error
  909.  *     0        = keep waiting
  910.  *     positive = count of bytes sent successfully
  911.  */
  912. static long
  913. hwoutput_write(struct output_device *dev,
  914.        const __u8 *user_buffer,
  915.        int user_buffer_size)
  916. {
  917. int len = user_buffer_size;
  919. if (!dev->ints_enabled)
  920. return -EIO;
  922. if (!dev->hwoutput_completed)
  923. {/* Not ready for another frame yet */
  924. //debug_msg("Not ready for write.n");
  925. return 0;/* caller should keep waiting */
  926. }
  928. len = hwoutput_writeimage(dev, dev->hwoutput_buffer,
  929.   user_buffer, user_buffer_size, 1);
  930. return len;
  931. }
  933. /*  Stop and free all resources used for operation.
  934.  */
  935. static void
  936. hwoutput_close(struct output_device *dev)
  937. {
  938. int i;
  940. if (dev->streaming)
  941. hwoutput_streamoff(dev, V4L2_BUF_TYPE_VIDEOOUT);
  942. hwoutput_abort(dev);
  943. dev->ready_to_output = 0;
  944. if (dev->hwoutput_dma_list)
  945. free_page((unsigned long)dev->hwoutput_dma_list);
  946. dev->hwoutput_dma_list = 0;
  947. if (dev->hwoutput_buffer != NULL)
  948. vfree(dev->hwoutput_buffer);
  949. dev->hwoutput_buffer = NULL;
  950. dev->hwoutput_buffer_size = 0;
  951. for (i = 0; i < MAX_OUTPUT_BUFFERS; ++i)
  952. {
  953. dev->stream_buf[i].requested = 0;
  954. if (dev->stream_buf[i].vaddress)
  955. vfree(dev->stream_buf[i].vaddress);
  956. dev->stream_buf[i].vaddress = NULL;
  957. if (dev->stream_buf[i].dma_list)
  958. free_page((unsigned long)dev->stream_buf[i].dma_list);
  959. dev->stream_buf[i].dma_list = NULL;
  960. }
  961. }
  963. /*
  964.  *
  965.  * I N T E R R U P T   R O U T I N E S
  966.  *
  967.  */
  969. /*  This function runs at interrupt time, either in response to a hardware
  970.  *  interrupt, or on each timer tick if there is no hardware interrupt.
  971.  */
  972. static void
  973. interrupt_handler(void *v)
  974. {
  975. struct output_device *dev = (struct output_device *)v;
  977. if (!dev->ints_enabled)
  978. return;
  980. /*  Call "bottom half" of handler  */
  981. dev->tqnode_dpc.routine = hwoutput_interrupt;
  982. dev->tqnode_dpc.data = dev;
  983. queue_task(&dev->tqnode_dpc, &tq_immediate);
  984. mark_bh(IMMEDIATE_BH);
  986. if (dev->tlnode.function != NULL &&
  987.     dev->ints_enabled)
  988. {/* Poll again on next timer tick  */
  989. dev->tlnode.expires = jiffies + HZ/100;
  990. add_timer(&dev->tlnode);
  991. }
  992. }
  994. /*  Called by the system when our hardware interrupt occurs
  995.  */
  996. static void
  997. interrupt_hw(int irq, void *v,
  998.      struct pt_regs *regs)
  999. {
  1000. /* struct output_device *dev = (struct output_device *)v; */
  1002. if (v == NULL)
  1003. return;
  1005. /*  if (!(our device has interrupt pending)) */
  1006. /*  { */
  1007. /*  Not us. Likely another device is sharing the IRQ */
  1008. /*  debug_msg("HW interrupt (not this device)n"); */
  1009. /*  return; */
  1010. /*  } */
  1012. //debug_msg("HW interrupt (real)n");
  1013. interrupt_handler(v);
  1014. }
  1016. static void
  1017. interrupt_disable(struct output_device *dev)
  1018. {
  1019. if (!dev->ints_enabled)
  1020. return;
  1021. dev->ints_enabled = 0;
  1023. /*  TODO: Disable interrupts on the device  */
  1025. if (dev->irq == 0)
  1026. {
  1027. del_timer(&dev->tlnode);
  1028. }
  1029. /*  Wake up any processes that might be waiting for a frame  */
  1030. /*  and let them return an error  */
  1031. wake_up_interruptible(&dev->new_video_frame);
  1032. }
  1034. static void
  1035. interrupt_enable(struct output_device *dev)
  1036. {
  1037. if (dev->ints_enabled)
  1038. interrupt_disable(dev);
  1039. dev->ints_enabled = 1;
  1041. /*  TODO: Enable interrupts on the device  */
  1043. dev->tlnode.function = NULL; /* NULL indicates h/w interrupts */
  1044. if (dev->irq == 0)
  1045. {
  1046. init_timer(&dev->tlnode);
  1047. dev->tlnode.function = 
  1048. (void(*)(unsigned long))interrupt_handler;
  1049. dev->tlnode.data = (unsigned long)dev;
  1050. dev->tlnode.expires = jiffies + HZ/100;
  1051. add_timer(&dev->tlnode);
  1052. }
  1053. debug_msg("%s interrupts enabledn",
  1054.   dev->tlnode.function?"Polled":"Hardware");
  1055. }
  1057. /*
  1058.  *
  1059.  * M E M O R Y   M A P P I N G
  1060.  *
  1061.  */
  1063. static struct stream_buffer *
  1064. mmap_stream_buffer_from_offset(struct output_device *dev,
  1065.        unsigned long offset)
  1066. {
  1067. int i;
  1068. for (i = 0; i < MAX_OUTPUT_BUFFERS; ++i)
  1069. if (offset == dev->stream_buf[i].vidbuf.offset)
  1070. return &dev->stream_buf[i];
  1071. return NULL;
  1072. }
  1074. static int
  1075. mmap_request_buffers(struct output_device *dev,
  1076.      struct v4l2_requestbuffers *req)
  1077. {
  1078. int i;
  1079. u32 buflen;
  1081. if (dev->stream_buffers_mapped)
  1082. return 0;/* can't make requests if buffers are mapped */
  1083. if (req->count < 1)
  1084. req->count = 1;
  1085. if (req->count > MAX_OUTPUT_BUFFERS)
  1086. req->count = MAX_OUTPUT_BUFFERS;
  1087. req->type = V4L2_BUF_TYPE_VIDEOOUT; /* only kind I know */
  1089. /*  The buffer length needs to be a multiple of the page size  */
  1090. buflen = (dev->clientfmt.sizeimage + PAGE_SIZE - 1)
  1091. & ~(PAGE_SIZE - 1);
  1093. debug_msg("Granting %d buffersn",req->count);
  1095. /*  Now initialize the buffer structures. Don't allocate the */
  1096. /*  buffers until they're mapped. */
  1097. for (i = 0; i < req->count; ++i)
  1098. {
  1099. dev->stream_buf[i].requested = 1;
  1100. dev->stream_buf[i].vidbuf.index = i;
  1101. dev->stream_buf[i].vidbuf.type = req->type;
  1102. dev->stream_buf[i].vidbuf.offset = 4*i;/* anything unique */
  1103. dev->stream_buf[i].vidbuf.length = buflen;
  1104. dev->stream_buf[i].vidbuf.bytesused = 0;
  1105. dev->stream_buf[i].vidbuf.timestamp.tv_sec = 0;
  1106. dev->stream_buf[i].vidbuf.timestamp.tv_usec = 0;
  1107. dev->stream_buf[i].vidbuf.flags = 0;
  1108. }
  1109. for (i = req->count; i < MAX_OUTPUT_BUFFERS; ++i)
  1110. dev->stream_buf[i].requested = 0;
  1112. return 1;
  1113. }
  1115. static void
  1116. mmap_unrequest_buffers(struct output_device *dev)
  1117. {
  1118. int i;
  1120. for (i = 0; i < MAX_OUTPUT_BUFFERS; ++i)
  1121. dev->stream_buf[i].requested = 0;
  1122. }
  1124. static void
  1125. mmap_vma_open(struct vm_area_struct *vma)
  1126. {
  1127. struct output_device *dev =
  1128. output_device_from_file(vma->vm_file);
  1129. if (dev == NULL)
  1130. return;
  1131. //debug_msg("vma_open calledn");
  1132. ++dev->stream_buffers_mapped;
  1133. //MOD_INC_USE_COUNT;
  1134. }
  1136. static void
  1137. mmap_vma_close(struct vm_area_struct *vma)
  1138. {
  1139. struct output_device *dev =
  1140. output_device_from_file(vma->vm_file);
  1141. struct stream_buffer *buf =
  1142. mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  1144. if (dev->streaming)
  1145. {
  1146. info_msg("Warning- munmap() called while streamingn");
  1147. hwoutput_streamoff(dev, buf->vidbuf.type);
  1148. }
  1149. v4l2_q_yank_node(&dev->stream_q_output, &buf->qnode);
  1150. v4l2_q_yank_node(&dev->stream_q_done, &buf->qnode);
  1152. if (buf->vaddress != NULL)
  1153. vfree(buf->vaddress);
  1154. buf->vaddress = NULL;
  1155. if (buf->dma_list)
  1156. free_page((unsigned long)buf->dma_list);
  1157. buf->dma_list = NULL;
  1158. buf->vidbuf.flags = 0;
  1159. //debug_msg("Buffer %d deallocatedn",(int)vma->vm_offset/4);
  1161. if (dev->stream_buffers_mapped > 0)
  1162. --dev->stream_buffers_mapped;
  1163. //MOD_DEC_USE_COUNT;
  1164. }
  1166. static unsigned long
  1167. mmap_vma_nopage(struct vm_area_struct *vma,
  1168. unsigned long address, int write)
  1169. {
  1170. struct output_device *dev;
  1171. struct stream_buffer *buf;
  1172. unsigned long offset_into_buffer;
  1173. unsigned long page;
  1175. dev = output_device_from_file(vma->vm_file);
  1176. if (dev == NULL)
  1177. return 0;
  1178. buf = mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  1179. if (buf == NULL)
  1180. return 0;
  1181. offset_into_buffer = address - vma->vm_start;
  1182. if (offset_into_buffer >= buf->vidbuf.length)
  1183. {
  1184. err_msg("Attempt to read past end of mmap() buffern");
  1185. return 0;
  1186. }
  1187. page = v4l2_vmalloc_to_page(buf->vaddress + offset_into_buffer);
  1188. if (page == 0)
  1189. return 0;
  1191. atomic_inc(&mem_map[MAP_NR(page)].count);
  1192. return page;
  1193. }
  1195. static struct vm_operations_struct hwoutput_vma_operations =
  1196. {
  1197. mmap_vma_open, mmap_vma_close, NULL, NULL, NULL, NULL,
  1198. mmap_vma_nopage,
  1199. };
  1202. /*
  1203.  *
  1204.  * V I D E O   F O R   L I N U X   I N T E R F A C I N G
  1205.  *
  1206.  */
  1208. static int
  1209. v4l2_open(struct v4l2_device *v, int flags, void **idptr)
  1210. {
  1211. struct output_device *dev = (struct output_device *)v;
  1212. int i, n;
  1213. int io;
  1215. for (i = 0, n = -1, io = 0; i < MAX_OPENS; ++i)
  1216. {
  1217. if (!dev->open_data[i].isopen)
  1218. n = i;/* available open_data structure */
  1219. else if (!dev->open_data[i].noio)
  1220. io = 1;/* another open is already operating */
  1221. }
  1222. if (n == -1)/* No available open_data structures */
  1223. {
  1224. debug_msg("No more opens on this devicen");
  1225. return -EBUSY;
  1226. }
  1228. if (flags & O_NOIO)/*  no-I/O open */
  1229. dev->open_data[n].noio = 1;
  1230. else if (io)
  1231. {
  1232. debug_msg("No more I/O opens on this devicen");
  1233. return -EBUSY;
  1234. }
  1235. else
  1236. {
  1237. dev->open_data[n].noio = 0;
  1238. /*  Keep track of whether there is an I/O open  */
  1239. ++dev->io_opens;
  1240. dev->perf.frames = 0;
  1241. dev->perf.framesdropped = 0;
  1242. dev->perf.bytesout = 0;
  1243. }
  1245. //MOD_INC_USE_COUNT;
  1246. ++dev->open_count;
  1247. dev->open_data[n].isopen = 1;
  1248. dev->open_data[n].dev = dev;
  1249. *idptr = &dev->open_data[n];
  1251. if (dev->open_count == 1)
  1252. {
  1253. if (dev->pci && dev->irq == 0)
  1254. {
  1255. dev->irq = dev->pci->irq;
  1256. if (request_irq(dev->irq, interrupt_hw, SA_SHIRQ,
  1257. dev->shortname, dev) < 0)
  1258. {
  1259. err_msg("Denied IRQ %dn", dev->irq);
  1260. dev->irq = 0;
  1261. }
  1262. }
  1263. dev->ready_to_output = 0;/* benchmark changes parameters! */
  1264. dev->hwoutput_completed = 0;
  1265. dev->hwoutput_enabled = 0;
  1266. v4l2_q_init(&dev->stream_q_output);
  1267. v4l2_q_init(&dev->stream_q_done);
  1268. }
  1269. debug_msg("Open succeededn");
  1270. return 0;
  1271. }
  1273. static void
  1274. v4l2_close(void *id)
  1275. {
  1276. struct device_open *o = (struct device_open *)id;
  1277. struct output_device *dev = o->dev;
  1279. if (!o->noio)
  1280. {
  1281. --dev->io_opens;
  1282. debug_msg("Closen");
  1283. }
  1284. o->isopen = 0;
  1285.         --dev->open_count;
  1286. if (dev->open_count == 0)
  1287. {
  1288. interrupt_disable(dev);
  1289. hwoutput_close(dev);
  1290. if (dev->irq)
  1291. free_irq(dev->irq, dev);
  1292. dev->irq = 0;
  1293. }
  1294. //MOD_DEC_USE_COUNT;
  1295. }
  1297. /*  The arguments are already copied into kernel memory, so don't use
  1298.     copy_from_user() or copy_to_user() on arg.  */
  1299. static int
  1300. v4l2_ioctl(void *id,
  1301.    unsigned int cmd,
  1302.    void *arg)
  1303. {
  1304. struct device_open *o = (struct device_open *)id;
  1305. struct output_device *dev = o->dev;
  1307. // debug_msg("ioctl %dn", _IOC_NR(cmd));
  1308. switch(cmd)
  1309. {
  1310. case VIDIOC_QUERYCAP:
  1311. {
  1312. struct v4l2_capability *b = arg;
  1313. strcpy(b->name, dev->v.name);
  1314. b->type = V4L2_TYPE_OUTPUT;
  1315. b->flags = V4L2_FLAG_WRITE |
  1316. V4L2_FLAG_STREAMING |
  1317. V4L2_FLAG_SELECT;
  1318. b->outputs = dev->viden.num_outputs;
  1319. b->inputs = 0;
  1320. b->audios = 0;
  1321. b->maxwidth = MAX_WIDTH;
  1322. b->maxheight = MAX_HEIGHT;
  1323. b->minwidth = MIN_WIDTH;
  1324. b->minheight = MIN_HEIGHT;
  1325. b->maxframerate = 30;
  1326. return 0;
  1327. }
  1329. case VIDIOC_ENUM_OUTFMT:
  1330. {
  1331. struct v4l2_fmtdesc *f = arg;
  1332. if (f->index < 0 || f->index >= NUM_OUTFMT)
  1333. return -EINVAL;
  1334. *f = outfmt[f->index];
  1335. return 0;
  1336. }
  1338. case VIDIOC_G_FMT:
  1339. {
  1340. memcpy(arg, &dev->clientfmt, sizeof(dev->clientfmt));
  1341. return 0;
  1342. }
  1344. case VIDIOC_S_FMT:
  1345. {
  1346. struct v4l2_format *fmt = arg;
  1347. if (o->noio)
  1348. {
  1349. debug_msg("S_FMT illegal in no-I/O openn");
  1350. return -EPERM;
  1351. }
  1352. if (dev->stream_buffers_mapped)
  1353. {
  1354. debug_msg("Can't set format if buffers are mappedn");
  1355. return -EPERM;
  1356. }
  1357. dev->clientfmt = *fmt;
  1358. hwoutput_new_format(dev);
  1359. mmap_unrequest_buffers(dev);
  1360. *fmt = dev->clientfmt;
  1361. return 0;
  1362. }
  1364. case VIDIOC_REQBUFS:
  1365. {
  1366. struct v4l2_requestbuffers *req = arg;
  1367. if (o->noio)
  1368. {
  1369. debug_msg("REQBUFS illegal in no-I/O openn");
  1370. return -EPERM;
  1371. }
  1372. if (dev->stream_buffers_mapped)
  1373. {
  1374. debug_msg("Can't request buffers if buffers are "
  1375.   "already mappedn");
  1376. return -EPERM;
  1377. }
  1378. hwoutput_begin(dev);
  1379. if (!mmap_request_buffers(dev, req))
  1380. return -EINVAL;
  1381. return 0;
  1382. }
  1384. case VIDIOC_QUERYBUF:
  1385. {
  1386. struct v4l2_buffer *buf = arg;
  1387. int i;
  1388. if (o->noio)
  1389. {
  1390. debug_msg("QUERYBUF illegal in no-I/O openn");
  1391. return -EPERM;
  1392. }
  1393. i = buf->index;
  1394. if (i < 0 || i >= MAX_OUTPUT_BUFFERS ||
  1395.     !dev->stream_buf[i].requested ||
  1396.     (buf->type & V4L2_BUF_TYPE_field) != 
  1397.     (dev->stream_buf[i].vidbuf.type & V4L2_BUF_TYPE_field))
  1398. {
  1399. debug_msg("QUERYBUF bad parametern");
  1400. return -EINVAL;
  1401. }
  1402. *buf = dev->stream_buf[i].vidbuf;
  1403. return 0;
  1404. }
  1406. case VIDIOC_QBUF:
  1407. {
  1408. struct v4l2_buffer *buf =arg;
  1409. if (o->noio)
  1410. {
  1411. debug_msg("QBUF illegal in no-I/O openn");
  1412. return -EPERM;
  1413. }
  1414. if (!dev->stream_buffers_mapped)
  1415. {
  1416. debug_msg("QBUF no buffers are mappedn");
  1417. return -EINVAL;
  1418. }
  1419. if (!hwoutput_queuebuffer(dev, buf))
  1420. return -EINVAL;
  1421. return 0;
  1422. }
  1424. case VIDIOC_DQBUF:
  1425. {
  1426. struct v4l2_buffer *buf = arg;
  1427. if (o->noio)
  1428. {
  1429. debug_msg("DQBUF illegal in no-I/O openn");
  1430. return -EPERM;
  1431. }
  1432. if (!hwoutput_dequeuebuffer(dev, buf))
  1433. return -EINVAL;
  1434. return 0;
  1435. }
  1437. case VIDIOC_STREAMON:
  1438. {
  1439. __u32 type = (__u32)arg;
  1440. if (o->noio)
  1441. {
  1442. debug_msg("STREAMON illegal in no-I/O openn");
  1443. return -EPERM;
  1444. }
  1445. if (!hwoutput_streamon(dev, type))
  1446. return -EINVAL;
  1447. return 0;
  1448. }
  1450. case VIDIOC_STREAMOFF:
  1451. {
  1452. __u32 type = (__u32)arg;
  1453. if (o->noio)
  1454. {
  1455. debug_msg("STREAMOFF illegal in no-I/O openn");
  1456. return -EPERM;
  1457. }
  1458. hwoutput_streamoff(dev, type);
  1459. return 0;
  1460. }
  1462. case VIDIOC_ENUM_FBUFFMT:
  1463.         {
  1464.                 struct v4l2_fmtdesc* fmt = (struct v4l2_fmtdesc*)arg;
  1465.                 strcpy( fmt->description, "Video Overlay" );
  1466.                 fmt->pixelformat = 0;
  1467.                 fmt->flags = 0;
  1468.                 fmt->depth = 0;
  1469.                 return 0;
  1470.         }
  1471. case VIDIOC_G_FBUF:
  1472.                 (struct v4l2_framebuffer*)arg = &dev->fbuf;
  1473.                 return 0;
  1474. case VIDIOC_S_FBUF: return -EINVAL;
  1475. case VIDIOC_G_WIN:
  1476.                 (struct v4l2_window*)arg = &dev->window;
  1477.                 return 0;
  1478. case VIDIOC_S_WIN:
  1479.         {
  1480.                 struct v4l2_window* win = (struct v4l2_window*)arg;
  1481.                 int red, green, blue;
  1483.                 if( ( win->clips != NULL ) || ( win->clipcount != 0 ) ) 
  1484.                         return -EINVAL;
  1486.                 memcpy( &dev->window, win, sizeof(dev->window) );
  1487.                 
  1488.                 /* set on hardware */
  1489.                 mgavideo_set_window( dev->mga, win->x, win->y,
  1490.                                      win->width, win->height );
  1492.                 red = (win->chromakey >> 16) & 0xff;
  1493.                 green = (win->chromakey >> 8) & 0xff;
  1494.                 blue = (win->chromakey >> 0) & 0xff;
  1495.                 mgavideo_set_colorkey( dev->mga, red, green, blue );
  1496.                 return 0;
  1497.         }
  1498. case VIDIOC_PREVIEW:
  1499.                 mgavideo_preview_enable( dev->mga, *(int*)arg );
  1500.                 return 0;
  1502. /*  TODO: Handle above if output is to frame buffer or
  1503.     graphics overlay  */
  1505. case VIDIOC_G_PERF:
  1506. {
  1507. memcpy(arg, &dev->perf, sizeof(dev->perf));
  1508. return 0;
  1509. }
  1511. case VIDIOC_G_OUTPUT:
  1512. {
  1513. memcpy(arg, &dev->output, sizeof(dev->output));
  1514. return 0;
  1515. }
  1517. case VIDIOC_S_OUTPUT:
  1518. {
  1519. int output = (int)arg;
  1520. if (output < 0 || output >= dev->viden.num_outputs)
  1521. {
  1522. debug_msg("Output out of range %dn", output);
  1523. return -EINVAL;
  1524. }
  1525. if (output != dev->output)
  1526. {
  1527. dev->output = output;
  1528. set_video_output(dev, output);
  1529. }
  1530. return 0;
  1531. }
  1533. case VIDIOC_G_OUTPARM:
  1534. {
  1535. memcpy(arg, &dev->outputparm, sizeof(dev->outputparm));
  1536. return 0;
  1537. }
  1539. case VIDIOC_S_OUTPARM:
  1540. {
  1541. struct v4l2_outputparm *vp = arg;
  1542. if (copy_from_user(&vp, arg, sizeof(vp)))
  1543. return -EFAULT;
  1544. if (vp->outputmode & ~dev->outputparm.capability)
  1545. {
  1546. debug_msg("OUTPARM unsupported capabilityn");
  1547. return -EINVAL;
  1548. }
  1549. if ((dev->outputparm.capability & V4L2_CAP_TIMEPERFRAME) &&
  1550.     vp->timeperframe < 10000)
  1551. {
  1552. debug_msg("OUTPARM time per frame out of range %ldn",
  1553.   vp->timeperframe);
  1554. return -EINVAL;
  1555. }
  1556. if (vp->outputmode != dev->outputparm.outputmode &&
  1557.     !o->noio && dev->streaming)
  1558. {
  1559. debug_msg("OUTPARM can't change mode while "
  1560.   "streamingn");
  1561. return -EINVAL;
  1562. }
  1564. if (o->noio)
  1565. return 0;
  1566. if (vp->outputmode != dev->outputparm.outputmode)
  1567. {
  1568. dev->outputparm.outputmode = vp->outputmode;
  1569. hwoutput_new_format(dev);
  1570. }
  1571. if ((vp->outputmode & V4L2_CAP_TIMEPERFRAME) &&
  1572.     vp->timeperframe >= dev->viden.frame_period)
  1573. dev->outputparm.timeperframe = vp->timeperframe;
  1574. else
  1575. dev->outputparm.timeperframe = dev->viden.frame_period;
  1576. return 0;
  1577. }
  1579. case VIDIOC_G_STD:
  1580. {
  1581. struct v4l2_standard *std = arg;
  1582. v4l2_video_std_construct(std, dev->viden.standard, 0);
  1583. return 0;
  1584. }
  1586. case VIDIOC_S_STD:
  1587. {
  1588. struct v4l2_standard *std = arg;
  1589. int id;
  1590. if ((o->noio && dev->io_opens) ||
  1591.     dev->stream_buffers_mapped)
  1592. return -EPERM;
  1593. id = v4l2_video_std_confirm(std);
  1594. if (!((1 << id) & dev->viden.standards))
  1595. {
  1596. debug_msg("Bad standard: %un", (unsigned)id);
  1597. return -EINVAL;
  1598. }
  1599. dev->viden.set_standard(dev, id);
  1600. return 0;
  1601. }
  1603. case VIDIOC_ENUMSTD:
  1604. {
  1605. struct v4l2_enumstd *estd = arg;
  1606. __u32 b, i;
  1607. if (estd->index < 0 || estd->index > 30)
  1608. return -EINVAL;
  1609. for (b = 1, i = 0; b < 32; ++b)
  1610. {
  1611. if (((1 << b) & dev->viden.standards) == 0)
  1612. continue;
  1613. if (i == estd->index)
  1614. {
  1615. v4l2_video_std_construct(&estd->std, b, 0);
  1616. estd->outputs = (__u32)-1; /* all outputs */
  1617. estd->inputs = 0;
  1618. return 0;
  1619. }
  1620. ++i;
  1621. }
  1622. return -EINVAL;
  1623. }
  1625. case VIDIOC_ENUMOUTPUT:
  1626. {
  1627. struct v4l2_output *vo = arg;
  1628. if (vo->index < 0 || vo->index >= dev->viden.num_outputs)
  1629. return -EINVAL;
  1630. *vo = dev->voutput[vo->index].output;
  1631. return 0;
  1632. }
  1634. case VIDIOC_QUERYCTRL:
  1635. {
  1636. struct v4l2_queryctrl *qc = arg;
  1637. int i;
  1638. i = find_vctrl(qc->id);
  1639. if (i < 0)
  1640. return i;
  1641. /*  V4L2 filled in category and catname, preserve them */
  1642. output_control[i].category = qc->category;
  1643. memcpy(output_control[i].catname, qc->catname, 
  1644.        sizeof(qc->catname));
  1645. *qc = output_control[i];
  1646. return 0;
  1647. }
  1649. case VIDIOC_G_CTRL:
  1650. {
  1651. struct v4l2_control *vc = arg;
  1652. int i;
  1653. i = find_vctrl(vc->id);
  1654. if (i < 0)
  1655. return i;
  1656. vc->value = dev->voutput[dev->output].control[i];
  1657. return 0;
  1658. }
  1660. case VIDIOC_S_CTRL:
  1661. {
  1662. struct v4l2_control *vc = arg;
  1663. int i;
  1664. i = find_vctrl(vc->id);
  1665. if (i < 0)
  1666. return i;
  1667. dev->voutput[dev->output].control[i] = vc->value;
  1668. device_tone_controls(dev);
  1669. return 0;
  1670. }
  1672. case VIDIOC_G_MODULATOR: return -EINVAL;
  1673. case VIDIOC_S_MODULATOR: return -EINVAL;
  1674. case VIDIOC_G_FREQ: return -EINVAL;
  1675. case VIDIOC_S_FREQ: return -EINVAL;
  1677. case VIDIOC_G_AUDIO: return -EINVAL;
  1678. case VIDIOC_S_AUDIO: return -EINVAL;
  1680. default:
  1681.         return I34_ioctl(dev->mga, cmd, arg);
  1682. }
  1683. return 0;
  1684. }
  1686. static int
  1687. v4l2_mmap(void *id,
  1688.   struct vm_area_struct *vma)
  1689. {
  1690. struct device_open *o   = (struct device_open *)id;
  1691. struct output_device *dev = o->dev;
  1692. struct stream_buffer *buf;
  1694. if (o->noio)
  1695. {
  1696. debug_msg("mmap() called on no-I/O openn");
  1697. return -ENODEV;
  1698. }
  1699. buf = mmap_stream_buffer_from_offset(dev, vma->vm_offset);
  1700. if (buf == NULL)
  1701. {
  1702. debug_msg("mmap() Invalid offset parametern");
  1703. return -EINVAL;/* no such buffer */
  1704. }
  1705. if (!buf->requested)
  1706. {
  1707. debug_msg("mmap() Buffer is not available for mappingn");
  1708. return -EINVAL;/* not requested */
  1709. }
  1710. if (buf->vidbuf.flags & V4L2_BUF_FLAG_MAPPED)
  1711. {
  1712. debug_msg("mmap() Buffer is already mappedn");
  1713. return -EINVAL;/* already mapped */
  1714. }
  1715. if (buf->vidbuf.length != vma->vm_end - vma->vm_start)
  1716. {
  1717. debug_msg("mmap() Wrong length parametern");
  1718. return -EINVAL;/* wrong length */
  1719. }
  1721. if (buf->vaddress != NULL)
  1722. vfree(buf->vaddress);
  1723. buf->vaddress = vmalloc(buf->vidbuf.length);
  1724. if (buf->vaddress == NULL)
  1725. {
  1726. err_msg("Could not allocate mmap() buffern");
  1727. return -ENODEV;
  1728. }
  1729. #if 0
  1730. if ((using DMA) &&
  1731.     !bm_build_gather_list(dev, buf->vaddress, &buf->dma_list))
  1732. return -ENODEV;
  1733. #endif
  1734. buf->vidbuf.flags |= V4L2_BUF_FLAG_MAPPED;
  1736. vma->vm_ops = &hwoutput_vma_operations;
  1737. if (vma->vm_ops->open)
  1738. vma->vm_ops->open(vma);
  1739. /*  Note: vma->vm_file will be set up by V4L2  */
  1741. return 0;
  1742. }
  1744. static int
  1745. v4l2_poll(void *id,
  1746.   struct file *file,
  1747.   poll_table *table)
  1748. {
  1749. struct device_open *o = (struct device_open *)id;
  1750. struct output_device *dev = o->dev;
  1752. if (o->noio)
  1753. {
  1754. debug_msg("poll() illegal in no-I/O openn");
  1755. return POLLERR;
  1756. }
  1758. if (dev->streaming)
  1759. {
  1760. void *node;
  1761. node = v4l2_q_peek_head(&dev->stream_q_done);
  1762. if (node != NULL)
  1763. return (POLLIN | POLLRDNORM);/* have done buffers */
  1764. node = v4l2_q_peek_head(&dev->stream_q_output);
  1765. if (node == NULL)
  1766. return POLLERR;  /* no buffers queued */
  1767. poll_wait(file, &dev->new_video_frame, table);
  1768. return 0;
  1769. }
  1771. /*  Output is through write() call */
  1773. if (dev->hwoutput_completed)/* ready for new data now */
  1774. return (POLLIN | POLLRDNORM);
  1775. if (!dev->ready_to_output)/* Not set up to accept data yet */
  1776. return POLLERR;
  1777. poll_wait(file, &dev->new_video_frame, table);
  1778. return 0;
  1779. }
  1781. static long
  1782. v4l2_read(void *id, 
  1783.   char *buf, 
  1784.   unsigned long count, 
  1785.   int noblock)
  1786. {
  1787. debug_msg("read() not handledn");
  1788. return -EINVAL;
  1789. }
  1791. static long
  1792. v4l2_write(void *id,
  1793.    const char *buf,
  1794.    unsigned long count,
  1795.    int noblock)
  1796. {
  1797. struct device_open *o = (struct device_open *)id;
  1798. struct output_device *dev = o->dev;
  1799. long len = 0;
  1800. long my_timeout;
  1802. if (o->noio)
  1803. {
  1804. debug_msg("write() illegal in no-I/O openn");
  1805. return -EPERM;
  1806. }
  1807. if (dev->streaming)
  1808. {
  1809. debug_msg("Can't write() when streaming is onn");
  1810. return -EPERM;
  1811. }
  1812. hwoutput_begin(dev);/* does nothing if device is already ready */
  1813. if (!dev->ready_to_output)
  1814. {
  1815. debug_msg("Can't send frames!n");
  1816. return 0;
  1817. }
  1819. my_timeout = HZ / 5;
  1820. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  1821. current->timeout = jiffies + my_timeout;
  1822. #endif
  1823. while (len == 0)
  1824. {
  1825. if (noblock)
  1826. {
  1827. /*  Is previous frame still in progress? */
  1828. if (!dev->hwoutput_completed)
  1829. return -EAGAIN;
  1830. }
  1831. else
  1832. {
  1833. /* watch out for race condition going to sleep! */
  1834. cli();
  1835. if (!dev->hwoutput_completed)
  1836. {
  1837. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  1838. interruptible_sleep_on(&dev->new_video_frame);
  1839. #else
  1840. my_timeout = interruptible_sleep_on_timeout(
  1841. &dev->new_video_frame, my_timeout);
  1842. #endif
  1843. }
  1844. sti();
  1845. }
  1846. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  1847. if (current->timeout <= jiffies)
  1848. #else
  1849. if (my_timeout == 0)
  1850. #endif
  1851. {
  1852. debug_msg("Timeout on readn");
  1853. break;
  1854. }
  1855. len = hwoutput_write(dev, buf, count);
  1856. }
  1857. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,127)
  1858. current->timeout = 0;
  1859. #endif
  1860. //debug_msg("read %dn", (int)len);
  1861. return len;
  1862. }
  1864. /*
  1865.  * Remaining initialization of video encoder etc. This is only
  1866.  * done when the device is successfully identified and registered.
  1867.  */
  1868. static int
  1869. v4l2_init_done(struct v4l2_device *v)
  1870. {
  1871. struct output_device *dev = (struct output_device *)v;
  1872. int i;
  1874. /*  Initialize video input array */
  1875. for (i = 0; i < VOUTPUT_COUNT; ++i)
  1876. {
  1877. dev->voutput[i].output.index = i;
  1878. dev->voutput[i].output.type = V4L2_OUTPUT_TYPE_ANALOG;
  1879. dev->voutput[i].output.capability = 0;
  1880. /*  Initialize video control properties */
  1881. dev->voutput[i].control[VCTRL_BRIGHTNESS] =
  1882. output_control[VCTRL_BRIGHTNESS].default_value;
  1883. dev->voutput[i].control[VCTRL_CONTRAST] =
  1884. output_control[VCTRL_CONTRAST].default_value;
  1885. dev->voutput[i].control[VCTRL_SATURATION] =
  1886. output_control[VCTRL_SATURATION].default_value;
  1887. /*  dev->voutput[i].control[VCTRL_HUE] = */
  1888. /*  output_control[VCTRL_HUE].default_value; */
  1889. }
  1890. strcpy(dev->voutput[VOUTPUT_COMP].output.name, "Composite");
  1891. strcpy(dev->voutput[VOUTPUT_SVIDEO].output.name, "S-Video");
  1893. /*  Initialize the video encoder hardware */
  1894. dev->viden.initialize(dev);
  1896. /*  BUG: get defaults from user somehow...  */
  1897. dev->viden.set_standard(dev, V4L2_STD_NTSC);
  1898. set_video_output(dev, VOUTPUT_COMP);
  1900. /*  Output mode parameters  */
  1901. dev->outputparm.capability = V4L2_CAP_TIMEPERFRAME;
  1902. dev->outputparm.outputmode = 0;
  1903. dev->outputparm.extendedmode = 0;
  1904. dev->outputparm.timeperframe = dev->viden.frame_period;
  1906. /*  Default image dimensions */
  1907. dev->clientfmt.width = 160;
  1908. dev->clientfmt.height = 120;
  1909. dev->clientfmt.depth = 16;
  1910. dev->clientfmt.pixelformat = V4L2_PIX_FMT_RGB565;
  1911. dev->clientfmt.flags = 0;
  1912. dev->clientfmt.bytesperline = 0;
  1913. dev->clientfmt.sizeimage = 0;
  1914. hwoutput_new_format(dev);
  1916. return 0;
  1917. }
  1919. /*  =====================================================================
  1920.  * The functions below this point are only called during loading
  1921.  * and unloading of the driver.
  1922.  */
  1925. /*
  1926.  * 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
  1927.  *
  1928.  * These routines locate and enable the hardware, and initialize
  1929.  * the device structure. 
  1930.  */
  1935. #if 0
  1936. /* Variables for assigning resources via the command line
  1937.  */
  1938. /*  ISA non-PnP IO base overrides */
  1939. static int isa0_iobase = 0;
  1940. static int isa1_iobase = 0;
  1941. #ifdef MODULE_PARM
  1942. MODULE_PARM(isa0_iobase, "i");
  1943. MODULE_PARM(isa1_iobase, "i");
  1944. #endif
  1946. /*  ISA PnP IO base override */
  1947. static int pnp0_iobase = 0;
  1948. #ifdef MODULE_PARM
  1949. MODULE_PARM(pnp0_iobase, "i");
  1950. #endif
  1951. #endif
  1953. /*  Initialize v4l2_device fields */
  1954. static int
  1955. init_device_fields(struct output_device *dev)
  1956. {
  1957. int num = dev - outputdev;
  1959. sprintf(dev->v.name, "Matrox DVD Video Out Driver (%d)", num);
  1960. dev->v.type = V4L2_TYPE_OUTPUT;
  1961. dev->v.minor = unit_vout[num];
  1963. dev->v.open = v4l2_open;
  1964. dev->v.close = v4l2_close;
  1965. dev->v.read = v4l2_read;
  1966. dev->v.write = v4l2_write;
  1967. dev->v.ioctl = v4l2_ioctl;
  1968. dev->v.mmap = v4l2_mmap;
  1969. dev->v.poll = v4l2_poll;
  1970. dev->v.initialize = v4l2_init_done;
  1971. dev->v.priv = NULL;
  1972. return 1;/* OK */
  1973. }
  1975. static int
  1976. config_a_device(struct output_device *dev)
  1977. {
  1978. sprintf(dev->shortname, "videoout%d", dev - outputdev);
  1980. /*  TODO: Search for an unconfigured device, configure the  */
  1981. /*        I/O port  */
  1982. /* if (!(found another device)) */
  1983. /* return 0; */
  1985. if ((dev->mga = mgavideo_get()) == NULL)
  1986. return 0;
  1988. device_initialize(dev);
  1989. if (!init_device_fields(dev))
  1990. return 0;
  1992. if (!find_encoder(dev))
  1993. {
  1994. err_msg("Bad or unrecognized video encodern");
  1995. return 0;/* failed */
  1996. }
  1997. return 1;
  1998. }
  2000. static void
  2001. unconfig_a_device(struct output_device *dev)
  2002. {
  2003. interrupt_disable(dev);
  2004. hwoutput_close(dev);
  2006. /*  TODO: Unconfigure the device, free the I/O port, etc.  */
  2007. mgavideo_release(dev->mga);
  2009. if (dev->is_registered)
  2010. {
  2011. v4l2_unregister_device((struct v4l2_device *)dev);
  2012. info_msg("Removed device %sn", dev->shortname);
  2013. }
  2014. memset(dev, 0, sizeof(outputdev[0]));
  2015. }
  2017. /*
  2018.  * M O D U L E   I N I T   A N D   C L E A N U P
  2019.  */
  2021. int
  2022. init_module(void)
  2023. {
  2024. int i;
  2026. for (i = 0; i < NBOARDS; ++i)
  2027. {
  2028. memset(&outputdev[i], 0, sizeof(outputdev[0]));
  2029. if (!config_a_device(&outputdev[i]))
  2030. {
  2031. break;
  2032. }
  2033. if (v4l2_register_device(
  2034. (struct v4l2_device *)&outputdev[i]) != 0)
  2035. {
  2036. err_msg("Couldn't register the driver.n");
  2037. unconfig_a_device(&outputdev[i]);
  2038. return 0;
  2039. }
  2040. outputdev[i].is_registered = 1;
  2041. }
  2042. if (i == 0)
  2043. {
  2044. err_msg("No devices found.n");
  2045. return -ENODEV;/* cleanup will not be called */
  2046. }
  2047. return 0;
  2048. }
  2050. void
  2051. cleanup_module(void)
  2052. {
  2053. int i;
  2055. for (i = 0; i < NBOARDS; ++i)
  2056. unconfig_a_device(&outputdev[i]);
  2057. }