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

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

DVD

开发平台：

Unix_Linux

videodev.c：源码内容
  1. /*
  2.  * Video for Linux Two
  3.  *
  4.  * A generic video device interface for the LINUX operating system
  5.  * using a set of device structures/vectors for low level operations.
  6.  *
  7.  * This file replaces the videodev.c file that comes with the
  8.  * regular kernel distribution.
  9.  *
  10.  * This program is free software; you can redistribute it and/or
  11.  * modify it under the terms of the GNU General Public License
  12.  * as published by the Free Software Foundation; either version
  13.  * 2 of the License, or (at your option) any later version.
  14.  *
  15.  * Author: Bill Dirks <bdirks@pacbell.net>
  16.  * based on code by Alan Cox, <alan@cymru.net>
  17.  *
  18.  * gcc -c -O2 -Wall -DMODULE videodev.c
  19.  */
  21. #ifndef __KERNEL__
  22. #define __KERNEL__
  23. #endif
  25. #include <linux/config.h>
  26. #ifndef EXPORT_SYMTAB
  27. #define EXPORT_SYMTAB
  28. #endif
  29. #include <linux/module.h>
  30. #include <linux/types.h>
  31. #include <linux/kernel.h>
  32. #include <linux/sched.h>
  33. #include <linux/mm.h>
  34. #include <linux/poll.h>
  35. #include <linux/string.h>
  36. #include <linux/errno.h>
  37. #include <linux/videodev2.h>
  38. #include <linux/proc_fs.h>
  40. #include <asm/uaccess.h>
  41. #include <asm/system.h>
  42. #include <asm/pgtable.h>
  43. #include <asm/io.h>
  45. #ifdef CONFIG_KMOD
  46. #include <linux/kmod.h>
  47. #endif
  49. #ifndef min
  50. #define min(a,b) (((a)<(b))?(a):(b))
  51. #endif
  54. static int v4l2_major = 81;
  55. MODULE_PARM(v4l2_major, "i");
  57. #define V4L2_NUM_DEVICES 256 
  59. /*
  60.  * Active devices 
  61.  */
  62. static struct v4l2_device *v4l2_device[V4L2_NUM_DEVICES];
  64. static struct v4l2_clock *masterclock;
  67. /*
  68.  * D E V I C E   O P E R A T I O N S
  69.  *
  70.  */
  72. /*
  73.  * Open a video device.
  74.  */
  75. static int
  76. video_open(struct inode *inode, struct file *file)
  77. {
  78. unsigned int minor = MINOR(inode->i_rdev);
  79. struct v4l2_device *vfl;
  80. int err;
  82. if (minor >= V4L2_NUM_DEVICES)
  83. return -ENODEV;
  84. vfl = v4l2_device[minor];
  85. if (vfl == NULL)
  86. {
  87. #ifdef CONFIG_KMOD /*  KMOD code by Erik Walthinsen  */
  88. char modname[20];
  90. sprintf(modname, "char-major-%d-%d", v4l2_major, minor);
  91. request_module(modname);
  92. vfl = v4l2_device[minor];
  93. if (vfl == NULL)
  94. #endif
  95. return -ENODEV;
  96. }
  97. if (vfl->open == NULL)
  98. return -ENODEV;
  99. err = vfl->open(vfl, file->f_flags, &file->private_data);
  100. if (err == 0 && file->private_data == NULL)
  101. {
  102. printk(KERN_ERR"V4L2: Device returned NULL open idn");
  103. err = -ENODEV;
  104. }
  105. if (err == 0)
  106. ++vfl->busy;
  107. return err;
  108. }
  110. /*
  111.  * Last close of a struct file
  112.  */
  113. static int
  114. video_release(struct inode *inode, struct file *file)
  115. {
  116. struct v4l2_device *vfl = v4l2_device[MINOR(inode->i_rdev)];
  117. if (vfl->close)
  118. vfl->close(file->private_data);
  119. file->private_data = NULL;
  120. if (vfl->busy)
  121. --vfl->busy;
  122. return 0;
  123. }
  125. /*
  126.  * Read from a video device
  127.  */
  128. static ssize_t
  129. video_read(struct file *file,
  130.    char *buf, size_t count, loff_t *ppos)
  131. {
  132. struct v4l2_device *vfl =
  133. v4l2_device[MINOR(file->f_dentry->d_inode->i_rdev)];
  134. if (vfl->read)
  135. return vfl->read(file->private_data, buf, count,
  136.  file->f_flags & O_NONBLOCK);
  137. return -EINVAL;
  138. }
  140. /*
  141.  * Write to a video device
  142.  */
  143. static ssize_t
  144. video_write(struct file *file,
  145.     const char *buf, size_t count, loff_t *ppos)
  146. {
  147. struct v4l2_device *vfl =
  148. v4l2_device[MINOR(file->f_dentry->d_inode->i_rdev)];
  149. if (vfl->write)
  150. return vfl->write(file->private_data, buf, count,
  151.   file->f_flags & O_NONBLOCK);
  152. return 0;
  153. }
  155. /*
  156.  * IO Control
  157.  */
  158. static void
  159. fill_ctrl_category(struct v4l2_queryctrl *qc);
  161. static int
  162. translate_ioctl(struct file *file,
  163. struct v4l2_device *vfl,
  164. void *per_open_data,
  165. int cmd,
  166. void *arg);
  168. static int
  169. video_ioctl(struct inode *inode, struct file *file,
  170.     unsigned int cmd, unsigned long arg)
  171. {
  172. struct v4l2_device *vfl = v4l2_device[MINOR(inode->i_rdev)];
  173. char targ[V4L2_MAX_IOCTL_SIZE];
  174. void *parg = (void *)arg;
  175. int err = -EINVAL;
  177. if (vfl->ioctl == NULL)
  178. return -EINVAL;
  180. /*  Copy arguments into temp kernel buffer  */
  181. switch (_IOC_DIR(cmd))
  182. {
  183. case _IOC_NONE:
  184. parg = (void *)arg;
  185. break;
  186. case _IOC_WRITE:
  187. case (_IOC_WRITE | _IOC_READ):
  188. if (_IOC_SIZE(cmd) > sizeof(targ))
  189. {
  190. printk(KERN_ERR"V4L2: ioctl 0x%08x arguments are "
  191.        "too big, > %dn", cmd, sizeof(targ));
  192. break;/*  Arguments are too big.  */
  193. }
  194. if (copy_from_user(targ, (void *)arg, _IOC_SIZE(cmd)))
  195. {
  196. printk(KERN_INFO"V4L2: Fault on write ioctl 0x%08x "
  197.        "copying data from user buffern", cmd);
  198. return -EFAULT;
  199. }
  200. parg = targ;
  201. break;
  202. case _IOC_READ:
  203. parg = targ;
  204. break;
  205. }
  207. /*  Fill in the category for pre-defined controls  */
  208. if (cmd == VIDIOC_QUERYCTRL)
  209. fill_ctrl_category((struct v4l2_queryctrl *)parg);
  211. /*  Try passing it to the driver first  */
  212. err = vfl->ioctl(file->private_data, cmd, parg);
  214. /*  If the driver doesn't recognize it and it's an old ioctl,
  215.     pass it through the translation layer.  */
  216. if (err == -ENOIOCTLCMD && _IOC_TYPE(cmd) == 'v')
  217. {
  218. err = translate_ioctl(file, vfl, file->private_data, 
  219.       cmd, parg);
  220. }
  222. /*  Copy results into user buffer  */
  223. switch (_IOC_DIR(cmd))
  224. {
  225. case _IOC_READ:
  226. case (_IOC_WRITE | _IOC_READ):
  227. if (parg == targ &&
  228.     copy_to_user((void *)arg, parg, _IOC_SIZE(cmd)))
  229. {
  230. printk(KERN_INFO"V4L2: Fault on read ioctl 0x%08x "
  231.        "copying results to user buffern", cmd);
  232. return -EFAULT;
  233. }
  234. break;
  235. }
  237. if (err != -ENOIOCTLCMD)
  238. return err;
  240. /*  Handle ioctls not recognized by the driver  */
  241. return -EINVAL;
  242. }
  244. /*
  245.  * Memory mapping
  246.  */ 
  247. static int
  248. video_mmap(struct file *file, struct vm_area_struct *vma)
  249. {
  250. struct v4l2_device *vfl =
  251. v4l2_device[MINOR(file->f_dentry->d_inode->i_rdev)];
  252. int err;
  253. if (vfl->mmap)
  254. {
  255. vma->vm_file = file;
  256. /*  For v4l compatibility. v4l apps typically pass zero */
  257. /*  for the offset, so replace it with the real value */
  258. /*  saved from before */
  259. if (vma->vm_offset == 0 && vfl->ioctl)
  260. {
  261. struct v4l2_buffer buf;
  262. buf.index = 0;
  263. buf.type = V4L2_BUF_TYPE_CAPTURE;
  264. if (vfl->ioctl(file->private_data,
  265.        VIDIOC_QUERYBUF, &buf) == 0)
  266. vma->vm_offset = buf.offset;
  267. }
  268. err = vfl->mmap(file->private_data, vma);
  269. #if LINUX_VERSION_CODE < KERNEL_VERSION(2,2,3)
  270. /* This is now done in the kernel, as it should be */
  271.   if (err == 0 && vma->vm_file != NULL)
  272. ++vma->vm_file->f_count;
  273. #endif
  274. return err;
  275. }
  276. return -ENODEV;
  277. }
  279. /*
  280.  * Poll (select()) support
  281.  */
  282. static unsigned int
  283. video_poll(struct file *file, poll_table *table)
  284. {
  285. struct v4l2_device *vfl =
  286. v4l2_device[MINOR(file->f_dentry->d_inode->i_rdev)];
  287. if (vfl->poll)
  288. return vfl->poll(file->private_data, file, table);
  289. return POLLERR;
  290. }
  292. /*
  293.  * Not used.
  294.  */ 
  295. static long long
  296. video_lseek(struct file *file,
  297.     long long offset, int origin)
  298. {
  299. return -ESPIPE;
  300. }
  302. /*
  303.  * CONTROL CATEGORIES
  304.  */
  305. static void
  306. fill_ctrl_category(struct v4l2_queryctrl *qc)
  307. {
  308. if ((qc->id >= V4L2_CID_BRIGHTNESS &&
  309.      qc->id <= V4L2_CID_HUE) ||
  310.     (qc->id >= V4L2_CID_BLACK_LEVEL &&
  311.      qc->id <= V4L2_CID_LASTP1-1))
  312. {
  313. qc->category = V4L2_CTRL_CAT_VIDEO;
  314. strcpy(qc->catname, "Video");
  315. }
  316. if ((qc->id >= V4L2_CID_AUDIO_VOLUME &&
  317.      qc->id <= V4L2_CID_AUDIO_LOUDNESS))
  318. {
  319. qc->category = V4L2_CTRL_CAT_AUDIO;
  320. strcpy(qc->catname, "Audio");
  321. }
  322. if ((qc->id >= V4L2_CID_EFFECT_BASE &&
  323.      qc->id <= V4L2_CID_EFFECT_BASE + 10000))
  324. {
  325. qc->category = V4L2_CTRL_CAT_EFFECT;
  326. strcpy(qc->catname, "Effect");
  327. }
  328. strcpy(qc->catname, "Private");
  329. }
  331. /*
  332.  * B A C K W A R D   C O M P A T I B I L I T Y
  333.  *
  334.  * This code allows applications written for the original API to
  335.  * work with drivers that only understand the new API.
  336.  */
  338. static int
  339. get_v4l_control(struct v4l2_device *vfl,
  340. void *context,
  341. int cid)
  342. {
  343. struct v4l2_queryctrl qctrl2;
  344. struct v4l2_control ctrl2;
  345. int err;
  347. qctrl2.id = cid;
  348. err = vfl->ioctl(context, VIDIOC_QUERYCTRL, &qctrl2);
  349. if (err == 0)
  350. {
  351. ctrl2.id = qctrl2.id;
  352. vfl->ioctl(context, VIDIOC_G_CTRL, &ctrl2);
  353. return ((ctrl2.value - qctrl2.minimum) * 65535
  354.  + (qctrl2.maximum - qctrl2.minimum) / 2)
  355. / (qctrl2.maximum - qctrl2.minimum);
  356. }
  357. return 0;
  358. }
  360. static int
  361. set_v4l_control(struct v4l2_device *vfl,
  362. void *context,
  363. int cid,
  364. int value)
  365. {
  366. struct v4l2_queryctrl qctrl2;
  367. struct v4l2_control ctrl2;
  368. int err;
  370. qctrl2.id = cid;
  371. err = vfl->ioctl(context, VIDIOC_QUERYCTRL, &qctrl2);
  372. if (err == 0)
  373. {
  374. if (value < 0)
  375. value = 0;
  376. if (value > 65535)
  377. value = 65535;
  378. ctrl2.id = qctrl2.id;
  379. ctrl2.value = 
  380. (value * (qctrl2.maximum - qctrl2.minimum)
  381.  + 32767)
  382. / 65535;
  383. vfl->ioctl(context, VIDIOC_S_CTRL, &ctrl2);
  384. }
  385. return 0;
  386. }
  388. static int
  389. find_tuner(struct v4l2_device *vfl,
  390.    void *context,
  391.    int n)
  392. {
  393. struct v4l2_input inp2;
  394. int i;
  395. int err;
  397. /*  Find the input number of the n'th tuner  */
  398. for (i = 0; i < 100/*arbitrary*/; ++i)
  399. {
  400. inp2.index = i;
  401. err = vfl->ioctl(context, VIDIOC_ENUMINPUT, &inp2);
  402. if (err < 0)
  403. break;
  404. if (inp2.type != V4L2_INPUT_TYPE_TUNER)
  405. continue;
  406. if (n == 0)
  407. break;
  408. --n;
  409. }
  410. if (err < 0)
  411. return err;
  412. return i;
  413. }
  415. static int
  416. palette_to_pixelformat(int palette)
  417. {
  418. int pixelformat = 0;
  419. switch (palette)
  420. {
  421. case VIDEO_PALETTE_GREY:
  422. pixelformat = V4L2_PIX_FMT_GREY;
  423. break;
  424. case VIDEO_PALETTE_RGB555:
  425. pixelformat = V4L2_PIX_FMT_RGB555;
  426. break;
  427. case VIDEO_PALETTE_RGB565:
  428. pixelformat = V4L2_PIX_FMT_RGB565;
  429. break;
  430. case VIDEO_PALETTE_RGB24:
  431. pixelformat = V4L2_PIX_FMT_BGR24;
  432. break;
  433. case VIDEO_PALETTE_RGB32:
  434. pixelformat = V4L2_PIX_FMT_BGR32;
  435. break;
  436. case VIDEO_PALETTE_YUYV:
  437. case VIDEO_PALETTE_YUV422:
  438. pixelformat = V4L2_PIX_FMT_YUYV;
  439. break;
  440. case VIDEO_PALETTE_UYVY:
  441. pixelformat = V4L2_PIX_FMT_UYVY;
  442. break;
  443. case VIDEO_PALETTE_YUV420:
  444. pixelformat = V4L2_PIX_FMT_YUV420;
  445. break;
  446. case VIDEO_PALETTE_YUV422P:
  447. pixelformat = V4L2_PIX_FMT_YVU422P;
  448. break;
  449. case VIDEO_PALETTE_YUV411P:
  450. pixelformat = V4L2_PIX_FMT_YVU411P;
  451. break;
  452. }
  453. return pixelformat;
  454. }
  456. static int
  457. pixelformat_to_palette(int pixelformat)
  458. {
  459. int palette = 0;
  460. switch (pixelformat)
  461. {
  462. case V4L2_PIX_FMT_GREY:
  463. palette = VIDEO_PALETTE_GREY;
  464. break;
  465. case V4L2_PIX_FMT_RGB555:
  466. palette = VIDEO_PALETTE_RGB555;
  467. break;
  468. case V4L2_PIX_FMT_RGB565:
  469. palette = VIDEO_PALETTE_RGB565;
  470. break;
  471. case V4L2_PIX_FMT_BGR24:
  472. palette = VIDEO_PALETTE_RGB24;
  473. break;
  474. case V4L2_PIX_FMT_BGR32:
  475. palette = VIDEO_PALETTE_RGB32;
  476. break;
  477. case V4L2_PIX_FMT_YUYV:
  478. palette = VIDEO_PALETTE_YUYV;
  479. break;
  480. case V4L2_PIX_FMT_UYVY:
  481. palette = VIDEO_PALETTE_UYVY;
  482. break;
  483. case V4L2_PIX_FMT_YUV420:
  484. palette = VIDEO_PALETTE_YUV420;
  485. break;
  486. case V4L2_PIX_FMT_YVU422P:
  487. palette = VIDEO_PALETTE_YUV422P;
  488. break;
  489. case V4L2_PIX_FMT_YVU411P:
  490. palette = VIDEO_PALETTE_YUV411P;
  491. break;
  492. }
  493. return palette;
  494. }
  496. /*  Do an 'in' (wait for input) select on a single file descriptor  */
  497. /*  This stuff plaigarized from linux/fs/select.c     */
  498. #define __FD_IN(fds, n) (fds->in + n)
  499. #define BIT(i) (1UL << ((i)&(__NFDBITS-1)))
  500. #define SET(i,m) (*(m) |= (i))
  502. #ifndef HAVE_DO_SELECT
  504. /*  Note: This code, inside the #ifndef HAVE_DO_SELECT ... #endif,
  505.     is copied from fs/select.c, and is only included
  506.     here because do_select() is not exported to modules. In the future
  507.     export do_select() to modules and delete this code down to the
  508.     #endif. Thank you.
  509. */
  511. #include <linux/smp_lock.h>
  512. #include <linux/file.h>
  513. #define BITS(fds, n) (*__FD_IN(fds, n))
  514. #define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
  515. #define POLLIN_SET (POLLRDNORM | POLLRDBAND | POLLIN | POLLHUP | POLLERR)
  516. #define ISSET(i,m) (((i)&*(m)) != 0)
  517. static void free_wait(poll_table * p)
  518. {
  519.         struct poll_table_entry * entry;
  520.         poll_table *old;
  522.         while (p) {
  523.                 entry = p->entry + p->nr;
  524.                 while (p->nr > 0) {
  525.                         p->nr--;
  526.                         entry--;
  527.                         remove_wait_queue(entry->wait_address,&entry->wait);
  528.                         fput(entry->filp);
  529.                 }
  530.                 old = p;
  531.                 p = p->next;
  532.                 free_page((unsigned long) old);
  533.         }
  534. }
  535. static int 
  536. my_do_select(int n, fd_set_bits *fds, long *timeout)
  537. {
  538. poll_table *wait_table, *wait;
  539. int retval, i, off;
  540. long __timeout = *timeout;
  542. wait = wait_table = NULL;
  543. if (__timeout) {
  544. wait_table = (poll_table *) __get_free_page(GFP_KERNEL);
  545. if (!wait_table)
  546. return -ENOMEM;
  548. wait_table->nr = 0;
  549. wait_table->entry = (struct poll_table_entry *)(wait_table + 1);
  550. wait_table->next = NULL;
  551. wait = wait_table;
  552. }
  554. lock_kernel();
  556. // retval = max_select_fd(n, fds);
  557. //if (retval < 0)
  558. // goto out;
  559. //n = retval;
  560. retval = 0;
  561. for (;;) {
  562. current->state = TASK_INTERRUPTIBLE;
  563. for (i = 0 ; i < n; i++) {
  564. unsigned long bit = BIT(i);
  565. unsigned long mask;
  566. struct file *file;
  568. off = i / __NFDBITS;
  569. if (!(bit & BITS(fds, off)))
  570. continue;
  571. /*
  572.  * The poll_wait routine will increment f_count if
  573.  * the file is added to the wait table, so we don't
  574.  * need to increment it now.
  575.  */
  576. file = fcheck(i);
  577. mask = POLLNVAL;
  578. if (file) {
  579. mask = DEFAULT_POLLMASK;
  580. if (file->f_op && file->f_op->poll)
  581. mask = file->f_op->poll(file, wait);
  582. }
  583. if ((mask & POLLIN_SET) && ISSET(bit, __FD_IN(fds,off))) {
  584. retval++;
  585. wait = NULL;
  586. }
  587. }
  588. wait = NULL;
  589. if (retval || !__timeout || signal_pending(current))
  590. break;
  591. __timeout = schedule_timeout(__timeout);
  592. }
  593. current->state = TASK_RUNNING;
  595. //out:
  596. if (*timeout)
  597. free_wait(wait_table);
  599. /*
  600.  * Up-to-date the caller timeout.
  601.  */
  602. *timeout = __timeout;
  603. unlock_kernel();
  604. return retval;
  605. }
  606. #endif // HAVE_DO_SELECT
  608. static int
  609. simple_select(struct file *file)
  610. {
  611. fd_set_bits fds;
  612. char *bits;
  613. long timeout;
  614. int i, fd, n, ret, size;
  616. for (i = 0; i < current->files->max_fds; ++i)
  617. if (file == current->files->fd[i])
  618. break;
  619. if (i == current->files->max_fds)
  620. return -EINVAL;
  621. fd = i;
  622. n = fd + 1;
  624. timeout = MAX_SCHEDULE_TIMEOUT;
  625. /*
  626.  * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
  627.  * since we used fdset we need to allocate memory in units of
  628.  * long-words. 
  629.  */
  630. ret = -ENOMEM;
  631. size = FDS_BYTES(n);
  632. bits = kmalloc(6 * size, GFP_KERNEL);
  633. if (!bits)
  634. goto out_nofds;
  635. fds.in      = (unsigned long *)  bits;
  636. fds.out     = (unsigned long *) (bits +   size);
  637. fds.ex      = (unsigned long *) (bits + 2*size);
  638. fds.res_in  = (unsigned long *) (bits + 3*size);
  639. fds.res_out = (unsigned long *) (bits + 4*size);
  640. fds.res_ex  = (unsigned long *) (bits + 5*size);
  642. /*  All zero except our one file descriptor bit, for input  */
  643. memset(bits, 0, 6 * size);
  644. SET(BIT(fd), __FD_IN((&fds), fd / __NFDBITS));
  646. ret = my_do_select(n, &fds, &timeout);
  648. if (ret < 0)
  649. goto out;
  650. if (!ret) {
  651. ret = -ERESTARTNOHAND;
  652. if (signal_pending(current))
  653. goto out;
  654. ret = 0;
  655. }
  656. out:
  657. kfree(bits);
  658. out_nofds:
  659. return ret;
  660. }
  662. extern int make_my_day(void);
  664. static int
  665. translate_ioctl(struct file *file,
  666. struct v4l2_device *vfl,
  667. void *context,
  668. int cmd,
  669. void *arg)
  670. {
  671. int err = -ENOIOCTLCMD;
  673. switch (cmd)
  674. {
  675. case VIDIOCGCAP: /* capability */
  676. {
  677. struct video_capability *cap = arg;
  678. struct v4l2_capability cap2;
  679. struct v4l2_framebuffer fbuf2;
  681. err = vfl->ioctl(context, VIDIOC_QUERYCAP, &cap2);
  682. if (err < 0)
  683. break;
  684. if (cap2.flags & V4L2_FLAG_PREVIEW)
  685. {
  686. err = vfl->ioctl(context, VIDIOC_G_FBUF, &fbuf2);
  687. if (err < 0)
  688. memset(&fbuf2, 0, sizeof(fbuf2));
  689. err = 0;
  690. }
  691. memset(cap, 0, sizeof(cap));
  692. memcpy(cap->name, cap2.name, 
  693.        min(sizeof(cap->name), sizeof(cap2.name)));
  694. cap->name[sizeof(cap->name) - 1] = 0;
  695. if (cap2.type == V4L2_TYPE_CAPTURE)
  696. cap->type = VID_TYPE_CAPTURE;
  697. if (cap2.flags & V4L2_FLAG_TUNER)
  698. cap->type |= VID_TYPE_TUNER;
  699. if (cap2.flags & V4L2_FLAG_DATA_SERVICE)
  700. cap->type |= VID_TYPE_TELETEXT;
  701. if (cap2.flags & V4L2_FLAG_PREVIEW)
  702. cap->type |= VID_TYPE_OVERLAY;
  703. if (cap2.flags & V4L2_FLAG_MONOCHROME)
  704. cap->type |= VID_TYPE_MONOCHROME;
  705. if (fbuf2.flags & V4L2_FBUF_FLAG_PRIMARY)
  706. cap->type |= VID_TYPE_FRAMERAM;
  707. if (fbuf2.capability & V4L2_FBUF_CAP_CHROMAKEY)
  708. cap->type |= VID_TYPE_CHROMAKEY;
  709. if (fbuf2.capability & V4L2_FBUF_CAP_CLIPPING)
  710. cap->type |= VID_TYPE_CLIPPING;
  711. if (fbuf2.capability & V4L2_FBUF_CAP_SCALEUP ||
  712.     fbuf2.capability & V4L2_FBUF_CAP_SCALEDOWN)
  713. cap->type |= VID_TYPE_SCALES;
  714. cap->channels  = cap2.inputs;
  715. cap->audios    = cap2.audios;
  716. cap->maxwidth  = cap2.maxwidth;
  717. cap->maxheight = cap2.maxheight;
  718. cap->minwidth  = cap2.minwidth;
  719. cap->minheight = cap2.minheight;
  720. break;
  721. }
  722. case VIDIOCGFBUF: /*  get frame buffer  */
  723. {
  724. struct video_buffer *buffer = arg;
  725. struct v4l2_framebuffer fbuf2;
  727. err = vfl->ioctl(context, VIDIOC_G_FBUF, &fbuf2);
  728. if (err < 0)
  729. break;
  730. buffer->base = fbuf2.base[0];
  731. buffer->height = fbuf2.fmt.height;
  732. buffer->width = fbuf2.fmt.width;
  733. buffer->depth = fbuf2.fmt.depth;
  734. if (fbuf2.fmt.flags & V4L2_FMT_FLAG_BYTESPERLINE)
  735. buffer->bytesperline = fbuf2.fmt.bytesperline;
  736. else
  737. {
  738. buffer->bytesperline = 
  739. (fbuf2.fmt.width * fbuf2.fmt.depth + 7) & 7;
  740. buffer->bytesperline >>= 3;
  741. }
  742. if (fbuf2.fmt.pixelformat == V4L2_PIX_FMT_RGB555)
  743. buffer->depth = 15;
  744. break;
  745. }
  746. case VIDIOCSFBUF: /*  set frame buffer  */
  747. {
  748. struct video_buffer *buffer = arg;
  749. struct v4l2_framebuffer fbuf2;
  751. memset(&fbuf2, 0, sizeof(fbuf2));
  752. fbuf2.base[0] = buffer->base;
  753. fbuf2.fmt.height = buffer->height;
  754. fbuf2.fmt.width = buffer->width;
  755. fbuf2.fmt.depth = buffer->depth;
  756. switch (fbuf2.fmt.depth)
  757. {
  758. case 8:
  759. fbuf2.fmt.pixelformat = V4L2_PIX_FMT_RGB332;
  760. break;
  761. case 15:
  762. fbuf2.fmt.depth = 16;
  763. fbuf2.fmt.pixelformat = V4L2_PIX_FMT_RGB555;
  764. break;
  765. case 16:
  766. fbuf2.fmt.pixelformat = V4L2_PIX_FMT_RGB565;
  767. break;
  768. case 24:
  769. fbuf2.fmt.pixelformat = V4L2_PIX_FMT_BGR24;
  770. break;
  771. case 32:
  772. fbuf2.fmt.pixelformat = V4L2_PIX_FMT_BGR32;
  773. break;
  774. }
  775. fbuf2.fmt.flags |= V4L2_FMT_FLAG_BYTESPERLINE;
  776. fbuf2.fmt.bytesperline = buffer->bytesperline;
  777. fbuf2.flags = V4L2_FBUF_FLAG_PRIMARY;
  778. err = vfl->ioctl(context, VIDIOC_S_FBUF, &fbuf2);
  779. break;
  780. }
  781. case VIDIOCGWIN: /*  get window or capture dimensions  */
  782. {
  783. struct video_window *win = arg;
  784. struct v4l2_window win2;
  785. struct v4l2_format fmt2;
  787. err = vfl->ioctl(context, VIDIOC_G_WIN, &win2);
  788. if (err == 0)
  789. {
  790. win->x = win2.x;
  791. win->y = win2.y;
  792. win->width = win2.width;
  793. win->height = win2.height;
  794. win->chromakey = win2.chromakey;
  795. win->clips = NULL;
  796. win->clipcount = 0;
  797. break;
  798. }
  799. err = vfl->ioctl(context, VIDIOC_G_FMT, &fmt2);
  800. if (err < 0)
  801. break;
  802. win->x = 0;
  803. win->y = 0;
  804. win->width = fmt2.width;
  805. win->height = fmt2.height;
  806. win->chromakey = 0;
  807. win->clips = NULL;
  808. win->clipcount = 0;
  809. break;
  810. }
  811. case VIDIOCSWIN: /*  set window and/or capture dimensions  */
  812. {
  813. struct video_window *win = arg;
  814. struct v4l2_window win2;
  815. struct v4l2_format fmt2;
  817. err = vfl->ioctl(context, VIDIOC_G_FMT, &fmt2);
  818. if (err == 0)
  819. {
  820. fmt2.width = win->width;
  821. fmt2.height = win->height;
  822. err = vfl->ioctl(context, VIDIOC_S_FMT, &fmt2);
  823. win->width = fmt2.width;
  824. win->height = fmt2.height;
  825. }
  826. win2.x = win->x;
  827. win2.y = win->y;
  828. win2.width = win->width;
  829. win2.height = win->height;
  830. win2.chromakey = win->chromakey;
  831. win2.clips = (void *)win->clips;
  832. win2.clipcount = win->clipcount;
  833. vfl->ioctl(context, VIDIOC_S_WIN, &win2);
  834. break;
  835. }
  836. case VIDIOCCAPTURE: /*  turn on/off preview  */
  837. {
  838. err = vfl->ioctl(context, VIDIOC_PREVIEW, arg);
  839. break;
  840. }
  841. case VIDIOCGCHAN: /*  get input information  */
  842. {
  843. struct video_channel *chan = arg;
  844. struct v4l2_input input2;
  845. struct v4l2_standard std2;
  846. int sid;
  848. input2.index = chan->channel;
  849. err = vfl->ioctl(context, VIDIOC_ENUMINPUT, &input2);
  850. if (err < 0)
  851. break;
  852. chan->channel = input2.index;
  853. memcpy(chan->name, input2.name,
  854.        min(sizeof(chan->name), sizeof(input2.name)));
  855. chan->name[sizeof(chan->name) - 1] = 0;
  856. chan->tuners = (input2.type == V4L2_INPUT_TYPE_TUNER) ? 1 : 0;
  857. chan->flags = (chan->tuners) ? VIDEO_VC_TUNER : 0;
  858. if (input2.capability & V4L2_INPUT_CAP_AUDIO)
  859. chan->flags |= VIDEO_VC_AUDIO;
  860. switch (input2.type)
  861. {
  862. case V4L2_INPUT_TYPE_TUNER:
  863. chan->type = VIDEO_TYPE_TV;
  864. break;
  865. default:
  866. case V4L2_INPUT_TYPE_CAMERA:
  867. chan->type = VIDEO_TYPE_CAMERA;
  868. break;
  869. }
  870. chan->norm = 0;
  871. err = vfl->ioctl(context, VIDIOC_G_STD, &std2);
  872. if (err == 0)
  873. {
  874. sid = v4l2_video_std_confirm(&std2);
  875. switch (sid)
  876. {
  877. case V4L2_STD_NTSC:
  878. chan->norm = VIDEO_MODE_NTSC;
  879. break;
  880. case V4L2_STD_PAL:
  881. chan->norm = VIDEO_MODE_PAL;
  882. break;
  883. case V4L2_STD_SECAM:
  884. chan->norm = VIDEO_MODE_SECAM;
  885. break;
  886. }
  887. }
  888. break;
  889. }
  890. case VIDIOCSCHAN: /*  set input  */
  891. {
  892. err = vfl->ioctl(context, VIDIOC_S_INPUT, 
  893.  (void *)(*(int *)arg));
  894. break;
  895. }
  896. case VIDIOCGPICT: /*  get tone controls & partial capture format  */
  897. {
  898. struct video_picture *pict = arg;
  899. struct v4l2_format fmt2;
  901. pict->brightness = get_v4l_control(vfl, context, 
  902.    V4L2_CID_BRIGHTNESS);
  903. pict->hue = get_v4l_control(vfl, context, 
  904.     V4L2_CID_HUE);
  905. pict->contrast = get_v4l_control(vfl, context, 
  906.  V4L2_CID_CONTRAST);
  907. pict->colour = get_v4l_control(vfl, context, 
  908.        V4L2_CID_SATURATION);
  909. pict->whiteness = get_v4l_control(vfl, context, 
  910.   V4L2_CID_WHITENESS);
  911. err = vfl->ioctl(context, VIDIOC_G_FMT, &fmt2);
  912. if (err < 0)
  913. break;
  914. pict->depth = fmt2.depth;
  915. pict->palette = pixelformat_to_palette(fmt2.pixelformat);
  916. if (pict->palette == VIDEO_PALETTE_RGB555)
  917. pict->depth = 15;
  918. break;
  919. }
  920. case VIDIOCSPICT: /*  set tone controls & partial capture format  */
  921. {
  922. struct video_picture *pict = arg;
  923. struct v4l2_format fmt2;
  925. set_v4l_control(vfl, context,
  926. V4L2_CID_BRIGHTNESS, pict->brightness);
  927. set_v4l_control(vfl, context,
  928. V4L2_CID_HUE, pict->hue);
  929. set_v4l_control(vfl, context,
  930. V4L2_CID_CONTRAST, pict->contrast);
  931. set_v4l_control(vfl, context,
  932. V4L2_CID_SATURATION, pict->colour);
  933. set_v4l_control(vfl, context,
  934. V4L2_CID_WHITENESS, pict->whiteness);
  935. err = 0;
  936. vfl->ioctl(context, VIDIOC_G_FMT, &fmt2);
  937. if (fmt2.pixelformat != palette_to_pixelformat(pict->palette))
  938. {
  939. fmt2.pixelformat = palette_to_pixelformat(
  940. pict->palette);
  941. err = vfl->ioctl(context, VIDIOC_S_FMT, &fmt2);
  942. }
  943. break;
  944. }
  945. case VIDIOCGTUNER: /*  get tuner information  */
  946. {
  947. struct video_tuner *tun = arg;
  948. struct v4l2_tuner tun2;
  949. int i;
  950. int sid;
  952. i = find_tuner(vfl, context, tun->tuner);
  953. if (i < 0)
  954. {
  955. err = i;
  956. break;
  957. }
  958. tun2.input = i;
  959. err = vfl->ioctl(context, VIDIOC_G_TUNER, &tun2);
  960. if (err < 0)
  961. break;
  962. memcpy(tun->name, tun2.name,
  963.        min(sizeof(tun->name), sizeof(tun2.name)));
  964. tun->name[sizeof(tun->name) - 1] = 0;
  965. tun->rangelow = tun2.rangelow;
  966. tun->rangehigh = tun2.rangehigh;
  967. tun->flags = 0;
  968. tun->mode = VIDEO_MODE_AUTO;
  969. sid = v4l2_video_std_confirm(&tun2.std);
  970. switch (sid)
  971. {
  972. case V4L2_STD_NTSC:
  973. tun->flags = VIDEO_TUNER_NTSC;
  974. tun->mode = VIDEO_MODE_NTSC;
  975. break;
  976. case V4L2_STD_PAL:
  977. tun->flags = VIDEO_TUNER_PAL;
  978. tun->mode = VIDEO_MODE_PAL;
  979. break;
  980. case V4L2_STD_SECAM:
  981. tun->flags = VIDEO_TUNER_SECAM;
  982. tun->mode = VIDEO_MODE_SECAM;
  983. break;
  984. }
  985. if (tun2.capability & V4L2_TUNER_CAP_LOW)
  986. tun->flags |= VIDEO_TUNER_LOW;
  987. if (tun2.rxsubchans & V4L2_TUNER_SUB_STEREO)
  988. tun->flags |= VIDEO_TUNER_STEREO_ON;
  989. tun->signal = tun2.signal;
  990. break;
  991. }
  992. case VIDIOCSTUNER: /*  select a tuner input  */
  993. {
  994. int i;
  996. i = find_tuner(vfl, context, (int)arg);
  997. if (i < 0)
  998. {
  999. err = i;
  1000. break;
  1001. }
  1002. err = vfl->ioctl(context, VIDIOC_S_INPUT, (void *)i);
  1003. break;
  1004. }
  1005. case VIDIOCGFREQ: /*  get frequency  */
  1006. {
  1007. err = vfl->ioctl(context, VIDIOC_G_FREQ, arg);
  1008. break;
  1009. }
  1010. case VIDIOCSFREQ: /*  set frequency  */
  1011. {
  1012. err = vfl->ioctl(context, VIDIOC_S_FREQ,
  1013.  (void *)(*(int *)arg));
  1014. break;
  1015. }
  1016. case VIDIOCGAUDIO: /*  get audio properties/controls  */
  1017. {
  1018. struct video_audio *aud = arg;
  1019. struct v4l2_audio aud2;
  1020. struct v4l2_queryctrl qctrl2;
  1021. struct v4l2_tuner tun2;
  1022. int v;
  1024. err = vfl->ioctl(context, VIDIOC_G_AUDIO, &aud2);
  1025. if (err < 0)
  1026. break;
  1027. memcpy(aud->name, aud2.name,
  1028.        min(sizeof(aud->name), sizeof(aud2.name)));
  1029. aud->name[sizeof(aud->name) - 1] = 0;
  1030. aud->audio = aud2.audio;
  1031. aud->flags = 0;
  1032. v = get_v4l_control(vfl, context, V4L2_CID_AUDIO_VOLUME);
  1033. if (v >= 0)
  1034. {
  1035. aud->volume = v;
  1036. aud->flags |= VIDEO_AUDIO_VOLUME;
  1037. }
  1038. v = get_v4l_control(vfl, context, V4L2_CID_AUDIO_BASS);
  1039. if (v >= 0)
  1040. {
  1041. aud->bass = v;
  1042. aud->flags |= VIDEO_AUDIO_BASS;
  1043. }
  1044. v = get_v4l_control(vfl, context, V4L2_CID_AUDIO_TREBLE);
  1045. if (v >= 0)
  1046. {
  1047. aud->treble = v;
  1048. aud->flags |= VIDEO_AUDIO_TREBLE;
  1049. }
  1050. v = get_v4l_control(vfl, context, V4L2_CID_AUDIO_BALANCE);
  1051. if (v >= 0)
  1052. {
  1053. aud->balance = v;
  1054. aud->flags |= VIDEO_AUDIO_BALANCE;
  1055. }
  1056. v = get_v4l_control(vfl, context, V4L2_CID_AUDIO_MUTE);
  1057. if (v >= 0)
  1058. {
  1059. if (v)
  1060. aud->flags |= VIDEO_AUDIO_MUTE;
  1061. aud->flags |= VIDEO_AUDIO_MUTABLE;
  1062. }
  1063. aud->step = 1;
  1064. qctrl2.id = V4L2_CID_AUDIO_VOLUME;
  1065. if (vfl->ioctl(context, VIDIOC_QUERYCTRL, &qctrl2) == 0)
  1066. aud->step = qctrl2.step;
  1067. aud->mode = 0;
  1068. err = vfl->ioctl(context, VIDIOC_G_TUNER, &tun2);
  1069. if (err < 0)
  1070. {
  1071. err = 0;
  1072. break;
  1073. }
  1074. switch (tun2.audmode)
  1075. {
  1076. case V4L2_TUNER_MODE_MONO:
  1077. aud->mode = VIDEO_SOUND_MONO;
  1078. break;
  1079. case V4L2_TUNER_MODE_STEREO:
  1080. aud->mode = VIDEO_SOUND_STEREO;
  1081. break;
  1082. case V4L2_TUNER_MODE_LANG2:
  1083. aud->mode = VIDEO_SOUND_LANG2;
  1084. break;
  1085. }
  1086. break;
  1087. }
  1088. case VIDIOCSAUDIO: /*  set audio controls  */
  1089. {
  1090. struct video_audio *aud = arg;
  1091. struct v4l2_audio aud2;
  1092. struct v4l2_tuner tun2;
  1093. int i;
  1095. aud2.audio = aud2.audio;
  1096. err = vfl->ioctl(context, VIDIOC_S_AUDIO, &aud2);
  1097. if (err < 0)
  1098. break;
  1100. set_v4l_control(vfl, context, V4L2_CID_AUDIO_VOLUME, 
  1101. aud->volume);
  1102. set_v4l_control(vfl, context, V4L2_CID_AUDIO_BASS,
  1103. aud->bass);
  1104. set_v4l_control(vfl, context, V4L2_CID_AUDIO_TREBLE,
  1105. aud->treble);
  1106. set_v4l_control(vfl, context, V4L2_CID_AUDIO_BALANCE,
  1107. aud->balance);
  1108. set_v4l_control(vfl, context, V4L2_CID_AUDIO_MUTE,
  1109. !!(aud->flags & VIDEO_AUDIO_MUTE));
  1111. err = vfl->ioctl(context, VIDIOC_G_INPUT, &i);
  1112. if (err < 0)
  1113. {
  1114. err = 0;
  1115. break;
  1116. }
  1117. tun2.input = i;
  1118. err = vfl->ioctl(context, VIDIOC_G_TUNER, &tun2);
  1119. if (err == 0)
  1120. {
  1121. switch (aud->mode)
  1122. {
  1123. default:
  1124. case VIDEO_SOUND_MONO:
  1125. tun2.audmode = V4L2_TUNER_MODE_MONO;
  1126. break;
  1127. case VIDEO_SOUND_STEREO:
  1128. tun2.audmode = V4L2_TUNER_MODE_STEREO;
  1129. break;
  1130. case VIDEO_SOUND_LANG2:
  1131. tun2.audmode = V4L2_TUNER_MODE_LANG2;
  1132. break;
  1133. }
  1134. vfl->ioctl(context, VIDIOC_S_TUNER, &tun2);
  1135. }
  1136. err = 0;
  1137. break;
  1138. }
  1139. case VIDIOCGMBUF: /*  get mmap parameters  */
  1140. {
  1141. struct video_mbuf *mbuf = arg;
  1142. struct v4l2_requestbuffers reqbuf2;
  1143. struct v4l2_buffer buf2;
  1144. struct v4l2_format fmt2, fmt2o;
  1145. struct v4l2_capability cap2;
  1146. int i;
  1148. /*  Set the format to maximum dimensions  */
  1149. if ((err = vfl->ioctl(context, VIDIOC_QUERYCAP, &cap2)) < 0)
  1150. break;
  1151. if ((err = vfl->ioctl(context, VIDIOC_G_FMT, &fmt2o)) < 0)
  1152. break;
  1153. fmt2 = fmt2o;
  1154. fmt2.width = cap2.maxwidth;
  1155. fmt2.height = cap2.maxheight;
  1156. if ((err = vfl->ioctl(context, VIDIOC_S_FMT, &fmt2)) < 0)
  1157. break;
  1158. reqbuf2.count = 2; /* v4l always used two buffers */
  1159. reqbuf2.type = V4L2_BUF_TYPE_CAPTURE | V4L2_BUF_REQ_CONTIG;
  1160. err = vfl->ioctl(context, VIDIOC_REQBUFS, &reqbuf2);
  1161. if (err < 0 || reqbuf2.count < 2 || reqbuf2.type
  1162.     != (V4L2_BUF_TYPE_CAPTURE | V4L2_BUF_REQ_CONTIG))
  1163. {/* Driver doesn't support v4l back-compatibility  */
  1164. vfl->ioctl(context, VIDIOC_S_FMT, &fmt2o);
  1165. reqbuf2.count = 1;
  1166. reqbuf2.type = V4L2_BUF_TYPE_CAPTURE;
  1167. err = vfl->ioctl(context, VIDIOC_REQBUFS, &reqbuf2);
  1168. if (err < 0)
  1169. {
  1170. err = -EINVAL;
  1171. break;
  1172. }
  1173. printk(KERN_INFO"V4L2: Device "%s" doesn't support"
  1174.        " v4l memory mappingn", vfl->name);
  1175. }
  1176. buf2.index = 0;
  1177. buf2.type = V4L2_BUF_TYPE_CAPTURE;
  1178. err = vfl->ioctl(context, VIDIOC_QUERYBUF, &buf2);
  1179. mbuf->size = buf2.length * reqbuf2.count;
  1180. mbuf->frames = reqbuf2.count;
  1181. memset(mbuf->offsets, 0, sizeof(mbuf->offsets));
  1182. for (i = 0; i < mbuf->frames; ++i)
  1183. mbuf->offsets[i] = i * buf2.length;
  1184. break;
  1185. }
  1186. case VIDIOCMCAPTURE: /*  capture a frame  */
  1187. {
  1188. struct video_mmap *mm = arg;
  1189. struct v4l2_buffer buf2;
  1190. struct v4l2_format fmt2;
  1192. err = vfl->ioctl(context, VIDIOC_G_FMT, &fmt2);
  1193. if (err < 0)
  1194. break;
  1195. if (mm->width != fmt2.width || mm->height != fmt2.height ||
  1196.     palette_to_pixelformat(mm->format) != fmt2.pixelformat)
  1197. {/* New capture format...  */
  1198. //vfl->ioctl(context, VIDIOC_STREAMOFF, 
  1199. //    (void *)V4L2_BUF_TYPE_CAPTURE);
  1200. fmt2.width = mm->width;
  1201. fmt2.height = mm->height;
  1202. fmt2.pixelformat = palette_to_pixelformat(mm->format);
  1203. err = vfl->ioctl(context, VIDIOC_S_FMT, &fmt2);
  1204. if (err < 0)
  1205. break;
  1206. }
  1207. buf2.index = mm->frame;
  1208. buf2.type = V4L2_BUF_TYPE_CAPTURE;
  1209. err = vfl->ioctl(context, VIDIOC_QUERYBUF, &buf2);
  1210. if (err < 0)
  1211. break;
  1212. err = vfl->ioctl(context, VIDIOC_QBUF, &buf2);
  1213. if (err < 0)
  1214. break;
  1215. vfl->ioctl(context, VIDIOC_STREAMON, (void *)buf2.type);
  1216. break;
  1217. }
  1218. case VIDIOCSYNC: /*  wait for a frame  */
  1219. {
  1220. int *i = arg;
  1221. struct v4l2_buffer buf2;
  1223. buf2.index = *i;
  1224. buf2.type = V4L2_BUF_TYPE_CAPTURE;
  1225. err = vfl->ioctl(context, VIDIOC_QUERYBUF, &buf2);
  1226. if (err < 0) /*  No such buffer */
  1227. break;
  1228. if (!(buf2.flags & V4L2_BUF_FLAG_MAPPED))
  1229. {/* Buffer is not mapped  */
  1230. err = -EINVAL;
  1231. break;
  1232. }
  1234. /*  Loop as long as the buffer is queued, but not done  */
  1235. while ((buf2.flags &
  1236. (V4L2_BUF_FLAG_QUEUED | V4L2_BUF_FLAG_DONE))
  1237.        == V4L2_BUF_FLAG_QUEUED)
  1238. {
  1239. err = simple_select(file);
  1240. if (err < 0 || /* error or sleep was interrupted  */
  1241.     err == 0) /* timeout? Shouldn't occur.  */
  1242. break;
  1243. vfl->ioctl(context, VIDIOC_QUERYBUF, &buf2);
  1244. }
  1245. if (!(buf2.flags & V4L2_BUF_FLAG_DONE)) /* not done */
  1246. break;
  1247. do
  1248. {
  1249. err = vfl->ioctl(context, VIDIOC_DQBUF, &buf2);
  1250. } while (err == 0 && buf2.index != *i);
  1251. break;
  1252. }
  1253. case VIDIOCGUNIT: /*  get related device minors  */
  1254. /*  No translation  */
  1255. break;
  1256. case VIDIOCGCAPTURE: /*    */
  1257. /*  No translation, yet...  */
  1258. printk(KERN_INFO"V4L2: VIDIOCGCAPTURE not implemented. "
  1259.        "Send patches to bdirks@pacbell.net :-)n");
  1260. break;
  1261. case VIDIOCSCAPTURE: /*    */
  1262. /*  No translation, yet...  */
  1263. printk(KERN_INFO"V4L2: VIDIOCSCAPTURE not implemented. "
  1264.        "Send patches to bdirks@pacbell.net :-)n");
  1265. break;
  1266. }
  1267. return err;
  1268. }
  1271. /*
  1272.  * D E V I C E   R E G I S T R A T I O N
  1273.  *
  1274.  * Video for Linux Two device drivers request registration here.
  1275.  */
  1276. int
  1277. v4l2_register_device(struct v4l2_device *vfl)
  1278. {
  1279. int i = 0;
  1280. int err;
  1282. if (vfl == NULL)
  1283. {
  1284. printk(KERN_ERR"V4L2: v4l2_register_device() passed"
  1285.        " a NULL pointer!n");
  1286. return -1;
  1287. }
  1288. i = vfl->minor;
  1289. if (vfl->open == NULL)
  1290. {
  1291. printk(KERN_ERR "V4L2: Device %d has no open methodn", i);
  1292. return -1;
  1293. }
  1294. if (i < 0 || i >= V4L2_NUM_DEVICES)
  1295. {
  1296. printk(KERN_ERR"V4L2: Minor value %d is out of rangen", i);
  1297. return -1;
  1298. }
  1299. if (v4l2_device[i] != NULL)
  1300. {
  1301. printk(KERN_ERR"V4L2: %s and %s have both been assigned"
  1302.        " minor %dn", v4l2_device[i]->name,
  1303.        vfl->name, i);
  1304. return 1;
  1305. }
  1307. v4l2_device[i] = vfl;
  1308. /* The init call may sleep so we book the slot out then call */
  1309. MOD_INC_USE_COUNT;
  1310. err = 0;
  1311. if (vfl->initialize)
  1312. err = vfl->initialize(vfl);
  1313. if (err < 0)
  1314. {
  1315. printk(KERN_ERR "V4L2: %s initialize method failedn",
  1316.        vfl->name);
  1317. v4l2_device[i] = NULL;
  1318. MOD_DEC_USE_COUNT;
  1319. return err;
  1320. }
  1322. vfl->busy = 0;
  1324. vfl->name[sizeof(vfl->name) - 1] = 0;
  1325. printk(KERN_INFO"V4L2: Registered "%s" as char device %d, %dn",
  1326.  vfl->name, v4l2_major, vfl->minor);
  1328. memset(vfl->v4l2_reserved, 0, sizeof(vfl->v4l2_reserved));
  1329. vfl->v4l2_priv = NULL;
  1330. return 0;
  1331. }
  1333. /*
  1334.  * Unregister an unused video for linux device
  1335.  */
  1336. void
  1337. v4l2_unregister_device(struct v4l2_device *vfl)
  1338. {
  1339. if (vfl->minor < 0 || vfl->minor >= V4L2_NUM_DEVICES ||
  1340.     v4l2_device[vfl->minor] != vfl)
  1341. {
  1342. printk(KERN_ERR"V4L2: bad unregistern");
  1343. return;
  1344. }
  1345. v4l2_device[vfl->minor] = NULL;
  1346. MOD_DEC_USE_COUNT;
  1347. }
  1350. /*
  1351.  * / p r o c / v i d e o d e v   H A N D L E R
  1352.  */
  1353. /*  Original /proc file code from Erik Walthinsen  */
  1355. static char *device_types[] =
  1356. {
  1357. "capture", "codec", "output", "effects", 
  1358. "vbi", "vtr", "teletext", "radio", 
  1359. "undef", "undef", "undef", "undef",
  1360. };
  1361. static int
  1362. video_read_proc(char *buf, char **start, off_t offset, int len, int unused)
  1363. {
  1364. struct v4l2_device *vfl;
  1365. int i;
  1366. char *t;
  1368. len = 0;
  1369. len += sprintf(buf, "Video for Linux Two: V%d.%d alpha."
  1370.        " Major device: %dn",
  1371.        V4L2_MAJOR_VERSION, V4L2_MINOR_VERSION,
  1372.        v4l2_major);
  1373. //len += sprintf(buf+len,"minor: type      busy namen");
  1374. for (i = 0; i < V4L2_NUM_DEVICES; i++)
  1375. {
  1376. vfl = v4l2_device[i];
  1377. if (vfl == NULL)
  1378. continue;
  1379. if  (len > (PAGE_SIZE - 80))
  1380. return len;
  1381. if (vfl->type >= 0 &&
  1382.     vfl->type < sizeof(device_types)/sizeof(char*))
  1383. t = device_types[vfl->type];
  1384. else if (vfl->type >= V4L2_TYPE_PRIVATE)
  1385. t = "private";
  1386. else 
  1387. t = "undef";
  1388. len += sprintf(buf+len, "%5d: %-9s %3d  %sn",
  1389.        vfl->minor, t, vfl->busy, vfl->name);
  1390. }
  1391. return len;
  1392. }
  1394. /* proc file for /proc/videodev */
  1395. static struct proc_dir_entry video_proc_entry =
  1396. {
  1397. 0, 8, "videodev", S_IFREG | S_IRUGO, 1, 0, 0, 0, NULL,
  1398. &video_read_proc
  1399. };
  1401. /*
  1402.  * V I D E O   F O R   L I N U X   T W O   I N I T I A L I Z A T I O N
  1403.  */
  1405. static struct file_operations video_fops =
  1406. {
  1407. video_lseek,
  1408. video_read,
  1409. video_write,
  1410. NULL, /* readdir */
  1411. video_poll,
  1412. video_ioctl,
  1413. video_mmap,
  1414. video_open,
  1415. #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,118)
  1416. NULL,
  1417. #endif
  1418. video_release
  1419. };
  1421. /*
  1422.  * Initialize Video for Linux Two
  1423.  */
  1424. int videodev_init(void)
  1425. {
  1426. int i;
  1428. printk(KERN_INFO"Video for Linux Two: V%d.%d alpha."
  1429.        " Major device: %dn",
  1430.        V4L2_MAJOR_VERSION, V4L2_MINOR_VERSION, v4l2_major);
  1431. if (register_chrdev(v4l2_major, "v4l2", &video_fops))
  1432. {
  1433. printk("V4L2: Unable to get major %dn", v4l2_major);
  1434. return -EIO;
  1435. }
  1437. /* make sure there's a way to tell if a device is not there */
  1438. for (i = 0; i < V4L2_NUM_DEVICES; i++)
  1439. v4l2_device[i] = NULL;
  1440. proc_register(&proc_root, &video_proc_entry);
  1442. masterclock = NULL;
  1444. return 0;
  1445. }
  1447. #ifdef MODULE
  1448. int init_module(void)
  1449. {
  1450. return videodev_init();
  1451. }
  1453. void cleanup_module(void)
  1454. {
  1455. proc_unregister(&proc_root, video_proc_entry.low_ino);
  1456. unregister_chrdev(v4l2_major, "v4l2");
  1457. }
  1458. #endif
  1461. /*
  1462.  *
  1463.  * V 4 L 2   D R I V E R   H E L P E R   A P I
  1464.  *
  1465.  */
  1467. void
  1468. v4l2_version(int *major, int *minor)
  1469. {
  1470. *major = V4L2_MAJOR_VERSION;
  1471. *minor = V4L2_MINOR_VERSION;
  1472. }
  1474. int
  1475. v4l2_major_number(void)
  1476. {
  1477. return v4l2_major;
  1478. }
  1480. struct v4l2_device *
  1481. v4l2_device_from_minor(int minor)
  1482. {
  1483. if (minor < 0 || minor >= V4L2_NUM_DEVICES)
  1484. return NULL;
  1485. return v4l2_device[minor];
  1486. }
  1488. struct v4l2_device *
  1489. v4l2_device_from_file(struct file *file)
  1490. {
  1491. if (file == NULL)
  1492. return NULL;
  1493. return v4l2_device_from_minor(MINOR(file->f_dentry->d_inode->i_rdev));
  1494. }
  1496. void *
  1497. v4l2_openid_from_file(struct file *file)
  1498. {
  1499. if (file == NULL)
  1500. return NULL;
  1501. return file->private_data;
  1502. }
  1504. static struct mm_struct *
  1505. find_init_mm(void)
  1506. {
  1507. static struct mm_struct *mm;
  1508. struct task_struct *p;
  1509. if (mm)
  1510. return mm;
  1511. for (p = current; p && (p = p->next_task) != current; )
  1512. if (p->pid == 0)
  1513. break;
  1514. mm = (p) ? p->mm : NULL;
  1515. return mm;
  1516. }
  1518. /*  Useful for using vmalloc()ed memory as DMA target  */
  1519. unsigned long
  1520. v4l2_vmalloc_to_bus(void *virt)
  1521. {
  1522. pgd_t *pgd;
  1523. pmd_t *pmd;
  1524. pte_t *pte;
  1525. unsigned long a = (unsigned long)virt;
  1526. struct mm_struct *mm = find_init_mm();
  1528. if (mm == NULL ||
  1529.     pgd_none(*(pgd = pgd_offset(mm,  a))) ||
  1530.     pmd_none(*(pmd = pmd_offset(pgd, a))) ||
  1531.     pte_none(*(pte = pte_offset(pmd, a))))
  1532. return 0;
  1533. return virt_to_bus((void *)pte_page(*pte))
  1534. + (a & (PAGE_SIZE - 1));
  1535. }
  1537. /*  Useful for a nopage handler when mmap()ing vmalloc()ed memory  */
  1538. unsigned long
  1539. v4l2_vmalloc_to_page(void *virt)
  1540. {
  1541. pgd_t *pgd;
  1542. pmd_t *pmd;
  1543. pte_t *pte;
  1544. unsigned long a = (unsigned long)virt;
  1545. struct mm_struct *mm = find_init_mm();
  1547. if (mm == NULL ||
  1548.     pgd_none(*(pgd = pgd_offset(current->mm, a))) ||
  1549.     pmd_none(*(pmd = pmd_offset(pgd,         a))) ||
  1550.     pte_none(*(pte = pte_offset(pmd,         a))))
  1551. return 0;
  1552. return pte_page(*pte);
  1553. }
  1555. /*
  1556.  *  Simple queue management
  1557.  */
  1558. static rwlock_t rw_lock_unlocked = RW_LOCK_UNLOCKED;
  1559. void
  1560. v4l2_q_init(struct v4l2_queue *q)
  1561. {
  1562. if (q == NULL)
  1563. return;
  1564. q->qlock = rw_lock_unlocked;
  1565. q->forw = (struct v4l2_q_node *)q;
  1566. q->back = (struct v4l2_q_node *)q;
  1567. }
  1568. void
  1569. v4l2_q_add_head(struct v4l2_queue *q, struct v4l2_q_node *node)
  1570. {
  1571. unsigned long flags;
  1572. if (q == NULL || node == NULL)
  1573. return;
  1574. if (q->forw == NULL || q->back == NULL)
  1575. v4l2_q_init(q);
  1576. write_lock_irqsave(&(q->qlock), flags);
  1577. node->forw = q->forw;
  1578. node->back = (struct v4l2_q_node *)q;
  1579. q->forw->back = node;
  1580. q->forw = node;
  1581. write_unlock_irqrestore(&(q->qlock), flags);
  1582. }
  1583. void
  1584. v4l2_q_add_tail(struct v4l2_queue *q, struct v4l2_q_node *node)
  1585. {
  1586. unsigned long flags;
  1587. if (q == NULL || node == NULL)
  1588. return;
  1589. if (q->forw == NULL || q->back == NULL)
  1590. v4l2_q_init(q);
  1591. write_lock_irqsave(&(q->qlock), flags);
  1592. node->forw = (struct v4l2_q_node *)q;
  1593. node->back = q->back;
  1594. q->back->forw = node;
  1595. q->back = node;
  1596. write_unlock_irqrestore(&(q->qlock), flags);
  1597. }
  1598. void *
  1599. v4l2_q_del_head(struct v4l2_queue *q)
  1600. {
  1601. unsigned long flags;
  1602. struct v4l2_q_node *node;
  1603. if (q == NULL)
  1604. return NULL;
  1605. write_lock_irqsave(&(q->qlock), flags);
  1606. if (q->forw == NULL || q->back == NULL ||
  1607.     q->forw == (struct v4l2_q_node *)q ||
  1608.     q->back == (struct v4l2_q_node *)q)
  1609. {
  1610. write_unlock_irqrestore(&(q->qlock), flags);
  1611. return NULL;
  1612. }
  1613. node = q->forw;
  1614. node->forw->back = (struct v4l2_q_node *)q;
  1615. q->forw = node->forw;
  1616. node->forw = NULL;
  1617. node->back = NULL;
  1618. write_unlock_irqrestore(&(q->qlock), flags);
  1619. return node;
  1620. }
  1621. void *
  1622. v4l2_q_del_tail(struct v4l2_queue *q)
  1623. {
  1624. unsigned long flags;
  1625. struct v4l2_q_node *node;
  1626. if (q == NULL)
  1627. return NULL;
  1628. write_lock_irqsave(&(q->qlock), flags);
  1629. if (q->forw == NULL || q->back == NULL ||
  1630.     q->forw == (struct v4l2_q_node *)q ||
  1631.     q->back == (struct v4l2_q_node *)q)
  1632. {
  1633. write_unlock_irqrestore(&(q->qlock), flags);
  1634. return NULL;
  1635. }
  1636. node = q->back;
  1637. node->back->forw = (struct v4l2_q_node *)q;
  1638. q->back = node->back;
  1639. node->forw = NULL;
  1640. node->back = NULL;
  1641. write_unlock_irqrestore(&(q->qlock), flags);
  1642. return node;
  1643. }
  1644. void *
  1645. v4l2_q_peek_head(struct v4l2_queue *q)
  1646. {
  1647. unsigned long flags;
  1648. struct v4l2_q_node *node;
  1649. read_lock_irqsave(&(q->qlock), flags);
  1650. if (q == NULL || q->forw == NULL || q->forw == (struct v4l2_q_node *)q)
  1651. {
  1652. read_unlock_irqrestore(&(q->qlock), flags);
  1653. return NULL;
  1654. }
  1655. node = q->forw;
  1656. read_unlock_irqrestore(&(q->qlock), flags);
  1657. return node;
  1658. }
  1659. void *
  1660. v4l2_q_peek_tail(struct v4l2_queue *q)
  1661. {
  1662. unsigned long flags;
  1663. struct v4l2_q_node *node;
  1664. read_lock_irqsave(&(q->qlock), flags);
  1665. if (q == NULL || q->back == NULL || q->back == (struct v4l2_q_node *)q)
  1666. {
  1667. read_unlock_irqrestore(&(q->qlock), flags);
  1668. return NULL;
  1669. }
  1670. node = q->back;
  1671. read_unlock_irqrestore(&(q->qlock), flags);
  1672. return node;
  1673. }
  1674. void *
  1675. v4l2_q_yank_node(struct v4l2_queue *q, struct v4l2_q_node *node)
  1676. {
  1677. unsigned long flags;
  1678. struct v4l2_q_node *t;
  1679. if (v4l2_q_peek_head(q) == NULL || node == NULL)
  1680. return NULL;
  1681. write_lock_irqsave(&(q->qlock), flags);
  1682. for (t = q->forw; t != (struct v4l2_q_node *)q; t = t->forw)
  1683. if (t == node)
  1684. {
  1685. node->back->forw = node->forw;
  1686. node->forw->back = node->back;
  1687. node->forw = NULL;
  1688. node->back = NULL;
  1689. write_unlock_irqrestore(&(q->qlock), flags);
  1690. return node;
  1691. }
  1692. write_unlock_irqrestore(&(q->qlock), flags);
  1693. return NULL;
  1694. }
  1696. /*
  1697.  *  Math functions
  1698.  */
  1700. u32
  1701. v4l2_math_div6432(u64 a, u32 d, u32 *r)
  1702. {
  1703. u32 q, m;
  1704. #ifdef __i386__
  1705. __asm__ __volatile__ (
  1706. " movl %2,%%eaxn"
  1707. " movl %3,%%edxn"
  1708. " divl %4n"
  1709. " movl %%eax,%0n"
  1710. " movl %%edx,%1n"
  1711. : "=g" (q), "=g" (m)
  1712. : "g" ((u32)a), "g" ((u32)(a >> 32)), "g" (d)
  1713. : "eax", "edx"
  1714. );
  1715. #else
  1716. q = a / d;
  1717. m = a % d;
  1718. #endif
  1719. if (r) *r = m;
  1720. return q;
  1721. }
  1723. void
  1724. v4l2_timeval_delta(struct timeval *d,
  1725.    struct timeval *a,
  1726.    struct timeval *b)
  1727. {
  1728. if (a->tv_sec < b->tv_sec ||
  1729.     (a->tv_sec == b->tv_sec && a->tv_usec < b->tv_usec))
  1730. {
  1731. d->tv_sec = b->tv_sec - a->tv_sec;
  1732. d->tv_usec = b->tv_usec - a->tv_usec;
  1733. }
  1734. else
  1735. {
  1736. d->tv_sec = a->tv_sec - b->tv_sec;
  1737. d->tv_usec = a->tv_usec - b->tv_usec;
  1738. }
  1739. if (d->tv_usec < 0)
  1740. {
  1741. d->tv_usec += 1000000;
  1742. d->tv_sec -= 1;
  1743. }
  1744. }
  1746. unsigned long
  1747. v4l2_timeval_divide(struct timeval *t, unsigned long p_100ns)
  1748. {
  1749. /*  Note: 'p_100ns' is in 100ns units, and the quotient is rounded  */
  1750. u64 t_100ns;
  1752. t_100ns = (u64)t->tv_sec * 10000000 + t->tv_usec * 10;
  1753. return v4l2_math_div6432(t_100ns + (p_100ns >> 1), p_100ns, NULL);
  1754. }
  1756. /*  Force the timeval to be an integer multiple of p_100ns  */
  1757. unsigned long
  1758. v4l2_timeval_correct(struct timeval *t, unsigned long p_100ns)
  1759. {
  1760. unsigned long n;
  1761. u32 m;
  1762. n = v4l2_timeval_divide(t, p_100ns);
  1763. t->tv_sec = v4l2_math_div6432((u64)p_100ns * n, 10000000, &m);
  1764. t->tv_usec = m / 10;
  1765. return n;
  1766. }
  1768. /*
  1769.  * Master clock and Timeval operations
  1770.  */
  1772. int
  1773. v4l2_masterclock_register(struct v4l2_clock *clock)
  1774. {
  1775. if (clock == NULL || clock->gettime == NULL)
  1776. return -1;
  1777. if (masterclock != NULL)
  1778. return -1;
  1779. masterclock = clock;
  1780. MOD_INC_USE_COUNT;
  1781. return 0;
  1782. }
  1783. void
  1784. v4l2_masterclock_unregister(struct v4l2_clock *clock)
  1785. {
  1786. if (clock != masterclock)
  1787. return;
  1788. masterclock = NULL;
  1789. MOD_DEC_USE_COUNT;
  1790. }
  1791. void
  1792. v4l2_masterclock_gettime(struct timeval *curr)
  1793. {
  1794. if (masterclock)
  1795. masterclock->gettime(curr);
  1796. else
  1797. do_gettimeofday(curr);
  1798. }
  1800. /*
  1801.  *  Video Standard Operations (contributed by Michael Schimek)
  1802.  */
  1804. /* This is the recommended method to deal with the framerate fields. More 
  1805.    sophisticated drivers will access the fields directly. */
  1806. unsigned int
  1807. v4l2_video_std_fps(struct v4l2_standard *vs)
  1808. { 
  1809. if (vs->framerate.numerator > 0)
  1810. return (((vs->framerate.denominator << 8) / 
  1811.  vs->framerate.numerator) + 
  1812. (1 << 7)) / (1 << 8);
  1813. return 0;
  1814. }
  1816. /*  Compute the time per frame in 100ns units  */
  1817. unsigned long
  1818. v4l2_video_std_tpf(struct v4l2_standard *vs)
  1819. {
  1820. return v4l2_math_div6432(
  1821. (u64)vs->framerate.numerator * 10000000
  1822. + vs->framerate.denominator / 2,
  1823. vs->framerate.denominator,
  1824. NULL);
  1825. }
  1827. /*  Used only in v4l2_video_std_confirm()  */
  1828. static void
  1829. catc1p2e6(__u8 *s, char c, int n)
  1830. {
  1831. n /= 10000;
  1832. sprintf(s + strlen(s), "%c%d.%02d", c, n / 100, n % 100);
  1833. }
  1835. /* Verify the validity of the parameters of a v4l2_standard structure and
  1836.    create the name and id from the other fields. It does not relieve a 
  1837.    driver from examining if it can fulfill the request.  Returns an 
  1838.    errno < 0 if inconsistent, 0 if an unknown but maybe usable format, 
  1839.    or the V4L2_STD_XXX_X value if a known standard. */
  1840. int
  1841. v4l2_video_std_confirm(struct v4l2_standard *vs)
  1842. {
  1843. unsigned int rate  = 0;
  1844. unsigned int lines = vs->framelines;
  1845. int std   = 0;
  1847. strcpy(vs->name, "Unknown");
  1848. if (vs->reserved1 || vs->reserved2)
  1849. return -EINVAL;
  1851. if (vs->framerate.numerator > 0 &&
  1852.     vs->framerate.denominator > 0)
  1853. rate = v4l2_video_std_fps(vs);
  1855. if (vs->framelines >= 624 && vs->framelines <= 626)
  1856. lines = 625;
  1857. else if (vs->framelines >= 524 && vs->framelines <= 526)
  1858. lines = 525;
  1860. if (rate == 0 || lines == 0 || rate > 200)
  1861. return -EINVAL;
  1863. switch (vs->colorstandard)
  1864. {
  1865. case V4L2_COLOR_STD_PAL:
  1866. strcpy(vs->name, "PAL");
  1867. if (rate == 25 && lines == 625)
  1868. switch (vs->colorstandard_data.pal.colorsubcarrier)
  1869. {
  1870. case V4L2_COLOR_SUBC_PAL_N:
  1871. strcpy(vs->name, "PAL-N");
  1872. if (vs->transmission & ~V4L2_TRANSM_STD_N)
  1873. return -EINVAL;
  1874. return V4L2_STD_PAL_N;
  1875. case V4L2_COLOR_SUBC_PAL:
  1876. if (vs->transmission & 
  1877.     ~(V4L2_TRANSM_STD_B | V4L2_TRANSM_STD_G |
  1878.       V4L2_TRANSM_STD_H | V4L2_TRANSM_STD_I |
  1879.       V4L2_TRANSM_STD_D))
  1880. return -EINVAL;
  1881. std = V4L2_STD_PAL;
  1882. goto addtransm;
  1883. }
  1884. else if (rate == 30 && lines == 525)
  1885. switch (vs->colorstandard_data.pal.colorsubcarrier)
  1886. {
  1887. case V4L2_COLOR_SUBC_PAL_M:
  1888. strcpy(vs->name, "PAL-M");
  1889. if (vs->transmission & ~V4L2_TRANSM_STD_M)
  1890. return -EINVAL;
  1891. return V4L2_STD_PAL_M;
  1892. case V4L2_COLOR_SUBC_PAL:
  1893. strcpy(vs->name, "PAL-60");
  1894. if (vs->transmission)
  1895. return -EINVAL;
  1896. return V4L2_STD_PAL_60;
  1897. }
  1898. if (vs->transmission)
  1899. return -EINVAL;
  1900. catc1p2e6(vs->name, ' ', 
  1901.   vs->colorstandard_data.pal.colorsubcarrier);
  1902. break;
  1904. case V4L2_COLOR_STD_NTSC:
  1905. strcpy(vs->name, "NTSC");
  1906. if (rate == 25 && lines == 625)
  1907. switch (vs->colorstandard_data.ntsc.colorsubcarrier)
  1908. {
  1909. case V4L2_COLOR_SUBC_NTSC:
  1910. strcpy(vs->name, "NTSC-N");
  1911. if (vs->transmission & ~V4L2_TRANSM_STD_N)
  1912. return -EINVAL;
  1913. return V4L2_STD_NTSC_N;
  1914. }
  1915. else if (rate == 30 && lines == 525)
  1916. switch (vs->colorstandard_data.ntsc.colorsubcarrier)
  1917. {
  1918. case V4L2_COLOR_SUBC_NTSC:
  1919. if (vs->transmission & ~V4L2_TRANSM_STD_M)
  1920. return -EINVAL;
  1921. std = V4L2_STD_NTSC;
  1922. goto addtransm;
  1923. case V4L2_COLOR_SUBC_PAL:
  1924. strcpy(vs->name, "NTSC-44");
  1925. if (vs->transmission)
  1926. return -EINVAL;
  1927. return V4L2_STD_NTSC_44;
  1928. }
  1929. if (vs->transmission)
  1930. return -EINVAL;
  1931. catc1p2e6(vs->name, ' ', 
  1932.   vs->colorstandard_data.ntsc.colorsubcarrier);
  1933. break;
  1935. case V4L2_COLOR_STD_SECAM:
  1936. strcpy(vs->name, "SECAM");
  1937. if (rate == 25 && lines == 625)
  1938. if (vs->colorstandard_data.secam.f0b == 
  1939.     V4L2_COLOR_SUBC_SECAMB &&
  1940.     vs->colorstandard_data.secam.f0r == 
  1941.     V4L2_COLOR_SUBC_SECAMR)
  1942. {
  1943. if (vs->transmission &
  1944.     ~(V4L2_TRANSM_STD_B | V4L2_TRANSM_STD_D |
  1945.               V4L2_TRANSM_STD_G | V4L2_TRANSM_STD_K |
  1946.               V4L2_TRANSM_STD_K1 | V4L2_TRANSM_STD_L))
  1947. return -EINVAL;
  1948. std = V4L2_STD_SECAM;
  1949. goto addtransm;
  1950. }
  1951. if (vs->transmission)
  1952. return -EINVAL;
  1953. catc1p2e6(vs->name, ' ', vs->colorstandard_data.secam.f0b);
  1954. catc1p2e6(vs->name, '/', vs->colorstandard_data.secam.f0r);
  1955. break;
  1957. default:
  1958. return -EINVAL;
  1959. }
  1961.         sprintf(vs->name + strlen(vs->name), " %d/%d",
  1962.         vs->framelines, rate);
  1964. return std;
  1966.  addtransm:
  1967. if (vs->transmission) strcat(vs->name, "-");
  1969.         if (vs->transmission & V4L2_TRANSM_STD_B) strcat(vs->name, "B/");
  1970.         if (vs->transmission & V4L2_TRANSM_STD_G) strcat(vs->name, "G/");
  1971.         if (vs->transmission & V4L2_TRANSM_STD_H) strcat(vs->name, "H/");
  1972. if (vs->transmission & V4L2_TRANSM_STD_I) strcat(vs->name, "I/");
  1973. if (vs->transmission & V4L2_TRANSM_STD_D) strcat(vs->name, "D/");
  1974. if (vs->transmission & V4L2_TRANSM_STD_K) strcat(vs->name, "K/");
  1975. if (vs->transmission & V4L2_TRANSM_STD_K1) strcat(vs->name, "K1/");
  1976. if (vs->transmission & V4L2_TRANSM_STD_L) strcat(vs->name, "L/");
  1977. if (vs->transmission & V4L2_TRANSM_STD_M) strcat(vs->name, "M/");
  1978. if (vs->transmission & V4L2_TRANSM_STD_N) strcat(vs->name, "N/");
  1980. if (vs->name[strlen(vs->name) - 1] == '/')
  1981. vs->name[strlen(vs->name) - 1] = 0;    
  1983. return std;
  1984. }
  1986. /* Fill in the fields of a v4l2_standard structure according to the
  1987.    'id' and 'transmission' parameters.  Returns negative on error.  */
  1988. int
  1989. v4l2_video_std_construct(struct v4l2_standard *vs,
  1990.  int id, __u32 transmission)
  1991. {
  1992. memset(vs, 0, sizeof(struct v4l2_standard));
  1994. vs->framerate.numerator = 1;
  1995. vs->framerate.denominator = 25;
  1996. vs->framelines = 625;
  1998. switch (id)
  1999. {
  2000. case V4L2_STD_PAL_60:
  2001. vs->framerate.numerator = 1001;
  2002. vs->framerate.denominator = 30000;
  2003. vs->framelines = 525;
  2004. /* fall thru */
  2005. case V4L2_STD_PAL:
  2006. vs->colorstandard = V4L2_COLOR_STD_PAL;
  2007. vs->colorstandard_data.pal.colorsubcarrier =
  2008. V4L2_COLOR_SUBC_PAL;
  2009. break;
  2010. case V4L2_STD_PAL_M:
  2011. vs->framerate.numerator = 1001;
  2012. vs->framerate.denominator = 30000;
  2013. vs->framelines = 525;
  2014. vs->colorstandard = V4L2_COLOR_STD_PAL;
  2015. vs->colorstandard_data.pal.colorsubcarrier = 
  2016. V4L2_COLOR_SUBC_PAL_M;
  2017. break;
  2018. case V4L2_STD_PAL_N:
  2019. vs->colorstandard = V4L2_COLOR_STD_PAL;
  2020. vs->colorstandard_data.pal.colorsubcarrier = 
  2021. V4L2_COLOR_SUBC_PAL_N;
  2022. break;
  2024. case V4L2_STD_NTSC:
  2025. vs->framerate.numerator = 1001;
  2026. vs->framerate.denominator = 30000;
  2027. vs->framelines = 525;
  2028. /* fall thru */
  2029. case V4L2_STD_NTSC_N:
  2030. vs->colorstandard = V4L2_COLOR_STD_NTSC;
  2031. vs->colorstandard_data.ntsc.colorsubcarrier = 
  2032. V4L2_COLOR_SUBC_NTSC;
  2033. break;
  2034. case V4L2_STD_NTSC_44:
  2035. vs->framerate.numerator = 1001;
  2036. vs->framerate.denominator = 30000;
  2037. vs->framelines = 525;
  2038. vs->colorstandard = V4L2_COLOR_STD_NTSC;
  2039. vs->colorstandard_data.ntsc.colorsubcarrier = 
  2040. V4L2_COLOR_SUBC_PAL;
  2041. break;
  2043. case V4L2_STD_SECAM:
  2044. vs->colorstandard = V4L2_COLOR_STD_SECAM;
  2045. vs->colorstandard_data.secam.f0b = V4L2_COLOR_SUBC_SECAMB;
  2046. vs->colorstandard_data.secam.f0r = V4L2_COLOR_SUBC_SECAMR;
  2047. break;
  2049. default:
  2050. return -EINVAL;
  2051. }
  2053. vs->transmission = transmission;
  2055. return v4l2_video_std_confirm(vs);
  2056. }
  2059. /*---------------------------------------*/
  2061. EXPORT_SYMBOL(v4l2_register_device);
  2062. EXPORT_SYMBOL(v4l2_unregister_device);
  2064. EXPORT_SYMBOL(v4l2_version);
  2065. EXPORT_SYMBOL(v4l2_major_number);
  2066. EXPORT_SYMBOL(v4l2_device_from_minor);
  2067. EXPORT_SYMBOL(v4l2_device_from_file);
  2068. EXPORT_SYMBOL(v4l2_openid_from_file);
  2069. EXPORT_SYMBOL(v4l2_vmalloc_to_bus);
  2070. EXPORT_SYMBOL(v4l2_vmalloc_to_page);
  2071. EXPORT_SYMBOL(v4l2_q_init);
  2072. EXPORT_SYMBOL(v4l2_q_add_head);
  2073. EXPORT_SYMBOL(v4l2_q_add_tail);
  2074. EXPORT_SYMBOL(v4l2_q_del_head);
  2075. EXPORT_SYMBOL(v4l2_q_del_tail);
  2076. EXPORT_SYMBOL(v4l2_q_peek_head);
  2077. EXPORT_SYMBOL(v4l2_q_peek_tail);
  2078. EXPORT_SYMBOL(v4l2_q_yank_node);
  2079. EXPORT_SYMBOL(v4l2_math_div6432);
  2080. EXPORT_SYMBOL(v4l2_timeval_delta);
  2081. EXPORT_SYMBOL(v4l2_timeval_divide);
  2082. EXPORT_SYMBOL(v4l2_timeval_correct);
  2083. EXPORT_SYMBOL(v4l2_masterclock_register);
  2084. EXPORT_SYMBOL(v4l2_masterclock_unregister);
  2085. EXPORT_SYMBOL(v4l2_masterclock_gettime);
  2086. EXPORT_SYMBOL(v4l2_video_std_fps);
  2087. EXPORT_SYMBOL(v4l2_video_std_tpf);
  2088. EXPORT_SYMBOL(v4l2_video_std_confirm);
  2089. EXPORT_SYMBOL(v4l2_video_std_construct);