]>
Commit | Line | Data |
---|---|---|
cf664a64 PDM |
1 | /* |
2 | * ioctl32.c: Conversion between 32bit and 64bit native ioctls. | |
3 | * Separated from fs stuff by Arnd Bergmann <arnd@arndb.de> | |
4 | * | |
5 | * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com) | |
6 | * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be) | |
7 | * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs | |
a2531293 | 8 | * Copyright (C) 2003 Pavel Machek (pavel@ucw.cz) |
cf664a64 | 9 | * Copyright (C) 2005 Philippe De Muyter (phdm@macqel.be) |
92f45bad | 10 | * Copyright (C) 2008 Hans Verkuil <hverkuil@xs4all.nl> |
cf664a64 PDM |
11 | * |
12 | * These routines maintain argument size conversion between 32bit and 64bit | |
13 | * ioctls. | |
14 | */ | |
15 | ||
0d0fbf81 | 16 | #include <linux/compat.h> |
92f45bad | 17 | #define __OLD_VIDIOC_ /* To allow fixing old calls*/ |
0d0fbf81 | 18 | #include <linux/videodev.h> |
cf664a64 | 19 | #include <linux/videodev2.h> |
133b7354 | 20 | #include <linux/module.h> |
e8efb71d | 21 | #include <linux/smp_lock.h> |
2864462e | 22 | #include <media/v4l2-ioctl.h> |
0d0fbf81 AB |
23 | |
24 | #ifdef CONFIG_COMPAT | |
a113bc78 | 25 | |
5bdd6cc3 | 26 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
0d0fbf81 AB |
27 | struct video_tuner32 { |
28 | compat_int_t tuner; | |
29 | char name[32]; | |
30 | compat_ulong_t rangelow, rangehigh; | |
31 | u32 flags; /* It is really u32 in videodev.h */ | |
32 | u16 mode, signal; | |
33 | }; | |
34 | ||
35 | static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up) | |
36 | { | |
d1f81da2 | 37 | if (!access_ok(VERIFY_READ, up, sizeof(struct video_tuner32)) || |
a113bc78 GM |
38 | get_user(kp->tuner, &up->tuner) || |
39 | copy_from_user(kp->name, up->name, 32) || | |
40 | get_user(kp->rangelow, &up->rangelow) || | |
41 | get_user(kp->rangehigh, &up->rangehigh) || | |
42 | get_user(kp->flags, &up->flags) || | |
43 | get_user(kp->mode, &up->mode) || | |
44 | get_user(kp->signal, &up->signal)) | |
0d0fbf81 | 45 | return -EFAULT; |
0d0fbf81 AB |
46 | return 0; |
47 | } | |
48 | ||
49 | static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up) | |
50 | { | |
d1f81da2 | 51 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_tuner32)) || |
a113bc78 GM |
52 | put_user(kp->tuner, &up->tuner) || |
53 | copy_to_user(up->name, kp->name, 32) || | |
54 | put_user(kp->rangelow, &up->rangelow) || | |
55 | put_user(kp->rangehigh, &up->rangehigh) || | |
56 | put_user(kp->flags, &up->flags) || | |
57 | put_user(kp->mode, &up->mode) || | |
58 | put_user(kp->signal, &up->signal)) | |
59 | return -EFAULT; | |
0d0fbf81 AB |
60 | return 0; |
61 | } | |
62 | ||
63 | struct video_buffer32 { | |
64 | compat_caddr_t base; | |
65 | compat_int_t height, width, depth, bytesperline; | |
66 | }; | |
67 | ||
68 | static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up) | |
69 | { | |
70 | u32 tmp; | |
71 | ||
a113bc78 GM |
72 | if (!access_ok(VERIFY_READ, up, sizeof(struct video_buffer32)) || |
73 | get_user(tmp, &up->base) || | |
74 | get_user(kp->height, &up->height) || | |
75 | get_user(kp->width, &up->width) || | |
76 | get_user(kp->depth, &up->depth) || | |
77 | get_user(kp->bytesperline, &up->bytesperline)) | |
78 | return -EFAULT; | |
0d0fbf81 AB |
79 | |
80 | /* This is actually a physical address stored | |
81 | * as a void pointer. | |
82 | */ | |
83 | kp->base = (void *)(unsigned long) tmp; | |
84 | ||
0d0fbf81 AB |
85 | return 0; |
86 | } | |
87 | ||
88 | static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up) | |
89 | { | |
90 | u32 tmp = (u32)((unsigned long)kp->base); | |
91 | ||
d1f81da2 | 92 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_buffer32)) || |
a113bc78 GM |
93 | put_user(tmp, &up->base) || |
94 | put_user(kp->height, &up->height) || | |
95 | put_user(kp->width, &up->width) || | |
96 | put_user(kp->depth, &up->depth) || | |
97 | put_user(kp->bytesperline, &up->bytesperline)) | |
98 | return -EFAULT; | |
0d0fbf81 AB |
99 | return 0; |
100 | } | |
101 | ||
102 | struct video_clip32 { | |
92f45bad | 103 | s32 x, y, width, height; /* It's really s32 in videodev.h */ |
0d0fbf81 AB |
104 | compat_caddr_t next; |
105 | }; | |
106 | ||
107 | struct video_window32 { | |
108 | u32 x, y, width, height, chromakey, flags; | |
109 | compat_caddr_t clips; | |
110 | compat_int_t clipcount; | |
111 | }; | |
112 | ||
92f45bad | 113 | static int get_video_window32(struct video_window *kp, struct video_window32 __user *up) |
0d0fbf81 | 114 | { |
92f45bad HV |
115 | struct video_clip __user *uclips; |
116 | struct video_clip __user *kclips; | |
117 | compat_caddr_t p; | |
118 | int nclips; | |
0d0fbf81 | 119 | |
92f45bad HV |
120 | if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32))) |
121 | return -EFAULT; | |
122 | ||
123 | if (get_user(nclips, &up->clipcount)) | |
124 | return -EFAULT; | |
125 | ||
126 | if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)) || | |
127 | get_user(kp->x, &up->x) || | |
128 | get_user(kp->y, &up->y) || | |
129 | get_user(kp->width, &up->width) || | |
130 | get_user(kp->height, &up->height) || | |
131 | get_user(kp->chromakey, &up->chromakey) || | |
132 | get_user(kp->flags, &up->flags) || | |
133 | get_user(kp->clipcount, &up->clipcount)) | |
134 | return -EFAULT; | |
135 | ||
136 | nclips = kp->clipcount; | |
137 | kp->clips = NULL; | |
138 | ||
139 | if (nclips == 0) | |
140 | return 0; | |
141 | if (get_user(p, &up->clips)) | |
142 | return -EFAULT; | |
143 | uclips = compat_ptr(p); | |
144 | ||
145 | /* If nclips < 0, then it is a clipping bitmap of size | |
146 | VIDEO_CLIPMAP_SIZE */ | |
147 | if (nclips < 0) { | |
148 | if (!access_ok(VERIFY_READ, uclips, VIDEO_CLIPMAP_SIZE)) | |
149 | return -EFAULT; | |
150 | kp->clips = compat_alloc_user_space(VIDEO_CLIPMAP_SIZE); | |
151 | if (copy_in_user(kp->clips, uclips, VIDEO_CLIPMAP_SIZE)) | |
152 | return -EFAULT; | |
153 | return 0; | |
0d0fbf81 AB |
154 | } |
155 | ||
92f45bad HV |
156 | /* Otherwise it is an array of video_clip structs. */ |
157 | if (!access_ok(VERIFY_READ, uclips, nclips * sizeof(struct video_clip))) | |
158 | return -EFAULT; | |
0d0fbf81 | 159 | |
92f45bad HV |
160 | kp->clips = compat_alloc_user_space(nclips * sizeof(struct video_clip)); |
161 | kclips = kp->clips; | |
162 | while (nclips--) { | |
163 | int err; | |
164 | ||
165 | err = copy_in_user(&kclips->x, &uclips->x, sizeof(kclips->x)); | |
166 | err |= copy_in_user(&kclips->y, &uclips->y, sizeof(kclips->y)); | |
167 | err |= copy_in_user(&kclips->width, &uclips->width, sizeof(kclips->width)); | |
168 | err |= copy_in_user(&kclips->height, &uclips->height, sizeof(kclips->height)); | |
169 | kclips->next = NULL; | |
170 | if (err) | |
171 | return -EFAULT; | |
172 | kclips++; | |
173 | uclips++; | |
174 | } | |
175 | return 0; | |
176 | } | |
0d0fbf81 AB |
177 | |
178 | /* You get back everything except the clips... */ | |
179 | static int put_video_window32(struct video_window *kp, struct video_window32 __user *up) | |
180 | { | |
d1f81da2 | 181 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_window32)) || |
a113bc78 GM |
182 | put_user(kp->x, &up->x) || |
183 | put_user(kp->y, &up->y) || | |
184 | put_user(kp->width, &up->width) || | |
185 | put_user(kp->height, &up->height) || | |
186 | put_user(kp->chromakey, &up->chromakey) || | |
187 | put_user(kp->flags, &up->flags) || | |
188 | put_user(kp->clipcount, &up->clipcount)) | |
189 | return -EFAULT; | |
0d0fbf81 AB |
190 | return 0; |
191 | } | |
92f45bad HV |
192 | |
193 | struct video_code32 { | |
194 | char loadwhat[16]; /* name or tag of file being passed */ | |
195 | compat_int_t datasize; | |
3e645d6b | 196 | compat_uptr_t data; |
92f45bad HV |
197 | }; |
198 | ||
3e645d6b | 199 | static struct video_code __user *get_microcode32(struct video_code32 *kp) |
92f45bad | 200 | { |
3e645d6b LT |
201 | struct video_code __user *up; |
202 | ||
203 | up = compat_alloc_user_space(sizeof(*up)); | |
204 | ||
205 | /* | |
206 | * NOTE! We don't actually care if these fail. If the | |
207 | * user address is invalid, the native ioctl will do | |
208 | * the error handling for us | |
209 | */ | |
210 | (void) copy_to_user(up->loadwhat, kp->loadwhat, sizeof(up->loadwhat)); | |
211 | (void) put_user(kp->datasize, &up->datasize); | |
212 | (void) put_user(compat_ptr(kp->data), &up->data); | |
213 | return up; | |
92f45bad HV |
214 | } |
215 | ||
216 | #define VIDIOCGTUNER32 _IOWR('v', 4, struct video_tuner32) | |
217 | #define VIDIOCSTUNER32 _IOW('v', 5, struct video_tuner32) | |
218 | #define VIDIOCGWIN32 _IOR('v', 9, struct video_window32) | |
219 | #define VIDIOCSWIN32 _IOW('v', 10, struct video_window32) | |
220 | #define VIDIOCGFBUF32 _IOR('v', 11, struct video_buffer32) | |
221 | #define VIDIOCSFBUF32 _IOW('v', 12, struct video_buffer32) | |
222 | #define VIDIOCGFREQ32 _IOR('v', 14, u32) | |
223 | #define VIDIOCSFREQ32 _IOW('v', 15, u32) | |
224 | #define VIDIOCSMICROCODE32 _IOW('v', 27, struct video_code32) | |
225 | ||
226 | #define VIDIOCCAPTURE32 _IOW('v', 8, s32) | |
227 | #define VIDIOCSYNC32 _IOW('v', 18, s32) | |
228 | #define VIDIOCSWRITEMODE32 _IOW('v', 25, s32) | |
229 | ||
5bdd6cc3 | 230 | #endif |
0d0fbf81 | 231 | |
069b7479 | 232 | static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
92f45bad | 233 | { |
069b7479 | 234 | long ret = -ENOIOCTLCMD; |
92f45bad HV |
235 | |
236 | if (file->f_op->unlocked_ioctl) | |
237 | ret = file->f_op->unlocked_ioctl(file, cmd, arg); | |
92f45bad HV |
238 | |
239 | return ret; | |
240 | } | |
241 | ||
242 | ||
d1f81da2 | 243 | struct v4l2_clip32 { |
cf664a64 PDM |
244 | struct v4l2_rect c; |
245 | compat_caddr_t next; | |
246 | }; | |
247 | ||
d1f81da2 | 248 | struct v4l2_window32 { |
cf664a64 PDM |
249 | struct v4l2_rect w; |
250 | enum v4l2_field field; | |
251 | __u32 chromakey; | |
252 | compat_caddr_t clips; /* actually struct v4l2_clip32 * */ | |
253 | __u32 clipcount; | |
254 | compat_caddr_t bitmap; | |
255 | }; | |
256 | ||
257 | static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) | |
258 | { | |
a113bc78 GM |
259 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) || |
260 | copy_from_user(&kp->w, &up->w, sizeof(up->w)) || | |
261 | get_user(kp->field, &up->field) || | |
262 | get_user(kp->chromakey, &up->chromakey) || | |
263 | get_user(kp->clipcount, &up->clipcount)) | |
264 | return -EFAULT; | |
cf664a64 PDM |
265 | if (kp->clipcount > 2048) |
266 | return -EINVAL; | |
267 | if (kp->clipcount) { | |
5b1a43d7 AV |
268 | struct v4l2_clip32 __user *uclips; |
269 | struct v4l2_clip __user *kclips; | |
cf664a64 | 270 | int n = kp->clipcount; |
5b1a43d7 | 271 | compat_caddr_t p; |
cf664a64 | 272 | |
5b1a43d7 AV |
273 | if (get_user(p, &up->clips)) |
274 | return -EFAULT; | |
275 | uclips = compat_ptr(p); | |
cf664a64 PDM |
276 | kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip)); |
277 | kp->clips = kclips; | |
278 | while (--n >= 0) { | |
5b1a43d7 AV |
279 | if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c))) |
280 | return -EFAULT; | |
281 | if (put_user(n ? kclips + 1 : NULL, &kclips->next)) | |
a113bc78 | 282 | return -EFAULT; |
cf664a64 PDM |
283 | uclips += 1; |
284 | kclips += 1; | |
285 | } | |
286 | } else | |
5b1a43d7 | 287 | kp->clips = NULL; |
cf664a64 PDM |
288 | return 0; |
289 | } | |
290 | ||
291 | static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) | |
292 | { | |
f2e6c6ad | 293 | if (copy_to_user(&up->w, &kp->w, sizeof(kp->w)) || |
a113bc78 GM |
294 | put_user(kp->field, &up->field) || |
295 | put_user(kp->chromakey, &up->chromakey) || | |
296 | put_user(kp->clipcount, &up->clipcount)) | |
297 | return -EFAULT; | |
cf664a64 PDM |
298 | return 0; |
299 | } | |
300 | ||
301 | static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | |
302 | { | |
5b1a43d7 AV |
303 | if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format))) |
304 | return -EFAULT; | |
a113bc78 | 305 | return 0; |
cf664a64 PDM |
306 | } |
307 | ||
308 | static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | |
309 | { | |
5b1a43d7 AV |
310 | if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format))) |
311 | return -EFAULT; | |
a113bc78 | 312 | return 0; |
cf664a64 PDM |
313 | } |
314 | ||
315 | static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | |
316 | { | |
5b1a43d7 AV |
317 | if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format))) |
318 | return -EFAULT; | |
a113bc78 | 319 | return 0; |
cf664a64 PDM |
320 | } |
321 | ||
322 | static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | |
323 | { | |
5b1a43d7 AV |
324 | if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format))) |
325 | return -EFAULT; | |
a113bc78 | 326 | return 0; |
cf664a64 PDM |
327 | } |
328 | ||
92f45bad HV |
329 | static inline int get_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up) |
330 | { | |
331 | if (copy_from_user(kp, up, sizeof(struct v4l2_sliced_vbi_format))) | |
332 | return -EFAULT; | |
333 | return 0; | |
334 | } | |
335 | ||
336 | static inline int put_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up) | |
337 | { | |
338 | if (copy_to_user(up, kp, sizeof(struct v4l2_sliced_vbi_format))) | |
339 | return -EFAULT; | |
340 | return 0; | |
341 | } | |
342 | ||
d1f81da2 | 343 | struct v4l2_format32 { |
cf664a64 | 344 | enum v4l2_buf_type type; |
d1f81da2 | 345 | union { |
92f45bad HV |
346 | struct v4l2_pix_format pix; |
347 | struct v4l2_window32 win; | |
348 | struct v4l2_vbi_format vbi; | |
349 | struct v4l2_sliced_vbi_format sliced; | |
d1f81da2 | 350 | __u8 raw_data[200]; /* user-defined */ |
cf664a64 PDM |
351 | } fmt; |
352 | }; | |
353 | ||
354 | static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) | |
355 | { | |
a113bc78 GM |
356 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) || |
357 | get_user(kp->type, &up->type)) | |
358 | return -EFAULT; | |
cf664a64 PDM |
359 | switch (kp->type) { |
360 | case V4L2_BUF_TYPE_VIDEO_CAPTURE: | |
92f45bad | 361 | case V4L2_BUF_TYPE_VIDEO_OUTPUT: |
cf664a64 PDM |
362 | return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); |
363 | case V4L2_BUF_TYPE_VIDEO_OVERLAY: | |
92f45bad | 364 | case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: |
cf664a64 PDM |
365 | return get_v4l2_window32(&kp->fmt.win, &up->fmt.win); |
366 | case V4L2_BUF_TYPE_VBI_CAPTURE: | |
92f45bad | 367 | case V4L2_BUF_TYPE_VBI_OUTPUT: |
cf664a64 | 368 | return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); |
92f45bad HV |
369 | case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: |
370 | case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: | |
371 | return get_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced); | |
372 | case V4L2_BUF_TYPE_PRIVATE: | |
373 | if (copy_from_user(kp, up, sizeof(kp->fmt.raw_data))) | |
374 | return -EFAULT; | |
375 | return 0; | |
376 | case 0: | |
377 | return -EINVAL; | |
cf664a64 | 378 | default: |
92f45bad | 379 | printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n", |
cf664a64 | 380 | kp->type); |
92f45bad | 381 | return -EINVAL; |
cf664a64 PDM |
382 | } |
383 | } | |
384 | ||
385 | static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) | |
386 | { | |
d1f81da2 | 387 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) || |
a113bc78 | 388 | put_user(kp->type, &up->type)) |
cf664a64 PDM |
389 | return -EFAULT; |
390 | switch (kp->type) { | |
391 | case V4L2_BUF_TYPE_VIDEO_CAPTURE: | |
92f45bad | 392 | case V4L2_BUF_TYPE_VIDEO_OUTPUT: |
cf664a64 PDM |
393 | return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); |
394 | case V4L2_BUF_TYPE_VIDEO_OVERLAY: | |
92f45bad | 395 | case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: |
cf664a64 PDM |
396 | return put_v4l2_window32(&kp->fmt.win, &up->fmt.win); |
397 | case V4L2_BUF_TYPE_VBI_CAPTURE: | |
92f45bad | 398 | case V4L2_BUF_TYPE_VBI_OUTPUT: |
cf664a64 | 399 | return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); |
92f45bad HV |
400 | case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE: |
401 | case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT: | |
402 | return put_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced); | |
403 | case V4L2_BUF_TYPE_PRIVATE: | |
404 | if (copy_to_user(up, kp, sizeof(up->fmt.raw_data))) | |
405 | return -EFAULT; | |
406 | return 0; | |
407 | case 0: | |
408 | return -EINVAL; | |
cf664a64 | 409 | default: |
92f45bad HV |
410 | printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n", |
411 | kp->type); | |
412 | return -EINVAL; | |
cf664a64 PDM |
413 | } |
414 | } | |
415 | ||
d1f81da2 | 416 | struct v4l2_standard32 { |
cf664a64 PDM |
417 | __u32 index; |
418 | __u32 id[2]; /* __u64 would get the alignment wrong */ | |
419 | __u8 name[24]; | |
420 | struct v4l2_fract frameperiod; /* Frames, not fields */ | |
421 | __u32 framelines; | |
422 | __u32 reserved[4]; | |
423 | }; | |
424 | ||
425 | static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) | |
426 | { | |
427 | /* other fields are not set by the user, nor used by the driver */ | |
a113bc78 GM |
428 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard32)) || |
429 | get_user(kp->index, &up->index)) | |
430 | return -EFAULT; | |
431 | return 0; | |
cf664a64 PDM |
432 | } |
433 | ||
434 | static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) | |
435 | { | |
d1f81da2 | 436 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard32)) || |
a113bc78 GM |
437 | put_user(kp->index, &up->index) || |
438 | copy_to_user(up->id, &kp->id, sizeof(__u64)) || | |
439 | copy_to_user(up->name, kp->name, 24) || | |
440 | copy_to_user(&up->frameperiod, &kp->frameperiod, sizeof(kp->frameperiod)) || | |
441 | put_user(kp->framelines, &up->framelines) || | |
442 | copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32))) | |
443 | return -EFAULT; | |
444 | return 0; | |
445 | } | |
446 | ||
d1f81da2 | 447 | struct v4l2_buffer32 { |
cf664a64 PDM |
448 | __u32 index; |
449 | enum v4l2_buf_type type; | |
450 | __u32 bytesused; | |
451 | __u32 flags; | |
452 | enum v4l2_field field; | |
453 | struct compat_timeval timestamp; | |
454 | struct v4l2_timecode timecode; | |
455 | __u32 sequence; | |
456 | ||
457 | /* memory location */ | |
458 | enum v4l2_memory memory; | |
459 | union { | |
460 | __u32 offset; | |
461 | compat_long_t userptr; | |
462 | } m; | |
463 | __u32 length; | |
464 | __u32 input; | |
465 | __u32 reserved; | |
466 | }; | |
467 | ||
468 | static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) | |
469 | { | |
470 | ||
a113bc78 GM |
471 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_buffer32)) || |
472 | get_user(kp->index, &up->index) || | |
473 | get_user(kp->type, &up->type) || | |
474 | get_user(kp->flags, &up->flags) || | |
475 | get_user(kp->memory, &up->memory) || | |
476 | get_user(kp->input, &up->input)) | |
477 | return -EFAULT; | |
d1f81da2 | 478 | switch (kp->memory) { |
cf664a64 | 479 | case V4L2_MEMORY_MMAP: |
22c859fa AP |
480 | if (get_user(kp->length, &up->length) || |
481 | get_user(kp->m.offset, &up->m.offset)) | |
482 | return -EFAULT; | |
cf664a64 PDM |
483 | break; |
484 | case V4L2_MEMORY_USERPTR: | |
485 | { | |
5b1a43d7 | 486 | compat_long_t tmp; |
cf664a64 | 487 | |
5b1a43d7 AV |
488 | if (get_user(kp->length, &up->length) || |
489 | get_user(tmp, &up->m.userptr)) | |
490 | return -EFAULT; | |
491 | ||
492 | kp->m.userptr = (unsigned long)compat_ptr(tmp); | |
cf664a64 PDM |
493 | } |
494 | break; | |
495 | case V4L2_MEMORY_OVERLAY: | |
d1f81da2 | 496 | if (get_user(kp->m.offset, &up->m.offset)) |
a113bc78 | 497 | return -EFAULT; |
cf664a64 PDM |
498 | break; |
499 | } | |
500 | return 0; | |
501 | } | |
502 | ||
503 | static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) | |
504 | { | |
a113bc78 GM |
505 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) || |
506 | put_user(kp->index, &up->index) || | |
507 | put_user(kp->type, &up->type) || | |
508 | put_user(kp->flags, &up->flags) || | |
509 | put_user(kp->memory, &up->memory) || | |
510 | put_user(kp->input, &up->input)) | |
511 | return -EFAULT; | |
d1f81da2 | 512 | switch (kp->memory) { |
cf664a64 | 513 | case V4L2_MEMORY_MMAP: |
a113bc78 GM |
514 | if (put_user(kp->length, &up->length) || |
515 | put_user(kp->m.offset, &up->m.offset)) | |
516 | return -EFAULT; | |
cf664a64 PDM |
517 | break; |
518 | case V4L2_MEMORY_USERPTR: | |
a113bc78 GM |
519 | if (put_user(kp->length, &up->length) || |
520 | put_user(kp->m.userptr, &up->m.userptr)) | |
521 | return -EFAULT; | |
cf664a64 PDM |
522 | break; |
523 | case V4L2_MEMORY_OVERLAY: | |
a113bc78 GM |
524 | if (put_user(kp->m.offset, &up->m.offset)) |
525 | return -EFAULT; | |
cf664a64 PDM |
526 | break; |
527 | } | |
a113bc78 GM |
528 | if (put_user(kp->bytesused, &up->bytesused) || |
529 | put_user(kp->field, &up->field) || | |
530 | put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) || | |
531 | put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) || | |
532 | copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) || | |
533 | put_user(kp->sequence, &up->sequence) || | |
534 | put_user(kp->reserved, &up->reserved)) | |
535 | return -EFAULT; | |
cf664a64 PDM |
536 | return 0; |
537 | } | |
538 | ||
d1f81da2 | 539 | struct v4l2_framebuffer32 { |
cf664a64 PDM |
540 | __u32 capability; |
541 | __u32 flags; | |
542 | compat_caddr_t base; | |
543 | struct v4l2_pix_format fmt; | |
544 | }; | |
545 | ||
13d133bc PDM |
546 | static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) |
547 | { | |
548 | u32 tmp; | |
549 | ||
a113bc78 GM |
550 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_framebuffer32)) || |
551 | get_user(tmp, &up->base) || | |
552 | get_user(kp->capability, &up->capability) || | |
553 | get_user(kp->flags, &up->flags)) | |
554 | return -EFAULT; | |
13d133bc | 555 | kp->base = compat_ptr(tmp); |
13d133bc PDM |
556 | get_v4l2_pix_format(&kp->fmt, &up->fmt); |
557 | return 0; | |
558 | } | |
559 | ||
cf664a64 PDM |
560 | static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) |
561 | { | |
562 | u32 tmp = (u32)((unsigned long)kp->base); | |
563 | ||
d1f81da2 | 564 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_framebuffer32)) || |
a113bc78 GM |
565 | put_user(tmp, &up->base) || |
566 | put_user(kp->capability, &up->capability) || | |
567 | put_user(kp->flags, &up->flags)) | |
568 | return -EFAULT; | |
cf664a64 PDM |
569 | put_v4l2_pix_format(&kp->fmt, &up->fmt); |
570 | return 0; | |
571 | } | |
572 | ||
92f45bad HV |
573 | struct v4l2_input32 { |
574 | __u32 index; /* Which input */ | |
575 | __u8 name[32]; /* Label */ | |
576 | __u32 type; /* Type of input */ | |
577 | __u32 audioset; /* Associated audios (bitfield) */ | |
578 | __u32 tuner; /* Associated tuner */ | |
579 | v4l2_std_id std; | |
580 | __u32 status; | |
581 | __u32 reserved[4]; | |
582 | } __attribute__ ((packed)); | |
583 | ||
584 | /* The 64-bit v4l2_input struct has extra padding at the end of the struct. | |
585 | Otherwise it is identical to the 32-bit version. */ | |
586 | static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up) | |
a113bc78 | 587 | { |
92f45bad | 588 | if (copy_from_user(kp, up, sizeof(struct v4l2_input32))) |
5b1a43d7 | 589 | return -EFAULT; |
a113bc78 GM |
590 | return 0; |
591 | } | |
592 | ||
92f45bad | 593 | static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up) |
a113bc78 | 594 | { |
92f45bad | 595 | if (copy_to_user(up, kp, sizeof(struct v4l2_input32))) |
5b1a43d7 | 596 | return -EFAULT; |
a113bc78 GM |
597 | return 0; |
598 | } | |
599 | ||
92f45bad HV |
600 | struct v4l2_ext_controls32 { |
601 | __u32 ctrl_class; | |
602 | __u32 count; | |
603 | __u32 error_idx; | |
604 | __u32 reserved[2]; | |
605 | compat_caddr_t controls; /* actually struct v4l2_ext_control32 * */ | |
eb4eeccc MCC |
606 | }; |
607 | ||
6b5a9492 HV |
608 | struct v4l2_ext_control32 { |
609 | __u32 id; | |
610 | __u32 size; | |
611 | __u32 reserved2[1]; | |
612 | union { | |
613 | __s32 value; | |
614 | __s64 value64; | |
615 | compat_caddr_t string; /* actually char * */ | |
616 | }; | |
617 | } __attribute__ ((packed)); | |
618 | ||
619 | /* The following function really belong in v4l2-common, but that causes | |
620 | a circular dependency between modules. We need to think about this, but | |
621 | for now this will do. */ | |
622 | ||
623 | /* Return non-zero if this control is a pointer type. Currently only | |
fdf82dc2 | 624 | type STRING is a pointer type. */ |
6b5a9492 HV |
625 | static inline int ctrl_is_pointer(u32 id) |
626 | { | |
fdf82dc2 EV |
627 | switch (id) { |
628 | case V4L2_CID_RDS_TX_PS_NAME: | |
629 | case V4L2_CID_RDS_TX_RADIO_TEXT: | |
630 | return 1; | |
631 | default: | |
632 | return 0; | |
633 | } | |
6b5a9492 HV |
634 | } |
635 | ||
92f45bad | 636 | static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up) |
eb4eeccc | 637 | { |
6b5a9492 | 638 | struct v4l2_ext_control32 __user *ucontrols; |
92f45bad HV |
639 | struct v4l2_ext_control __user *kcontrols; |
640 | int n; | |
641 | compat_caddr_t p; | |
642 | ||
643 | if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_ext_controls32)) || | |
644 | get_user(kp->ctrl_class, &up->ctrl_class) || | |
645 | get_user(kp->count, &up->count) || | |
646 | get_user(kp->error_idx, &up->error_idx) || | |
647 | copy_from_user(kp->reserved, up->reserved, sizeof(kp->reserved))) | |
648 | return -EFAULT; | |
649 | n = kp->count; | |
650 | if (n == 0) { | |
651 | kp->controls = NULL; | |
652 | return 0; | |
653 | } | |
654 | if (get_user(p, &up->controls)) | |
655 | return -EFAULT; | |
656 | ucontrols = compat_ptr(p); | |
657 | if (!access_ok(VERIFY_READ, ucontrols, n * sizeof(struct v4l2_ext_control))) | |
658 | return -EFAULT; | |
659 | kcontrols = compat_alloc_user_space(n * sizeof(struct v4l2_ext_control)); | |
660 | kp->controls = kcontrols; | |
661 | while (--n >= 0) { | |
6b5a9492 | 662 | if (copy_in_user(kcontrols, ucontrols, sizeof(*kcontrols))) |
92f45bad | 663 | return -EFAULT; |
6b5a9492 HV |
664 | if (ctrl_is_pointer(kcontrols->id)) { |
665 | void __user *s; | |
666 | ||
667 | if (get_user(p, &ucontrols->string)) | |
668 | return -EFAULT; | |
669 | s = compat_ptr(p); | |
670 | if (put_user(s, &kcontrols->string)) | |
671 | return -EFAULT; | |
672 | } | |
92f45bad HV |
673 | ucontrols++; |
674 | kcontrols++; | |
675 | } | |
eb4eeccc MCC |
676 | return 0; |
677 | } | |
678 | ||
92f45bad | 679 | static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up) |
0d0fbf81 | 680 | { |
6b5a9492 | 681 | struct v4l2_ext_control32 __user *ucontrols; |
92f45bad HV |
682 | struct v4l2_ext_control __user *kcontrols = kp->controls; |
683 | int n = kp->count; | |
684 | compat_caddr_t p; | |
685 | ||
686 | if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_ext_controls32)) || | |
687 | put_user(kp->ctrl_class, &up->ctrl_class) || | |
688 | put_user(kp->count, &up->count) || | |
689 | put_user(kp->error_idx, &up->error_idx) || | |
690 | copy_to_user(up->reserved, kp->reserved, sizeof(up->reserved))) | |
691 | return -EFAULT; | |
692 | if (!kp->count) | |
693 | return 0; | |
a113bc78 | 694 | |
92f45bad | 695 | if (get_user(p, &up->controls)) |
0d0fbf81 | 696 | return -EFAULT; |
92f45bad HV |
697 | ucontrols = compat_ptr(p); |
698 | if (!access_ok(VERIFY_WRITE, ucontrols, n * sizeof(struct v4l2_ext_control))) | |
0d0fbf81 AB |
699 | return -EFAULT; |
700 | ||
92f45bad | 701 | while (--n >= 0) { |
6b5a9492 HV |
702 | unsigned size = sizeof(*ucontrols); |
703 | ||
704 | /* Do not modify the pointer when copying a pointer control. | |
705 | The contents of the pointer was changed, not the pointer | |
706 | itself. */ | |
707 | if (ctrl_is_pointer(kcontrols->id)) | |
708 | size -= sizeof(ucontrols->value64); | |
709 | if (copy_in_user(ucontrols, kcontrols, size)) | |
92f45bad HV |
710 | return -EFAULT; |
711 | ucontrols++; | |
712 | kcontrols++; | |
0d0fbf81 | 713 | } |
92f45bad | 714 | return 0; |
0d0fbf81 | 715 | } |
92f45bad HV |
716 | |
717 | #define VIDIOC_G_FMT32 _IOWR('V', 4, struct v4l2_format32) | |
718 | #define VIDIOC_S_FMT32 _IOWR('V', 5, struct v4l2_format32) | |
719 | #define VIDIOC_QUERYBUF32 _IOWR('V', 9, struct v4l2_buffer32) | |
720 | #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32) | |
721 | #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32) | |
722 | #define VIDIOC_QBUF32 _IOWR('V', 15, struct v4l2_buffer32) | |
723 | #define VIDIOC_DQBUF32 _IOWR('V', 17, struct v4l2_buffer32) | |
724 | #define VIDIOC_ENUMSTD32 _IOWR('V', 25, struct v4l2_standard32) | |
725 | #define VIDIOC_ENUMINPUT32 _IOWR('V', 26, struct v4l2_input32) | |
726 | #define VIDIOC_TRY_FMT32 _IOWR('V', 64, struct v4l2_format32) | |
727 | #define VIDIOC_G_EXT_CTRLS32 _IOWR('V', 71, struct v4l2_ext_controls32) | |
728 | #define VIDIOC_S_EXT_CTRLS32 _IOWR('V', 72, struct v4l2_ext_controls32) | |
729 | #define VIDIOC_TRY_EXT_CTRLS32 _IOWR('V', 73, struct v4l2_ext_controls32) | |
730 | ||
731 | #define VIDIOC_OVERLAY32 _IOW ('V', 14, s32) | |
15029b39 | 732 | #ifdef __OLD_VIDIOC_ |
92f45bad | 733 | #define VIDIOC_OVERLAY32_OLD _IOWR('V', 14, s32) |
15029b39 | 734 | #endif |
92f45bad HV |
735 | #define VIDIOC_STREAMON32 _IOW ('V', 18, s32) |
736 | #define VIDIOC_STREAMOFF32 _IOW ('V', 19, s32) | |
737 | #define VIDIOC_G_INPUT32 _IOR ('V', 38, s32) | |
738 | #define VIDIOC_S_INPUT32 _IOWR('V', 39, s32) | |
739 | #define VIDIOC_G_OUTPUT32 _IOR ('V', 46, s32) | |
740 | #define VIDIOC_S_OUTPUT32 _IOWR('V', 47, s32) | |
0d0fbf81 | 741 | |
069b7479 | 742 | static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
0d0fbf81 AB |
743 | { |
744 | union { | |
5bdd6cc3 | 745 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
0d0fbf81 AB |
746 | struct video_tuner vt; |
747 | struct video_buffer vb; | |
748 | struct video_window vw; | |
3e645d6b | 749 | struct video_code32 vc; |
8a36ecf0 | 750 | struct video_audio va; |
5bdd6cc3 | 751 | #endif |
cf664a64 PDM |
752 | struct v4l2_format v2f; |
753 | struct v4l2_buffer v2b; | |
754 | struct v4l2_framebuffer v2fb; | |
a113bc78 | 755 | struct v4l2_input v2i; |
92f45bad HV |
756 | struct v4l2_standard v2s; |
757 | struct v4l2_ext_controls v2ecs; | |
0d0fbf81 | 758 | unsigned long vx; |
92f45bad | 759 | int vi; |
0d0fbf81 | 760 | } karg; |
0d0fbf81 | 761 | void __user *up = compat_ptr(arg); |
cf664a64 | 762 | int compatible_arg = 1; |
069b7479 | 763 | long err = 0; |
0d0fbf81 AB |
764 | |
765 | /* First, convert the command. */ | |
d1f81da2 | 766 | switch (cmd) { |
5bdd6cc3 | 767 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
92f45bad HV |
768 | case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break; |
769 | case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break; | |
770 | case VIDIOCGWIN32: cmd = VIDIOCGWIN; break; | |
771 | case VIDIOCSWIN32: cmd = VIDIOCSWIN; break; | |
772 | case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break; | |
773 | case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break; | |
774 | case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break; | |
775 | case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break; | |
776 | case VIDIOCSMICROCODE32: cmd = VIDIOCSMICROCODE; break; | |
5bdd6cc3 | 777 | #endif |
92f45bad HV |
778 | case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break; |
779 | case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break; | |
780 | case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break; | |
781 | case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break; | |
782 | case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break; | |
783 | case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break; | |
784 | case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break; | |
785 | case VIDIOC_ENUMSTD32: cmd = VIDIOC_ENUMSTD; break; | |
786 | case VIDIOC_ENUMINPUT32: cmd = VIDIOC_ENUMINPUT; break; | |
787 | case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break; | |
788 | case VIDIOC_G_EXT_CTRLS32: cmd = VIDIOC_G_EXT_CTRLS; break; | |
789 | case VIDIOC_S_EXT_CTRLS32: cmd = VIDIOC_S_EXT_CTRLS; break; | |
790 | case VIDIOC_TRY_EXT_CTRLS32: cmd = VIDIOC_TRY_EXT_CTRLS; break; | |
791 | case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break; | |
15029b39 | 792 | #ifdef __OLD_VIDIOC_ |
92f45bad | 793 | case VIDIOC_OVERLAY32_OLD: cmd = VIDIOC_OVERLAY; break; |
15029b39 | 794 | #endif |
92f45bad HV |
795 | case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break; |
796 | case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break; | |
797 | case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break; | |
798 | case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break; | |
799 | case VIDIOC_G_OUTPUT32: cmd = VIDIOC_G_OUTPUT; break; | |
800 | case VIDIOC_S_OUTPUT32: cmd = VIDIOC_S_OUTPUT; break; | |
801 | } | |
0d0fbf81 | 802 | |
d1f81da2 | 803 | switch (cmd) { |
5bdd6cc3 | 804 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
0d0fbf81 AB |
805 | case VIDIOCSTUNER: |
806 | case VIDIOCGTUNER: | |
807 | err = get_video_tuner32(&karg.vt, up); | |
cf664a64 | 808 | compatible_arg = 0; |
0d0fbf81 AB |
809 | break; |
810 | ||
811 | case VIDIOCSFBUF: | |
812 | err = get_video_buffer32(&karg.vb, up); | |
cf664a64 | 813 | compatible_arg = 0; |
0d0fbf81 AB |
814 | break; |
815 | ||
92f45bad HV |
816 | case VIDIOCSWIN: |
817 | err = get_video_window32(&karg.vw, up); | |
818 | compatible_arg = 0; | |
819 | break; | |
820 | ||
821 | case VIDIOCGWIN: | |
822 | case VIDIOCGFBUF: | |
823 | case VIDIOCGFREQ: | |
824 | compatible_arg = 0; | |
825 | break; | |
826 | ||
827 | case VIDIOCSMICROCODE: | |
3e645d6b LT |
828 | /* Copy the 32-bit "video_code32" to kernel space */ |
829 | if (copy_from_user(&karg.vc, up, sizeof(karg.vc))) | |
830 | return -EFAULT; | |
831 | /* Convert the 32-bit version to a 64-bit version in user space */ | |
832 | up = get_microcode32(&karg.vc); | |
92f45bad | 833 | break; |
8a36ecf0 | 834 | |
0d0fbf81 | 835 | case VIDIOCSFREQ: |
92f45bad HV |
836 | err = get_user(karg.vx, (u32 __user *)up); |
837 | compatible_arg = 0; | |
838 | break; | |
839 | ||
840 | case VIDIOCCAPTURE: | |
841 | case VIDIOCSYNC: | |
842 | case VIDIOCSWRITEMODE: | |
5bdd6cc3 | 843 | #endif |
cf664a64 | 844 | case VIDIOC_OVERLAY: |
13d133bc PDM |
845 | case VIDIOC_STREAMON: |
846 | case VIDIOC_STREAMOFF: | |
92f45bad HV |
847 | case VIDIOC_S_INPUT: |
848 | case VIDIOC_S_OUTPUT: | |
849 | err = get_user(karg.vi, (s32 __user *)up); | |
850 | compatible_arg = 0; | |
0d0fbf81 | 851 | break; |
13d133bc | 852 | |
92f45bad HV |
853 | case VIDIOC_G_INPUT: |
854 | case VIDIOC_G_OUTPUT: | |
13d133bc PDM |
855 | compatible_arg = 0; |
856 | break; | |
cf664a64 PDM |
857 | |
858 | case VIDIOC_G_FMT: | |
859 | case VIDIOC_S_FMT: | |
860 | case VIDIOC_TRY_FMT: | |
861 | err = get_v4l2_format32(&karg.v2f, up); | |
862 | compatible_arg = 0; | |
863 | break; | |
864 | ||
865 | case VIDIOC_QUERYBUF: | |
866 | case VIDIOC_QBUF: | |
867 | case VIDIOC_DQBUF: | |
868 | err = get_v4l2_buffer32(&karg.v2b, up); | |
869 | compatible_arg = 0; | |
870 | break; | |
871 | ||
92f45bad HV |
872 | case VIDIOC_S_FBUF: |
873 | err = get_v4l2_framebuffer32(&karg.v2fb, up); | |
a113bc78 GM |
874 | compatible_arg = 0; |
875 | break; | |
876 | ||
92f45bad | 877 | case VIDIOC_G_FBUF: |
cf664a64 PDM |
878 | compatible_arg = 0; |
879 | break; | |
880 | ||
92f45bad HV |
881 | case VIDIOC_ENUMSTD: |
882 | err = get_v4l2_standard32(&karg.v2s, up); | |
a113bc78 GM |
883 | compatible_arg = 0; |
884 | break; | |
885 | ||
92f45bad | 886 | case VIDIOC_ENUMINPUT: |
a113bc78 GM |
887 | err = get_v4l2_input32(&karg.v2i, up); |
888 | compatible_arg = 0; | |
889 | break; | |
890 | ||
92f45bad HV |
891 | case VIDIOC_G_EXT_CTRLS: |
892 | case VIDIOC_S_EXT_CTRLS: | |
893 | case VIDIOC_TRY_EXT_CTRLS: | |
894 | err = get_v4l2_ext_controls32(&karg.v2ecs, up); | |
a113bc78 GM |
895 | compatible_arg = 0; |
896 | break; | |
92f45bad | 897 | } |
d1f81da2 | 898 | if (err) |
92f45bad | 899 | return err; |
0d0fbf81 | 900 | |
d1f81da2 | 901 | if (compatible_arg) |
92f45bad | 902 | err = native_ioctl(file, cmd, (unsigned long)up); |
cf664a64 PDM |
903 | else { |
904 | mm_segment_t old_fs = get_fs(); | |
0d0fbf81 | 905 | |
cf664a64 | 906 | set_fs(KERNEL_DS); |
92f45bad | 907 | err = native_ioctl(file, cmd, (unsigned long)&karg); |
cf664a64 PDM |
908 | set_fs(old_fs); |
909 | } | |
92f45bad HV |
910 | |
911 | /* Special case: even after an error we need to put the | |
912 | results back for these ioctls since the error_idx will | |
913 | contain information on which control failed. */ | |
914 | switch (cmd) { | |
915 | case VIDIOC_G_EXT_CTRLS: | |
916 | case VIDIOC_S_EXT_CTRLS: | |
917 | case VIDIOC_TRY_EXT_CTRLS: | |
918 | if (put_v4l2_ext_controls32(&karg.v2ecs, up)) | |
919 | err = -EFAULT; | |
920 | break; | |
921 | } | |
922 | if (err) | |
923 | return err; | |
924 | ||
925 | switch (cmd) { | |
5bdd6cc3 | 926 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
92f45bad HV |
927 | case VIDIOCGTUNER: |
928 | err = put_video_tuner32(&karg.vt, up); | |
929 | break; | |
0d0fbf81 | 930 | |
92f45bad HV |
931 | case VIDIOCGWIN: |
932 | err = put_video_window32(&karg.vw, up); | |
933 | break; | |
0d0fbf81 | 934 | |
92f45bad HV |
935 | case VIDIOCGFBUF: |
936 | err = put_video_buffer32(&karg.vb, up); | |
937 | break; | |
8a36ecf0 | 938 | |
92f45bad HV |
939 | case VIDIOCGFREQ: |
940 | err = put_user(((u32)karg.vx), (u32 __user *)up); | |
941 | break; | |
5bdd6cc3 | 942 | #endif |
92f45bad HV |
943 | case VIDIOC_S_INPUT: |
944 | case VIDIOC_S_OUTPUT: | |
945 | case VIDIOC_G_INPUT: | |
946 | case VIDIOC_G_OUTPUT: | |
947 | err = put_user(((s32)karg.vi), (s32 __user *)up); | |
948 | break; | |
a113bc78 | 949 | |
92f45bad HV |
950 | case VIDIOC_G_FBUF: |
951 | err = put_v4l2_framebuffer32(&karg.v2fb, up); | |
952 | break; | |
953 | ||
954 | case VIDIOC_G_FMT: | |
955 | case VIDIOC_S_FMT: | |
956 | case VIDIOC_TRY_FMT: | |
957 | err = put_v4l2_format32(&karg.v2f, up); | |
958 | break; | |
959 | ||
960 | case VIDIOC_QUERYBUF: | |
961 | case VIDIOC_QBUF: | |
962 | case VIDIOC_DQBUF: | |
963 | err = put_v4l2_buffer32(&karg.v2b, up); | |
964 | break; | |
965 | ||
966 | case VIDIOC_ENUMSTD: | |
967 | err = put_v4l2_standard32(&karg.v2s, up); | |
968 | break; | |
969 | ||
970 | case VIDIOC_ENUMINPUT: | |
971 | err = put_v4l2_input32(&karg.v2i, up); | |
972 | break; | |
0d0fbf81 | 973 | } |
0d0fbf81 AB |
974 | return err; |
975 | } | |
976 | ||
9bb7cde7 | 977 | long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) |
0d0fbf81 | 978 | { |
069b7479 | 979 | long ret = -ENOIOCTLCMD; |
0d0fbf81 | 980 | |
c6d7ba8b | 981 | if (!file->f_op->unlocked_ioctl) |
0d0fbf81 AB |
982 | return ret; |
983 | ||
984 | switch (cmd) { | |
5bdd6cc3 | 985 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
92f45bad HV |
986 | case VIDIOCGCAP: |
987 | case VIDIOCGCHAN: | |
988 | case VIDIOCSCHAN: | |
0d0fbf81 AB |
989 | case VIDIOCGTUNER32: |
990 | case VIDIOCSTUNER32: | |
92f45bad HV |
991 | case VIDIOCGPICT: |
992 | case VIDIOCSPICT: | |
993 | case VIDIOCCAPTURE32: | |
0d0fbf81 | 994 | case VIDIOCGWIN32: |
92f45bad | 995 | case VIDIOCSWIN32: |
0d0fbf81 AB |
996 | case VIDIOCGFBUF32: |
997 | case VIDIOCSFBUF32: | |
92f45bad | 998 | case VIDIOCKEY: |
0d0fbf81 | 999 | case VIDIOCGFREQ32: |
133b7354 | 1000 | case VIDIOCSFREQ32: |
8a36ecf0 MCC |
1001 | case VIDIOCGAUDIO: |
1002 | case VIDIOCSAUDIO: | |
92f45bad HV |
1003 | case VIDIOCSYNC32: |
1004 | case VIDIOCMCAPTURE: | |
1005 | case VIDIOCGMBUF: | |
1006 | case VIDIOCGUNIT: | |
1007 | case VIDIOCGCAPTURE: | |
1008 | case VIDIOCSCAPTURE: | |
1009 | case VIDIOCSPLAYMODE: | |
1010 | case VIDIOCSWRITEMODE32: | |
1011 | case VIDIOCGPLAYINFO: | |
1012 | case VIDIOCSMICROCODE32: | |
7963fa48 SW |
1013 | case VIDIOCGVBIFMT: |
1014 | case VIDIOCSVBIFMT: | |
92f45bad HV |
1015 | #endif |
1016 | #ifdef __OLD_VIDIOC_ | |
1017 | case VIDIOC_OVERLAY32_OLD: | |
1018 | case VIDIOC_S_PARM_OLD: | |
1019 | case VIDIOC_S_CTRL_OLD: | |
1020 | case VIDIOC_G_AUDIO_OLD: | |
1021 | case VIDIOC_G_AUDOUT_OLD: | |
1022 | case VIDIOC_CROPCAP_OLD: | |
5bdd6cc3 | 1023 | #endif |
13d133bc | 1024 | case VIDIOC_QUERYCAP: |
92f45bad | 1025 | case VIDIOC_RESERVED: |
13d133bc PDM |
1026 | case VIDIOC_ENUM_FMT: |
1027 | case VIDIOC_G_FMT32: | |
1028 | case VIDIOC_S_FMT32: | |
1029 | case VIDIOC_REQBUFS: | |
1030 | case VIDIOC_QUERYBUF32: | |
1031 | case VIDIOC_G_FBUF32: | |
1032 | case VIDIOC_S_FBUF32: | |
1033 | case VIDIOC_OVERLAY32: | |
1034 | case VIDIOC_QBUF32: | |
1035 | case VIDIOC_DQBUF32: | |
1036 | case VIDIOC_STREAMON32: | |
1037 | case VIDIOC_STREAMOFF32: | |
1038 | case VIDIOC_G_PARM: | |
c7f09db6 | 1039 | case VIDIOC_S_PARM: |
13d133bc PDM |
1040 | case VIDIOC_G_STD: |
1041 | case VIDIOC_S_STD: | |
1042 | case VIDIOC_ENUMSTD32: | |
1043 | case VIDIOC_ENUMINPUT32: | |
1044 | case VIDIOC_G_CTRL: | |
7963fa48 | 1045 | case VIDIOC_S_CTRL: |
92f45bad HV |
1046 | case VIDIOC_G_TUNER: |
1047 | case VIDIOC_S_TUNER: | |
1048 | case VIDIOC_G_AUDIO: | |
1049 | case VIDIOC_S_AUDIO: | |
13d133bc | 1050 | case VIDIOC_QUERYCTRL: |
92f45bad | 1051 | case VIDIOC_QUERYMENU: |
13d133bc PDM |
1052 | case VIDIOC_G_INPUT32: |
1053 | case VIDIOC_S_INPUT32: | |
92f45bad HV |
1054 | case VIDIOC_G_OUTPUT32: |
1055 | case VIDIOC_S_OUTPUT32: | |
1056 | case VIDIOC_ENUMOUTPUT: | |
1057 | case VIDIOC_G_AUDOUT: | |
1058 | case VIDIOC_S_AUDOUT: | |
1059 | case VIDIOC_G_MODULATOR: | |
1060 | case VIDIOC_S_MODULATOR: | |
1061 | case VIDIOC_S_FREQUENCY: | |
1062 | case VIDIOC_G_FREQUENCY: | |
1063 | case VIDIOC_CROPCAP: | |
1064 | case VIDIOC_G_CROP: | |
1065 | case VIDIOC_S_CROP: | |
1066 | case VIDIOC_G_JPEGCOMP: | |
1067 | case VIDIOC_S_JPEGCOMP: | |
1068 | case VIDIOC_QUERYSTD: | |
13d133bc | 1069 | case VIDIOC_TRY_FMT32: |
92f45bad HV |
1070 | case VIDIOC_ENUMAUDIO: |
1071 | case VIDIOC_ENUMAUDOUT: | |
1072 | case VIDIOC_G_PRIORITY: | |
1073 | case VIDIOC_S_PRIORITY: | |
1074 | case VIDIOC_G_SLICED_VBI_CAP: | |
1075 | case VIDIOC_LOG_STATUS: | |
1076 | case VIDIOC_G_EXT_CTRLS32: | |
1077 | case VIDIOC_S_EXT_CTRLS32: | |
1078 | case VIDIOC_TRY_EXT_CTRLS32: | |
c7f09db6 GJ |
1079 | case VIDIOC_ENUM_FRAMESIZES: |
1080 | case VIDIOC_ENUM_FRAMEINTERVALS: | |
92f45bad HV |
1081 | case VIDIOC_G_ENC_INDEX: |
1082 | case VIDIOC_ENCODER_CMD: | |
1083 | case VIDIOC_TRY_ENCODER_CMD: | |
1084 | case VIDIOC_DBG_S_REGISTER: | |
1085 | case VIDIOC_DBG_G_REGISTER: | |
aecde8b5 | 1086 | case VIDIOC_DBG_G_CHIP_IDENT: |
92f45bad | 1087 | case VIDIOC_S_HW_FREQ_SEEK: |
b6456c0c MK |
1088 | case VIDIOC_ENUM_DV_PRESETS: |
1089 | case VIDIOC_S_DV_PRESET: | |
1090 | case VIDIOC_G_DV_PRESET: | |
1091 | case VIDIOC_QUERY_DV_PRESET: | |
1092 | case VIDIOC_S_DV_TIMINGS: | |
1093 | case VIDIOC_G_DV_TIMINGS: | |
fda10214 SA |
1094 | case VIDIOC_DQEVENT: |
1095 | case VIDIOC_SUBSCRIBE_EVENT: | |
1096 | case VIDIOC_UNSUBSCRIBE_EVENT: | |
0d0fbf81 AB |
1097 | ret = do_video_ioctl(file, cmd, arg); |
1098 | break; | |
1099 | ||
5bdd6cc3 | 1100 | #ifdef CONFIG_VIDEO_V4L1_COMPAT |
0d0fbf81 AB |
1101 | /* BTTV specific... */ |
1102 | case _IOW('v', BASE_VIDIOCPRIVATE+0, char [256]): | |
1103 | case _IOR('v', BASE_VIDIOCPRIVATE+1, char [256]): | |
1104 | case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int): | |
1105 | case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */ | |
1106 | case _IOR('v' , BASE_VIDIOCPRIVATE+4, int): | |
1107 | case _IOR('v' , BASE_VIDIOCPRIVATE+5, int): | |
1108 | case _IOR('v' , BASE_VIDIOCPRIVATE+6, int): | |
1109 | case _IOR('v' , BASE_VIDIOCPRIVATE+7, int): | |
1110 | ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); | |
1111 | break; | |
5bdd6cc3 | 1112 | #endif |
a113bc78 | 1113 | default: |
7943ecf1 HV |
1114 | printk(KERN_WARNING "compat_ioctl32: " |
1115 | "unknown ioctl '%c', dir=%d, #%d (0x%08x)\n", | |
1116 | _IOC_TYPE(cmd), _IOC_DIR(cmd), _IOC_NR(cmd), cmd); | |
7d4f0b81 | 1117 | break; |