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 | |
8 | * Copyright (C) 2003 Pavel Machek (pavel@suse.cz) | |
9 | * Copyright (C) 2005 Philippe De Muyter (phdm@macqel.be) | |
10 | * | |
11 | * These routines maintain argument size conversion between 32bit and 64bit | |
12 | * ioctls. | |
13 | */ | |
14 | ||
0d0fbf81 AB |
15 | #include <linux/config.h> |
16 | #include <linux/compat.h> | |
17 | #include <linux/videodev.h> | |
cf664a64 | 18 | #include <linux/videodev2.h> |
133b7354 | 19 | #include <linux/module.h> |
e8efb71d | 20 | #include <linux/smp_lock.h> |
0d0fbf81 AB |
21 | |
22 | #ifdef CONFIG_COMPAT | |
23 | struct video_tuner32 { | |
24 | compat_int_t tuner; | |
25 | char name[32]; | |
26 | compat_ulong_t rangelow, rangehigh; | |
27 | u32 flags; /* It is really u32 in videodev.h */ | |
28 | u16 mode, signal; | |
29 | }; | |
30 | ||
31 | static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up) | |
32 | { | |
0d0fbf81 AB |
33 | if(get_user(kp->tuner, &up->tuner)) |
34 | return -EFAULT; | |
cf664a64 | 35 | __copy_from_user(kp->name, up->name, 32); |
0d0fbf81 AB |
36 | __get_user(kp->rangelow, &up->rangelow); |
37 | __get_user(kp->rangehigh, &up->rangehigh); | |
38 | __get_user(kp->flags, &up->flags); | |
39 | __get_user(kp->mode, &up->mode); | |
40 | __get_user(kp->signal, &up->signal); | |
41 | return 0; | |
42 | } | |
43 | ||
44 | static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up) | |
45 | { | |
0d0fbf81 AB |
46 | if(put_user(kp->tuner, &up->tuner)) |
47 | return -EFAULT; | |
cf664a64 | 48 | __copy_to_user(up->name, kp->name, 32); |
0d0fbf81 AB |
49 | __put_user(kp->rangelow, &up->rangelow); |
50 | __put_user(kp->rangehigh, &up->rangehigh); | |
51 | __put_user(kp->flags, &up->flags); | |
52 | __put_user(kp->mode, &up->mode); | |
53 | __put_user(kp->signal, &up->signal); | |
54 | return 0; | |
55 | } | |
56 | ||
57 | struct video_buffer32 { | |
58 | compat_caddr_t base; | |
59 | compat_int_t height, width, depth, bytesperline; | |
60 | }; | |
61 | ||
62 | static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up) | |
63 | { | |
64 | u32 tmp; | |
65 | ||
66 | if (get_user(tmp, &up->base)) | |
67 | return -EFAULT; | |
68 | ||
69 | /* This is actually a physical address stored | |
70 | * as a void pointer. | |
71 | */ | |
72 | kp->base = (void *)(unsigned long) tmp; | |
73 | ||
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 0; | |
79 | } | |
80 | ||
81 | static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up) | |
82 | { | |
83 | u32 tmp = (u32)((unsigned long)kp->base); | |
84 | ||
85 | if(put_user(tmp, &up->base)) | |
86 | return -EFAULT; | |
87 | __put_user(kp->height, &up->height); | |
88 | __put_user(kp->width, &up->width); | |
89 | __put_user(kp->depth, &up->depth); | |
90 | __put_user(kp->bytesperline, &up->bytesperline); | |
91 | return 0; | |
92 | } | |
93 | ||
94 | struct video_clip32 { | |
95 | s32 x, y, width, height; /* Its really s32 in videodev.h */ | |
96 | compat_caddr_t next; | |
97 | }; | |
98 | ||
99 | struct video_window32 { | |
100 | u32 x, y, width, height, chromakey, flags; | |
101 | compat_caddr_t clips; | |
102 | compat_int_t clipcount; | |
103 | }; | |
104 | ||
105 | static int native_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |
106 | { | |
107 | int ret = -ENOIOCTLCMD; | |
108 | ||
13d133bc PDM |
109 | if (file->f_op->unlocked_ioctl) |
110 | ret = file->f_op->unlocked_ioctl(file, cmd, arg); | |
111 | else if (file->f_op->ioctl) { | |
0d0fbf81 | 112 | lock_kernel(); |
13d133bc | 113 | ret = file->f_op->ioctl(file->f_dentry->d_inode, file, cmd, arg); |
0d0fbf81 AB |
114 | unlock_kernel(); |
115 | } | |
116 | ||
117 | return ret; | |
118 | } | |
119 | ||
120 | ||
121 | /* You get back everything except the clips... */ | |
122 | static int put_video_window32(struct video_window *kp, struct video_window32 __user *up) | |
123 | { | |
124 | if(put_user(kp->x, &up->x)) | |
125 | return -EFAULT; | |
126 | __put_user(kp->y, &up->y); | |
127 | __put_user(kp->width, &up->width); | |
128 | __put_user(kp->height, &up->height); | |
129 | __put_user(kp->chromakey, &up->chromakey); | |
130 | __put_user(kp->flags, &up->flags); | |
131 | __put_user(kp->clipcount, &up->clipcount); | |
132 | return 0; | |
133 | } | |
134 | ||
cf664a64 PDM |
135 | struct v4l2_clip32 |
136 | { | |
137 | struct v4l2_rect c; | |
138 | compat_caddr_t next; | |
139 | }; | |
140 | ||
141 | struct v4l2_window32 | |
142 | { | |
143 | struct v4l2_rect w; | |
144 | enum v4l2_field field; | |
145 | __u32 chromakey; | |
146 | compat_caddr_t clips; /* actually struct v4l2_clip32 * */ | |
147 | __u32 clipcount; | |
148 | compat_caddr_t bitmap; | |
149 | }; | |
150 | ||
151 | static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) | |
152 | { | |
153 | if (copy_from_user(&kp->w, &up->w, sizeof(up->w))) | |
154 | return -EFAULT; | |
155 | __get_user(kp->field, &up->field); | |
156 | __get_user(kp->chromakey, &up->chromakey); | |
157 | __get_user(kp->clipcount, &up->clipcount); | |
158 | if (kp->clipcount > 2048) | |
159 | return -EINVAL; | |
160 | if (kp->clipcount) { | |
161 | struct v4l2_clip32 *uclips = compat_ptr(up->clips); | |
162 | struct v4l2_clip *kclips; | |
163 | int n = kp->clipcount; | |
164 | ||
165 | kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip)); | |
166 | kp->clips = kclips; | |
167 | while (--n >= 0) { | |
168 | copy_from_user(&kclips->c, &uclips->c, sizeof(uclips->c)); | |
169 | kclips->next = n ? kclips + 1 : 0; | |
170 | uclips += 1; | |
171 | kclips += 1; | |
172 | } | |
173 | } else | |
174 | kp->clips = 0; | |
175 | return 0; | |
176 | } | |
177 | ||
178 | static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up) | |
179 | { | |
180 | if (copy_to_user(&up->w, &kp->w, sizeof(up->w))) | |
181 | return -EFAULT; | |
182 | __put_user(kp->field, &up->field); | |
183 | __put_user(kp->chromakey, &up->chromakey); | |
184 | __put_user(kp->clipcount, &up->clipcount); | |
185 | return 0; | |
186 | } | |
187 | ||
188 | static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | |
189 | { | |
190 | return copy_from_user(kp, up, sizeof(struct v4l2_pix_format)); | |
191 | } | |
192 | ||
193 | static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up) | |
194 | { | |
195 | return copy_to_user(up, kp, sizeof(struct v4l2_pix_format)); | |
196 | } | |
197 | ||
198 | static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | |
199 | { | |
200 | return copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)); | |
201 | } | |
202 | ||
203 | static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up) | |
204 | { | |
205 | return copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)); | |
206 | } | |
207 | ||
208 | struct v4l2_format32 | |
209 | { | |
210 | enum v4l2_buf_type type; | |
211 | union | |
212 | { | |
213 | struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE | |
214 | struct v4l2_window32 win; // V4L2_BUF_TYPE_VIDEO_OVERLAY | |
215 | struct v4l2_vbi_format vbi; // V4L2_BUF_TYPE_VBI_CAPTURE | |
216 | __u8 raw_data[200]; // user-defined | |
217 | } fmt; | |
218 | }; | |
219 | ||
220 | static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) | |
221 | { | |
222 | if(get_user(kp->type, &up->type)) | |
223 | return -EFAULT; | |
224 | switch (kp->type) { | |
225 | case V4L2_BUF_TYPE_VIDEO_CAPTURE: | |
226 | return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); | |
227 | case V4L2_BUF_TYPE_VIDEO_OVERLAY: | |
228 | return get_v4l2_window32(&kp->fmt.win, &up->fmt.win); | |
229 | case V4L2_BUF_TYPE_VBI_CAPTURE: | |
230 | return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); | |
231 | default: | |
232 | printk("compat_ioctl : unexpected VIDIOC_FMT type %d\n", | |
233 | kp->type); | |
234 | return -ENXIO; | |
235 | } | |
236 | } | |
237 | ||
238 | static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up) | |
239 | { | |
240 | if(put_user(kp->type, &up->type)) | |
241 | return -EFAULT; | |
242 | switch (kp->type) { | |
243 | case V4L2_BUF_TYPE_VIDEO_CAPTURE: | |
244 | return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix); | |
245 | case V4L2_BUF_TYPE_VIDEO_OVERLAY: | |
246 | return put_v4l2_window32(&kp->fmt.win, &up->fmt.win); | |
247 | case V4L2_BUF_TYPE_VBI_CAPTURE: | |
248 | return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi); | |
249 | default: | |
250 | return -ENXIO; | |
251 | } | |
252 | } | |
253 | ||
254 | struct v4l2_standard32 | |
255 | { | |
256 | __u32 index; | |
257 | __u32 id[2]; /* __u64 would get the alignment wrong */ | |
258 | __u8 name[24]; | |
259 | struct v4l2_fract frameperiod; /* Frames, not fields */ | |
260 | __u32 framelines; | |
261 | __u32 reserved[4]; | |
262 | }; | |
263 | ||
264 | static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) | |
265 | { | |
266 | /* other fields are not set by the user, nor used by the driver */ | |
267 | return get_user(kp->index, &up->index); | |
268 | } | |
269 | ||
270 | static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up) | |
271 | { | |
272 | if(put_user(kp->index, &up->index)) | |
273 | return -EFAULT; | |
274 | __copy_to_user(up->id, &kp->id, sizeof(__u64)); | |
275 | __copy_to_user(up->name, kp->name, 24); | |
276 | __put_user(kp->frameperiod, &up->frameperiod); | |
277 | __put_user(kp->framelines, &up->framelines); | |
278 | __copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32)); | |
279 | return 0; | |
280 | } | |
281 | ||
282 | struct v4l2_buffer32 | |
283 | { | |
284 | __u32 index; | |
285 | enum v4l2_buf_type type; | |
286 | __u32 bytesused; | |
287 | __u32 flags; | |
288 | enum v4l2_field field; | |
289 | struct compat_timeval timestamp; | |
290 | struct v4l2_timecode timecode; | |
291 | __u32 sequence; | |
292 | ||
293 | /* memory location */ | |
294 | enum v4l2_memory memory; | |
295 | union { | |
296 | __u32 offset; | |
297 | compat_long_t userptr; | |
298 | } m; | |
299 | __u32 length; | |
300 | __u32 input; | |
301 | __u32 reserved; | |
302 | }; | |
303 | ||
304 | static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) | |
305 | { | |
306 | ||
307 | if (get_user(kp->index, &up->index)) | |
308 | return -EFAULT; | |
309 | __get_user(kp->type, &up->type); | |
310 | __get_user(kp->flags, &up->flags); | |
311 | __get_user(kp->memory, &up->memory); | |
312 | __get_user(kp->input, &up->input); | |
313 | switch(kp->memory) { | |
314 | case V4L2_MEMORY_MMAP: | |
315 | break; | |
316 | case V4L2_MEMORY_USERPTR: | |
317 | { | |
318 | unsigned long tmp = (unsigned long)compat_ptr(up->m.userptr); | |
319 | ||
320 | __get_user(kp->length, &up->length); | |
321 | __get_user(kp->m.userptr, &tmp); | |
322 | } | |
323 | break; | |
324 | case V4L2_MEMORY_OVERLAY: | |
325 | __get_user(kp->m.offset, &up->m.offset); | |
326 | break; | |
327 | } | |
328 | return 0; | |
329 | } | |
330 | ||
331 | static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up) | |
332 | { | |
333 | if (put_user(kp->index, &up->index)) | |
334 | return -EFAULT; | |
335 | __put_user(kp->type, &up->type); | |
336 | __put_user(kp->flags, &up->flags); | |
337 | __put_user(kp->memory, &up->memory); | |
338 | __put_user(kp->input, &up->input); | |
339 | switch(kp->memory) { | |
340 | case V4L2_MEMORY_MMAP: | |
341 | __put_user(kp->length, &up->length); | |
342 | __put_user(kp->m.offset, &up->m.offset); | |
343 | break; | |
344 | case V4L2_MEMORY_USERPTR: | |
345 | __put_user(kp->length, &up->length); | |
346 | __put_user(kp->m.userptr, &up->m.userptr); | |
347 | break; | |
348 | case V4L2_MEMORY_OVERLAY: | |
349 | __put_user(kp->m.offset, &up->m.offset); | |
350 | break; | |
351 | } | |
352 | __put_user(kp->bytesused, &up->bytesused); | |
353 | __put_user(kp->field, &up->field); | |
354 | __put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec); | |
355 | __put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec); | |
356 | __copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)); | |
357 | __put_user(kp->sequence, &up->sequence); | |
358 | __put_user(kp->reserved, &up->reserved); | |
359 | return 0; | |
360 | } | |
361 | ||
362 | struct v4l2_framebuffer32 | |
363 | { | |
364 | __u32 capability; | |
365 | __u32 flags; | |
366 | compat_caddr_t base; | |
367 | struct v4l2_pix_format fmt; | |
368 | }; | |
369 | ||
13d133bc PDM |
370 | static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) |
371 | { | |
372 | u32 tmp; | |
373 | ||
374 | if (get_user(tmp, &up->base)) | |
375 | return -EFAULT; | |
376 | kp->base = compat_ptr(tmp); | |
377 | __get_user(kp->capability, &up->capability); | |
378 | __get_user(kp->flags, &up->flags); | |
379 | get_v4l2_pix_format(&kp->fmt, &up->fmt); | |
380 | return 0; | |
381 | } | |
382 | ||
cf664a64 PDM |
383 | static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up) |
384 | { | |
385 | u32 tmp = (u32)((unsigned long)kp->base); | |
386 | ||
387 | if(put_user(tmp, &up->base)) | |
388 | return -EFAULT; | |
389 | __put_user(kp->capability, &up->capability); | |
390 | __put_user(kp->flags, &up->flags); | |
391 | put_v4l2_pix_format(&kp->fmt, &up->fmt); | |
392 | return 0; | |
393 | } | |
394 | ||
395 | struct v4l2_input32 /* identical layout, but different size */ | |
396 | { | |
397 | __u32 index; /* Which input */ | |
398 | __u8 name[32]; /* Label */ | |
399 | __u32 type; /* Type of input */ | |
400 | __u32 audioset; /* Associated audios (bitfield) */ | |
401 | __u32 tuner; /* Associated tuner */ | |
402 | __u32 std[2]; /* __u64 would get the padding wrong */ | |
403 | __u32 status; | |
404 | __u32 reserved[4]; | |
405 | }; | |
406 | ||
0d0fbf81 AB |
407 | #define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32) |
408 | #define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32) | |
409 | #define VIDIOCGWIN32 _IOR('v',9, struct video_window32) | |
410 | #define VIDIOCSWIN32 _IOW('v',10, struct video_window32) | |
411 | #define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32) | |
412 | #define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32) | |
413 | #define VIDIOCGFREQ32 _IOR('v',14, u32) | |
414 | #define VIDIOCSFREQ32 _IOW('v',15, u32) | |
415 | ||
cf664a64 PDM |
416 | #define VIDIOC_G_FMT32 _IOWR ('V', 4, struct v4l2_format32) |
417 | #define VIDIOC_S_FMT32 _IOWR ('V', 5, struct v4l2_format32) | |
418 | #define VIDIOC_QUERYBUF32 _IOWR ('V', 9, struct v4l2_buffer32) | |
419 | #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32) | |
13d133bc | 420 | #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32) |
cf664a64 PDM |
421 | /* VIDIOC_OVERLAY is now _IOW, but was _IOWR */ |
422 | #define VIDIOC_OVERLAY32 _IOWR ('V', 14, compat_int_t) | |
423 | #define VIDIOC_QBUF32 _IOWR ('V', 15, struct v4l2_buffer32) | |
424 | #define VIDIOC_DQBUF32 _IOWR ('V', 17, struct v4l2_buffer32) | |
425 | #define VIDIOC_STREAMON32 _IOW ('V', 18, compat_int_t) | |
426 | #define VIDIOC_STREAMOFF32 _IOW ('V', 19, compat_int_t) | |
427 | #define VIDIOC_ENUMSTD32 _IOWR ('V', 25, struct v4l2_standard32) | |
428 | #define VIDIOC_ENUMINPUT32 _IOWR ('V', 26, struct v4l2_input32) | |
429 | /* VIDIOC_S_CTRL is now _IOWR, but was _IOW */ | |
430 | #define VIDIOC_S_CTRL32 _IOW ('V', 28, struct v4l2_control) | |
431 | #define VIDIOC_G_INPUT32 _IOR ('V', 38, compat_int_t) | |
432 | #define VIDIOC_S_INPUT32 _IOWR ('V', 39, compat_int_t) | |
433 | #define VIDIOC_TRY_FMT32 _IOWR ('V', 64, struct v4l2_format32) | |
434 | ||
0d0fbf81 AB |
435 | enum { |
436 | MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip) | |
437 | }; | |
438 | ||
439 | static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg) | |
440 | { | |
441 | struct video_window32 __user *up = compat_ptr(arg); | |
442 | struct video_window __user *vw; | |
443 | struct video_clip __user *p; | |
444 | int nclips; | |
445 | u32 n; | |
446 | ||
447 | if (get_user(nclips, &up->clipcount)) | |
448 | return -EFAULT; | |
449 | ||
450 | /* Peculiar interface... */ | |
451 | if (nclips < 0) | |
452 | nclips = VIDEO_CLIPMAP_SIZE; | |
453 | ||
454 | if (nclips > MaxClips) | |
455 | return -ENOMEM; | |
456 | ||
457 | vw = compat_alloc_user_space(sizeof(struct video_window) + | |
458 | nclips * sizeof(struct video_clip)); | |
459 | ||
460 | p = nclips ? (struct video_clip __user *)(vw + 1) : NULL; | |
461 | ||
462 | if (get_user(n, &up->x) || put_user(n, &vw->x) || | |
463 | get_user(n, &up->y) || put_user(n, &vw->y) || | |
464 | get_user(n, &up->width) || put_user(n, &vw->width) || | |
465 | get_user(n, &up->height) || put_user(n, &vw->height) || | |
466 | get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) || | |
467 | get_user(n, &up->flags) || put_user(n, &vw->flags) || | |
468 | get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) || | |
469 | get_user(n, &up->clips) || put_user(p, &vw->clips)) | |
470 | return -EFAULT; | |
471 | ||
472 | if (nclips) { | |
473 | struct video_clip32 __user *u = compat_ptr(n); | |
474 | int i; | |
475 | if (!u) | |
476 | return -EINVAL; | |
477 | for (i = 0; i < nclips; i++, u++, p++) { | |
478 | s32 v; | |
479 | if (get_user(v, &u->x) || | |
480 | put_user(v, &p->x) || | |
481 | get_user(v, &u->y) || | |
482 | put_user(v, &p->y) || | |
483 | get_user(v, &u->width) || | |
484 | put_user(v, &p->width) || | |
485 | get_user(v, &u->height) || | |
486 | put_user(v, &p->height) || | |
487 | put_user(NULL, &p->next)) | |
488 | return -EFAULT; | |
489 | } | |
490 | } | |
491 | ||
009494ef | 492 | return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw); |
0d0fbf81 AB |
493 | } |
494 | ||
495 | static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg) | |
496 | { | |
497 | union { | |
498 | struct video_tuner vt; | |
499 | struct video_buffer vb; | |
500 | struct video_window vw; | |
cf664a64 PDM |
501 | struct v4l2_format v2f; |
502 | struct v4l2_buffer v2b; | |
503 | struct v4l2_framebuffer v2fb; | |
504 | struct v4l2_standard v2s; | |
0d0fbf81 AB |
505 | unsigned long vx; |
506 | } karg; | |
0d0fbf81 | 507 | void __user *up = compat_ptr(arg); |
cf664a64 | 508 | int compatible_arg = 1; |
0d0fbf81 AB |
509 | int err = 0; |
510 | ||
511 | /* First, convert the command. */ | |
512 | switch(cmd) { | |
513 | case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break; | |
514 | case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break; | |
515 | case VIDIOCGWIN32: cmd = VIDIOCGWIN; break; | |
516 | case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break; | |
517 | case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break; | |
518 | case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break; | |
519 | case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break; | |
cf664a64 PDM |
520 | case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break; |
521 | case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break; | |
522 | case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break; | |
523 | case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break; | |
524 | case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break; | |
525 | case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break; | |
526 | case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break; | |
527 | case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break; | |
13d133bc | 528 | case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break; |
cf664a64 PDM |
529 | case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break; |
530 | case VIDIOC_ENUMSTD32: cmd = VIDIOC_ENUMSTD; break; | |
531 | case VIDIOC_ENUMINPUT32: cmd = VIDIOC_ENUMINPUT; break; | |
532 | case VIDIOC_S_CTRL32: cmd = VIDIOC_S_CTRL; break; | |
533 | case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break; | |
534 | case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break; | |
535 | case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break; | |
0d0fbf81 AB |
536 | }; |
537 | ||
538 | switch(cmd) { | |
539 | case VIDIOCSTUNER: | |
540 | case VIDIOCGTUNER: | |
541 | err = get_video_tuner32(&karg.vt, up); | |
cf664a64 PDM |
542 | compatible_arg = 0; |
543 | ||
0d0fbf81 AB |
544 | break; |
545 | ||
546 | case VIDIOCSFBUF: | |
547 | err = get_video_buffer32(&karg.vb, up); | |
cf664a64 | 548 | compatible_arg = 0; |
0d0fbf81 AB |
549 | break; |
550 | ||
551 | case VIDIOCSFREQ: | |
cf664a64 PDM |
552 | case VIDIOC_S_INPUT: |
553 | case VIDIOC_OVERLAY: | |
13d133bc PDM |
554 | case VIDIOC_STREAMON: |
555 | case VIDIOC_STREAMOFF: | |
0d0fbf81 | 556 | err = get_user(karg.vx, (u32 __user *)up); |
cf664a64 | 557 | compatible_arg = 0; |
0d0fbf81 | 558 | break; |
13d133bc PDM |
559 | |
560 | case VIDIOC_S_FBUF: | |
561 | err = get_v4l2_framebuffer32(&karg.v2fb, up); | |
562 | compatible_arg = 0; | |
563 | break; | |
cf664a64 PDM |
564 | |
565 | case VIDIOC_G_FMT: | |
566 | case VIDIOC_S_FMT: | |
567 | case VIDIOC_TRY_FMT: | |
568 | err = get_v4l2_format32(&karg.v2f, up); | |
569 | compatible_arg = 0; | |
570 | break; | |
571 | ||
572 | case VIDIOC_QUERYBUF: | |
573 | case VIDIOC_QBUF: | |
574 | case VIDIOC_DQBUF: | |
575 | err = get_v4l2_buffer32(&karg.v2b, up); | |
576 | compatible_arg = 0; | |
577 | break; | |
578 | ||
579 | case VIDIOC_ENUMSTD: | |
580 | err = get_v4l2_standard32(&karg.v2s, up); | |
581 | compatible_arg = 0; | |
582 | break; | |
583 | ||
584 | case VIDIOCGWIN: | |
585 | case VIDIOCGFBUF: | |
586 | case VIDIOCGFREQ: | |
587 | case VIDIOC_G_FBUF: | |
588 | case VIDIOC_G_INPUT: | |
589 | compatible_arg = 0; | |
13d133bc | 590 | }; |
cf664a64 | 591 | |
0d0fbf81 AB |
592 | if(err) |
593 | goto out; | |
594 | ||
cf664a64 | 595 | if(compatible_arg) |
13d133bc | 596 | err = native_ioctl(file, cmd, (unsigned long)up); |
cf664a64 PDM |
597 | else { |
598 | mm_segment_t old_fs = get_fs(); | |
0d0fbf81 | 599 | |
cf664a64 | 600 | set_fs(KERNEL_DS); |
13d133bc | 601 | err = native_ioctl(file, cmd, (unsigned long)&karg); |
cf664a64 PDM |
602 | set_fs(old_fs); |
603 | } | |
0d0fbf81 AB |
604 | if(err == 0) { |
605 | switch(cmd) { | |
606 | case VIDIOCGTUNER: | |
607 | err = put_video_tuner32(&karg.vt, up); | |
608 | break; | |
609 | ||
610 | case VIDIOCGWIN: | |
611 | err = put_video_window32(&karg.vw, up); | |
612 | break; | |
613 | ||
614 | case VIDIOCGFBUF: | |
615 | err = put_video_buffer32(&karg.vb, up); | |
616 | break; | |
617 | ||
cf664a64 PDM |
618 | case VIDIOC_G_FBUF: |
619 | err = put_v4l2_framebuffer32(&karg.v2fb, up); | |
620 | break; | |
621 | ||
622 | case VIDIOC_G_FMT: | |
623 | case VIDIOC_S_FMT: | |
624 | case VIDIOC_TRY_FMT: | |
625 | err = put_v4l2_format32(&karg.v2f, up); | |
626 | break; | |
627 | ||
628 | case VIDIOC_QUERYBUF: | |
629 | case VIDIOC_QBUF: | |
630 | case VIDIOC_DQBUF: | |
631 | err = put_v4l2_buffer32(&karg.v2b, up); | |
632 | break; | |
633 | ||
634 | case VIDIOC_ENUMSTD: | |
635 | err = put_v4l2_standard32(&karg.v2s, up); | |
636 | break; | |
637 | ||
0d0fbf81 | 638 | case VIDIOCGFREQ: |
cf664a64 | 639 | case VIDIOC_G_INPUT: |
0d0fbf81 AB |
640 | err = put_user(((u32)karg.vx), (u32 __user *)up); |
641 | break; | |
642 | }; | |
643 | } | |
644 | out: | |
645 | return err; | |
646 | } | |
647 | ||
648 | long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg) | |
649 | { | |
650 | int ret = -ENOIOCTLCMD; | |
651 | ||
13d133bc | 652 | if (!file->f_op->ioctl) |
0d0fbf81 AB |
653 | return ret; |
654 | ||
655 | switch (cmd) { | |
656 | case VIDIOCSWIN32: | |
657 | ret = do_set_window(file, cmd, arg); | |
658 | break; | |
659 | case VIDIOCGTUNER32: | |
660 | case VIDIOCSTUNER32: | |
661 | case VIDIOCGWIN32: | |
662 | case VIDIOCGFBUF32: | |
663 | case VIDIOCSFBUF32: | |
664 | case VIDIOCGFREQ32: | |
133b7354 | 665 | case VIDIOCSFREQ32: |
13d133bc PDM |
666 | case VIDIOC_QUERYCAP: |
667 | case VIDIOC_ENUM_FMT: | |
668 | case VIDIOC_G_FMT32: | |
669 | case VIDIOC_S_FMT32: | |
670 | case VIDIOC_REQBUFS: | |
671 | case VIDIOC_QUERYBUF32: | |
672 | case VIDIOC_G_FBUF32: | |
673 | case VIDIOC_S_FBUF32: | |
674 | case VIDIOC_OVERLAY32: | |
675 | case VIDIOC_QBUF32: | |
676 | case VIDIOC_DQBUF32: | |
677 | case VIDIOC_STREAMON32: | |
678 | case VIDIOC_STREAMOFF32: | |
679 | case VIDIOC_G_PARM: | |
680 | case VIDIOC_G_STD: | |
681 | case VIDIOC_S_STD: | |
682 | case VIDIOC_ENUMSTD32: | |
683 | case VIDIOC_ENUMINPUT32: | |
684 | case VIDIOC_G_CTRL: | |
685 | case VIDIOC_S_CTRL32: | |
686 | case VIDIOC_QUERYCTRL: | |
687 | case VIDIOC_G_INPUT32: | |
688 | case VIDIOC_S_INPUT32: | |
689 | case VIDIOC_TRY_FMT32: | |
0d0fbf81 AB |
690 | ret = do_video_ioctl(file, cmd, arg); |
691 | break; | |
692 | ||
693 | /* Little v, the video4linux ioctls (conflict?) */ | |
694 | case VIDIOCGCAP: | |
695 | case VIDIOCGCHAN: | |
696 | case VIDIOCSCHAN: | |
697 | case VIDIOCGPICT: | |
698 | case VIDIOCSPICT: | |
699 | case VIDIOCCAPTURE: | |
700 | case VIDIOCKEY: | |
701 | case VIDIOCGAUDIO: | |
702 | case VIDIOCSAUDIO: | |
703 | case VIDIOCSYNC: | |
704 | case VIDIOCMCAPTURE: | |
705 | case VIDIOCGMBUF: | |
706 | case VIDIOCGUNIT: | |
707 | case VIDIOCGCAPTURE: | |
708 | case VIDIOCSCAPTURE: | |
709 | ||
710 | /* BTTV specific... */ | |
711 | case _IOW('v', BASE_VIDIOCPRIVATE+0, char [256]): | |
712 | case _IOR('v', BASE_VIDIOCPRIVATE+1, char [256]): | |
713 | case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int): | |
714 | case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */ | |
715 | case _IOR('v' , BASE_VIDIOCPRIVATE+4, int): | |
716 | case _IOR('v' , BASE_VIDIOCPRIVATE+5, int): | |
717 | case _IOR('v' , BASE_VIDIOCPRIVATE+6, int): | |
718 | case _IOR('v' , BASE_VIDIOCPRIVATE+7, int): | |
719 | ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); | |
720 | break; |