Galaxy S2 camera module
[exynos_camera.git] / exynos_v4l2.c
1 /*
2  * Copyright (C) 2013 Paul Kocialkowski
3  *
4  * Based on crespo libcamera and exynos4 hal libcamera:
5  * Copyright 2008, The Android Open Source Project
6  * Copyright 2010, Samsung Electronics Co. LTD
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <fcntl.h>
23 #include <unistd.h>
24 #include <errno.h>
25 #include <malloc.h>
26 #include <poll.h>
27 #include <sys/stat.h>
28 #include <sys/types.h>
29 #include <sys/time.h>
30 #include <sys/mman.h>
31 #include <sys/ioctl.h>
32
33 #include <asm/types.h>
34
35 #define LOG_TAG "exynos_v4l2"
36 #include <utils/Log.h>
37
38 #include "exynos_camera.h"
39
40 /*
41  * Utils
42  */
43
44 int exynos_v4l2_find_index(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
45 {
46         int index;
47         int i;
48
49         if (exynos_camera == NULL || exynos_camera->config == NULL ||
50                 exynos_camera->config->v4l2_nodes == NULL)
51                 return -EINVAL;
52
53         if (exynos_v4l2_id > exynos_camera->config->v4l2_nodes_count)
54                 return -1;
55
56         index = -1;
57         for (i=0 ; i < exynos_camera->config->v4l2_nodes_count ; i++) {
58                 if (exynos_camera->config->v4l2_nodes[i].id == exynos_v4l2_id &&
59                         exynos_camera->config->v4l2_nodes[i].node != NULL) {
60                         index = i;
61                 }
62         }
63
64         return index;
65 }
66
67 int exynos_v4l2_find_fd(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
68 {
69         int index;
70
71         if (exynos_camera == NULL)
72                 return -EINVAL;
73
74         index = exynos_v4l2_find_index(exynos_camera, exynos_v4l2_id);
75         if (index < 0)
76                 return -1;
77
78         return exynos_camera->v4l2_fds[index];
79 }
80
81 /*
82  * File ops
83  */
84
85 int exynos_v4l2_open(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
86 {
87         char *node;
88         int index;
89         int fd;
90
91         if (exynos_camera == NULL || exynos_camera->config == NULL ||
92                 exynos_camera->config->v4l2_nodes == NULL)
93                 return -EINVAL;
94
95         index = exynos_v4l2_find_index(exynos_camera, exynos_v4l2_id);
96         if (index < 0) {
97                 LOGE("%s: Unable to find v4l2 node #%d", __func__, exynos_v4l2_id);
98                 return -1;
99         }
100
101         node = exynos_camera->config->v4l2_nodes[index].node;
102         fd = open(node, O_RDWR);
103         if (fd < 0) {
104                 LOGE("%s: Unable to open v4l2 node #%d", __func__, exynos_v4l2_id);
105                 return -1;
106         }
107
108         exynos_camera->v4l2_fds[index] = fd;
109
110         return 0;
111 }
112
113 void exynos_v4l2_close(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
114 {
115         int index;
116
117         if (exynos_camera == NULL || exynos_camera->config == NULL ||
118                 exynos_camera->config->v4l2_nodes == NULL)
119                 return;
120
121         index = exynos_v4l2_find_index(exynos_camera, exynos_v4l2_id);
122         if (index < 0) {
123                 LOGE("%s: Unable to find v4l2 node #%d", __func__, exynos_v4l2_id);
124                 return;
125         }
126
127         if (exynos_camera->v4l2_fds[index] > 0)
128                 close(exynos_camera->v4l2_fds[index]);
129
130         exynos_camera->v4l2_fds[index] = -1;
131 }
132
133 int exynos_v4l2_ioctl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
134         int request, void *data)
135 {
136         int fd;
137
138         if (exynos_camera == NULL)
139                 return -EINVAL;
140
141         fd = exynos_v4l2_find_fd(exynos_camera, exynos_v4l2_id);
142         if (fd < 0) {
143                 LOGE("%s: Unable to find v4l2 fd #%d", __func__, exynos_v4l2_id);
144                 return -1;
145         }
146
147         return ioctl(fd, request, data);
148 }
149
150 int exynos_v4l2_poll(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
151 {
152         struct pollfd events;
153         int fd;
154         int rc;
155
156         if (exynos_camera == NULL)
157                 return -EINVAL;
158
159         fd = exynos_v4l2_find_fd(exynos_camera, exynos_v4l2_id);
160         if (fd < 0) {
161                 LOGE("%s: Unable to find v4l2 fd #%d", __func__, exynos_v4l2_id);
162                 return -1;
163         }
164
165         memset(&events, 0, sizeof(events));
166         events.fd = fd;
167         events.events = POLLIN | POLLERR;
168
169         rc = poll(&events, 1, 1000);
170         if (rc < 0 || events.revents & POLLERR) {
171                 LOGE("%s: poll failed", __func__);
172                 return -1;
173         }
174
175         return rc;
176 }
177
178 /*
179  * VIDIOC
180  */
181
182 int exynos_v4l2_qbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
183         int type, int memory, int index)
184 {
185         struct v4l2_buffer buffer;
186         int rc;
187
188         if (exynos_camera == NULL || index < 0)
189                 return -EINVAL;
190
191         buffer.type = type;
192         buffer.memory = memory;
193         buffer.index = index;
194
195         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QBUF, &buffer);
196         if (rc < 0) {
197                 LOGE("%s: ioctl failed", __func__);
198                 return -1;
199         }
200
201         return 0;
202 }
203
204 int exynos_v4l2_qbuf_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
205         int index)
206 {
207         return exynos_v4l2_qbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
208                 V4L2_MEMORY_MMAP, index);
209 }
210
211 int exynos_v4l2_qbuf_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
212         int index)
213 {
214         return exynos_v4l2_qbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
215                 V4L2_MEMORY_USERPTR, index);
216 }
217
218 int exynos_v4l2_dqbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
219         int type, int memory)
220 {
221         struct v4l2_buffer buffer;
222         int rc;
223
224         if (exynos_camera == NULL)
225                 return -EINVAL;
226
227         memset(&buffer, 0, sizeof(buffer));
228         buffer.type = type;
229         buffer.memory = memory;
230
231         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_DQBUF, &buffer);
232         if (rc < 0) {
233                 LOGE("%s: ioctl failed", __func__);
234                 return -1;
235         }
236
237         return buffer.index;
238 }
239
240 int exynos_v4l2_dqbuf_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
241 {
242         return exynos_v4l2_dqbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
243                 V4L2_MEMORY_MMAP);
244 }
245
246 int exynos_v4l2_dqbuf_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
247 {
248         return exynos_v4l2_dqbuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
249                 V4L2_MEMORY_USERPTR);
250 }
251
252 int exynos_v4l2_reqbufs(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
253         int type, int memory, int count)
254 {
255         struct v4l2_requestbuffers requestbuffers;
256         int rc;
257
258         if (exynos_camera == NULL || count < 0)
259                 return -EINVAL;
260
261         requestbuffers.type = type;
262         requestbuffers.count = count;
263         requestbuffers.memory = memory;
264
265         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_REQBUFS, &requestbuffers);
266         if (rc < 0) {
267                 LOGE("%s: ioctl failed", __func__);
268                 return -1;
269         }
270
271         return requestbuffers.count;
272 }
273
274 int exynos_v4l2_reqbufs_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
275         int count)
276 {
277         return exynos_v4l2_reqbufs(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
278                 V4L2_MEMORY_MMAP, count);
279 }
280
281 int exynos_v4l2_reqbufs_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
282         int count)
283 {
284         return exynos_v4l2_reqbufs(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
285                 V4L2_MEMORY_USERPTR, count);
286 }
287
288 int exynos_v4l2_querybuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
289         int type, int memory, int index)
290 {
291         struct v4l2_buffer buffer;
292         int rc;
293
294         if (exynos_camera == NULL)
295                 return -EINVAL;
296
297         memset(&buffer, 0, sizeof(buffer));
298         buffer.type = type;
299         buffer.memory = memory;
300         buffer.index = index;
301
302         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QUERYBUF, &buffer);
303         if (rc < 0) {
304                 LOGE("%s: ioctl failed", __func__);
305                 return -1;
306         }
307
308         return buffer.length;
309 }
310
311 int exynos_v4l2_querybuf_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
312         int index)
313 {
314         return exynos_v4l2_querybuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
315                 V4L2_MEMORY_MMAP, index);
316 }
317
318 int exynos_v4l2_querybuf_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
319         int index)
320 {
321         return exynos_v4l2_querybuf(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
322                 V4L2_MEMORY_USERPTR, index);
323 }
324
325 int exynos_v4l2_querycap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
326         int flags)
327 {
328         struct v4l2_capability cap;
329         int rc;
330
331         if (exynos_camera == NULL)
332                 return -EINVAL;
333
334         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_QUERYCAP, &cap);
335         if (rc < 0) {
336                 LOGE("%s: ioctl failed", __func__);
337                 return -1;
338         }
339
340         if (!(cap.capabilities & flags))
341                 return -1;
342
343         return 0;
344 }
345
346 int exynos_v4l2_querycap_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
347 {
348         return exynos_v4l2_querycap(exynos_camera, exynos_v4l2_id, V4L2_CAP_VIDEO_CAPTURE);
349 }
350
351 int exynos_v4l2_querycap_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
352 {
353         return exynos_v4l2_querycap(exynos_camera, exynos_v4l2_id, V4L2_CAP_VIDEO_OUTPUT);
354 }
355
356 int exynos_v4l2_streamon(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
357         int type)
358 {
359         enum v4l2_buf_type buf_type;
360         int rc;
361
362         if (exynos_camera == NULL)
363                 return -EINVAL;
364
365         buf_type = type;
366
367         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_STREAMON, &buf_type);
368         if (rc < 0) {
369                 LOGE("%s: ioctl failed", __func__);
370                 return -1;
371         }
372
373         return 0;
374 }
375
376 int exynos_v4l2_streamon_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
377 {
378         return exynos_v4l2_streamon(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
379 }
380
381 int exynos_v4l2_streamon_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
382 {
383         return exynos_v4l2_streamon(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
384 }
385
386 int exynos_v4l2_streamoff(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
387         int type)
388 {
389         enum v4l2_buf_type buf_type;
390         int rc;
391
392         if (exynos_camera == NULL)
393                 return -EINVAL;
394
395         buf_type = type;
396
397         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_STREAMOFF, &buf_type);
398         if (rc < 0) {
399                 LOGE("%s: ioctl failed", __func__);
400                 return -1;
401         }
402
403         return 0;
404 }
405
406 int exynos_v4l2_streamoff_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
407 {
408         return exynos_v4l2_streamoff(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE);
409 }
410
411 int exynos_v4l2_streamoff_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id)
412 {
413         return exynos_v4l2_streamoff(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT);
414 }
415
416 int exynos_v4l2_g_fmt(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
417         int type, int *width, int *height, int *fmt)
418 {
419         struct v4l2_format format;
420         int rc;
421
422         if (exynos_camera == NULL)
423                 return -EINVAL;
424
425         format.type = type;
426         format.fmt.pix.field = V4L2_FIELD_NONE;
427
428         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_FMT, &format);
429         if (rc < 0) {
430                 LOGE("%s: ioctl failed", __func__);
431                 return -1;
432         }
433
434         if (width != NULL)
435                 *width = format.fmt.pix.width;
436         if (height != NULL)
437                 *height = format.fmt.pix.height;
438         if (fmt != NULL)
439                 *fmt = format.fmt.pix.pixelformat;
440
441         return 0;
442 }
443
444 int exynos_v4l2_g_fmt_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
445         int *width, int *height, int *fmt)
446 {
447         return exynos_v4l2_g_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
448                 width, height, fmt);
449 }
450
451 int exynos_v4l2_g_fmt_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
452         int *width, int *height, int *fmt)
453 {
454         return exynos_v4l2_g_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
455                 width, height, fmt);
456 }
457
458 int exynos_v4l2_s_fmt_pix(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
459         int type, int width, int height, int fmt, int priv)
460 {
461         struct v4l2_format format;
462         int rc;
463
464         if (exynos_camera == NULL)
465                 return -EINVAL;
466
467         memset(&format, 0, sizeof(format));
468         format.type = type;
469         format.fmt.pix.width = width;
470         format.fmt.pix.height = height;
471         format.fmt.pix.pixelformat = fmt;
472         format.fmt.pix.field = V4L2_FIELD_NONE;
473         format.fmt.pix.priv = priv;
474
475         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FMT, &format);
476         if (rc < 0) {
477                 LOGE("%s: ioctl failed", __func__);
478                 return -1;
479         }
480
481         return 0;
482 }
483
484 int exynos_v4l2_s_fmt_pix_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
485         int width, int height, int fmt, int priv)
486 {
487         return exynos_v4l2_s_fmt_pix(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
488                 width, height, fmt, priv);
489 }
490
491 int exynos_v4l2_s_fmt_pix_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
492         int width, int height, int fmt, int priv)
493 {
494         return exynos_v4l2_s_fmt_pix(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
495                 width, height, fmt, priv);
496 }
497
498 int exynos_v4l2_s_fmt_win(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
499         int left, int top, int width, int height)
500 {
501         struct v4l2_format format;
502         int rc;
503
504         if (exynos_camera == NULL)
505                 return -EINVAL;
506
507         memset(&format, 0, sizeof(format));
508         format.type = V4L2_BUF_TYPE_VIDEO_OVERLAY;
509         format.fmt.win.w.left = left;
510         format.fmt.win.w.top = top;
511         format.fmt.win.w.width = width;
512         format.fmt.win.w.height = height;
513
514
515         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FMT, &format);
516         if (rc < 0) {
517                 LOGE("%s: ioctl failed", __func__);
518                 return -1;
519         }
520
521         return 0;
522 }
523
524 int exynos_v4l2_enum_fmt(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
525         int type, int fmt)
526 {
527         struct v4l2_fmtdesc fmtdesc;
528         int rc;
529
530         if (exynos_camera == NULL)
531                 return -EINVAL;
532
533         fmtdesc.type = type;
534         fmtdesc.index = 0;
535
536         do {
537                 rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_ENUM_FMT, &fmtdesc);
538                 if (rc < 0) {
539                         LOGE("%s: ioctl failed", __func__);
540                         return -1;
541                 }
542
543                 if (fmtdesc.pixelformat == (unsigned int) fmt)
544                         return 0;
545
546                 fmtdesc.index++;
547         } while (rc >= 0);
548
549         return -1;
550 }
551
552 int exynos_v4l2_enum_fmt_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
553         int fmt)
554 {
555         return exynos_v4l2_enum_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
556                 fmt);
557 }
558
559 int exynos_v4l2_enum_fmt_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
560         int fmt)
561 {
562         return exynos_v4l2_enum_fmt(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
563                 fmt);
564 }
565
566 int exynos_v4l2_enum_input(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
567         int id)
568 {
569         struct v4l2_input input;
570         int rc;
571
572         if (exynos_camera == NULL || id < 0)
573                 return -EINVAL;
574
575         input.index = id;
576
577         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_ENUMINPUT, &input);
578         if (rc < 0) {
579                 LOGE("%s: ioctl failed", __func__);
580                 return -1;
581         }
582
583         if (input.name[0] == '\0')
584                 return -1;
585
586         return 0;
587 }
588
589 int exynos_v4l2_s_input(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
590         int id)
591 {
592         struct v4l2_input input;
593         int rc;
594
595         if (exynos_camera == NULL || id < 0)
596                 return -EINVAL;
597
598         input.index = id;
599
600         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_INPUT, &input);
601         if (rc < 0) {
602                 LOGE("%s: ioctl failed", __func__);
603                 return -1;
604         }
605
606         return 0;
607 }
608
609 int exynos_v4l2_g_ext_ctrls(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
610         struct v4l2_ext_control *control, int count)
611 {
612         struct v4l2_ext_controls controls;
613         int rc;
614
615         if (exynos_camera == NULL || control == NULL)
616                 return -EINVAL;
617
618         memset(&controls, 0, sizeof(controls));
619         controls.ctrl_class = V4L2_CTRL_CLASS_CAMERA;
620         controls.count = count;
621         controls.controls = control;
622
623         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_EXT_CTRLS, &controls);
624         if (rc < 0) {
625                 LOGE("%s: ioctl failed", __func__);
626                 return -1;
627         }
628
629         return 0;
630 }
631
632 int exynos_v4l2_g_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
633         int id, int *value)
634 {
635         struct v4l2_control control;
636         int rc;
637
638         if (exynos_camera == NULL)
639                 return -EINVAL;
640
641         control.id = id;
642
643         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_CTRL, &control);
644         if (rc < 0) {
645                 LOGE("%s: ioctl failed", __func__);
646                 return -1;
647         }
648
649         if (value != NULL)
650                 *value = control.value;
651
652         return 0;
653 }
654
655 int exynos_v4l2_s_ctrl(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
656         int id, int value)
657 {
658         struct v4l2_control control;
659         int rc;
660
661         if (exynos_camera == NULL)
662                 return -EINVAL;
663
664         control.id = id;
665         control.value = value;
666
667         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_CTRL, &control);
668         if (rc < 0) {
669                 LOGE("%s: ioctl failed", __func__);
670                 return -1;
671         }
672
673         return control.value;
674 }
675
676 int exynos_v4l2_s_parm(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
677         int type, struct v4l2_streamparm *streamparm)
678 {
679         int rc;
680
681         if (exynos_camera == NULL || streamparm == NULL)
682                 return -EINVAL;
683
684         streamparm->type = type;
685
686         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_PARM, streamparm);
687         if (rc < 0) {
688                 LOGE("%s: ioctl failed", __func__);
689                 return -1;
690         }
691
692         return 0;
693 }
694
695 int exynos_v4l2_s_parm_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
696         struct v4l2_streamparm *streamparm)
697 {
698         return exynos_v4l2_s_parm(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
699                 streamparm);
700 }
701
702 int exynos_v4l2_s_parm_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
703         struct v4l2_streamparm *streamparm)
704 {
705         return exynos_v4l2_s_parm(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
706                 streamparm);
707 }
708
709 int exynos_v4l2_s_crop(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
710         int type, int left, int top, int width, int height)
711 {
712         struct v4l2_crop crop;
713         int rc;
714
715         if (exynos_camera == NULL)
716                 return -EINVAL;
717
718         crop.type = type;
719         crop.c.left = left;
720         crop.c.top = top;
721         crop.c.width = width;
722         crop.c.height = height;
723
724         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_CROP, &crop);
725         if (rc < 0) {
726                 LOGE("%s: ioctl failed", __func__);
727                 return -1;
728         }
729
730         return 0;
731 }
732
733 int exynos_v4l2_s_crop_cap(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
734         int left, int top, int width, int height)
735 {
736         return exynos_v4l2_s_crop(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_CAPTURE,
737                 left, top, width, height);
738 }
739
740 int exynos_v4l2_s_crop_out(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
741         int left, int top, int width, int height)
742 {
743         return exynos_v4l2_s_crop(exynos_camera, exynos_v4l2_id, V4L2_BUF_TYPE_VIDEO_OUTPUT,
744                 left, top, width, height);
745 }
746
747 int exynos_v4l2_g_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
748         void **base, int *width, int *height, int *fmt)
749 {
750         struct v4l2_framebuffer framebuffer;
751         int rc;
752
753         if (exynos_camera == NULL)
754                 return -EINVAL;
755
756         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_G_FBUF, &framebuffer);
757         if (rc < 0) {
758                 LOGE("%s: ioctl failed", __func__);
759                 return -1;
760         }
761
762         if (base != NULL)
763                 *base = framebuffer.base;
764         if (width != NULL)
765                 *width = framebuffer.fmt.width;
766         if (height != NULL)
767                 *height = framebuffer.fmt.height;
768         if (fmt != NULL)
769                 *fmt = framebuffer.fmt.pixelformat;
770
771         return 0;
772 }
773
774 int exynos_v4l2_s_fbuf(struct exynos_camera *exynos_camera, int exynos_v4l2_id,
775         void *base, int width, int height, int fmt)
776 {
777         struct v4l2_framebuffer framebuffer;
778         int rc;
779
780         if (exynos_camera == NULL)
781                 return -EINVAL;
782
783         memset(&framebuffer, 0, sizeof(framebuffer));
784         framebuffer.base = base;
785         framebuffer.fmt.width = width;
786         framebuffer.fmt.height = height;
787         framebuffer.fmt.pixelformat = fmt;
788
789         rc = exynos_v4l2_ioctl(exynos_camera, exynos_v4l2_id, VIDIOC_S_FBUF, &framebuffer);
790         if (rc < 0) {
791                 LOGE("%s: ioctl failed", __func__);
792                 return -1;
793         }
794
795         return 0;
796 }