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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
pwc-ctrl.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：36k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

pwc-ctrl.c：源码内容
  1. /* Driver for Philips webcam
  2.    Functions that send various control messages to the webcam, including
  3.    video modes.
  4.    (C) 1999-2002 Nemosoft Unv. (webcam@smcc.demon.nl)
  6.    This program is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2 of the License, or
  9.    (at your option) any later version.
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19. */
  21. /*
  22.    Changes
  23.    2001/08/03  Alvarado   Added methods for changing white balance and 
  24.                           red/green gains
  25.  */
  27. /* Control functions for the cam; brightness, contrast, video mode, etc. */
  29. #ifdef __KERNEL__
  30. #include <asm/uaccess.h> 
  31. #endif
  32. #include <asm/errno.h>
  33.  
  34. #include "pwc.h"
  35. #include "pwc-ioctl.h"
  36. #include "pwc-uncompress.h"
  38. /* Request types: video */
  39. #define SET_LUM_CTL 0x01
  40. #define GET_LUM_CTL 0x02
  41. #define SET_CHROM_CTL 0x03
  42. #define GET_CHROM_CTL 0x04
  43. #define SET_STATUS_CTL 0x05
  44. #define GET_STATUS_CTL 0x06
  45. #define SET_EP_STREAM_CTL 0x07
  46. #define GET_EP_STREAM_CTL 0x08
  48. /* Selectors for the Luminance controls [GS]ET_LUM_CTL */
  49. #define AGC_MODE_FORMATTER 0x2000
  50. #define PRESET_AGC_FORMATTER 0x2100
  51. #define SHUTTER_MODE_FORMATTER 0x2200
  52. #define PRESET_SHUTTER_FORMATTER 0x2300
  53. #define PRESET_CONTOUR_FORMATTER 0x2400
  54. #define AUTO_CONTOUR_FORMATTER 0x2500
  55. #define BACK_LIGHT_COMPENSATION_FORMATTER 0x2600
  56. #define CONTRAST_FORMATTER 0x2700
  57. #define DYNAMIC_NOISE_CONTROL_FORMATTER 0x2800
  58. #define FLICKERLESS_MODE_FORMATTER 0x2900
  59. #define AE_CONTROL_SPEED 0x2A00
  60. #define BRIGHTNESS_FORMATTER 0x2B00
  61. #define GAMMA_FORMATTER 0x2C00
  63. /* Selectors for the Chrominance controls [GS]ET_CHROM_CTL */
  64. #define WB_MODE_FORMATTER 0x1000
  65. #define AWB_CONTROL_SPEED_FORMATTER 0x1100
  66. #define AWB_CONTROL_DELAY_FORMATTER 0x1200
  67. #define PRESET_MANUAL_RED_GAIN_FORMATTER 0x1300
  68. #define PRESET_MANUAL_BLUE_GAIN_FORMATTER 0x1400
  69. #define COLOUR_MODE_FORMATTER 0x1500
  70. #define SATURATION_MODE_FORMATTER1 0x1600
  71. #define SATURATION_MODE_FORMATTER2 0x1700
  73. /* Selectors for the Status controls [GS]ET_STATUS_CTL */
  74. #define SAVE_USER_DEFAULTS_FORMATTER 0x0200
  75. #define RESTORE_USER_DEFAULTS_FORMATTER 0x0300
  76. #define RESTORE_FACTORY_DEFAULTS_FORMATTER 0x0400
  77. #define READ_AGC_FORMATTER 0x0500
  78. #define READ_SHUTTER_FORMATTER 0x0600
  79. #define READ_RED_GAIN_FORMATTER 0x0700
  80. #define READ_BLUE_GAIN_FORMATTER 0x0800
  81. #define SENSOR_TYPE_FORMATTER1 0x0C00
  82. #define READ_RAW_Y_MEAN_FORMATTER 0x3100
  83. #define SET_POWER_SAVE_MODE_FORMATTER 0x3200
  84. #define MIRROR_IMAGE_FORMATTER 0x3300
  85. #define LED_FORMATTER 0x3400
  86. #define SENSOR_TYPE_FORMATTER2 0x3700
  88. /* Formatters for the Video Endpoint controls [GS]ET_EP_STREAM_CTL */
  89. #define VIDEO_OUTPUT_CONTROL_FORMATTER 0x0100
  91. static char *size2name[PSZ_MAX] =
  92. {
  93. "subQCIF",
  94. "QSIF",
  95. "QCIF",
  96. "SIF",
  97. "CIF",
  98. "VGA",
  99. };  
  101. /********/
  103. /* Entries for the Nala (645/646) camera; the Nala doesn't have compression 
  104.    preferences, so you either get compressed or non-compressed streams.
  105.    
  106.    An alternate value of 0 means this mode is not available at all.
  107.  */
  109. struct Nala_table_entry {
  110. char alternate; /* USB alternate setting */
  111. int compressed; /* Compressed yes/no */
  113. unsigned char mode[3]; /* precomputed mode table */
  114. };
  116. static struct Nala_table_entry Nala_table[PSZ_MAX][8] =
  117. {
  118. #include "pwc_nala.h"
  119. };
  121. /* This tables contains entries for the 675/680/690 (Timon) camera, with
  122.    4 different qualities (no compression, low, medium, high).
  123.    It lists the bandwidth requirements for said mode by its alternate interface 
  124.    number. An alternate of 0 means that the mode is unavailable.
  125.    
  126.    There are 6 * 4 * 4 entries: 
  127.      6 different resolutions subqcif, qsif, qcif, sif, cif, vga
  128.      6 framerates: 5, 10, 15, 20, 25, 30
  129.      4 compression modi: none, low, medium, high
  130.      
  131.    When an uncompressed mode is not available, the next available compressed mode 
  132.    will be choosen (unless the decompressor is absent). Sometimes there are only
  133.    1 or 2 compressed modes available; in that case entries are duplicated.
  134. */
  135. struct Timon_table_entry 
  136. {
  137. char alternate; /* USB alternate interface */
  138. unsigned short packetsize; /* Normal packet size */
  139. unsigned short bandlength; /* Bandlength when decompressing */
  140. unsigned char mode[13]; /* precomputed mode settings for cam */
  141. };
  143. static struct Timon_table_entry Timon_table[PSZ_MAX][6][4] = 
  144. {
  145. #include "pwc_timon.h"
  146. };
  148. /* Entries for the Kiara (730/740/750) camera */
  150. struct Kiara_table_entry
  151. {
  152. char alternate; /* USB alternate interface */
  153. unsigned short packetsize; /* Normal packet size */
  154. unsigned short bandlength; /* Bandlength when decompressing */
  155. unsigned char mode[12]; /* precomputed mode settings for cam */
  156. };
  158. static struct Kiara_table_entry Kiara_table[PSZ_MAX][6][4] =
  159. {
  160. #include "pwc_kiara.h"
  161. };
  164. /****************************************************************************/
  167. #define SendControlMsg(request, value, buflen) 
  168. usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0), 
  169. request, 
  170. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 
  171. value, 
  172. pdev->vcinterface, 
  173. &buf, buflen, HZ / 2)
  175. #define RecvControlMsg(request, value, buflen) 
  176. usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0), 
  177. request, 
  178. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 
  179. value, 
  180. pdev->vcinterface, 
  181. &buf, buflen, HZ / 2)
  184. #if PWC_DEBUG
  185. void pwc_hexdump(void *p, int len)
  186. {
  187. int i;
  188. unsigned char *s;
  189. char buf[100], *d;
  191. s = (unsigned char *)p;
  192. d = buf;
  193. *d = '';
  194. Debug("Doing hexdump @ %p, %d bytes.n", p, len);
  195. for (i = 0; i < len; i++) {
  196. d += sprintf(d, "%02X ", *s++);
  197. if ((i & 0xF) == 0xF) {
  198. Debug("%sn", buf);
  199. d = buf;
  200. *d = '';
  201. }
  202. }
  203. if ((i & 0xF) != 0)
  204. Debug("%sn", buf);
  205. }
  206. #endif
  208. static inline int send_video_command(struct usb_device *udev, int index, void *buf, int buflen)
  209. {
  210. return usb_control_msg(udev,
  211. usb_sndctrlpipe(udev, 0),
  212. SET_EP_STREAM_CTL,
  213. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  214. VIDEO_OUTPUT_CONTROL_FORMATTER,
  215. index,
  216. buf, buflen, HZ);
  217. }
  221. static inline int set_video_mode_Nala(struct pwc_device *pdev, int size, int frames)
  222. {
  223. unsigned char buf[3];
  224. int ret, fps;
  225. struct Nala_table_entry *pEntry;
  226. int frames2frames[31] = 
  227. { /* closest match of framerate */
  228.    0,  0,  0,  0,  4,  /*  0-4  */
  229.    5,  5,  7,  7, 10,  /*  5-9  */
  230.           10, 10, 12, 12, 15,  /* 10-14 */
  231.           15, 15, 15, 20, 20,  /* 15-19 */
  232.           20, 20, 20, 24, 24,  /* 20-24 */
  233.           24, 24, 24, 24, 24,  /* 25-29 */
  234.           24                   /* 30    */
  235. };
  236. int frames2table[31] = 
  237. { 0, 0, 0, 0, 0, /*  0-4  */
  238.   1, 1, 1, 2, 2, /*  5-9  */
  239.   3, 3, 4, 4, 4, /* 10-14 */
  240.   5, 5, 5, 5, 5, /* 15-19 */
  241.   6, 6, 6, 6, 7, /* 20-24 */
  242.   7, 7, 7, 7, 7, /* 25-29 */
  243.   7              /* 30    */
  244. };
  246. if (size < 0 || size > PSZ_CIF || frames < 4 || frames > 25)
  247. return -EINVAL;
  248. frames = frames2frames[frames];
  249. fps = frames2table[frames];
  250. pEntry = &Nala_table[size][fps];
  251. if (pEntry->alternate == 0)
  252. return -EINVAL;
  254. if (pEntry->compressed && pdev->decompressor == NULL)
  255. return -ENOENT; /* Not supported. */
  257. memcpy(buf, pEntry->mode, 3);
  258. ret = send_video_command(pdev->udev, pdev->vendpoint, buf, 3);
  259. if (ret < 0)
  260. return ret;
  261. if (pEntry->compressed && pdev->decompressor != NULL)
  262. pdev->decompressor->init(pdev->release, buf, pdev->decompress_data);
  264. /* Set various parameters */
  265. pdev->vframes = frames;
  266. pdev->vsize = size;
  267. pdev->valternate = pEntry->alternate;
  268. pdev->image = pwc_image_sizes[size];
  269. pdev->frame_size = (pdev->image.x * pdev->image.y * 3) / 2;
  270. if (pEntry->compressed) {
  271. if (pdev->release < 5) { /* 4 fold compression */
  272. pdev->vbandlength = 528;
  273. pdev->frame_size /= 4;
  274. }
  275. else {
  276. pdev->vbandlength = 704;
  277. pdev->frame_size /= 3;
  278. }
  279. }
  280. else
  281. pdev->vbandlength = 0;
  282. return 0;
  283. }
  286. static inline int set_video_mode_Timon(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
  287. {
  288. unsigned char buf[13];
  289. struct Timon_table_entry *pChoose;
  290. int ret, fps;
  292. if (size >= PSZ_MAX || frames < 5 || frames > 30 || compression < 0 || compression > 3)
  293. return -EINVAL;
  294. if (size == PSZ_VGA && frames > 15)
  295. return -EINVAL;
  296. fps = (frames / 5) - 1;
  298. /* Find a supported framerate with progressively higher compression ratios
  299.    if the preferred ratio is not available.
  300. */
  301. pChoose = NULL;
  302. if (pdev->decompressor == NULL) {
  303. #if PWC_DEBUG
  304. Debug("Trying to find uncompressed mode.n");
  305. #endif
  306. pChoose = &Timon_table[size][fps][0];
  307. }
  308. else {
  309. while (compression <= 3) {
  310. pChoose = &Timon_table[size][fps][compression];
  311. if (pChoose->alternate != 0)
  312. break;
  313. compression++;
  314. }
  315. }
  316. if (pChoose == NULL || pChoose->alternate == 0)
  317. return -ENOENT; /* Not supported. */
  319. memcpy(buf, pChoose->mode, 13);
  320. if (snapshot)
  321. buf[0] |= 0x80;
  322. ret = send_video_command(pdev->udev, pdev->vendpoint, buf, 13);
  323. if (ret < 0)
  324. return ret;
  326. if (pChoose->bandlength > 0)
  327. pdev->decompressor->init(pdev->release, buf, pdev->decompress_data);
  329. /* Set various parameters */
  330. pdev->vframes = frames;
  331. pdev->vsize = size;
  332. pdev->vsnapshot = snapshot;
  333. pdev->valternate = pChoose->alternate;
  334. pdev->image = pwc_image_sizes[size];
  335. pdev->vbandlength = pChoose->bandlength;
  336. if (pChoose->bandlength > 0) 
  337. pdev->frame_size = (pChoose->bandlength * pdev->image.y) / 4;
  338. else
  339. pdev->frame_size = (pdev->image.x * pdev->image.y * 12) / 8;
  340. return 0;
  341. }
  344. static inline int set_video_mode_Kiara(struct pwc_device *pdev, int size, int frames, int compression, int snapshot)
  345. {
  346. struct Kiara_table_entry *pChoose;
  347. int fps, ret;
  348. unsigned char buf[12];
  350. if (size >= PSZ_MAX || frames < 5 || frames > 30 || compression < 0 || compression > 3)
  351. return -EINVAL;
  352. if (size == PSZ_VGA && frames > 15)
  353. return -EINVAL;
  354. fps = (frames / 5) - 1;
  356. /* Find a supported framerate with progressively higher compression ratios
  357.    if the preferred ratio is not available.
  358. */
  359. pChoose = NULL;
  360. if (pdev->decompressor == NULL) {
  361. #if PWC_DEBUG
  362. Debug("Trying to find uncompressed mode.n");
  363. #endif
  364. pChoose = &Kiara_table[size][fps][0];
  365. }
  366. else {
  367. while (compression <= 3) {
  368. pChoose = &Kiara_table[size][fps][compression];
  369. if (pChoose->alternate != 0)
  370. break;
  371. compression++;
  372. }
  373. }
  374. if (pChoose == NULL || pChoose->alternate == 0)
  375. return -ENOENT; /* Not supported. */
  377. /* usb_control_msg won't take staticly allocated arrays as argument?? */
  378. memcpy(buf, pChoose->mode, 12);
  379. if (snapshot)
  380. buf[0] |= 0x80;
  382. /* Firmware bug: video endpoint is 5, but commands are sent to endpoint 4 */
  383. ret = send_video_command(pdev->udev, 4 /* pdev->vendpoint */, buf, 12);
  384. if (ret < 0)
  385. return ret;
  387. if (pChoose->bandlength > 0)
  388. pdev->decompressor->init(pdev->release, buf, pdev->decompress_data);
  390. /* All set and go */
  391. pdev->vframes = frames;
  392. pdev->vsize = size;
  393. pdev->vsnapshot = snapshot;
  394. pdev->valternate = pChoose->alternate;
  395. pdev->image = pwc_image_sizes[size];
  396. pdev->vbandlength = pChoose->bandlength;
  397. if (pChoose->bandlength > 0)
  398. pdev->frame_size = (pChoose->bandlength * pdev->image.y) / 4;
  399. else 
  400. pdev->frame_size = (pdev->image.x * pdev->image.y * 12) / 8;
  401. pdev->frame_size += (pdev->frame_header_size + pdev->frame_trailer_size);
  402. return 0;
  403. }
  406. /**
  407.    @pdev: device structure
  408.    @width: viewport width
  409.    @height: viewport height
  410.    @frame: framerate, in fps
  411.    @compression: preferred compression ratio
  412.    @snapshot: snapshot mode or streaming
  413.  */
  414. int pwc_set_video_mode(struct pwc_device *pdev, int width, int height, int frames, int compression, int snapshot)
  415. {
  416. int ret, size;
  418. size = pwc_decode_size(pdev, width, height);
  419. if (size < 0) {
  420. Debug("Could not find suitable size.n");
  421. return -ERANGE;
  422. }
  423. ret = -EINVAL;
  424. switch(pdev->type) {
  425. case 645:
  426. case 646:
  427. ret = set_video_mode_Nala(pdev, size, frames);
  428. break;
  430. case 675:
  431. case 680:
  432. case 690:
  433. ret = set_video_mode_Timon(pdev, size, frames, compression, snapshot);
  434. break;
  436. case 730:
  437. case 740:
  438. case 750:
  439. ret = set_video_mode_Kiara(pdev, size, frames, compression, snapshot);
  440. break;
  441. }
  442. if (ret < 0) {
  443. if (ret == -ENOENT)
  444. Info("Video mode %s@%d fps is only supported with the decompressor module (pwcx).n", size2name[size], frames);
  445. else {
  446. Err("Failed to set video mode %s@%d fps; return code = %dn", size2name[size], frames, ret);
  447. return ret;
  448. }
  449. }
  450. pdev->view.x = width;
  451. pdev->view.y = height;
  452. pwc_set_image_buffer_size(pdev);
  453. Trace(TRACE_SIZE, "Set viewport to %dx%d, image size is %dx%d, palette = %d.n", width, height, pwc_image_sizes[size].x, pwc_image_sizes[size].y, pdev->vpalette);
  454. return 0;
  455. }
  458. void pwc_set_image_buffer_size(struct pwc_device *pdev)
  459. {
  460. int factor, i, filler = 0;
  462. switch(pdev->vpalette) {
  463. case VIDEO_PALETTE_RGB32 | 0x80:
  464. case VIDEO_PALETTE_RGB32:
  465. factor = 16;
  466. filler = 0;
  467. break;
  468. case VIDEO_PALETTE_RGB24 | 0x80:
  469. case VIDEO_PALETTE_RGB24:
  470. factor = 12;
  471. filler = 0;
  472. break;
  473. case VIDEO_PALETTE_YUYV:
  474. case VIDEO_PALETTE_YUV422:
  475. factor = 8;
  476. filler = 128;
  477. break;
  478. case VIDEO_PALETTE_YUV420:
  479. case VIDEO_PALETTE_YUV420P:
  480. factor = 6;
  481. filler = 128;
  482. break;
  483. #if PWC_DEBUG
  484. case VIDEO_PALETTE_RAW:
  485. pdev->image.size = pdev->frame_size;
  486. pdev->view.size = pdev->frame_size;
  487. return;
  488. break;
  489. #endif
  490. default:
  491. factor = 0;
  492. break;
  493. }
  495. /* Set sizes in bytes */
  496. pdev->image.size = pdev->image.x * pdev->image.y * factor / 4;
  497. pdev->view.size  = pdev->view.x  * pdev->view.y  * factor / 4;
  499. /* Align offset, or you'll get some very weird results in
  500.    YUV420 mode... x must be multiple of 4 (to get the Y's in 
  501.    place), and y even (or you'll mixup U & V). This is less of a
  502.    problem for YUV420P.
  503.  */
  504. pdev->offset.x = ((pdev->view.x - pdev->image.x) / 2) & 0xFFFC;
  505. pdev->offset.y = ((pdev->view.y - pdev->image.y) / 2) & 0xFFFE;
  507. /* Fill buffers with gray or black */
  508. for (i = 0; i < MAX_IMAGES; i++) {
  509. if (pdev->image_ptr[i] != NULL)
  510. memset(pdev->image_ptr[i], filler, pdev->view.size);
  511. }
  512. }
  516. /* BRIGHTNESS */
  518. int pwc_get_brightness(struct pwc_device *pdev)
  519. {
  520. char buf;
  521. int ret;
  523. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  524. GET_LUM_CTL,
  525. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  526. BRIGHTNESS_FORMATTER,
  527. pdev->vcinterface,
  528. &buf, 1, HZ / 2);
  529. if (ret < 0)
  530. return ret;
  531. return buf << 9;
  532. }
  534. int pwc_set_brightness(struct pwc_device *pdev, int value)
  535. {
  536. char buf;
  538. if (value < 0)
  539. value = 0;
  540. if (value > 0xffff)
  541. value = 0xffff;
  542. buf = (value >> 9) & 0x7f;
  543. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  544. SET_LUM_CTL,
  545. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  546. BRIGHTNESS_FORMATTER,
  547. pdev->vcinterface,
  548. &buf, 1, HZ / 2);
  549. }
  551. /* CONTRAST */
  553. int pwc_get_contrast(struct pwc_device *pdev)
  554. {
  555. char buf;
  556. int ret;
  558. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  559. GET_LUM_CTL,
  560. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  561. CONTRAST_FORMATTER,
  562. pdev->vcinterface,
  563. &buf, 1, HZ / 2);
  564. if (ret < 0)
  565. return ret;
  566. return buf << 10;
  567. }
  569. int pwc_set_contrast(struct pwc_device *pdev, int value)
  570. {
  571. char buf;
  573. if (value < 0)
  574. value = 0;
  575. if (value > 0xffff)
  576. value = 0xffff;
  577. buf = (value >> 10) & 0x3f;
  578. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  579. SET_LUM_CTL,
  580. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  581. CONTRAST_FORMATTER,
  582. pdev->vcinterface,
  583. &buf, 1, HZ / 2);
  584. }
  586. /* GAMMA */
  588. int pwc_get_gamma(struct pwc_device *pdev)
  589. {
  590. char buf;
  591. int ret;
  593. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  594. GET_LUM_CTL,
  595. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  596. GAMMA_FORMATTER,
  597. pdev->vcinterface,
  598. &buf, 1, HZ / 2);
  599. if (ret < 0)
  600. return ret;
  601. return buf << 11;
  602. }
  604. int pwc_set_gamma(struct pwc_device *pdev, int value)
  605. {
  606. char buf;
  608. if (value < 0)
  609. value = 0;
  610. if (value > 0xffff)
  611. value = 0xffff;
  612. buf = (value >> 11) & 0x1f;
  613. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  614. SET_LUM_CTL,
  615. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  616. GAMMA_FORMATTER,
  617. pdev->vcinterface,
  618. &buf, 1, HZ / 2);
  619. }
  622. /* SATURATION */
  624. int pwc_get_saturation(struct pwc_device *pdev)
  625. {
  626. char buf;
  627. int ret;
  629. if (pdev->type < 675)
  630. return -1;
  631. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  632. GET_CHROM_CTL,
  633. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  634. pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1,
  635. pdev->vcinterface,
  636. &buf, 1, HZ / 2);
  637. if (ret < 0)
  638. return ret;
  639. return 32768 + buf * 327;
  640. }
  642. int pwc_set_saturation(struct pwc_device *pdev, int value)
  643. {
  644. char buf;
  646. if (pdev->type < 675)
  647. return -EINVAL;
  648. if (value < 0)
  649. value = 0;
  650. if (value > 0xffff)
  651. value = 0xffff;
  652. /* saturation ranges from -100 to +100 */
  653. buf = (value - 32768) / 327;
  654. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  655. SET_CHROM_CTL,
  656. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  657. pdev->type < 730 ? SATURATION_MODE_FORMATTER2 : SATURATION_MODE_FORMATTER1,
  658. pdev->vcinterface,
  659. &buf, 1, HZ / 2);
  660. }
  662. /* AGC */
  664. static inline int pwc_set_agc(struct pwc_device *pdev, int mode, int value)
  665. {
  666. char buf;
  667. int ret;
  669. if (mode)
  670. buf = 0x0; /* auto */
  671. else
  672. buf = 0xff; /* fixed */
  674. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  675. SET_LUM_CTL,
  676. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  677. AGC_MODE_FORMATTER,
  678. pdev->vcinterface,
  679. &buf, 1, HZ / 2);
  681. if (!mode && ret >= 0) {
  682. if (value < 0)
  683. value = 0;
  684. if (value > 0xffff)
  685. value = 0xffff;
  686. buf = (value >> 10) & 0x3F;
  687. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  688. SET_LUM_CTL,
  689. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  690. PRESET_AGC_FORMATTER,
  691. pdev->vcinterface,
  692. &buf, 1, HZ / 2);
  693. }
  694. if (ret < 0)
  695. return ret;
  696. return 0;
  697. }
  699. static inline int pwc_get_agc(struct pwc_device *pdev, int *value)
  700. {
  701. unsigned char buf;
  702. int ret;
  704. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  705. GET_LUM_CTL,
  706. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  707. AGC_MODE_FORMATTER,
  708. pdev->vcinterface,
  709. &buf, 1, HZ / 2);
  710. if (ret < 0)
  711. return ret;
  713. if (buf != 0) { /* fixed */
  714. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  715. GET_LUM_CTL,
  716. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  717. PRESET_AGC_FORMATTER,
  718. pdev->vcinterface,
  719. &buf, 1, HZ / 2);
  720. if (ret < 0)
  721. return ret;
  722. if (buf > 0x3F)
  723. buf = 0x3F;
  724. *value = (buf << 10);
  725. }
  726. else { /* auto */
  727. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  728. GET_STATUS_CTL,
  729. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  730. READ_AGC_FORMATTER,
  731. pdev->vcinterface,
  732. &buf, 1, HZ / 2);
  733. if (ret < 0)
  734. return ret;
  735. /* Gah... this value ranges from 0x00 ... 0x9F */
  736. if (buf > 0x9F)
  737. buf = 0x9F;
  738. *value = -(48 + buf * 409);
  739. }
  741. return 0;
  742. }
  744. static inline int pwc_set_shutter_speed(struct pwc_device *pdev, int mode, int value)
  745. {
  746. char buf[2];
  747. int speed, ret;
  750. if (mode)
  751. buf[0] = 0x0; /* auto */
  752. else
  753. buf[0] = 0xff; /* fixed */
  755. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  756. SET_LUM_CTL,
  757. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  758. SHUTTER_MODE_FORMATTER,
  759. pdev->vcinterface,
  760. buf, 1, HZ / 2);
  762. if (!mode && ret >= 0) {
  763. if (value < 0)
  764. value = 0;
  765. if (value > 0xffff)
  766. value = 0xffff;
  767. switch(pdev->type) {
  768. case 675:
  769. case 680:
  770. case 690:
  771. /* speed ranges from 0x0 to 0x290 (656) */
  772. speed = (value / 100);
  773. buf[1] = speed >> 8;
  774. buf[0] = speed & 0xff;
  775. break;
  776. case 730:
  777. case 740:
  778. case 750:
  779. /* speed seems to range from 0x0 to 0xff */
  780. buf[1] = 0;
  781. buf[0] = value >> 8;
  782. break;
  783. }
  785. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  786. SET_LUM_CTL,
  787. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  788. PRESET_SHUTTER_FORMATTER,
  789. pdev->vcinterface,
  790. &buf, 2, HZ / 2);
  791. }
  792. return ret;
  793. }
  796. /* POWER */
  798. int pwc_camera_power(struct pwc_device *pdev, int power)
  799. {
  800. char buf;
  802. if (pdev->type < 675 || (pdev->type < 730 && pdev->release < 6))
  803. return 0; /* Not supported by Nala or Timon < release 6 */
  805. if (power)
  806. buf = 0x00; /* active */
  807. else
  808. buf = 0xFF; /* power save */
  809. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  810. SET_STATUS_CTL,
  811. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  812. SET_POWER_SAVE_MODE_FORMATTER,
  813. pdev->vcinterface,
  814. &buf, 1, HZ / 2);
  815. }
  819. /* private calls */
  821. static inline int pwc_restore_user(struct pwc_device *pdev)
  822. {
  823. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  824. SET_STATUS_CTL,
  825. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  826. RESTORE_USER_DEFAULTS_FORMATTER,
  827. pdev->vcinterface,
  828. NULL, 0, HZ / 2);
  829. }
  831. static inline int pwc_save_user(struct pwc_device *pdev)
  832. {
  833. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  834. SET_STATUS_CTL,
  835. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  836. SAVE_USER_DEFAULTS_FORMATTER,
  837. pdev->vcinterface,
  838. NULL, 0, HZ / 2);
  839. }
  841. static inline int pwc_restore_factory(struct pwc_device *pdev)
  842. {
  843. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  844. SET_STATUS_CTL,
  845. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  846. RESTORE_FACTORY_DEFAULTS_FORMATTER,
  847. pdev->vcinterface,
  848. NULL, 0, HZ / 2);
  849. }
  851.  /* ************************************************* */
  852.  /* Patch by Alvarado: (not in the original version   */
  854.  /*
  855.   * the camera recognizes modes from 0 to 4:
  856.   *
  857.   * 00: indoor (incandescant lighting)
  858.   * 01: outdoor (sunlight)
  859.   * 02: fluorescent lighting
  860.   * 03: manual
  861.   * 04: auto
  862.   */ 
  863. static inline int pwc_set_awb(struct pwc_device *pdev, int mode)
  864. {
  865. char buf;
  866. int ret;
  868. if (mode < 0)
  869.     mode = 0;
  871. if (mode > 4)
  872.     mode = 4;
  874. buf = mode & 0x07; /* just the lowest three bits */
  876. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  877. SET_CHROM_CTL,
  878. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  879. WB_MODE_FORMATTER,
  880. pdev->vcinterface,
  881. &buf, 1, HZ / 2);
  883. if (ret < 0)
  884. return ret;
  885. return 0;
  886. }
  888. static inline int pwc_get_awb(struct pwc_device *pdev)
  889. {
  890. unsigned char buf;
  891. int ret;
  893. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  894. GET_CHROM_CTL,
  895. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  896. WB_MODE_FORMATTER,
  897. pdev->vcinterface,
  898. &buf, 1, HZ / 2);
  900. if (ret < 0) 
  901. return ret;
  902. return buf;
  903. }
  905. static inline int pwc_set_red_gain(struct pwc_device *pdev, int value)
  906. {
  907.         unsigned char buf;
  909. if (value < 0)
  910. value = 0;
  911. if (value > 0xffff)
  912. value = 0xffff;
  914. /* only the msb are considered */
  915. buf = value >> 8;
  917. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  918. SET_CHROM_CTL,
  919. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  920. PRESET_MANUAL_RED_GAIN_FORMATTER,
  921. pdev->vcinterface,
  922. &buf, 1, HZ / 2);
  923. }
  925. static inline int pwc_get_red_gain(struct pwc_device *pdev)
  926. {
  927. unsigned char buf;
  928. int ret;
  930. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  931.           GET_CHROM_CTL, 
  932. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  933.         PRESET_MANUAL_RED_GAIN_FORMATTER,
  934. pdev->vcinterface,
  935. &buf, 1, HZ / 2);
  937. if (ret < 0)
  938.     return ret;
  940. return (buf << 8);
  941. }
  944. static inline int pwc_set_blue_gain(struct pwc_device *pdev, int value)
  945. {
  946. unsigned char buf;
  948. if (value < 0)
  949. value = 0;
  950. if (value > 0xffff)
  951. value = 0xffff;
  953. /* linear mapping of 0..0xffff to -0x80..0x7f */
  954. buf = (value >> 8);
  956. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  957. SET_CHROM_CTL,
  958. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  959. PRESET_MANUAL_BLUE_GAIN_FORMATTER,
  960. pdev->vcinterface,
  961. &buf, 1, HZ / 2);
  962. }
  964. static inline int pwc_get_blue_gain(struct pwc_device *pdev)
  965. {
  966. unsigned char buf;
  967. int ret;
  969. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  970.             GET_CHROM_CTL,
  971. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  972. PRESET_MANUAL_BLUE_GAIN_FORMATTER,
  973. pdev->vcinterface,
  974. &buf, 1, HZ / 2);
  976. if (ret < 0)
  977.     return ret;
  979. return (buf << 8);
  980. }
  983. /* The following two functions are different, since they only read the
  984.    internal red/blue gains, which may be different from the manual 
  985.    gains set or read above.
  986.  */   
  987. static inline int pwc_read_red_gain(struct pwc_device *pdev)
  988. {
  989. unsigned char buf;
  990. int ret;
  992. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  993.           GET_STATUS_CTL, 
  994. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  995.         READ_RED_GAIN_FORMATTER,
  996. pdev->vcinterface,
  997. &buf, 1, HZ / 2);
  999. if (ret < 0)
  1000.     return ret;
  1002. return (buf << 8);
  1003. }
  1005. static inline int pwc_read_blue_gain(struct pwc_device *pdev)
  1006. {
  1007. unsigned char buf;
  1008. int ret;
  1010. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1011.             GET_STATUS_CTL,
  1012. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1013. READ_BLUE_GAIN_FORMATTER,
  1014. pdev->vcinterface,
  1015. &buf, 1, HZ / 2);
  1017. if (ret < 0)
  1018. return ret;
  1020. return (buf << 8);
  1021. }
  1024. static inline int pwc_set_wb_speed(struct pwc_device *pdev, int speed)
  1025. {
  1026. unsigned char buf;
  1028. /* useful range is 0x01..0x20 */
  1029. buf = speed / 0x7f0;
  1030. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1031. SET_CHROM_CTL,
  1032. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1033. AWB_CONTROL_SPEED_FORMATTER,
  1034. pdev->vcinterface,
  1035. &buf, 1, HZ / 2);
  1036. }
  1038. static inline int pwc_get_wb_speed(struct pwc_device *pdev)
  1039. {
  1040. unsigned char buf;
  1041. int ret;
  1043. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1044. GET_CHROM_CTL,
  1045. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1046. AWB_CONTROL_SPEED_FORMATTER,
  1047. pdev->vcinterface,
  1048. &buf, 1, HZ / 2);
  1049. if (ret < 0)
  1050. return ret;
  1051. return (buf * 0x7f0);
  1052. }
  1055. static inline int pwc_set_wb_delay(struct pwc_device *pdev, int delay)
  1056. {
  1057. unsigned char buf;
  1059. /* useful range is 0x01..0x3F */
  1060. buf = (delay >> 10);
  1061. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1062. SET_CHROM_CTL,
  1063. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1064. AWB_CONTROL_DELAY_FORMATTER,
  1065. pdev->vcinterface,
  1066. &buf, 1, HZ / 2);
  1067. }
  1069. static inline int pwc_get_wb_delay(struct pwc_device *pdev)
  1070. {
  1071. unsigned char buf;
  1072. int ret;
  1074. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1075. GET_CHROM_CTL,
  1076. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1077. AWB_CONTROL_DELAY_FORMATTER,
  1078. pdev->vcinterface,
  1079. &buf, 1, HZ / 2);
  1080. if (ret < 0)
  1081. return ret;
  1082. return (buf << 10);
  1083. }
  1086. int pwc_set_leds(struct pwc_device *pdev, int on_value, int off_value)
  1087. {
  1088. unsigned char buf[2];
  1090. if (pdev->type < 730)
  1091. return 0;
  1092. on_value /= 100;
  1093. off_value /= 100;
  1094. if (on_value < 0)
  1095. on_value = 0;
  1096. if (on_value > 0xff)
  1097. on_value = 0xff;
  1098. if (off_value < 0)
  1099. off_value = 0;
  1100. if (off_value > 0xff)
  1101. off_value = 0xff;
  1103. buf[0] = on_value;
  1104. buf[1] = off_value;
  1106. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1107. SET_STATUS_CTL,
  1108. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1109. LED_FORMATTER,
  1110. pdev->vcinterface,
  1111. &buf, 2, HZ / 2);
  1112. }
  1114. int pwc_get_leds(struct pwc_device *pdev, int *on_value, int *off_value)
  1115. {
  1116. unsigned char buf[2];
  1117. int ret;
  1119. if (pdev->type < 730) {
  1120. *on_value = -1;
  1121. *off_value = -1;
  1122. return 0;
  1123. }
  1125. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1126.             GET_STATUS_CTL,
  1127. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1128. LED_FORMATTER,
  1129. pdev->vcinterface,
  1130. &buf, 2, HZ / 2);
  1132. if (ret < 0)
  1133. return ret;
  1134. *on_value = buf[0] * 100;
  1135. *off_value = buf[1] * 100;
  1136. return 0;
  1137. }
  1139. static inline int pwc_set_contour(struct pwc_device *pdev, int contour)
  1140. {
  1141. unsigned char buf;
  1142. int ret;
  1144. if (contour < 0)
  1145. buf = 0xff; /* auto contour on */
  1146. else
  1147. buf = 0x0; /* auto contour off */
  1148. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1149. SET_LUM_CTL,
  1150. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1151. AUTO_CONTOUR_FORMATTER,
  1152. pdev->vcinterface,
  1153. &buf, 1, HZ / 2);
  1154. if (ret < 0)
  1155. return ret;
  1157. if (contour < 0)
  1158. return 0;
  1159. if (contour > 0xffff)
  1160. contour = 0xffff;
  1162. buf = (contour >> 10); /* contour preset is [0..3f] */
  1163. ret = usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1164. SET_LUM_CTL,
  1165. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1166. PRESET_CONTOUR_FORMATTER,
  1167. pdev->vcinterface,
  1168. &buf, 1, HZ / 2);
  1169. if (ret < 0)
  1170. return ret;
  1171. return 0;
  1172. }
  1174. static inline int pwc_get_contour(struct pwc_device *pdev, int *contour)
  1175. {
  1176. unsigned char buf;
  1177. int ret;
  1179. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1180. GET_LUM_CTL,
  1181. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1182. AUTO_CONTOUR_FORMATTER,
  1183. pdev->vcinterface,
  1184. &buf, 1, HZ / 2);
  1185. if (ret < 0)
  1186. return ret;
  1188. if (buf == 0) {
  1189. /* auto mode off, query current preset value */
  1190. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1191. GET_LUM_CTL,
  1192. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1193. PRESET_CONTOUR_FORMATTER,
  1194. pdev->vcinterface,
  1195. &buf, 1, HZ / 2);
  1196. if (ret < 0)
  1197. return ret;
  1198. *contour =  (buf << 10);
  1199. }
  1200. else
  1201. *contour = -1;
  1202. return 0;
  1203. }
  1206. static inline int pwc_set_backlight(struct pwc_device *pdev, int backlight)
  1207. {
  1208. unsigned char buf;
  1210. if (backlight)
  1211. buf = 0xff;
  1212. else
  1213. buf = 0x0;
  1214. return usb_control_msg(pdev->udev, usb_sndctrlpipe(pdev->udev, 0),
  1215. SET_LUM_CTL,
  1216. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1217. BACK_LIGHT_COMPENSATION_FORMATTER,
  1218. pdev->vcinterface,
  1219. &buf, 1, HZ / 2);
  1220. }
  1222. static inline int pwc_get_backlight(struct pwc_device *pdev)
  1223. {
  1224. int ret;
  1225. unsigned char buf;
  1227. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1228. GET_LUM_CTL,
  1229. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1230. BACK_LIGHT_COMPENSATION_FORMATTER,
  1231. pdev->vcinterface,
  1232. &buf, 1, HZ / 2);
  1233. if (ret < 0)
  1234. return ret;
  1235. return buf;
  1236. }
  1239. static inline int pwc_set_flicker(struct pwc_device *pdev, int flicker)
  1240. {
  1241. unsigned char buf;
  1243. if (flicker)
  1244. buf = 0xff;
  1245. else
  1246. buf = 0x0;
  1247. return SendControlMsg(SET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
  1248. }
  1250. static inline int pwc_get_flicker(struct pwc_device *pdev)
  1251. {
  1252. int ret;
  1253. unsigned char buf;
  1255. ret = RecvControlMsg(SET_LUM_CTL, FLICKERLESS_MODE_FORMATTER, 1);
  1256. if (ret < 0)
  1257. return ret;
  1258. return buf;
  1259. }
  1262. static inline int pwc_set_dynamic_noise(struct pwc_device *pdev, int noise)
  1263. {
  1264. unsigned char buf;
  1266. if (noise < 0)
  1267. noise = 0;
  1268. if (noise > 3)
  1269. noise = 3;
  1270. buf = noise;
  1271. return SendControlMsg(SET_LUM_CTL, DYNAMIC_NOISE_CONTROL_FORMATTER, 1);
  1272. }
  1274. static inline int pwc_get_dynamic_noise(struct pwc_device *pdev)
  1275. {
  1276. int ret;
  1277. unsigned char buf;
  1279. ret = RecvControlMsg(SET_LUM_CTL, DYNAMIC_NOISE_CONTROL_FORMATTER, 1);
  1280. if (ret < 0)
  1281. return ret;
  1282. Debug("pwc_get_dynamic_noise = %dn", buf);
  1283. return buf;
  1284. }
  1287. int pwc_get_cmos_sensor(struct pwc_device *pdev)
  1288. {
  1289. unsigned char buf;
  1290. int ret = -1, request;
  1292. if (pdev->type < 675)
  1293. request = SENSOR_TYPE_FORMATTER1;
  1294. else if (pdev->type < 730)
  1295. return -1; /* The Vesta series doesn't have this call */
  1296. else
  1297. request = SENSOR_TYPE_FORMATTER2;
  1299. ret = usb_control_msg(pdev->udev, usb_rcvctrlpipe(pdev->udev, 0),
  1300. GET_STATUS_CTL,
  1301. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1302. request,
  1303. pdev->vcinterface,
  1304. &buf, 1, HZ / 2);
  1305. if (ret < 0)
  1306. return ret;
  1307. if (pdev->type < 675)
  1308. return buf | 0x100;
  1309. else
  1310. return buf;
  1311. }
  1314.  /* End of Add-Ons                                    */
  1315.  /* ************************************************* */
  1317. int pwc_ioctl(struct pwc_device *pdev, unsigned int cmd, void *arg)
  1318. {
  1319. int ret = 0;
  1321. switch(cmd) {
  1322. case VIDIOCPWCRUSER:
  1323. {
  1324. if (pwc_restore_user(pdev))
  1325. ret = -EINVAL;
  1326. break;
  1327. }
  1329. case VIDIOCPWCSUSER:
  1330. {
  1331. if (pwc_save_user(pdev))
  1332. ret = -EINVAL;
  1333. break;
  1334. }
  1336. case VIDIOCPWCFACTORY:
  1337. {
  1338. if (pwc_restore_factory(pdev))
  1339. ret = -EINVAL;
  1340. break;
  1341. }
  1343. case VIDIOCPWCSCQUAL:
  1344. {
  1345. int qual;
  1347. if (copy_from_user(&qual, arg, sizeof(int)))
  1348. ret = -EFAULT;
  1349. else {
  1350. if (qual < 0 || qual > 3)
  1351. ret = -EINVAL;
  1352. else
  1353. ret = pwc_try_video_mode(pdev, pdev->view.x, pdev->view.y, pdev->vframes, qual, pdev->vsnapshot);
  1354. if (ret >= 0)
  1355. pdev->vcompression = qual;
  1356. }
  1357. break;
  1358. }
  1360. case VIDIOCPWCGCQUAL:
  1361. {
  1362. if (copy_to_user(arg, &pdev->vcompression, sizeof(int)))
  1363. ret = -EFAULT;
  1364. break;
  1365. }
  1367. case VIDIOCPWCPROBE:
  1368. {
  1369. struct pwc_probe probe;
  1371. strcpy(probe.name, pdev->vdev->name);
  1372. probe.type = pdev->type;
  1373. if (copy_to_user(arg, &probe, sizeof(probe)))
  1374. ret = -EFAULT;
  1375. break;
  1376. }
  1378. case VIDIOCPWCSAGC:
  1379. {
  1380. int agc;
  1382. if (copy_from_user(&agc, arg, sizeof(agc)))
  1383. ret = -EFAULT;
  1384. else {
  1385. if (pwc_set_agc(pdev, agc < 0 ? 1 : 0, agc))
  1386. ret = -EINVAL;
  1387. }
  1388. break;
  1389. }
  1391. case VIDIOCPWCGAGC:
  1392. {
  1393. int agc;
  1395. if (pwc_get_agc(pdev, &agc))
  1396. ret = -EINVAL;
  1397. else
  1398. if (copy_to_user(arg, &agc, sizeof(agc)))
  1399. ret = -EFAULT;
  1400. break;
  1401. }
  1403. case VIDIOCPWCSSHUTTER:
  1404. {
  1405. int shutter_speed;
  1407. if (copy_from_user(&shutter_speed, arg, sizeof(shutter_speed)))
  1408. ret = -EFAULT;
  1409. else
  1410. ret = pwc_set_shutter_speed(pdev, shutter_speed < 0 ? 1 : 0, shutter_speed);
  1411. break;
  1412. }
  1414.         case VIDIOCPWCSAWB:
  1415. {
  1416. struct pwc_whitebalance wb;
  1418. if (copy_from_user(&wb, arg, sizeof(wb)))
  1419. ret = -EFAULT;
  1420. else {
  1421. ret = pwc_set_awb(pdev, wb.mode);
  1422. if (ret >= 0 && wb.mode == PWC_WB_MANUAL) {
  1423. pwc_set_red_gain(pdev, wb.manual_red);
  1424. pwc_set_blue_gain(pdev, wb.manual_blue);
  1425. }
  1426. }
  1427. break;
  1428. }
  1430. case VIDIOCPWCGAWB:
  1431. {
  1432. struct pwc_whitebalance wb;
  1434. memset(&wb, 0, sizeof(wb));
  1435. wb.mode = pwc_get_awb(pdev);
  1436. if (wb.mode < 0)
  1437. ret = -EINVAL;
  1438. else {
  1439. if (wb.mode == PWC_WB_MANUAL) {
  1440. wb.manual_red = pwc_get_red_gain(pdev);
  1441. wb.manual_blue = pwc_get_blue_gain(pdev);
  1442. }
  1443. if (wb.mode == PWC_WB_AUTO) {
  1444. wb.read_red = pwc_read_red_gain(pdev);
  1445. wb.read_blue = pwc_read_blue_gain(pdev);
  1446. }
  1447. if (copy_to_user(arg, &wb, sizeof(wb)))
  1448. ret= -EFAULT;
  1449. }
  1450. break;
  1451. }
  1453. case VIDIOCPWCSAWBSPEED:
  1454. {
  1455. struct pwc_wb_speed wbs;
  1457. if (copy_from_user(&wbs, arg, sizeof(wbs)))
  1458. ret = -EFAULT;
  1459. else {
  1460. if (wbs.control_speed > 0) {
  1461. ret = pwc_set_wb_speed(pdev, wbs.control_speed);
  1462. }
  1463. if (wbs.control_delay > 0) {
  1464. ret = pwc_set_wb_delay(pdev, wbs.control_delay);
  1465. }
  1466. }
  1467. break;
  1468. }
  1470. case VIDIOCPWCGAWBSPEED:
  1471. {
  1472. struct pwc_wb_speed wbs;
  1474. ret = pwc_get_wb_speed(pdev);
  1475. if (ret < 0)
  1476. break;
  1477. wbs.control_speed = ret;
  1478. ret = pwc_get_wb_delay(pdev);
  1479. if (ret < 0)
  1480. break;
  1481. wbs.control_delay = ret;
  1482. if (copy_to_user(arg, &wbs, sizeof(wbs)))
  1483. ret = -EFAULT;
  1484. break;
  1485. }
  1487.         case VIDIOCPWCSLED:
  1488. {
  1489. struct pwc_leds leds;
  1491. if (copy_from_user(&leds, arg, sizeof(leds)))
  1492. ret = -EFAULT;
  1493. else
  1494. ret = pwc_set_leds(pdev, leds.led_on, leds.led_off);
  1495.      break;
  1496. }
  1499. case VIDIOCPWCGLED:
  1500. {
  1501. struct pwc_leds leds;
  1503. ret = pwc_get_leds(pdev, &leds.led_on, &leds.led_off); 
  1504. if (ret < 0)
  1505. break;
  1506. if (copy_to_user(arg, &leds, sizeof(leds)))
  1507. ret = -EFAULT;
  1508. break;
  1509. }
  1511. case VIDIOCPWCSCONTOUR:
  1512. {
  1513. int contour;
  1515. if (copy_from_user(&contour, arg, sizeof(contour)))
  1516. ret = -EFAULT;
  1517. else
  1518. ret = pwc_set_contour(pdev, contour);
  1519. break;
  1520. }
  1522. case VIDIOCPWCGCONTOUR:
  1523. {
  1524. int contour;
  1526. ret = pwc_get_contour(pdev, &contour);
  1527. if (ret < 0)
  1528. break;
  1530. if (copy_to_user(arg, &contour, sizeof(contour)))
  1531. ret = -EFAULT;
  1532. break;
  1533. }
  1535. case VIDIOCPWCSBACKLIGHT:
  1536. {
  1537. int backlight;
  1539. if (copy_from_user(&backlight, arg, sizeof(backlight)))
  1540. ret = -EFAULT;
  1541. else
  1542. ret = pwc_set_backlight(pdev, backlight);
  1543. break;
  1544. }
  1546. case VIDIOCPWCGBACKLIGHT:
  1547. {
  1548. ret = pwc_get_backlight(pdev);
  1549. if (ret < 0)
  1550. break;
  1551. if (copy_to_user(arg, &ret, sizeof(ret)))
  1552. ret = -EFAULT;
  1553. break;
  1554. }
  1556. case VIDIOCPWCSFLICKER:
  1557. {
  1558. int flicker;
  1560. if (copy_from_user(&flicker, arg, sizeof(flicker)))
  1561. ret = -EFAULT;
  1562. else
  1563. ret = pwc_set_flicker(pdev, flicker);
  1564. break;
  1565. }
  1567. case VIDIOCPWCGFLICKER:
  1568. {
  1569. ret = pwc_get_flicker(pdev);
  1570. if (ret < 0)
  1571. break;
  1572. if (copy_to_user(arg, &ret, sizeof(ret)))
  1573. ret = -EFAULT;
  1574. break;
  1575. }
  1577. case VIDIOCPWCSDYNNOISE:
  1578. {
  1579. int dynnoise;
  1581. if (copy_from_user(&dynnoise, arg, sizeof(dynnoise)))
  1582. ret = -EFAULT;
  1583. else
  1584. ret = pwc_set_dynamic_noise(pdev, dynnoise);
  1585. break;
  1586. }
  1588. case VIDIOCPWCGDYNNOISE:
  1589. {
  1590. ret = pwc_get_dynamic_noise(pdev);
  1591. if (ret < 0)
  1592. break;
  1593. if (copy_to_user(arg, &ret, sizeof(ret)))
  1594. ret = -EFAULT;
  1595. break;
  1596. }
  1599. default:
  1600. ret = -ENOIOCTLCMD;
  1601. break;
  1602. }
  1604. if (ret > 0)
  1605. return 0;
  1606. return ret;
  1607. }