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 (C) 2011 Hans de Goede <hdegoede@redhat.com>
7 NOTE: this version of pwc is an unofficial (modified) release of pwc & pcwx
8 driver and thus may have bugs that are not present in the original version.
9 Please send bug reports and support requests to <luc@saillard.org>.
10 The decompression routines have been implemented by reverse-engineering the
11 Nemosoft binary pwcx module. Caveat emptor.
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 #include <linux/errno.h>
30 #include <linux/init.h>
32 #include <linux/module.h>
33 #include <linux/poll.h>
34 #include <linux/vmalloc.h>
35 #include <linux/jiffies.h>
40 #define PWC_CID_CUSTOM(ctrl) ((V4L2_CID_USER_BASE | 0xf000) + custom_ ## ctrl)
42 static int pwc_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
);
43 static int pwc_s_ctrl(struct v4l2_ctrl
*ctrl
);
45 static const struct v4l2_ctrl_ops pwc_ctrl_ops
= {
46 .g_volatile_ctrl
= pwc_g_volatile_ctrl
,
50 enum { awb_indoor
, awb_outdoor
, awb_fl
, awb_manual
, awb_auto
};
51 enum { custom_autocontour
, custom_contour
, custom_noise_reduction
,
52 custom_awb_speed
, custom_awb_delay
,
53 custom_save_user
, custom_restore_user
, custom_restore_factory
};
55 const char * const pwc_auto_whitebal_qmenu
[] = {
56 "Indoor (Incandescant Lighting) Mode",
57 "Outdoor (Sunlight) Mode",
58 "Indoor (Fluorescent Lighting) Mode",
64 static const struct v4l2_ctrl_config pwc_auto_white_balance_cfg
= {
66 .id
= V4L2_CID_AUTO_WHITE_BALANCE
,
67 .type
= V4L2_CTRL_TYPE_MENU
,
69 .qmenu
= pwc_auto_whitebal_qmenu
,
72 static const struct v4l2_ctrl_config pwc_autocontour_cfg
= {
74 .id
= PWC_CID_CUSTOM(autocontour
),
75 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
76 .name
= "Auto contour",
82 static const struct v4l2_ctrl_config pwc_contour_cfg
= {
84 .id
= PWC_CID_CUSTOM(contour
),
85 .type
= V4L2_CTRL_TYPE_INTEGER
,
87 .flags
= V4L2_CTRL_FLAG_SLIDER
,
93 static const struct v4l2_ctrl_config pwc_backlight_cfg
= {
95 .id
= V4L2_CID_BACKLIGHT_COMPENSATION
,
96 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
102 static const struct v4l2_ctrl_config pwc_flicker_cfg
= {
103 .ops
= &pwc_ctrl_ops
,
104 .id
= V4L2_CID_BAND_STOP_FILTER
,
105 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
111 static const struct v4l2_ctrl_config pwc_noise_reduction_cfg
= {
112 .ops
= &pwc_ctrl_ops
,
113 .id
= PWC_CID_CUSTOM(noise_reduction
),
114 .type
= V4L2_CTRL_TYPE_INTEGER
,
115 .name
= "Dynamic Noise Reduction",
121 static const struct v4l2_ctrl_config pwc_save_user_cfg
= {
122 .ops
= &pwc_ctrl_ops
,
123 .id
= PWC_CID_CUSTOM(save_user
),
124 .type
= V4L2_CTRL_TYPE_BUTTON
,
125 .name
= "Save User Settings",
128 static const struct v4l2_ctrl_config pwc_restore_user_cfg
= {
129 .ops
= &pwc_ctrl_ops
,
130 .id
= PWC_CID_CUSTOM(restore_user
),
131 .type
= V4L2_CTRL_TYPE_BUTTON
,
132 .name
= "Restore User Settings",
135 static const struct v4l2_ctrl_config pwc_restore_factory_cfg
= {
136 .ops
= &pwc_ctrl_ops
,
137 .id
= PWC_CID_CUSTOM(restore_factory
),
138 .type
= V4L2_CTRL_TYPE_BUTTON
,
139 .name
= "Restore Factory Settings",
142 static const struct v4l2_ctrl_config pwc_awb_speed_cfg
= {
143 .ops
= &pwc_ctrl_ops
,
144 .id
= PWC_CID_CUSTOM(awb_speed
),
145 .type
= V4L2_CTRL_TYPE_INTEGER
,
146 .name
= "Auto White Balance Speed",
152 static const struct v4l2_ctrl_config pwc_awb_delay_cfg
= {
153 .ops
= &pwc_ctrl_ops
,
154 .id
= PWC_CID_CUSTOM(awb_delay
),
155 .type
= V4L2_CTRL_TYPE_INTEGER
,
156 .name
= "Auto White Balance Delay",
162 int pwc_init_controls(struct pwc_device
*pdev
)
164 struct v4l2_ctrl_handler
*hdl
;
165 struct v4l2_ctrl_config cfg
;
168 hdl
= &pdev
->ctrl_handler
;
169 r
= v4l2_ctrl_handler_init(hdl
, 20);
173 /* Brightness, contrast, saturation, gamma */
174 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, BRIGHTNESS_FORMATTER
, &def
);
177 pdev
->brightness
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
178 V4L2_CID_BRIGHTNESS
, 0, 127, 1, def
);
180 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, CONTRAST_FORMATTER
, &def
);
183 pdev
->contrast
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
184 V4L2_CID_CONTRAST
, 0, 63, 1, def
);
186 if (pdev
->type
>= 675) {
187 if (pdev
->type
< 730)
188 pdev
->saturation_fmt
= SATURATION_MODE_FORMATTER2
;
190 pdev
->saturation_fmt
= SATURATION_MODE_FORMATTER1
;
191 r
= pwc_get_s8_ctrl(pdev
, GET_CHROM_CTL
, pdev
->saturation_fmt
,
193 if (r
|| def
< -100 || def
> 100)
195 pdev
->saturation
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
196 V4L2_CID_SATURATION
, -100, 100, 1, def
);
199 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, GAMMA_FORMATTER
, &def
);
202 pdev
->gamma
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
203 V4L2_CID_GAMMA
, 0, 31, 1, def
);
205 /* auto white balance, red gain, blue gain */
206 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
, WB_MODE_FORMATTER
, &def
);
207 if (r
|| def
> awb_auto
)
209 cfg
= pwc_auto_white_balance_cfg
;
210 cfg
.name
= v4l2_ctrl_get_name(cfg
.id
);
212 pdev
->auto_white_balance
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
213 /* check auto controls to avoid NULL deref in v4l2_ctrl_auto_cluster */
214 if (!pdev
->auto_white_balance
)
217 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
,
218 PRESET_MANUAL_RED_GAIN_FORMATTER
, &def
);
221 pdev
->red_balance
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
222 V4L2_CID_RED_BALANCE
, 0, 255, 1, def
);
224 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
,
225 PRESET_MANUAL_BLUE_GAIN_FORMATTER
, &def
);
228 pdev
->blue_balance
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
229 V4L2_CID_BLUE_BALANCE
, 0, 255, 1, def
);
231 v4l2_ctrl_auto_cluster(3, &pdev
->auto_white_balance
, awb_manual
, true);
234 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, AGC_MODE_FORMATTER
, &def
);
235 if (r
|| (def
!= 0 && def
!= 0xff))
237 /* Note a register value if 0 means auto gain is on */
238 pdev
->autogain
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
239 V4L2_CID_AUTOGAIN
, 0, 1, 1, def
== 0);
243 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, PRESET_AGC_FORMATTER
, &def
);
246 pdev
->gain
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
247 V4L2_CID_GAIN
, 0, 63, 1, def
);
249 /* auto exposure, exposure */
250 if (DEVICE_USE_CODEC2(pdev
->type
)) {
251 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, SHUTTER_MODE_FORMATTER
,
253 if (r
|| (def
!= 0 && def
!= 0xff))
256 * def = 0 auto, def = ff manual
257 * menu idx 0 = auto, idx 1 = manual
259 pdev
->exposure_auto
= v4l2_ctrl_new_std_menu(hdl
,
261 V4L2_CID_EXPOSURE_AUTO
,
263 if (!pdev
->exposure_auto
)
266 /* GET_LUM_CTL, PRESET_SHUTTER_FORMATTER is unreliable */
267 r
= pwc_get_u16_ctrl(pdev
, GET_STATUS_CTL
,
268 READ_SHUTTER_FORMATTER
, &def
);
271 pdev
->exposure
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
272 V4L2_CID_EXPOSURE
, 0, 655, 1, def
);
273 /* CODEC2: separate auto gain & auto exposure */
274 v4l2_ctrl_auto_cluster(2, &pdev
->autogain
, 0, true);
275 v4l2_ctrl_auto_cluster(2, &pdev
->exposure_auto
,
276 V4L2_EXPOSURE_MANUAL
, true);
277 } else if (DEVICE_USE_CODEC3(pdev
->type
)) {
278 /* GET_LUM_CTL, PRESET_SHUTTER_FORMATTER is unreliable */
279 r
= pwc_get_u16_ctrl(pdev
, GET_STATUS_CTL
,
280 READ_SHUTTER_FORMATTER
, &def
);
283 pdev
->exposure
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
284 V4L2_CID_EXPOSURE
, 0, 255, 1, def
);
285 /* CODEC3: both gain and exposure controlled by autogain */
286 pdev
->autogain_expo_cluster
[0] = pdev
->autogain
;
287 pdev
->autogain_expo_cluster
[1] = pdev
->gain
;
288 pdev
->autogain_expo_cluster
[2] = pdev
->exposure
;
289 v4l2_ctrl_auto_cluster(3, pdev
->autogain_expo_cluster
,
293 /* color / bw setting */
294 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
, COLOUR_MODE_FORMATTER
,
296 if (r
|| (def
!= 0 && def
!= 0xff))
298 /* def = 0 bw, def = ff color, menu idx 0 = color, idx 1 = bw */
299 pdev
->colorfx
= v4l2_ctrl_new_std_menu(hdl
, &pwc_ctrl_ops
,
300 V4L2_CID_COLORFX
, 1, 0, def
== 0);
302 /* autocontour, contour */
303 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, AUTO_CONTOUR_FORMATTER
, &def
);
304 if (r
|| (def
!= 0 && def
!= 0xff))
306 cfg
= pwc_autocontour_cfg
;
308 pdev
->autocontour
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
309 if (!pdev
->autocontour
)
312 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
, PRESET_CONTOUR_FORMATTER
, &def
);
315 cfg
= pwc_contour_cfg
;
317 pdev
->contour
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
319 v4l2_ctrl_auto_cluster(2, &pdev
->autocontour
, 0, false);
322 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
,
323 BACK_LIGHT_COMPENSATION_FORMATTER
, &def
);
324 if (r
|| (def
!= 0 && def
!= 0xff))
326 cfg
= pwc_backlight_cfg
;
327 cfg
.name
= v4l2_ctrl_get_name(cfg
.id
);
329 pdev
->backlight
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
331 /* flikker rediction */
332 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
,
333 FLICKERLESS_MODE_FORMATTER
, &def
);
334 if (r
|| (def
!= 0 && def
!= 0xff))
336 cfg
= pwc_flicker_cfg
;
337 cfg
.name
= v4l2_ctrl_get_name(cfg
.id
);
339 pdev
->flicker
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
341 /* Dynamic noise reduction */
342 r
= pwc_get_u8_ctrl(pdev
, GET_LUM_CTL
,
343 DYNAMIC_NOISE_CONTROL_FORMATTER
, &def
);
346 cfg
= pwc_noise_reduction_cfg
;
348 pdev
->noise_reduction
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
350 /* Save / Restore User / Factory Settings */
351 pdev
->save_user
= v4l2_ctrl_new_custom(hdl
, &pwc_save_user_cfg
, NULL
);
352 pdev
->restore_user
= v4l2_ctrl_new_custom(hdl
, &pwc_restore_user_cfg
,
354 if (pdev
->restore_user
)
355 pdev
->restore_user
->flags
|= V4L2_CTRL_FLAG_UPDATE
;
356 pdev
->restore_factory
= v4l2_ctrl_new_custom(hdl
,
357 &pwc_restore_factory_cfg
,
359 if (pdev
->restore_factory
)
360 pdev
->restore_factory
->flags
|= V4L2_CTRL_FLAG_UPDATE
;
362 /* Auto White Balance speed & delay */
363 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
,
364 AWB_CONTROL_SPEED_FORMATTER
, &def
);
365 if (r
|| def
< 1 || def
> 32)
367 cfg
= pwc_awb_speed_cfg
;
369 pdev
->awb_speed
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
371 r
= pwc_get_u8_ctrl(pdev
, GET_CHROM_CTL
,
372 AWB_CONTROL_DELAY_FORMATTER
, &def
);
375 cfg
= pwc_awb_delay_cfg
;
377 pdev
->awb_delay
= v4l2_ctrl_new_custom(hdl
, &cfg
, NULL
);
379 if (!(pdev
->features
& FEATURE_MOTOR_PANTILT
))
382 /* Motor pan / tilt / reset */
383 pdev
->motor_pan
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
384 V4L2_CID_PAN_RELATIVE
, -4480, 4480, 64, 0);
385 if (!pdev
->motor_pan
)
387 pdev
->motor_tilt
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
388 V4L2_CID_TILT_RELATIVE
, -1920, 1920, 64, 0);
389 pdev
->motor_pan_reset
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
390 V4L2_CID_PAN_RESET
, 0, 0, 0, 0);
391 pdev
->motor_tilt_reset
= v4l2_ctrl_new_std(hdl
, &pwc_ctrl_ops
,
392 V4L2_CID_TILT_RESET
, 0, 0, 0, 0);
393 v4l2_ctrl_cluster(4, &pdev
->motor_pan
);
398 static void pwc_vidioc_fill_fmt(struct v4l2_format
*f
,
399 int width
, int height
, u32 pixfmt
)
401 memset(&f
->fmt
.pix
, 0, sizeof(struct v4l2_pix_format
));
402 f
->fmt
.pix
.width
= width
;
403 f
->fmt
.pix
.height
= height
;
404 f
->fmt
.pix
.field
= V4L2_FIELD_NONE
;
405 f
->fmt
.pix
.pixelformat
= pixfmt
;
406 f
->fmt
.pix
.bytesperline
= f
->fmt
.pix
.width
;
407 f
->fmt
.pix
.sizeimage
= f
->fmt
.pix
.height
* f
->fmt
.pix
.width
* 3 / 2;
408 PWC_DEBUG_IOCTL("pwc_vidioc_fill_fmt() "
409 "width=%d, height=%d, bytesperline=%d, sizeimage=%d, pixelformat=%c%c%c%c\n",
412 f
->fmt
.pix
.bytesperline
,
413 f
->fmt
.pix
.sizeimage
,
414 (f
->fmt
.pix
.pixelformat
)&255,
415 (f
->fmt
.pix
.pixelformat
>>8)&255,
416 (f
->fmt
.pix
.pixelformat
>>16)&255,
417 (f
->fmt
.pix
.pixelformat
>>24)&255);
420 /* ioctl(VIDIOC_TRY_FMT) */
421 static int pwc_vidioc_try_fmt(struct pwc_device
*pdev
, struct v4l2_format
*f
)
425 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
) {
426 PWC_DEBUG_IOCTL("Bad video type must be V4L2_BUF_TYPE_VIDEO_CAPTURE\n");
430 switch (f
->fmt
.pix
.pixelformat
) {
431 case V4L2_PIX_FMT_YUV420
:
433 case V4L2_PIX_FMT_PWC1
:
434 if (DEVICE_USE_CODEC23(pdev
->type
)) {
435 PWC_DEBUG_IOCTL("codec1 is only supported for old pwc webcam\n");
439 case V4L2_PIX_FMT_PWC2
:
440 if (DEVICE_USE_CODEC1(pdev
->type
)) {
441 PWC_DEBUG_IOCTL("codec23 is only supported for new pwc webcam\n");
446 PWC_DEBUG_IOCTL("Unsupported pixel format\n");
451 size
= pwc_get_size(pdev
, f
->fmt
.pix
.width
, f
->fmt
.pix
.height
);
452 pwc_vidioc_fill_fmt(f
,
453 pwc_image_sizes
[size
][0],
454 pwc_image_sizes
[size
][1],
455 f
->fmt
.pix
.pixelformat
);
460 /* ioctl(VIDIOC_SET_FMT) */
462 static int pwc_s_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
464 struct pwc_device
*pdev
= video_drvdata(file
);
465 int ret
, pixelformat
, compression
= 0;
467 if (pwc_test_n_set_capt_file(pdev
, file
))
470 ret
= pwc_vidioc_try_fmt(pdev
, f
);
474 pixelformat
= f
->fmt
.pix
.pixelformat
;
476 mutex_lock(&pdev
->udevlock
);
482 if (pdev
->iso_init
) {
487 PWC_DEBUG_IOCTL("Trying to set format to: width=%d height=%d fps=%d "
489 f
->fmt
.pix
.width
, f
->fmt
.pix
.height
, pdev
->vframes
,
491 (pixelformat
>>8)&255,
492 (pixelformat
>>16)&255,
493 (pixelformat
>>24)&255);
495 ret
= pwc_set_video_mode(pdev
, f
->fmt
.pix
.width
, f
->fmt
.pix
.height
,
496 pdev
->vframes
, &compression
);
498 PWC_DEBUG_IOCTL("pwc_set_video_mode(), return=%d\n", ret
);
501 pdev
->pixfmt
= pixelformat
;
502 pwc_vidioc_fill_fmt(f
, pdev
->width
, pdev
->height
,
507 mutex_unlock(&pdev
->udevlock
);
511 static int pwc_querycap(struct file
*file
, void *fh
, struct v4l2_capability
*cap
)
513 struct pwc_device
*pdev
= video_drvdata(file
);
518 strcpy(cap
->driver
, PWC_NAME
);
519 strlcpy(cap
->card
, pdev
->vdev
.name
, sizeof(cap
->card
));
520 usb_make_path(pdev
->udev
, cap
->bus_info
, sizeof(cap
->bus_info
));
522 V4L2_CAP_VIDEO_CAPTURE
|
528 static int pwc_enum_input(struct file
*file
, void *fh
, struct v4l2_input
*i
)
530 if (i
->index
) /* Only one INPUT is supported */
533 strcpy(i
->name
, "usb");
537 static int pwc_g_input(struct file
*file
, void *fh
, unsigned int *i
)
543 static int pwc_s_input(struct file
*file
, void *fh
, unsigned int i
)
545 return i
? -EINVAL
: 0;
548 static int pwc_g_volatile_ctrl_unlocked(struct v4l2_ctrl
*ctrl
)
550 struct pwc_device
*pdev
=
551 container_of(ctrl
->handler
, struct pwc_device
, ctrl_handler
);
558 case V4L2_CID_AUTO_WHITE_BALANCE
:
559 if (pdev
->color_bal_valid
&&
560 (pdev
->auto_white_balance
->val
!= awb_auto
||
562 pdev
->last_color_bal_update
+ HZ
/ 4))) {
563 pdev
->red_balance
->val
= pdev
->last_red_balance
;
564 pdev
->blue_balance
->val
= pdev
->last_blue_balance
;
567 ret
= pwc_get_u8_ctrl(pdev
, GET_STATUS_CTL
,
568 READ_RED_GAIN_FORMATTER
,
569 &pdev
->red_balance
->val
);
572 ret
= pwc_get_u8_ctrl(pdev
, GET_STATUS_CTL
,
573 READ_BLUE_GAIN_FORMATTER
,
574 &pdev
->blue_balance
->val
);
577 pdev
->last_red_balance
= pdev
->red_balance
->val
;
578 pdev
->last_blue_balance
= pdev
->blue_balance
->val
;
579 pdev
->last_color_bal_update
= jiffies
;
580 pdev
->color_bal_valid
= true;
582 case V4L2_CID_AUTOGAIN
:
583 if (pdev
->gain_valid
&& time_before(jiffies
,
584 pdev
->last_gain_update
+ HZ
/ 4)) {
585 pdev
->gain
->val
= pdev
->last_gain
;
588 ret
= pwc_get_u8_ctrl(pdev
, GET_STATUS_CTL
,
589 READ_AGC_FORMATTER
, &pdev
->gain
->val
);
592 pdev
->last_gain
= pdev
->gain
->val
;
593 pdev
->last_gain_update
= jiffies
;
594 pdev
->gain_valid
= true;
595 if (!DEVICE_USE_CODEC3(pdev
->type
))
597 /* Fall through for CODEC3 where autogain also controls expo */
598 case V4L2_CID_EXPOSURE_AUTO
:
599 if (pdev
->exposure_valid
&& time_before(jiffies
,
600 pdev
->last_exposure_update
+ HZ
/ 4)) {
601 pdev
->exposure
->val
= pdev
->last_exposure
;
604 ret
= pwc_get_u16_ctrl(pdev
, GET_STATUS_CTL
,
605 READ_SHUTTER_FORMATTER
,
606 &pdev
->exposure
->val
);
609 pdev
->last_exposure
= pdev
->exposure
->val
;
610 pdev
->last_exposure_update
= jiffies
;
611 pdev
->exposure_valid
= true;
618 PWC_ERROR("g_ctrl %s error %d\n", ctrl
->name
, ret
);
623 static int pwc_g_volatile_ctrl(struct v4l2_ctrl
*ctrl
)
625 struct pwc_device
*pdev
=
626 container_of(ctrl
->handler
, struct pwc_device
, ctrl_handler
);
629 mutex_lock(&pdev
->udevlock
);
630 ret
= pwc_g_volatile_ctrl_unlocked(ctrl
);
631 mutex_unlock(&pdev
->udevlock
);
635 static int pwc_set_awb(struct pwc_device
*pdev
)
639 if (pdev
->auto_white_balance
->is_new
) {
640 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
642 pdev
->auto_white_balance
->val
);
646 if (pdev
->auto_white_balance
->val
!= awb_manual
)
647 pdev
->color_bal_valid
= false; /* Force cache update */
650 * If this is a preset, update our red / blue balance values
651 * so that events get generated for the new preset values
653 if (pdev
->auto_white_balance
->val
== awb_indoor
||
654 pdev
->auto_white_balance
->val
== awb_outdoor
||
655 pdev
->auto_white_balance
->val
== awb_fl
)
656 pwc_g_volatile_ctrl_unlocked(pdev
->auto_white_balance
);
658 if (pdev
->auto_white_balance
->val
!= awb_manual
)
661 if (pdev
->red_balance
->is_new
) {
662 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
663 PRESET_MANUAL_RED_GAIN_FORMATTER
,
664 pdev
->red_balance
->val
);
669 if (pdev
->blue_balance
->is_new
) {
670 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
671 PRESET_MANUAL_BLUE_GAIN_FORMATTER
,
672 pdev
->blue_balance
->val
);
679 /* For CODEC2 models which have separate autogain and auto exposure */
680 static int pwc_set_autogain(struct pwc_device
*pdev
)
684 if (pdev
->autogain
->is_new
) {
685 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
687 pdev
->autogain
->val
? 0 : 0xff);
691 if (pdev
->autogain
->val
)
692 pdev
->gain_valid
= false; /* Force cache update */
695 if (pdev
->autogain
->val
)
698 if (pdev
->gain
->is_new
) {
699 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
700 PRESET_AGC_FORMATTER
,
708 /* For CODEC2 models which have separate autogain and auto exposure */
709 static int pwc_set_exposure_auto(struct pwc_device
*pdev
)
712 int is_auto
= pdev
->exposure_auto
->val
== V4L2_EXPOSURE_AUTO
;
714 if (pdev
->exposure_auto
->is_new
) {
715 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
716 SHUTTER_MODE_FORMATTER
,
722 pdev
->exposure_valid
= false; /* Force cache update */
728 if (pdev
->exposure
->is_new
) {
729 ret
= pwc_set_u16_ctrl(pdev
, SET_LUM_CTL
,
730 PRESET_SHUTTER_FORMATTER
,
731 pdev
->exposure
->val
);
738 /* For CODEC3 models which have autogain controlling both gain and exposure */
739 static int pwc_set_autogain_expo(struct pwc_device
*pdev
)
743 if (pdev
->autogain
->is_new
) {
744 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
746 pdev
->autogain
->val
? 0 : 0xff);
750 if (pdev
->autogain
->val
) {
751 pdev
->gain_valid
= false; /* Force cache update */
752 pdev
->exposure_valid
= false; /* Force cache update */
756 if (pdev
->autogain
->val
)
759 if (pdev
->gain
->is_new
) {
760 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
761 PRESET_AGC_FORMATTER
,
767 if (pdev
->exposure
->is_new
) {
768 ret
= pwc_set_u16_ctrl(pdev
, SET_LUM_CTL
,
769 PRESET_SHUTTER_FORMATTER
,
770 pdev
->exposure
->val
);
777 static int pwc_set_motor(struct pwc_device
*pdev
)
783 if (pdev
->motor_pan_reset
->is_new
)
785 if (pdev
->motor_tilt_reset
->is_new
)
787 if (pdev
->motor_pan_reset
->is_new
|| pdev
->motor_tilt_reset
->is_new
) {
788 ret
= send_control_msg(pdev
, SET_MPT_CTL
,
789 PT_RESET_CONTROL_FORMATTER
, buf
, 1);
794 memset(buf
, 0, sizeof(buf
));
795 if (pdev
->motor_pan
->is_new
) {
796 buf
[0] = pdev
->motor_pan
->val
& 0xFF;
797 buf
[1] = (pdev
->motor_pan
->val
>> 8);
799 if (pdev
->motor_tilt
->is_new
) {
800 buf
[2] = pdev
->motor_tilt
->val
& 0xFF;
801 buf
[3] = (pdev
->motor_tilt
->val
>> 8);
803 if (pdev
->motor_pan
->is_new
|| pdev
->motor_tilt
->is_new
) {
804 ret
= send_control_msg(pdev
, SET_MPT_CTL
,
805 PT_RELATIVE_CONTROL_FORMATTER
,
814 static int pwc_s_ctrl(struct v4l2_ctrl
*ctrl
)
816 struct pwc_device
*pdev
=
817 container_of(ctrl
->handler
, struct pwc_device
, ctrl_handler
);
820 mutex_lock(&pdev
->udevlock
);
828 case V4L2_CID_BRIGHTNESS
:
829 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
830 BRIGHTNESS_FORMATTER
, ctrl
->val
);
832 case V4L2_CID_CONTRAST
:
833 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
834 CONTRAST_FORMATTER
, ctrl
->val
);
836 case V4L2_CID_SATURATION
:
837 ret
= pwc_set_s8_ctrl(pdev
, SET_CHROM_CTL
,
838 pdev
->saturation_fmt
, ctrl
->val
);
841 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
842 GAMMA_FORMATTER
, ctrl
->val
);
844 case V4L2_CID_AUTO_WHITE_BALANCE
:
845 ret
= pwc_set_awb(pdev
);
847 case V4L2_CID_AUTOGAIN
:
848 if (DEVICE_USE_CODEC2(pdev
->type
))
849 ret
= pwc_set_autogain(pdev
);
850 else if (DEVICE_USE_CODEC3(pdev
->type
))
851 ret
= pwc_set_autogain_expo(pdev
);
855 case V4L2_CID_EXPOSURE_AUTO
:
856 if (DEVICE_USE_CODEC2(pdev
->type
))
857 ret
= pwc_set_exposure_auto(pdev
);
861 case V4L2_CID_COLORFX
:
862 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
863 COLOUR_MODE_FORMATTER
,
864 ctrl
->val
? 0 : 0xff);
866 case PWC_CID_CUSTOM(autocontour
):
867 if (pdev
->autocontour
->is_new
) {
868 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
869 AUTO_CONTOUR_FORMATTER
,
870 pdev
->autocontour
->val
? 0 : 0xff);
872 if (ret
== 0 && pdev
->contour
->is_new
) {
873 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
874 PRESET_CONTOUR_FORMATTER
,
878 case V4L2_CID_BACKLIGHT_COMPENSATION
:
879 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
880 BACK_LIGHT_COMPENSATION_FORMATTER
,
881 ctrl
->val
? 0 : 0xff);
883 case V4L2_CID_BAND_STOP_FILTER
:
884 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
885 FLICKERLESS_MODE_FORMATTER
,
886 ctrl
->val
? 0 : 0xff);
888 case PWC_CID_CUSTOM(noise_reduction
):
889 ret
= pwc_set_u8_ctrl(pdev
, SET_LUM_CTL
,
890 DYNAMIC_NOISE_CONTROL_FORMATTER
,
893 case PWC_CID_CUSTOM(save_user
):
894 ret
= pwc_button_ctrl(pdev
, SAVE_USER_DEFAULTS_FORMATTER
);
896 case PWC_CID_CUSTOM(restore_user
):
897 ret
= pwc_button_ctrl(pdev
, RESTORE_USER_DEFAULTS_FORMATTER
);
899 case PWC_CID_CUSTOM(restore_factory
):
900 ret
= pwc_button_ctrl(pdev
,
901 RESTORE_FACTORY_DEFAULTS_FORMATTER
);
903 case PWC_CID_CUSTOM(awb_speed
):
904 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
905 AWB_CONTROL_SPEED_FORMATTER
,
908 case PWC_CID_CUSTOM(awb_delay
):
909 ret
= pwc_set_u8_ctrl(pdev
, SET_CHROM_CTL
,
910 AWB_CONTROL_DELAY_FORMATTER
,
913 case V4L2_CID_PAN_RELATIVE
:
914 ret
= pwc_set_motor(pdev
);
921 PWC_ERROR("s_ctrl %s error %d\n", ctrl
->name
, ret
);
924 mutex_unlock(&pdev
->udevlock
);
928 static int pwc_enum_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_fmtdesc
*f
)
930 struct pwc_device
*pdev
= video_drvdata(file
);
932 /* We only support two format: the raw format, and YUV */
936 f
->pixelformat
= pdev
->type
<= 646 ? V4L2_PIX_FMT_PWC1
: V4L2_PIX_FMT_PWC2
;
937 f
->flags
= V4L2_FMT_FLAG_COMPRESSED
;
938 strlcpy(f
->description
, "Raw Philips Webcam", sizeof(f
->description
));
941 f
->pixelformat
= V4L2_PIX_FMT_YUV420
;
942 strlcpy(f
->description
, "4:2:0, planar, Y-Cb-Cr", sizeof(f
->description
));
950 static int pwc_g_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
952 struct pwc_device
*pdev
= video_drvdata(file
);
954 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
957 mutex_lock(&pdev
->udevlock
); /* To avoid race with s_fmt */
958 PWC_DEBUG_IOCTL("ioctl(VIDIOC_G_FMT) return size %dx%d\n",
959 pdev
->width
, pdev
->height
);
960 pwc_vidioc_fill_fmt(f
, pdev
->width
, pdev
->height
, pdev
->pixfmt
);
961 mutex_unlock(&pdev
->udevlock
);
965 static int pwc_try_fmt_vid_cap(struct file
*file
, void *fh
, struct v4l2_format
*f
)
967 struct pwc_device
*pdev
= video_drvdata(file
);
969 return pwc_vidioc_try_fmt(pdev
, f
);
972 static int pwc_reqbufs(struct file
*file
, void *fh
,
973 struct v4l2_requestbuffers
*rb
)
975 struct pwc_device
*pdev
= video_drvdata(file
);
977 if (pwc_test_n_set_capt_file(pdev
, file
))
980 return vb2_reqbufs(&pdev
->vb_queue
, rb
);
983 static int pwc_querybuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
985 struct pwc_device
*pdev
= video_drvdata(file
);
987 return vb2_querybuf(&pdev
->vb_queue
, buf
);
990 static int pwc_qbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
992 struct pwc_device
*pdev
= video_drvdata(file
);
997 if (pdev
->capt_file
!= file
)
1000 return vb2_qbuf(&pdev
->vb_queue
, buf
);
1003 static int pwc_dqbuf(struct file
*file
, void *fh
, struct v4l2_buffer
*buf
)
1005 struct pwc_device
*pdev
= video_drvdata(file
);
1010 if (pdev
->capt_file
!= file
)
1013 return vb2_dqbuf(&pdev
->vb_queue
, buf
, file
->f_flags
& O_NONBLOCK
);
1016 static int pwc_streamon(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1018 struct pwc_device
*pdev
= video_drvdata(file
);
1023 if (pdev
->capt_file
!= file
)
1026 return vb2_streamon(&pdev
->vb_queue
, i
);
1029 static int pwc_streamoff(struct file
*file
, void *fh
, enum v4l2_buf_type i
)
1031 struct pwc_device
*pdev
= video_drvdata(file
);
1036 if (pdev
->capt_file
!= file
)
1039 return vb2_streamoff(&pdev
->vb_queue
, i
);
1042 static int pwc_enum_framesizes(struct file
*file
, void *fh
,
1043 struct v4l2_frmsizeenum
*fsize
)
1045 struct pwc_device
*pdev
= video_drvdata(file
);
1046 unsigned int i
= 0, index
= fsize
->index
;
1048 if (fsize
->pixel_format
== V4L2_PIX_FMT_YUV420
||
1049 (fsize
->pixel_format
== V4L2_PIX_FMT_PWC1
&&
1050 DEVICE_USE_CODEC1(pdev
->type
)) ||
1051 (fsize
->pixel_format
== V4L2_PIX_FMT_PWC2
&&
1052 DEVICE_USE_CODEC23(pdev
->type
))) {
1053 for (i
= 0; i
< PSZ_MAX
; i
++) {
1054 if (!(pdev
->image_mask
& (1UL << i
)))
1057 fsize
->type
= V4L2_FRMSIZE_TYPE_DISCRETE
;
1058 fsize
->discrete
.width
= pwc_image_sizes
[i
][0];
1059 fsize
->discrete
.height
= pwc_image_sizes
[i
][1];
1067 static int pwc_enum_frameintervals(struct file
*file
, void *fh
,
1068 struct v4l2_frmivalenum
*fival
)
1070 struct pwc_device
*pdev
= video_drvdata(file
);
1074 for (i
= 0; i
< PSZ_MAX
; i
++) {
1075 if (pwc_image_sizes
[i
][0] == fival
->width
&&
1076 pwc_image_sizes
[i
][1] == fival
->height
) {
1082 /* TODO: Support raw format */
1083 if (size
< 0 || fival
->pixel_format
!= V4L2_PIX_FMT_YUV420
)
1086 i
= pwc_get_fps(pdev
, fival
->index
, size
);
1090 fival
->type
= V4L2_FRMIVAL_TYPE_DISCRETE
;
1091 fival
->discrete
.numerator
= 1;
1092 fival
->discrete
.denominator
= i
;
1097 static int pwc_log_status(struct file
*file
, void *priv
)
1099 struct pwc_device
*pdev
= video_drvdata(file
);
1101 v4l2_ctrl_handler_log_status(&pdev
->ctrl_handler
, PWC_NAME
);
1105 const struct v4l2_ioctl_ops pwc_ioctl_ops
= {
1106 .vidioc_querycap
= pwc_querycap
,
1107 .vidioc_enum_input
= pwc_enum_input
,
1108 .vidioc_g_input
= pwc_g_input
,
1109 .vidioc_s_input
= pwc_s_input
,
1110 .vidioc_enum_fmt_vid_cap
= pwc_enum_fmt_vid_cap
,
1111 .vidioc_g_fmt_vid_cap
= pwc_g_fmt_vid_cap
,
1112 .vidioc_s_fmt_vid_cap
= pwc_s_fmt_vid_cap
,
1113 .vidioc_try_fmt_vid_cap
= pwc_try_fmt_vid_cap
,
1114 .vidioc_reqbufs
= pwc_reqbufs
,
1115 .vidioc_querybuf
= pwc_querybuf
,
1116 .vidioc_qbuf
= pwc_qbuf
,
1117 .vidioc_dqbuf
= pwc_dqbuf
,
1118 .vidioc_streamon
= pwc_streamon
,
1119 .vidioc_streamoff
= pwc_streamoff
,
1120 .vidioc_log_status
= pwc_log_status
,
1121 .vidioc_enum_framesizes
= pwc_enum_framesizes
,
1122 .vidioc_enum_frameintervals
= pwc_enum_frameintervals
,