pwc-v4l.c 24 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960
  1. /* Linux driver for Philips webcam
  2. USB and Video4Linux interface part.
  3. (C) 1999-2004 Nemosoft Unv.
  4. (C) 2004-2006 Luc Saillard (luc@saillard.org)
  5. NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
  6. driver and thus may have bugs that are not present in the original version.
  7. Please send bug reports and support requests to <luc@saillard.org>.
  8. The decompression routines have been implemented by reverse-engineering the
  9. Nemosoft binary pwcx module. Caveat emptor.
  10. This program is free software; you can redistribute it and/or modify
  11. it under the terms of the GNU General Public License as published by
  12. the Free Software Foundation; either version 2 of the License, or
  13. (at your option) any later version.
  14. This program is distributed in the hope that it will be useful,
  15. but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17. GNU General Public License for more details.
  18. You should have received a copy of the GNU General Public License
  19. along with this program; if not, write to the Free Software
  20. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  21. */
  22. #include <linux/errno.h>
  23. #include <linux/init.h>
  24. #include <linux/mm.h>
  25. #include <linux/module.h>
  26. #include <linux/poll.h>
  27. #include <linux/vmalloc.h>
  28. #include <asm/io.h>
  29. #include "pwc.h"
  30. static struct v4l2_queryctrl pwc_controls[] = {
  31. {
  32. .id = V4L2_CID_BRIGHTNESS,
  33. .type = V4L2_CTRL_TYPE_INTEGER,
  34. .name = "Brightness",
  35. .minimum = 0,
  36. .maximum = 128,
  37. .step = 1,
  38. .default_value = 64,
  39. },
  40. {
  41. .id = V4L2_CID_CONTRAST,
  42. .type = V4L2_CTRL_TYPE_INTEGER,
  43. .name = "Contrast",
  44. .minimum = 0,
  45. .maximum = 64,
  46. .step = 1,
  47. .default_value = 0,
  48. },
  49. {
  50. .id = V4L2_CID_SATURATION,
  51. .type = V4L2_CTRL_TYPE_INTEGER,
  52. .name = "Saturation",
  53. .minimum = -100,
  54. .maximum = 100,
  55. .step = 1,
  56. .default_value = 0,
  57. },
  58. {
  59. .id = V4L2_CID_GAMMA,
  60. .type = V4L2_CTRL_TYPE_INTEGER,
  61. .name = "Gamma",
  62. .minimum = 0,
  63. .maximum = 32,
  64. .step = 1,
  65. .default_value = 0,
  66. },
  67. {
  68. .id = V4L2_CID_RED_BALANCE,
  69. .type = V4L2_CTRL_TYPE_INTEGER,
  70. .name = "Red Gain",
  71. .minimum = 0,
  72. .maximum = 256,
  73. .step = 1,
  74. .default_value = 0,
  75. },
  76. {
  77. .id = V4L2_CID_BLUE_BALANCE,
  78. .type = V4L2_CTRL_TYPE_INTEGER,
  79. .name = "Blue Gain",
  80. .minimum = 0,
  81. .maximum = 256,
  82. .step = 1,
  83. .default_value = 0,
  84. },
  85. {
  86. .id = V4L2_CID_AUTO_WHITE_BALANCE,
  87. .type = V4L2_CTRL_TYPE_BOOLEAN,
  88. .name = "Auto White Balance",
  89. .minimum = 0,
  90. .maximum = 1,
  91. .step = 1,
  92. .default_value = 0,
  93. },
  94. {
  95. .id = V4L2_CID_EXPOSURE,
  96. .type = V4L2_CTRL_TYPE_INTEGER,
  97. .name = "Shutter Speed (Exposure)",
  98. .minimum = 0,
  99. .maximum = 256,
  100. .step = 1,
  101. .default_value = 200,
  102. },
  103. {
  104. .id = V4L2_CID_AUTOGAIN,
  105. .type = V4L2_CTRL_TYPE_BOOLEAN,
  106. .name = "Auto Gain Enabled",
  107. .minimum = 0,
  108. .maximum = 1,
  109. .step = 1,
  110. .default_value = 1,
  111. },
  112. {
  113. .id = V4L2_CID_GAIN,
  114. .type = V4L2_CTRL_TYPE_INTEGER,
  115. .name = "Gain Level",
  116. .minimum = 0,
  117. .maximum = 256,
  118. .step = 1,
  119. .default_value = 0,
  120. },
  121. {
  122. .id = V4L2_CID_PRIVATE_SAVE_USER,
  123. .type = V4L2_CTRL_TYPE_BUTTON,
  124. .name = "Save User Settings",
  125. .minimum = 0,
  126. .maximum = 0,
  127. .step = 0,
  128. .default_value = 0,
  129. },
  130. {
  131. .id = V4L2_CID_PRIVATE_RESTORE_USER,
  132. .type = V4L2_CTRL_TYPE_BUTTON,
  133. .name = "Restore User Settings",
  134. .minimum = 0,
  135. .maximum = 0,
  136. .step = 0,
  137. .default_value = 0,
  138. },
  139. {
  140. .id = V4L2_CID_PRIVATE_RESTORE_FACTORY,
  141. .type = V4L2_CTRL_TYPE_BUTTON,
  142. .name = "Restore Factory Settings",
  143. .minimum = 0,
  144. .maximum = 0,
  145. .step = 0,
  146. .default_value = 0,
  147. },
  148. {
  149. .id = V4L2_CID_PRIVATE_COLOUR_MODE,
  150. .type = V4L2_CTRL_TYPE_BOOLEAN,
  151. .name = "Colour mode",
  152. .minimum = 0,
  153. .maximum = 1,
  154. .step = 1,
  155. .default_value = 0,
  156. },
  157. {
  158. .id = V4L2_CID_PRIVATE_AUTOCONTOUR,
  159. .type = V4L2_CTRL_TYPE_BOOLEAN,
  160. .name = "Auto contour",
  161. .minimum = 0,
  162. .maximum = 1,
  163. .step = 1,
  164. .default_value = 0,
  165. },
  166. {
  167. .id = V4L2_CID_PRIVATE_CONTOUR,
  168. .type = V4L2_CTRL_TYPE_INTEGER,
  169. .name = "Contour",
  170. .minimum = 0,
  171. .maximum = 63,
  172. .step = 1,
  173. .default_value = 0,
  174. },
  175. {
  176. .id = V4L2_CID_PRIVATE_BACKLIGHT,
  177. .type = V4L2_CTRL_TYPE_BOOLEAN,
  178. .name = "Backlight compensation",
  179. .minimum = 0,
  180. .maximum = 1,
  181. .step = 1,
  182. .default_value = 0,
  183. },
  184. {
  185. .id = V4L2_CID_PRIVATE_FLICKERLESS,
  186. .type = V4L2_CTRL_TYPE_BOOLEAN,
  187. .name = "Flickerless",
  188. .minimum = 0,
  189. .maximum = 1,
  190. .step = 1,
  191. .default_value = 0,
  192. },
  193. {
  194. .id = V4L2_CID_PRIVATE_NOISE_REDUCTION,
  195. .type = V4L2_CTRL_TYPE_INTEGER,
  196. .name = "Noise reduction",
  197. .minimum = 0,
  198. .maximum = 3,
  199. .step = 1,
  200. .default_value = 0,
  201. },
  202. };
  203. static void pwc_vidioc_fill_fmt(const struct pwc_device *pdev, struct v4l2_format *f)
  204. {
  205. memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
  206. f->fmt.pix.width = pdev->view.x;
  207. f->fmt.pix.height = pdev->view.y;
  208. f->fmt.pix.field = V4L2_FIELD_NONE;
  209. if (pdev->pixfmt == V4L2_PIX_FMT_YUV420) {
  210. f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
  211. f->fmt.pix.bytesperline = (f->fmt.pix.width * 3)/2;
  212. f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
  213. } else {
  214. /* vbandlength contains 4 lines ... */
  215. f->fmt.pix.bytesperline = pdev->vbandlength/4;
  216. f->fmt.pix.sizeimage = pdev->frame_size + sizeof(struct pwc_raw_frame);
  217. if (DEVICE_USE_CODEC1(pdev->type))
  218. f->fmt.pix.pixelformat = V4L2_PIX_FMT_PWC1;
  219. else
  220. f->fmt.pix.pixelformat = V4L2_PIX_FMT_PWC2;
  221. }
  222. PWC_DEBUG_IOCTL("pwc_vidioc_fill_fmt() "
  223. "width=%d, height=%d, bytesperline=%d, sizeimage=%d, pixelformat=%c%c%c%c\n",
  224. f->fmt.pix.width,
  225. f->fmt.pix.height,
  226. f->fmt.pix.bytesperline,
  227. f->fmt.pix.sizeimage,
  228. (f->fmt.pix.pixelformat)&255,
  229. (f->fmt.pix.pixelformat>>8)&255,
  230. (f->fmt.pix.pixelformat>>16)&255,
  231. (f->fmt.pix.pixelformat>>24)&255);
  232. }
  233. /* ioctl(VIDIOC_TRY_FMT) */
  234. static int pwc_vidioc_try_fmt(struct pwc_device *pdev, struct v4l2_format *f)
  235. {
  236. if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
  237. PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
  238. return -EINVAL;
  239. }
  240. switch (f->fmt.pix.pixelformat) {
  241. case V4L2_PIX_FMT_YUV420:
  242. break;
  243. case V4L2_PIX_FMT_PWC1:
  244. if (DEVICE_USE_CODEC23(pdev->type)) {
  245. PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
  246. return -EINVAL;
  247. }
  248. break;
  249. case V4L2_PIX_FMT_PWC2:
  250. if (DEVICE_USE_CODEC1(pdev->type)) {
  251. PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
  252. return -EINVAL;
  253. }
  254. break;
  255. default:
  256. PWC_DEBUG_IOCTL("Unsupported pixel format\n");
  257. return -EINVAL;
  258. }
  259. if (f->fmt.pix.width > pdev->view_max.x)
  260. f->fmt.pix.width = pdev->view_max.x;
  261. else if (f->fmt.pix.width < pdev->view_min.x)
  262. f->fmt.pix.width = pdev->view_min.x;
  263. if (f->fmt.pix.height > pdev->view_max.y)
  264. f->fmt.pix.height = pdev->view_max.y;
  265. else if (f->fmt.pix.height < pdev->view_min.y)
  266. f->fmt.pix.height = pdev->view_min.y;
  267. return 0;
  268. }
  269. /* ioctl(VIDIOC_SET_FMT) */
  270. static int pwc_vidioc_set_fmt(struct pwc_device *pdev, struct v4l2_format *f)
  271. {
  272. int ret, fps, snapshot, compression, pixelformat;
  273. ret = pwc_vidioc_try_fmt(pdev, f);
  274. if (ret<0)
  275. return ret;
  276. pixelformat = f->fmt.pix.pixelformat;
  277. compression = pdev->vcompression;
  278. snapshot = 0;
  279. fps = pdev->vframes;
  280. if (f->fmt.pix.priv) {
  281. compression = (f->fmt.pix.priv & PWC_QLT_MASK) >> PWC_QLT_SHIFT;
  282. snapshot = !!(f->fmt.pix.priv & PWC_FPS_SNAPSHOT);
  283. fps = (f->fmt.pix.priv & PWC_FPS_FRMASK) >> PWC_FPS_SHIFT;
  284. if (fps == 0)
  285. fps = pdev->vframes;
  286. }
  287. if (pixelformat != V4L2_PIX_FMT_YUV420 &&
  288. pixelformat != V4L2_PIX_FMT_PWC1 &&
  289. pixelformat != V4L2_PIX_FMT_PWC2)
  290. return -EINVAL;
  291. PWC_DEBUG_IOCTL("Try to change format to: width=%d height=%d fps=%d "
  292. "compression=%d snapshot=%d format=%c%c%c%c\n",
  293. f->fmt.pix.width, f->fmt.pix.height, fps,
  294. compression, snapshot,
  295. (pixelformat)&255,
  296. (pixelformat>>8)&255,
  297. (pixelformat>>16)&255,
  298. (pixelformat>>24)&255);
  299. ret = pwc_try_video_mode(pdev,
  300. f->fmt.pix.width,
  301. f->fmt.pix.height,
  302. fps,
  303. compression,
  304. snapshot);
  305. PWC_DEBUG_IOCTL("pwc_try_video_mode(), return=%d\n", ret);
  306. if (ret)
  307. return ret;
  308. pdev->pixfmt = pixelformat;
  309. pwc_vidioc_fill_fmt(pdev, f);
  310. return 0;
  311. }
  312. long pwc_video_do_ioctl(struct file *file, unsigned int cmd, void *arg)
  313. {
  314. struct video_device *vdev = video_devdata(file);
  315. struct pwc_device *pdev;
  316. DECLARE_WAITQUEUE(wait, current);
  317. if (vdev == NULL)
  318. return -EFAULT;
  319. pdev = video_get_drvdata(vdev);
  320. if (pdev == NULL)
  321. return -EFAULT;
  322. #ifdef CONFIG_USB_PWC_DEBUG
  323. if (PWC_DEBUG_LEVEL_IOCTL & pwc_trace) {
  324. v4l_printk_ioctl(cmd);
  325. printk("\n");
  326. }
  327. #endif
  328. switch (cmd) {
  329. #ifdef CONFIG_VIDEO_V4L1_COMPAT
  330. /* mmap() functions */
  331. case VIDIOCGMBUF:
  332. {
  333. /* Tell the user program how much memory is needed for a mmap() */
  334. struct video_mbuf *vm = arg;
  335. int i;
  336. memset(vm, 0, sizeof(*vm));
  337. vm->size = pwc_mbufs * pdev->len_per_image;
  338. vm->frames = pwc_mbufs; /* double buffering should be enough for most applications */
  339. for (i = 0; i < pwc_mbufs; i++)
  340. vm->offsets[i] = i * pdev->len_per_image;
  341. break;
  342. }
  343. #endif
  344. /* V4L2 Layer */
  345. case VIDIOC_QUERYCAP:
  346. {
  347. struct v4l2_capability *cap = arg;
  348. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCAP) This application "\
  349. "try to use the v4l2 layer\n");
  350. strcpy(cap->driver,PWC_NAME);
  351. strlcpy(cap->card, vdev->name, sizeof(cap->card));
  352. usb_make_path(pdev->udev,cap->bus_info,sizeof(cap->bus_info));
  353. cap->version = PWC_VERSION_CODE;
  354. cap->capabilities =
  355. V4L2_CAP_VIDEO_CAPTURE |
  356. V4L2_CAP_STREAMING |
  357. V4L2_CAP_READWRITE;
  358. return 0;
  359. }
  360. case VIDIOC_ENUMINPUT:
  361. {
  362. struct v4l2_input *i = arg;
  363. if ( i->index ) /* Only one INPUT is supported */
  364. return -EINVAL;
  365. memset(i, 0, sizeof(struct v4l2_input));
  366. strcpy(i->name, "usb");
  367. return 0;
  368. }
  369. case VIDIOC_G_INPUT:
  370. {
  371. int *i = arg;
  372. *i = 0; /* Only one INPUT is supported */
  373. return 0;
  374. }
  375. case VIDIOC_S_INPUT:
  376. {
  377. int *i = arg;
  378. if ( *i ) { /* Only one INPUT is supported */
  379. PWC_DEBUG_IOCTL("Only one input source is"\
  380. " supported with this webcam.\n");
  381. return -EINVAL;
  382. }
  383. return 0;
  384. }
  385. /* TODO: */
  386. case VIDIOC_QUERYCTRL:
  387. {
  388. struct v4l2_queryctrl *c = arg;
  389. int i;
  390. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) query id=%d\n", c->id);
  391. for (i=0; i<sizeof(pwc_controls)/sizeof(struct v4l2_queryctrl); i++) {
  392. if (pwc_controls[i].id == c->id) {
  393. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) found\n");
  394. memcpy(c,&pwc_controls[i],sizeof(struct v4l2_queryctrl));
  395. return 0;
  396. }
  397. }
  398. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYCTRL) not found\n");
  399. return -EINVAL;
  400. }
  401. case VIDIOC_G_CTRL:
  402. {
  403. struct v4l2_control *c = arg;
  404. int ret;
  405. switch (c->id)
  406. {
  407. case V4L2_CID_BRIGHTNESS:
  408. c->value = pwc_get_brightness(pdev);
  409. if (c->value<0)
  410. return -EINVAL;
  411. return 0;
  412. case V4L2_CID_CONTRAST:
  413. c->value = pwc_get_contrast(pdev);
  414. if (c->value<0)
  415. return -EINVAL;
  416. return 0;
  417. case V4L2_CID_SATURATION:
  418. ret = pwc_get_saturation(pdev, &c->value);
  419. if (ret<0)
  420. return -EINVAL;
  421. return 0;
  422. case V4L2_CID_GAMMA:
  423. c->value = pwc_get_gamma(pdev);
  424. if (c->value<0)
  425. return -EINVAL;
  426. return 0;
  427. case V4L2_CID_RED_BALANCE:
  428. ret = pwc_get_red_gain(pdev, &c->value);
  429. if (ret<0)
  430. return -EINVAL;
  431. c->value >>= 8;
  432. return 0;
  433. case V4L2_CID_BLUE_BALANCE:
  434. ret = pwc_get_blue_gain(pdev, &c->value);
  435. if (ret<0)
  436. return -EINVAL;
  437. c->value >>= 8;
  438. return 0;
  439. case V4L2_CID_AUTO_WHITE_BALANCE:
  440. ret = pwc_get_awb(pdev);
  441. if (ret<0)
  442. return -EINVAL;
  443. c->value = (ret == PWC_WB_MANUAL)?0:1;
  444. return 0;
  445. case V4L2_CID_GAIN:
  446. ret = pwc_get_agc(pdev, &c->value);
  447. if (ret<0)
  448. return -EINVAL;
  449. c->value >>= 8;
  450. return 0;
  451. case V4L2_CID_AUTOGAIN:
  452. ret = pwc_get_agc(pdev, &c->value);
  453. if (ret<0)
  454. return -EINVAL;
  455. c->value = (c->value < 0)?1:0;
  456. return 0;
  457. case V4L2_CID_EXPOSURE:
  458. ret = pwc_get_shutter_speed(pdev, &c->value);
  459. if (ret<0)
  460. return -EINVAL;
  461. return 0;
  462. case V4L2_CID_PRIVATE_COLOUR_MODE:
  463. ret = pwc_get_colour_mode(pdev, &c->value);
  464. if (ret < 0)
  465. return -EINVAL;
  466. return 0;
  467. case V4L2_CID_PRIVATE_AUTOCONTOUR:
  468. ret = pwc_get_contour(pdev, &c->value);
  469. if (ret < 0)
  470. return -EINVAL;
  471. c->value=(c->value == -1?1:0);
  472. return 0;
  473. case V4L2_CID_PRIVATE_CONTOUR:
  474. ret = pwc_get_contour(pdev, &c->value);
  475. if (ret < 0)
  476. return -EINVAL;
  477. c->value >>= 10;
  478. return 0;
  479. case V4L2_CID_PRIVATE_BACKLIGHT:
  480. ret = pwc_get_backlight(pdev, &c->value);
  481. if (ret < 0)
  482. return -EINVAL;
  483. return 0;
  484. case V4L2_CID_PRIVATE_FLICKERLESS:
  485. ret = pwc_get_flicker(pdev, &c->value);
  486. if (ret < 0)
  487. return -EINVAL;
  488. c->value=(c->value?1:0);
  489. return 0;
  490. case V4L2_CID_PRIVATE_NOISE_REDUCTION:
  491. ret = pwc_get_dynamic_noise(pdev, &c->value);
  492. if (ret < 0)
  493. return -EINVAL;
  494. return 0;
  495. case V4L2_CID_PRIVATE_SAVE_USER:
  496. case V4L2_CID_PRIVATE_RESTORE_USER:
  497. case V4L2_CID_PRIVATE_RESTORE_FACTORY:
  498. return -EINVAL;
  499. }
  500. return -EINVAL;
  501. }
  502. case VIDIOC_S_CTRL:
  503. {
  504. struct v4l2_control *c = arg;
  505. int ret;
  506. switch (c->id)
  507. {
  508. case V4L2_CID_BRIGHTNESS:
  509. c->value <<= 9;
  510. ret = pwc_set_brightness(pdev, c->value);
  511. if (ret<0)
  512. return -EINVAL;
  513. return 0;
  514. case V4L2_CID_CONTRAST:
  515. c->value <<= 10;
  516. ret = pwc_set_contrast(pdev, c->value);
  517. if (ret<0)
  518. return -EINVAL;
  519. return 0;
  520. case V4L2_CID_SATURATION:
  521. ret = pwc_set_saturation(pdev, c->value);
  522. if (ret<0)
  523. return -EINVAL;
  524. return 0;
  525. case V4L2_CID_GAMMA:
  526. c->value <<= 11;
  527. ret = pwc_set_gamma(pdev, c->value);
  528. if (ret<0)
  529. return -EINVAL;
  530. return 0;
  531. case V4L2_CID_RED_BALANCE:
  532. c->value <<= 8;
  533. ret = pwc_set_red_gain(pdev, c->value);
  534. if (ret<0)
  535. return -EINVAL;
  536. return 0;
  537. case V4L2_CID_BLUE_BALANCE:
  538. c->value <<= 8;
  539. ret = pwc_set_blue_gain(pdev, c->value);
  540. if (ret<0)
  541. return -EINVAL;
  542. return 0;
  543. case V4L2_CID_AUTO_WHITE_BALANCE:
  544. c->value = (c->value == 0)?PWC_WB_MANUAL:PWC_WB_AUTO;
  545. ret = pwc_set_awb(pdev, c->value);
  546. if (ret<0)
  547. return -EINVAL;
  548. return 0;
  549. case V4L2_CID_EXPOSURE:
  550. c->value <<= 8;
  551. ret = pwc_set_shutter_speed(pdev, c->value?0:1, c->value);
  552. if (ret<0)
  553. return -EINVAL;
  554. return 0;
  555. case V4L2_CID_AUTOGAIN:
  556. /* autogain off means nothing without a gain */
  557. if (c->value == 0)
  558. return 0;
  559. ret = pwc_set_agc(pdev, c->value, 0);
  560. if (ret<0)
  561. return -EINVAL;
  562. return 0;
  563. case V4L2_CID_GAIN:
  564. c->value <<= 8;
  565. ret = pwc_set_agc(pdev, 0, c->value);
  566. if (ret<0)
  567. return -EINVAL;
  568. return 0;
  569. case V4L2_CID_PRIVATE_SAVE_USER:
  570. if (pwc_save_user(pdev))
  571. return -EINVAL;
  572. return 0;
  573. case V4L2_CID_PRIVATE_RESTORE_USER:
  574. if (pwc_restore_user(pdev))
  575. return -EINVAL;
  576. return 0;
  577. case V4L2_CID_PRIVATE_RESTORE_FACTORY:
  578. if (pwc_restore_factory(pdev))
  579. return -EINVAL;
  580. return 0;
  581. case V4L2_CID_PRIVATE_COLOUR_MODE:
  582. ret = pwc_set_colour_mode(pdev, c->value);
  583. if (ret < 0)
  584. return -EINVAL;
  585. return 0;
  586. case V4L2_CID_PRIVATE_AUTOCONTOUR:
  587. c->value=(c->value == 1)?-1:0;
  588. ret = pwc_set_contour(pdev, c->value);
  589. if (ret < 0)
  590. return -EINVAL;
  591. return 0;
  592. case V4L2_CID_PRIVATE_CONTOUR:
  593. c->value <<= 10;
  594. ret = pwc_set_contour(pdev, c->value);
  595. if (ret < 0)
  596. return -EINVAL;
  597. return 0;
  598. case V4L2_CID_PRIVATE_BACKLIGHT:
  599. ret = pwc_set_backlight(pdev, c->value);
  600. if (ret < 0)
  601. return -EINVAL;
  602. return 0;
  603. case V4L2_CID_PRIVATE_FLICKERLESS:
  604. ret = pwc_set_flicker(pdev, c->value);
  605. if (ret < 0)
  606. return -EINVAL;
  607. case V4L2_CID_PRIVATE_NOISE_REDUCTION:
  608. ret = pwc_set_dynamic_noise(pdev, c->value);
  609. if (ret < 0)
  610. return -EINVAL;
  611. return 0;
  612. }
  613. return -EINVAL;
  614. }
  615. case VIDIOC_ENUM_FMT:
  616. {
  617. struct v4l2_fmtdesc *f = arg;
  618. int index;
  619. if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  620. return -EINVAL;
  621. /* We only support two format: the raw format, and YUV */
  622. index = f->index;
  623. memset(f,0,sizeof(struct v4l2_fmtdesc));
  624. f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  625. f->index = index;
  626. switch(index)
  627. {
  628. case 0:
  629. /* RAW format */
  630. f->pixelformat = pdev->type<=646?V4L2_PIX_FMT_PWC1:V4L2_PIX_FMT_PWC2;
  631. f->flags = V4L2_FMT_FLAG_COMPRESSED;
  632. strlcpy(f->description,"Raw Philips Webcam",sizeof(f->description));
  633. break;
  634. case 1:
  635. f->pixelformat = V4L2_PIX_FMT_YUV420;
  636. strlcpy(f->description,"4:2:0, planar, Y-Cb-Cr",sizeof(f->description));
  637. break;
  638. default:
  639. return -EINVAL;
  640. }
  641. return 0;
  642. }
  643. case VIDIOC_G_FMT:
  644. {
  645. struct v4l2_format *f = arg;
  646. PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",pdev->image.x,pdev->image.y);
  647. if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  648. return -EINVAL;
  649. pwc_vidioc_fill_fmt(pdev, f);
  650. return 0;
  651. }
  652. case VIDIOC_TRY_FMT:
  653. return pwc_vidioc_try_fmt(pdev, arg);
  654. case VIDIOC_S_FMT:
  655. return pwc_vidioc_set_fmt(pdev, arg);
  656. case VIDIOC_G_STD:
  657. {
  658. v4l2_std_id *std = arg;
  659. *std = V4L2_STD_UNKNOWN;
  660. return 0;
  661. }
  662. case VIDIOC_S_STD:
  663. {
  664. v4l2_std_id *std = arg;
  665. if (*std != V4L2_STD_UNKNOWN)
  666. return -EINVAL;
  667. return 0;
  668. }
  669. case VIDIOC_ENUMSTD:
  670. {
  671. struct v4l2_standard *std = arg;
  672. if (std->index != 0)
  673. return -EINVAL;
  674. std->id = V4L2_STD_UNKNOWN;
  675. strlcpy(std->name, "webcam", sizeof(std->name));
  676. return 0;
  677. }
  678. case VIDIOC_REQBUFS:
  679. {
  680. struct v4l2_requestbuffers *rb = arg;
  681. int nbuffers;
  682. PWC_DEBUG_IOCTL("ioctl(VIDIOC_REQBUFS) count=%d\n",rb->count);
  683. if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  684. return -EINVAL;
  685. if (rb->memory != V4L2_MEMORY_MMAP)
  686. return -EINVAL;
  687. nbuffers = rb->count;
  688. if (nbuffers < 2)
  689. nbuffers = 2;
  690. else if (nbuffers > pwc_mbufs)
  691. nbuffers = pwc_mbufs;
  692. /* Force to use our # of buffers */
  693. rb->count = pwc_mbufs;
  694. return 0;
  695. }
  696. case VIDIOC_QUERYBUF:
  697. {
  698. struct v4l2_buffer *buf = arg;
  699. int index;
  700. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) index=%d\n",buf->index);
  701. if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
  702. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad type\n");
  703. return -EINVAL;
  704. }
  705. if (buf->memory != V4L2_MEMORY_MMAP) {
  706. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad memory type\n");
  707. return -EINVAL;
  708. }
  709. index = buf->index;
  710. if (index < 0 || index >= pwc_mbufs) {
  711. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QUERYBUF) Bad index %d\n", buf->index);
  712. return -EINVAL;
  713. }
  714. memset(buf, 0, sizeof(struct v4l2_buffer));
  715. buf->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
  716. buf->index = index;
  717. buf->m.offset = index * pdev->len_per_image;
  718. if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
  719. buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
  720. else
  721. buf->bytesused = pdev->view.size;
  722. buf->field = V4L2_FIELD_NONE;
  723. buf->memory = V4L2_MEMORY_MMAP;
  724. //buf->flags = V4L2_BUF_FLAG_MAPPED;
  725. buf->length = pdev->len_per_image;
  726. PWC_DEBUG_READ("VIDIOC_QUERYBUF: index=%d\n",buf->index);
  727. PWC_DEBUG_READ("VIDIOC_QUERYBUF: m.offset=%d\n",buf->m.offset);
  728. PWC_DEBUG_READ("VIDIOC_QUERYBUF: bytesused=%d\n",buf->bytesused);
  729. return 0;
  730. }
  731. case VIDIOC_QBUF:
  732. {
  733. struct v4l2_buffer *buf = arg;
  734. PWC_DEBUG_IOCTL("ioctl(VIDIOC_QBUF) index=%d\n",buf->index);
  735. if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  736. return -EINVAL;
  737. if (buf->memory != V4L2_MEMORY_MMAP)
  738. return -EINVAL;
  739. if (buf->index >= pwc_mbufs)
  740. return -EINVAL;
  741. buf->flags |= V4L2_BUF_FLAG_QUEUED;
  742. buf->flags &= ~V4L2_BUF_FLAG_DONE;
  743. return 0;
  744. }
  745. case VIDIOC_DQBUF:
  746. {
  747. struct v4l2_buffer *buf = arg;
  748. int ret;
  749. PWC_DEBUG_IOCTL("ioctl(VIDIOC_DQBUF)\n");
  750. if (buf->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
  751. return -EINVAL;
  752. /* Add ourselves to the frame wait-queue.
  753. FIXME: needs auditing for safety.
  754. QUESTION: In what respect? I think that using the
  755. frameq is safe now.
  756. */
  757. add_wait_queue(&pdev->frameq, &wait);
  758. while (pdev->full_frames == NULL) {
  759. if (pdev->error_status) {
  760. remove_wait_queue(&pdev->frameq, &wait);
  761. set_current_state(TASK_RUNNING);
  762. return -pdev->error_status;
  763. }
  764. if (signal_pending(current)) {
  765. remove_wait_queue(&pdev->frameq, &wait);
  766. set_current_state(TASK_RUNNING);
  767. return -ERESTARTSYS;
  768. }
  769. schedule();
  770. set_current_state(TASK_INTERRUPTIBLE);
  771. }
  772. remove_wait_queue(&pdev->frameq, &wait);
  773. set_current_state(TASK_RUNNING);
  774. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: frame ready.\n");
  775. /* Decompress data in pdev->images[pdev->fill_image] */
  776. ret = pwc_handle_frame(pdev);
  777. if (ret)
  778. return -EFAULT;
  779. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: after pwc_handle_frame\n");
  780. buf->index = pdev->fill_image;
  781. if (pdev->pixfmt != V4L2_PIX_FMT_YUV420)
  782. buf->bytesused = pdev->frame_size + sizeof(struct pwc_raw_frame);
  783. else
  784. buf->bytesused = pdev->view.size;
  785. buf->flags = V4L2_BUF_FLAG_MAPPED;
  786. buf->field = V4L2_FIELD_NONE;
  787. do_gettimeofday(&buf->timestamp);
  788. buf->sequence = 0;
  789. buf->memory = V4L2_MEMORY_MMAP;
  790. buf->m.offset = pdev->fill_image * pdev->len_per_image;
  791. buf->length = pdev->len_per_image;
  792. pwc_next_image(pdev);
  793. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->index=%d\n",buf->index);
  794. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: buf->length=%d\n",buf->length);
  795. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: m.offset=%d\n",buf->m.offset);
  796. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: bytesused=%d\n",buf->bytesused);
  797. PWC_DEBUG_IOCTL("VIDIOC_DQBUF: leaving\n");
  798. return 0;
  799. }
  800. case VIDIOC_STREAMON:
  801. {
  802. /* WARNING: pwc_try_video_mode() called pwc_isoc_init */
  803. pwc_isoc_init(pdev);
  804. return 0;
  805. }
  806. case VIDIOC_STREAMOFF:
  807. {
  808. pwc_isoc_cleanup(pdev);
  809. return 0;
  810. }
  811. case VIDIOC_ENUM_FRAMESIZES:
  812. {
  813. struct v4l2_frmsizeenum *fsize = arg;
  814. unsigned int i = 0, index = fsize->index;
  815. if (fsize->pixel_format == V4L2_PIX_FMT_YUV420) {
  816. for (i = 0; i < PSZ_MAX; i++) {
  817. if (pdev->image_mask & (1UL << i)) {
  818. if (!index--) {
  819. fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
  820. fsize->discrete.width = pwc_image_sizes[i].x;
  821. fsize->discrete.height = pwc_image_sizes[i].y;
  822. return 0;
  823. }
  824. }
  825. }
  826. } else if (fsize->index == 0 &&
  827. ((fsize->pixel_format == V4L2_PIX_FMT_PWC1 && DEVICE_USE_CODEC1(pdev->type)) ||
  828. (fsize->pixel_format == V4L2_PIX_FMT_PWC2 && DEVICE_USE_CODEC23(pdev->type)))) {
  829. fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
  830. fsize->discrete.width = pdev->abs_max.x;
  831. fsize->discrete.height = pdev->abs_max.y;
  832. return 0;
  833. }
  834. return -EINVAL;
  835. }
  836. case VIDIOC_ENUM_FRAMEINTERVALS:
  837. {
  838. struct v4l2_frmivalenum *fival = arg;
  839. int size = -1;
  840. unsigned int i;
  841. for (i = 0; i < PSZ_MAX; i++) {
  842. if (pwc_image_sizes[i].x == fival->width &&
  843. pwc_image_sizes[i].y == fival->height) {
  844. size = i;
  845. break;
  846. }
  847. }
  848. /* TODO: Support raw format */
  849. if (size < 0 || fival->pixel_format != V4L2_PIX_FMT_YUV420) {
  850. return -EINVAL;
  851. }
  852. i = pwc_get_fps(pdev, fival->index, size);
  853. if (!i)
  854. return -EINVAL;
  855. fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
  856. fival->discrete.numerator = 1;
  857. fival->discrete.denominator = i;
  858. return 0;
  859. }
  860. default:
  861. return pwc_ioctl(pdev, cmd, arg);
  862. } /* ..switch */
  863. return 0;
  864. }
  865. /* vim: set cino= formatoptions=croql cindent shiftwidth=8 tabstop=8: */