]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/video/s5p-fimc/fimc-capture.c
2f500809f53d9b418dd2d3117ce44ef7706d0287
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / s5p-fimc / fimc-capture.c
1 /*
2 * Samsung S5P SoC series camera interface (camera capture) driver
3 *
4 * Copyright (c) 2010 Samsung Electronics Co., Ltd
5 * Author: Sylwester Nawrocki, <s.nawrocki@samsung.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/version.h>
15 #include <linux/types.h>
16 #include <linux/errno.h>
17 #include <linux/bug.h>
18 #include <linux/interrupt.h>
19 #include <linux/device.h>
20 #include <linux/platform_device.h>
21 #include <linux/list.h>
22 #include <linux/slab.h>
23 #include <linux/clk.h>
24 #include <linux/i2c.h>
25
26 #include <linux/videodev2.h>
27 #include <media/v4l2-device.h>
28 #include <media/v4l2-ioctl.h>
29 #include <media/v4l2-mem2mem.h>
30 #include <media/videobuf-core.h>
31 #include <media/videobuf-dma-contig.h>
32
33 #include "fimc-core.h"
34
35 static struct v4l2_subdev *fimc_subdev_register(struct fimc_dev *fimc,
36 struct s3c_fimc_isp_info *isp_info)
37 {
38 struct i2c_adapter *i2c_adap;
39 struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
40 struct v4l2_subdev *sd = NULL;
41
42 i2c_adap = i2c_get_adapter(isp_info->i2c_bus_num);
43 if (!i2c_adap)
44 return ERR_PTR(-ENOMEM);
45
46 sd = v4l2_i2c_new_subdev_board(&vid_cap->v4l2_dev, i2c_adap,
47 isp_info->board_info, NULL);
48 if (!sd) {
49 v4l2_err(&vid_cap->v4l2_dev, "failed to acquire subdev\n");
50 return NULL;
51 }
52
53 v4l2_info(&vid_cap->v4l2_dev, "subdevice %s registered successfuly\n",
54 isp_info->board_info->type);
55
56 return sd;
57 }
58
59 static void fimc_subdev_unregister(struct fimc_dev *fimc)
60 {
61 struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
62 struct i2c_client *client;
63
64 if (vid_cap->input_index < 0)
65 return; /* Subdevice already released or not registered. */
66
67 if (vid_cap->sd) {
68 v4l2_device_unregister_subdev(vid_cap->sd);
69 client = v4l2_get_subdevdata(vid_cap->sd);
70 i2c_unregister_device(client);
71 i2c_put_adapter(client->adapter);
72 vid_cap->sd = NULL;
73 }
74
75 vid_cap->input_index = -1;
76 }
77
78 /**
79 * fimc_subdev_attach - attach v4l2_subdev to camera host interface
80 *
81 * @fimc: FIMC device information
82 * @index: index to the array of available subdevices,
83 * -1 for full array search or non negative value
84 * to select specific subdevice
85 */
86 static int fimc_subdev_attach(struct fimc_dev *fimc, int index)
87 {
88 struct fimc_vid_cap *vid_cap = &fimc->vid_cap;
89 struct s3c_platform_fimc *pdata = fimc->pdata;
90 struct s3c_fimc_isp_info *isp_info;
91 struct v4l2_subdev *sd;
92 int i;
93
94 for (i = 0; i < FIMC_MAX_CAMIF_CLIENTS; ++i) {
95 isp_info = pdata->isp_info[i];
96
97 if (!isp_info || (index >= 0 && i != index))
98 continue;
99
100 sd = fimc_subdev_register(fimc, isp_info);
101 if (sd) {
102 vid_cap->sd = sd;
103 vid_cap->input_index = i;
104
105 return 0;
106 }
107 }
108
109 vid_cap->input_index = -1;
110 vid_cap->sd = NULL;
111 v4l2_err(&vid_cap->v4l2_dev, "fimc%d: sensor attach failed\n",
112 fimc->id);
113 return -ENODEV;
114 }
115
116 static int fimc_isp_subdev_init(struct fimc_dev *fimc, int index)
117 {
118 struct s3c_fimc_isp_info *isp_info;
119 int ret;
120
121 ret = fimc_subdev_attach(fimc, index);
122 if (ret)
123 return ret;
124
125 isp_info = fimc->pdata->isp_info[fimc->vid_cap.input_index];
126 ret = fimc_hw_set_camera_polarity(fimc, isp_info);
127 if (!ret) {
128 ret = v4l2_subdev_call(fimc->vid_cap.sd, core,
129 s_power, 1);
130 if (!ret)
131 return ret;
132 }
133
134 fimc_subdev_unregister(fimc);
135 err("ISP initialization failed: %d", ret);
136 return ret;
137 }
138
139 /*
140 * At least one buffer on the pending_buf_q queue is required.
141 * Locking: The caller holds fimc->slock spinlock.
142 */
143 int fimc_vid_cap_buf_queue(struct fimc_dev *fimc,
144 struct fimc_vid_buffer *fimc_vb)
145 {
146 struct fimc_vid_cap *cap = &fimc->vid_cap;
147 struct fimc_ctx *ctx = cap->ctx;
148 int ret = 0;
149
150 BUG_ON(!fimc || !fimc_vb);
151
152 ret = fimc_prepare_addr(ctx, fimc_vb, &ctx->d_frame,
153 &fimc_vb->paddr);
154 if (ret)
155 return ret;
156
157 if (test_bit(ST_CAPT_STREAM, &fimc->state)) {
158 fimc_pending_queue_add(cap, fimc_vb);
159 } else {
160 /* Setup the buffer directly for processing. */
161 int buf_id = (cap->reqbufs_count == 1) ? -1 : cap->buf_index;
162 fimc_hw_set_output_addr(fimc, &fimc_vb->paddr, buf_id);
163
164 fimc_vb->index = cap->buf_index;
165 active_queue_add(cap, fimc_vb);
166
167 if (++cap->buf_index >= FIMC_MAX_OUT_BUFS)
168 cap->buf_index = 0;
169 }
170 return ret;
171 }
172
173 static int fimc_stop_capture(struct fimc_dev *fimc)
174 {
175 unsigned long flags;
176 struct fimc_vid_cap *cap;
177 int ret;
178
179 cap = &fimc->vid_cap;
180
181 if (!fimc_capture_active(fimc))
182 return 0;
183
184 spin_lock_irqsave(&fimc->slock, flags);
185 set_bit(ST_CAPT_SHUT, &fimc->state);
186 fimc_deactivate_capture(fimc);
187 spin_unlock_irqrestore(&fimc->slock, flags);
188
189 wait_event_timeout(fimc->irq_queue,
190 test_bit(ST_CAPT_SHUT, &fimc->state),
191 FIMC_SHUTDOWN_TIMEOUT);
192
193 ret = v4l2_subdev_call(cap->sd, video, s_stream, 0);
194 if (ret)
195 v4l2_err(&fimc->vid_cap.v4l2_dev, "s_stream(0) failed\n");
196
197 spin_lock_irqsave(&fimc->slock, flags);
198 fimc->state &= ~(1 << ST_CAPT_RUN | 1 << ST_CAPT_PEND |
199 1 << ST_CAPT_STREAM);
200
201 fimc->vid_cap.active_buf_cnt = 0;
202 spin_unlock_irqrestore(&fimc->slock, flags);
203
204 dbg("state: 0x%lx", fimc->state);
205 return 0;
206 }
207
208 static int fimc_capture_open(struct file *file)
209 {
210 struct fimc_dev *fimc = video_drvdata(file);
211 int ret = 0;
212
213 dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
214
215 /* Return if the corresponding video mem2mem node is already opened. */
216 if (fimc_m2m_active(fimc))
217 return -EBUSY;
218
219 if (mutex_lock_interruptible(&fimc->lock))
220 return -ERESTARTSYS;
221
222 if (++fimc->vid_cap.refcnt == 1) {
223 ret = fimc_isp_subdev_init(fimc, -1);
224 if (ret) {
225 fimc->vid_cap.refcnt--;
226 ret = -EIO;
227 }
228 }
229
230 file->private_data = fimc->vid_cap.ctx;
231
232 mutex_unlock(&fimc->lock);
233 return ret;
234 }
235
236 static int fimc_capture_close(struct file *file)
237 {
238 struct fimc_dev *fimc = video_drvdata(file);
239
240 if (mutex_lock_interruptible(&fimc->lock))
241 return -ERESTARTSYS;
242
243 dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
244
245 if (--fimc->vid_cap.refcnt == 0) {
246 fimc_stop_capture(fimc);
247
248 videobuf_stop(&fimc->vid_cap.vbq);
249 videobuf_mmap_free(&fimc->vid_cap.vbq);
250
251 v4l2_err(&fimc->vid_cap.v4l2_dev, "releasing ISP\n");
252 v4l2_subdev_call(fimc->vid_cap.sd, core, s_power, 0);
253 fimc_subdev_unregister(fimc);
254 }
255
256 mutex_unlock(&fimc->lock);
257 return 0;
258 }
259
260 static unsigned int fimc_capture_poll(struct file *file,
261 struct poll_table_struct *wait)
262 {
263 struct fimc_ctx *ctx = file->private_data;
264 struct fimc_dev *fimc = ctx->fimc_dev;
265 struct fimc_vid_cap *cap = &fimc->vid_cap;
266 int ret;
267
268 if (mutex_lock_interruptible(&fimc->lock))
269 return POLLERR;
270
271 ret = videobuf_poll_stream(file, &cap->vbq, wait);
272 mutex_unlock(&fimc->lock);
273
274 return ret;
275 }
276
277 static int fimc_capture_mmap(struct file *file, struct vm_area_struct *vma)
278 {
279 struct fimc_ctx *ctx = file->private_data;
280 struct fimc_dev *fimc = ctx->fimc_dev;
281 struct fimc_vid_cap *cap = &fimc->vid_cap;
282 int ret;
283
284 if (mutex_lock_interruptible(&fimc->lock))
285 return -ERESTARTSYS;
286
287 ret = videobuf_mmap_mapper(&cap->vbq, vma);
288 mutex_unlock(&fimc->lock);
289
290 return ret;
291 }
292
293 /* video device file operations */
294 static const struct v4l2_file_operations fimc_capture_fops = {
295 .owner = THIS_MODULE,
296 .open = fimc_capture_open,
297 .release = fimc_capture_close,
298 .poll = fimc_capture_poll,
299 .unlocked_ioctl = video_ioctl2,
300 .mmap = fimc_capture_mmap,
301 };
302
303 static int fimc_vidioc_querycap_capture(struct file *file, void *priv,
304 struct v4l2_capability *cap)
305 {
306 struct fimc_ctx *ctx = file->private_data;
307 struct fimc_dev *fimc = ctx->fimc_dev;
308
309 strncpy(cap->driver, fimc->pdev->name, sizeof(cap->driver) - 1);
310 strncpy(cap->card, fimc->pdev->name, sizeof(cap->card) - 1);
311 cap->bus_info[0] = 0;
312 cap->version = KERNEL_VERSION(1, 0, 0);
313 cap->capabilities = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_CAPTURE;
314
315 return 0;
316 }
317
318 /* Synchronize formats of the camera interface input and attached sensor. */
319 static int sync_capture_fmt(struct fimc_ctx *ctx)
320 {
321 struct fimc_frame *frame = &ctx->s_frame;
322 struct fimc_dev *fimc = ctx->fimc_dev;
323 struct v4l2_mbus_framefmt *fmt = &fimc->vid_cap.fmt;
324 int ret;
325
326 fmt->width = ctx->d_frame.o_width;
327 fmt->height = ctx->d_frame.o_height;
328
329 ret = v4l2_subdev_call(fimc->vid_cap.sd, video, s_mbus_fmt, fmt);
330 if (ret == -ENOIOCTLCMD) {
331 err("s_mbus_fmt failed");
332 return ret;
333 }
334 dbg("w: %d, h: %d, code= %d", fmt->width, fmt->height, fmt->code);
335
336 frame->fmt = find_mbus_format(fmt, FMT_FLAGS_CAM);
337 if (!frame->fmt) {
338 err("fimc source format not found\n");
339 return -EINVAL;
340 }
341
342 frame->f_width = fmt->width;
343 frame->f_height = fmt->height;
344 frame->width = fmt->width;
345 frame->height = fmt->height;
346 frame->o_width = fmt->width;
347 frame->o_height = fmt->height;
348 frame->offs_h = 0;
349 frame->offs_v = 0;
350
351 return 0;
352 }
353
354 static int fimc_cap_s_fmt(struct file *file, void *priv,
355 struct v4l2_format *f)
356 {
357 struct fimc_ctx *ctx = priv;
358 struct fimc_dev *fimc = ctx->fimc_dev;
359 struct fimc_frame *frame;
360 struct v4l2_pix_format *pix;
361 int ret;
362
363 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
364 return -EINVAL;
365
366 ret = fimc_vidioc_try_fmt(file, priv, f);
367 if (ret)
368 return ret;
369
370 if (mutex_lock_interruptible(&fimc->lock))
371 return -ERESTARTSYS;
372
373 if (fimc_capture_active(fimc)) {
374 ret = -EBUSY;
375 goto sf_unlock;
376 }
377
378 frame = &ctx->d_frame;
379
380 pix = &f->fmt.pix;
381 frame->fmt = find_format(f, FMT_FLAGS_M2M | FMT_FLAGS_CAM);
382 if (!frame->fmt) {
383 err("fimc target format not found\n");
384 ret = -EINVAL;
385 goto sf_unlock;
386 }
387
388 /* Output DMA frame pixel size and offsets. */
389 frame->f_width = pix->bytesperline * 8 / frame->fmt->depth;
390 frame->f_height = pix->height;
391 frame->width = pix->width;
392 frame->height = pix->height;
393 frame->o_width = pix->width;
394 frame->o_height = pix->height;
395 frame->size = (pix->width * pix->height * frame->fmt->depth) >> 3;
396 frame->offs_h = 0;
397 frame->offs_v = 0;
398
399 ret = sync_capture_fmt(ctx);
400
401 ctx->state |= (FIMC_PARAMS | FIMC_DST_FMT);
402
403 sf_unlock:
404 mutex_unlock(&fimc->lock);
405 return ret;
406 }
407
408 static int fimc_cap_enum_input(struct file *file, void *priv,
409 struct v4l2_input *i)
410 {
411 struct fimc_ctx *ctx = priv;
412 struct s3c_platform_fimc *pldata = ctx->fimc_dev->pdata;
413 struct s3c_fimc_isp_info *isp_info;
414
415 if (i->index >= FIMC_MAX_CAMIF_CLIENTS)
416 return -EINVAL;
417
418 isp_info = pldata->isp_info[i->index];
419 if (isp_info == NULL)
420 return -EINVAL;
421
422 i->type = V4L2_INPUT_TYPE_CAMERA;
423 strncpy(i->name, isp_info->board_info->type, 32);
424 return 0;
425 }
426
427 static int fimc_cap_s_input(struct file *file, void *priv,
428 unsigned int i)
429 {
430 struct fimc_ctx *ctx = priv;
431 struct fimc_dev *fimc = ctx->fimc_dev;
432 struct s3c_platform_fimc *pdata = fimc->pdata;
433 int ret;
434
435 if (fimc_capture_active(ctx->fimc_dev))
436 return -EBUSY;
437
438 if (mutex_lock_interruptible(&fimc->lock))
439 return -ERESTARTSYS;
440
441 if (i >= FIMC_MAX_CAMIF_CLIENTS || !pdata->isp_info[i]) {
442 ret = -EINVAL;
443 goto si_unlock;
444 }
445
446 if (fimc->vid_cap.sd) {
447 ret = v4l2_subdev_call(fimc->vid_cap.sd, core, s_power, 0);
448 if (ret)
449 err("s_power failed: %d", ret);
450 }
451
452 /* Release the attached sensor subdevice. */
453 fimc_subdev_unregister(fimc);
454
455 ret = fimc_isp_subdev_init(fimc, i);
456
457 si_unlock:
458 mutex_unlock(&fimc->lock);
459 return ret;
460 }
461
462 static int fimc_cap_g_input(struct file *file, void *priv,
463 unsigned int *i)
464 {
465 struct fimc_ctx *ctx = priv;
466 struct fimc_vid_cap *cap = &ctx->fimc_dev->vid_cap;
467
468 *i = cap->input_index;
469 return 0;
470 }
471
472 static int fimc_cap_streamon(struct file *file, void *priv,
473 enum v4l2_buf_type type)
474 {
475 struct s3c_fimc_isp_info *isp_info;
476 struct fimc_ctx *ctx = priv;
477 struct fimc_dev *fimc = ctx->fimc_dev;
478 int ret = -EBUSY;
479
480 if (mutex_lock_interruptible(&fimc->lock))
481 return -ERESTARTSYS;
482
483 if (fimc_capture_active(fimc) || !fimc->vid_cap.sd)
484 goto s_unlock;
485
486 if (!(ctx->state & FIMC_DST_FMT)) {
487 v4l2_err(&fimc->vid_cap.v4l2_dev, "Format is not set\n");
488 ret = -EINVAL;
489 goto s_unlock;
490 }
491
492 ret = v4l2_subdev_call(fimc->vid_cap.sd, video, s_stream, 1);
493 if (ret && ret != -ENOIOCTLCMD)
494 goto s_unlock;
495
496 ret = fimc_prepare_config(ctx, ctx->state);
497 if (ret)
498 goto s_unlock;
499
500 isp_info = fimc->pdata->isp_info[fimc->vid_cap.input_index];
501 fimc_hw_set_camera_type(fimc, isp_info);
502 fimc_hw_set_camera_source(fimc, isp_info);
503 fimc_hw_set_camera_offset(fimc, &ctx->s_frame);
504
505 if (ctx->state & FIMC_PARAMS) {
506 ret = fimc_set_scaler_info(ctx);
507 if (ret) {
508 err("Scaler setup error");
509 goto s_unlock;
510 }
511 fimc_hw_set_input_path(ctx);
512 fimc_hw_set_scaler(ctx);
513 fimc_hw_set_target_format(ctx);
514 fimc_hw_set_rotation(ctx);
515 fimc_hw_set_effect(ctx);
516 }
517
518 fimc_hw_set_output_path(ctx);
519 fimc_hw_set_out_dma(ctx);
520
521 INIT_LIST_HEAD(&fimc->vid_cap.pending_buf_q);
522 INIT_LIST_HEAD(&fimc->vid_cap.active_buf_q);
523 fimc->vid_cap.active_buf_cnt = 0;
524 fimc->vid_cap.frame_count = 0;
525 fimc->vid_cap.buf_index = fimc_hw_get_frame_index(fimc);
526
527 set_bit(ST_CAPT_PEND, &fimc->state);
528 ret = videobuf_streamon(&fimc->vid_cap.vbq);
529
530 s_unlock:
531 mutex_unlock(&fimc->lock);
532 return ret;
533 }
534
535 static int fimc_cap_streamoff(struct file *file, void *priv,
536 enum v4l2_buf_type type)
537 {
538 struct fimc_ctx *ctx = priv;
539 struct fimc_dev *fimc = ctx->fimc_dev;
540 struct fimc_vid_cap *cap = &fimc->vid_cap;
541 unsigned long flags;
542 int ret;
543
544 spin_lock_irqsave(&fimc->slock, flags);
545 if (!fimc_capture_running(fimc) && !fimc_capture_pending(fimc)) {
546 spin_unlock_irqrestore(&fimc->slock, flags);
547 dbg("state: 0x%lx", fimc->state);
548 return -EINVAL;
549 }
550 spin_unlock_irqrestore(&fimc->slock, flags);
551
552 if (mutex_lock_interruptible(&fimc->lock))
553 return -ERESTARTSYS;
554
555 fimc_stop_capture(fimc);
556 ret = videobuf_streamoff(&cap->vbq);
557 mutex_unlock(&fimc->lock);
558 return ret;
559 }
560
561 static int fimc_cap_reqbufs(struct file *file, void *priv,
562 struct v4l2_requestbuffers *reqbufs)
563 {
564 struct fimc_ctx *ctx = priv;
565 struct fimc_dev *fimc = ctx->fimc_dev;
566 struct fimc_vid_cap *cap = &fimc->vid_cap;
567 int ret;
568
569 if (fimc_capture_active(ctx->fimc_dev))
570 return -EBUSY;
571
572 if (mutex_lock_interruptible(&fimc->lock))
573 return -ERESTARTSYS;
574
575 ret = videobuf_reqbufs(&cap->vbq, reqbufs);
576 if (!ret)
577 cap->reqbufs_count = reqbufs->count;
578
579 mutex_unlock(&fimc->lock);
580 return ret;
581 }
582
583 static int fimc_cap_querybuf(struct file *file, void *priv,
584 struct v4l2_buffer *buf)
585 {
586 struct fimc_ctx *ctx = priv;
587 struct fimc_vid_cap *cap = &ctx->fimc_dev->vid_cap;
588
589 if (fimc_capture_active(ctx->fimc_dev))
590 return -EBUSY;
591
592 return videobuf_querybuf(&cap->vbq, buf);
593 }
594
595 static int fimc_cap_qbuf(struct file *file, void *priv,
596 struct v4l2_buffer *buf)
597 {
598 struct fimc_ctx *ctx = priv;
599 struct fimc_dev *fimc = ctx->fimc_dev;
600 struct fimc_vid_cap *cap = &fimc->vid_cap;
601 int ret;
602
603 if (mutex_lock_interruptible(&fimc->lock))
604 return -ERESTARTSYS;
605
606 ret = videobuf_qbuf(&cap->vbq, buf);
607
608 mutex_unlock(&fimc->lock);
609 return ret;
610 }
611
612 static int fimc_cap_dqbuf(struct file *file, void *priv,
613 struct v4l2_buffer *buf)
614 {
615 struct fimc_ctx *ctx = priv;
616 int ret;
617
618 if (mutex_lock_interruptible(&ctx->fimc_dev->lock))
619 return -ERESTARTSYS;
620
621 ret = videobuf_dqbuf(&ctx->fimc_dev->vid_cap.vbq, buf,
622 file->f_flags & O_NONBLOCK);
623
624 mutex_unlock(&ctx->fimc_dev->lock);
625 return ret;
626 }
627
628 static int fimc_cap_s_ctrl(struct file *file, void *priv,
629 struct v4l2_control *ctrl)
630 {
631 struct fimc_ctx *ctx = priv;
632 int ret = -EINVAL;
633
634 if (mutex_lock_interruptible(&ctx->fimc_dev->lock))
635 return -ERESTARTSYS;
636
637 /* Allow any controls but 90/270 rotation while streaming */
638 if (!fimc_capture_active(ctx->fimc_dev) ||
639 ctrl->id != V4L2_CID_ROTATE ||
640 (ctrl->value != 90 && ctrl->value != 270)) {
641 ret = check_ctrl_val(ctx, ctrl);
642 if (!ret) {
643 ret = fimc_s_ctrl(ctx, ctrl);
644 if (!ret)
645 ctx->state |= FIMC_PARAMS;
646 }
647 }
648 if (ret == -EINVAL)
649 ret = v4l2_subdev_call(ctx->fimc_dev->vid_cap.sd,
650 core, s_ctrl, ctrl);
651
652 mutex_unlock(&ctx->fimc_dev->lock);
653 return ret;
654 }
655
656 static int fimc_cap_cropcap(struct file *file, void *fh,
657 struct v4l2_cropcap *cr)
658 {
659 struct fimc_frame *f;
660 struct fimc_ctx *ctx = fh;
661 struct fimc_dev *fimc = ctx->fimc_dev;
662
663 if (cr->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
664 return -EINVAL;
665
666 if (mutex_lock_interruptible(&fimc->lock))
667 return -ERESTARTSYS;
668
669 f = &ctx->s_frame;
670 cr->bounds.left = 0;
671 cr->bounds.top = 0;
672 cr->bounds.width = f->o_width;
673 cr->bounds.height = f->o_height;
674 cr->defrect = cr->bounds;
675
676 mutex_unlock(&fimc->lock);
677 return 0;
678 }
679
680 static int fimc_cap_g_crop(struct file *file, void *fh, struct v4l2_crop *cr)
681 {
682 struct fimc_frame *f;
683 struct fimc_ctx *ctx = file->private_data;
684 struct fimc_dev *fimc = ctx->fimc_dev;
685
686
687 if (mutex_lock_interruptible(&fimc->lock))
688 return -ERESTARTSYS;
689
690 f = &ctx->s_frame;
691 cr->c.left = f->offs_h;
692 cr->c.top = f->offs_v;
693 cr->c.width = f->width;
694 cr->c.height = f->height;
695
696 mutex_unlock(&fimc->lock);
697 return 0;
698 }
699
700 static int fimc_cap_s_crop(struct file *file, void *fh,
701 struct v4l2_crop *cr)
702 {
703 struct fimc_frame *f;
704 struct fimc_ctx *ctx = file->private_data;
705 struct fimc_dev *fimc = ctx->fimc_dev;
706 int ret = -EINVAL;
707
708 if (fimc_capture_active(fimc))
709 return -EBUSY;
710
711 ret = fimc_try_crop(ctx, cr);
712 if (ret)
713 return ret;
714
715 if (mutex_lock_interruptible(&fimc->lock))
716 return -ERESTARTSYS;
717
718 if (!(ctx->state & FIMC_DST_FMT)) {
719 v4l2_err(&fimc->vid_cap.v4l2_dev,
720 "Capture color format not set\n");
721 goto sc_unlock;
722 }
723
724 f = &ctx->s_frame;
725 /* Check for the pixel scaling ratio when cropping input image. */
726 ret = fimc_check_scaler_ratio(&cr->c, &ctx->d_frame);
727 if (ret) {
728 v4l2_err(&fimc->vid_cap.v4l2_dev, "Out of the scaler range");
729 } else {
730 ret = 0;
731 f->offs_h = cr->c.left;
732 f->offs_v = cr->c.top;
733 f->width = cr->c.width;
734 f->height = cr->c.height;
735 }
736
737 sc_unlock:
738 mutex_unlock(&fimc->lock);
739 return ret;
740 }
741
742
743 static const struct v4l2_ioctl_ops fimc_capture_ioctl_ops = {
744 .vidioc_querycap = fimc_vidioc_querycap_capture,
745
746 .vidioc_enum_fmt_vid_cap = fimc_vidioc_enum_fmt,
747 .vidioc_try_fmt_vid_cap = fimc_vidioc_try_fmt,
748 .vidioc_s_fmt_vid_cap = fimc_cap_s_fmt,
749 .vidioc_g_fmt_vid_cap = fimc_vidioc_g_fmt,
750
751 .vidioc_reqbufs = fimc_cap_reqbufs,
752 .vidioc_querybuf = fimc_cap_querybuf,
753
754 .vidioc_qbuf = fimc_cap_qbuf,
755 .vidioc_dqbuf = fimc_cap_dqbuf,
756
757 .vidioc_streamon = fimc_cap_streamon,
758 .vidioc_streamoff = fimc_cap_streamoff,
759
760 .vidioc_queryctrl = fimc_vidioc_queryctrl,
761 .vidioc_g_ctrl = fimc_vidioc_g_ctrl,
762 .vidioc_s_ctrl = fimc_cap_s_ctrl,
763
764 .vidioc_g_crop = fimc_cap_g_crop,
765 .vidioc_s_crop = fimc_cap_s_crop,
766 .vidioc_cropcap = fimc_cap_cropcap,
767
768 .vidioc_enum_input = fimc_cap_enum_input,
769 .vidioc_s_input = fimc_cap_s_input,
770 .vidioc_g_input = fimc_cap_g_input,
771 };
772
773 int fimc_register_capture_device(struct fimc_dev *fimc)
774 {
775 struct v4l2_device *v4l2_dev = &fimc->vid_cap.v4l2_dev;
776 struct video_device *vfd;
777 struct fimc_vid_cap *vid_cap;
778 struct fimc_ctx *ctx;
779 struct v4l2_format f;
780 int ret;
781
782 ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
783 if (!ctx)
784 return -ENOMEM;
785
786 ctx->fimc_dev = fimc;
787 ctx->in_path = FIMC_CAMERA;
788 ctx->out_path = FIMC_DMA;
789 ctx->state = FIMC_CTX_CAP;
790
791 f.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB24;
792 ctx->d_frame.fmt = find_format(&f, FMT_FLAGS_M2M);
793
794 if (!v4l2_dev->name[0])
795 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
796 "%s.capture", dev_name(&fimc->pdev->dev));
797
798 ret = v4l2_device_register(NULL, v4l2_dev);
799 if (ret)
800 goto err_info;
801
802 vfd = video_device_alloc();
803 if (!vfd) {
804 v4l2_err(v4l2_dev, "Failed to allocate video device\n");
805 goto err_v4l2_reg;
806 }
807
808 snprintf(vfd->name, sizeof(vfd->name), "%s:cap",
809 dev_name(&fimc->pdev->dev));
810
811 vfd->fops = &fimc_capture_fops;
812 vfd->ioctl_ops = &fimc_capture_ioctl_ops;
813 vfd->minor = -1;
814 vfd->release = video_device_release;
815 video_set_drvdata(vfd, fimc);
816
817 vid_cap = &fimc->vid_cap;
818 vid_cap->vfd = vfd;
819 vid_cap->active_buf_cnt = 0;
820 vid_cap->reqbufs_count = 0;
821 vid_cap->refcnt = 0;
822 /* The default color format for image sensor. */
823 vid_cap->fmt.code = V4L2_MBUS_FMT_YUYV8_2X8;
824
825 INIT_LIST_HEAD(&vid_cap->pending_buf_q);
826 INIT_LIST_HEAD(&vid_cap->active_buf_q);
827 spin_lock_init(&ctx->slock);
828 vid_cap->ctx = ctx;
829
830 videobuf_queue_dma_contig_init(&vid_cap->vbq, &fimc_qops,
831 vid_cap->v4l2_dev.dev, &fimc->irqlock,
832 V4L2_BUF_TYPE_VIDEO_CAPTURE, V4L2_FIELD_NONE,
833 sizeof(struct fimc_vid_buffer), (void *)ctx, NULL);
834
835 ret = video_register_device(vfd, VFL_TYPE_GRABBER, -1);
836 if (ret) {
837 v4l2_err(v4l2_dev, "Failed to register video device\n");
838 goto err_vd_reg;
839 }
840
841 v4l2_info(v4l2_dev,
842 "FIMC capture driver registered as /dev/video%d\n",
843 vfd->num);
844
845 return 0;
846
847 err_vd_reg:
848 video_device_release(vfd);
849 err_v4l2_reg:
850 v4l2_device_unregister(v4l2_dev);
851 err_info:
852 dev_err(&fimc->pdev->dev, "failed to install\n");
853 return ret;
854 }
855
856 void fimc_unregister_capture_device(struct fimc_dev *fimc)
857 {
858 struct fimc_vid_cap *capture = &fimc->vid_cap;
859
860 if (capture->vfd)
861 video_unregister_device(capture->vfd);
862
863 kfree(capture->ctx);
864 }