1// SPDX-License-Identifier: GPL-2.0
2/*
3 * The Marvell camera core. This device appears in a number of settings,
4 * so it needs platform-specific support outside of the core.
5 *
6 * Copyright 2011 Jonathan Corbet corbet@lwn.net
7 * Copyright 2018 Lubomir Rintel <lkundrak@v3.sk>
8 */
9#include <linux/kernel.h>
10#include <linux/module.h>
11#include <linux/fs.h>
12#include <linux/mm.h>
13#include <linux/i2c.h>
14#include <linux/interrupt.h>
15#include <linux/spinlock.h>
16#include <linux/slab.h>
17#include <linux/device.h>
18#include <linux/wait.h>
19#include <linux/list.h>
20#include <linux/dma-mapping.h>
21#include <linux/delay.h>
22#include <linux/vmalloc.h>
23#include <linux/io.h>
24#include <linux/clk.h>
25#include <linux/clk-provider.h>
26#include <linux/videodev2.h>
27#include <linux/pm_runtime.h>
28#include <media/v4l2-device.h>
29#include <media/v4l2-ioctl.h>
30#include <media/v4l2-ctrls.h>
31#include <media/v4l2-event.h>
32#include <media/videobuf2-vmalloc.h>
33#include <media/videobuf2-dma-contig.h>
34#include <media/videobuf2-dma-sg.h>
35
36#include "mcam-core.h"
37
38#ifdef MCAM_MODE_VMALLOC
39/*
40 * Internal DMA buffer management. Since the controller cannot do S/G I/O,
41 * we must have physically contiguous buffers to bring frames into.
42 * These parameters control how many buffers we use, whether we
43 * allocate them at load time (better chance of success, but nails down
44 * memory) or when somebody tries to use the camera (riskier), and,
45 * for load-time allocation, how big they should be.
46 *
47 * The controller can cycle through three buffers. We could use
48 * more by flipping pointers around, but it probably makes little
49 * sense.
50 */
51
52static bool alloc_bufs_at_read;
53module_param(alloc_bufs_at_read, bool, 0444);
54MODULE_PARM_DESC(alloc_bufs_at_read,
55 "Non-zero value causes DMA buffers to be allocated when the video capture device is read, rather than at module load time. This saves memory, but decreases the chances of successfully getting those buffers. This parameter is only used in the vmalloc buffer mode");
56
57static int n_dma_bufs = 3;
58module_param(n_dma_bufs, uint, 0644);
59MODULE_PARM_DESC(n_dma_bufs,
60 "The number of DMA buffers to allocate. Can be either two (saves memory, makes timing tighter) or three.");
61
62static int dma_buf_size = VGA_WIDTH * VGA_HEIGHT * 2; /* Worst case */
63module_param(dma_buf_size, uint, 0444);
64MODULE_PARM_DESC(dma_buf_size,
65 "The size of the allocated DMA buffers. If actual operating parameters require larger buffers, an attempt to reallocate will be made.");
66#else /* MCAM_MODE_VMALLOC */
67static const bool alloc_bufs_at_read;
68static const int n_dma_bufs = 3; /* Used by S/G_PARM */
69#endif /* MCAM_MODE_VMALLOC */
70
71static bool flip;
72module_param(flip, bool, 0444);
73MODULE_PARM_DESC(flip,
74 "If set, the sensor will be instructed to flip the image vertically.");
75
76static int buffer_mode = -1;
77module_param(buffer_mode, int, 0444);
78MODULE_PARM_DESC(buffer_mode,
79 "Set the buffer mode to be used; default is to go with what the platform driver asks for. Set to 0 for vmalloc, 1 for DMA contiguous.");
80
81/*
82 * Status flags. Always manipulated with bit operations.
83 */
84#define CF_BUF0_VALID 0 /* Buffers valid - first three */
85#define CF_BUF1_VALID 1
86#define CF_BUF2_VALID 2
87#define CF_DMA_ACTIVE 3 /* A frame is incoming */
88#define CF_CONFIG_NEEDED 4 /* Must configure hardware */
89#define CF_SINGLE_BUFFER 5 /* Running with a single buffer */
90#define CF_SG_RESTART 6 /* SG restart needed */
91#define CF_FRAME_SOF0 7 /* Frame 0 started */
92#define CF_FRAME_SOF1 8
93#define CF_FRAME_SOF2 9
94
95#define sensor_call(cam, o, f, args...) \
96 v4l2_subdev_call(cam->sensor, o, f, ##args)
97
98#define notifier_to_mcam(notifier) \
99 container_of(notifier, struct mcam_camera, notifier)
100
101static struct mcam_format_struct {
102 __u32 pixelformat;
103 int bpp; /* Bytes per pixel */
104 bool planar;
105 u32 mbus_code;
106} mcam_formats[] = {
107 {
108 .pixelformat = V4L2_PIX_FMT_YUYV,
109 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
110 .bpp = 2,
111 .planar = false,
112 },
113 {
114 .pixelformat = V4L2_PIX_FMT_YVYU,
115 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
116 .bpp = 2,
117 .planar = false,
118 },
119 {
120 .pixelformat = V4L2_PIX_FMT_YUV420,
121 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
122 .bpp = 1,
123 .planar = true,
124 },
125 {
126 .pixelformat = V4L2_PIX_FMT_YVU420,
127 .mbus_code = MEDIA_BUS_FMT_YUYV8_2X8,
128 .bpp = 1,
129 .planar = true,
130 },
131 {
132 .pixelformat = V4L2_PIX_FMT_XRGB444,
133 .mbus_code = MEDIA_BUS_FMT_RGB444_2X8_PADHI_LE,
134 .bpp = 2,
135 .planar = false,
136 },
137 {
138 .pixelformat = V4L2_PIX_FMT_RGB565,
139 .mbus_code = MEDIA_BUS_FMT_RGB565_2X8_LE,
140 .bpp = 2,
141 .planar = false,
142 },
143 {
144 .pixelformat = V4L2_PIX_FMT_SBGGR8,
145 .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8,
146 .bpp = 1,
147 .planar = false,
148 },
149};
150#define N_MCAM_FMTS ARRAY_SIZE(mcam_formats)
151
152static struct mcam_format_struct *mcam_find_format(u32 pixelformat)
153{
154 unsigned i;
155
156 for (i = 0; i < N_MCAM_FMTS; i++)
157 if (mcam_formats[i].pixelformat == pixelformat)
158 return mcam_formats + i;
159 /* Not found? Then return the first format. */
160 return mcam_formats;
161}
162
163/*
164 * The default format we use until somebody says otherwise.
165 */
166static const struct v4l2_pix_format mcam_def_pix_format = {
167 .width = VGA_WIDTH,
168 .height = VGA_HEIGHT,
169 .pixelformat = V4L2_PIX_FMT_YUYV,
170 .field = V4L2_FIELD_NONE,
171 .bytesperline = VGA_WIDTH*2,
172 .sizeimage = VGA_WIDTH*VGA_HEIGHT*2,
173 .colorspace = V4L2_COLORSPACE_SRGB,
174};
175
176static const u32 mcam_def_mbus_code = MEDIA_BUS_FMT_YUYV8_2X8;
177
178
179/*
180 * The two-word DMA descriptor format used by the Armada 610 and like. There
181 * Is a three-word format as well (set C1_DESC_3WORD) where the third
182 * word is a pointer to the next descriptor, but we don't use it. Two-word
183 * descriptors have to be contiguous in memory.
184 */
185struct mcam_dma_desc {
186 u32 dma_addr;
187 u32 segment_len;
188};
189
190/*
191 * Our buffer type for working with videobuf2. Note that the vb2
192 * developers have decreed that struct vb2_v4l2_buffer must be at the
193 * beginning of this structure.
194 */
195struct mcam_vb_buffer {
196 struct vb2_v4l2_buffer vb_buf;
197 struct list_head queue;
198 struct mcam_dma_desc *dma_desc; /* Descriptor virtual address */
199 dma_addr_t dma_desc_pa; /* Descriptor physical address */
200};
201
202static inline struct mcam_vb_buffer *vb_to_mvb(struct vb2_v4l2_buffer *vb)
203{
204 return container_of(vb, struct mcam_vb_buffer, vb_buf);
205}
206
207/*
208 * Hand a completed buffer back to user space.
209 */
210static void mcam_buffer_done(struct mcam_camera *cam, int frame,
211 struct vb2_v4l2_buffer *vbuf)
212{
213 vbuf->vb2_buf.planes[0].bytesused = cam->pix_format.sizeimage;
214 vbuf->sequence = cam->buf_seq[frame];
215 vbuf->field = V4L2_FIELD_NONE;
216 vbuf->vb2_buf.timestamp = ktime_get_ns();
217 vb2_set_plane_payload(vb: &vbuf->vb2_buf, plane_no: 0, size: cam->pix_format.sizeimage);
218 vb2_buffer_done(vb: &vbuf->vb2_buf, state: VB2_BUF_STATE_DONE);
219}
220
221
222
223/*
224 * Debugging and related.
225 */
226#define cam_err(cam, fmt, arg...) \
227 dev_err((cam)->dev, fmt, ##arg);
228#define cam_warn(cam, fmt, arg...) \
229 dev_warn((cam)->dev, fmt, ##arg);
230#define cam_dbg(cam, fmt, arg...) \
231 dev_dbg((cam)->dev, fmt, ##arg);
232
233
234/*
235 * Flag manipulation helpers
236 */
237static void mcam_reset_buffers(struct mcam_camera *cam)
238{
239 int i;
240
241 cam->next_buf = -1;
242 for (i = 0; i < cam->nbufs; i++) {
243 clear_bit(nr: i, addr: &cam->flags);
244 clear_bit(CF_FRAME_SOF0 + i, addr: &cam->flags);
245 }
246}
247
248static inline int mcam_needs_config(struct mcam_camera *cam)
249{
250 return test_bit(CF_CONFIG_NEEDED, &cam->flags);
251}
252
253static void mcam_set_config_needed(struct mcam_camera *cam, int needed)
254{
255 if (needed)
256 set_bit(CF_CONFIG_NEEDED, addr: &cam->flags);
257 else
258 clear_bit(CF_CONFIG_NEEDED, addr: &cam->flags);
259}
260
261/* ------------------------------------------------------------------- */
262/*
263 * Make the controller start grabbing images. Everything must
264 * be set up before doing this.
265 */
266static void mcam_ctlr_start(struct mcam_camera *cam)
267{
268 /* set_bit performs a read, so no other barrier should be
269 needed here */
270 mcam_reg_set_bit(cam, REG_CTRL0, C0_ENABLE);
271}
272
273static void mcam_ctlr_stop(struct mcam_camera *cam)
274{
275 mcam_reg_clear_bit(cam, REG_CTRL0, C0_ENABLE);
276}
277
278static void mcam_enable_mipi(struct mcam_camera *mcam)
279{
280 /* Using MIPI mode and enable MIPI */
281 if (mcam->calc_dphy)
282 mcam->calc_dphy(mcam);
283 cam_dbg(mcam, "camera: DPHY3=0x%x, DPHY5=0x%x, DPHY6=0x%x\n",
284 mcam->dphy[0], mcam->dphy[1], mcam->dphy[2]);
285 mcam_reg_write(cam: mcam, REG_CSI2_DPHY3, val: mcam->dphy[0]);
286 mcam_reg_write(cam: mcam, REG_CSI2_DPHY5, val: mcam->dphy[1]);
287 mcam_reg_write(cam: mcam, REG_CSI2_DPHY6, val: mcam->dphy[2]);
288
289 if (!mcam->mipi_enabled) {
290 if (mcam->lane > 4 || mcam->lane <= 0) {
291 cam_warn(mcam, "lane number error\n");
292 mcam->lane = 1; /* set the default value */
293 }
294 /*
295 * 0x41 actives 1 lane
296 * 0x43 actives 2 lanes
297 * 0x45 actives 3 lanes (never happen)
298 * 0x47 actives 4 lanes
299 */
300 mcam_reg_write(cam: mcam, REG_CSI2_CTRL0,
301 CSI2_C0_MIPI_EN | CSI2_C0_ACT_LANE(mcam->lane));
302 mcam->mipi_enabled = true;
303 }
304}
305
306static void mcam_disable_mipi(struct mcam_camera *mcam)
307{
308 /* Using Parallel mode or disable MIPI */
309 mcam_reg_write(cam: mcam, REG_CSI2_CTRL0, val: 0x0);
310 mcam_reg_write(cam: mcam, REG_CSI2_DPHY3, val: 0x0);
311 mcam_reg_write(cam: mcam, REG_CSI2_DPHY5, val: 0x0);
312 mcam_reg_write(cam: mcam, REG_CSI2_DPHY6, val: 0x0);
313 mcam->mipi_enabled = false;
314}
315
316static bool mcam_fmt_is_planar(__u32 pfmt)
317{
318 struct mcam_format_struct *f;
319
320 f = mcam_find_format(pixelformat: pfmt);
321 return f->planar;
322}
323
324static void mcam_write_yuv_bases(struct mcam_camera *cam,
325 unsigned frame, dma_addr_t base)
326{
327 struct v4l2_pix_format *fmt = &cam->pix_format;
328 u32 pixel_count = fmt->width * fmt->height;
329 dma_addr_t y, u = 0, v = 0;
330
331 y = base;
332
333 switch (fmt->pixelformat) {
334 case V4L2_PIX_FMT_YUV420:
335 u = y + pixel_count;
336 v = u + pixel_count / 4;
337 break;
338 case V4L2_PIX_FMT_YVU420:
339 v = y + pixel_count;
340 u = v + pixel_count / 4;
341 break;
342 default:
343 break;
344 }
345
346 mcam_reg_write(cam, REG_Y0BAR + frame * 4, val: y);
347 if (mcam_fmt_is_planar(pfmt: fmt->pixelformat)) {
348 mcam_reg_write(cam, REG_U0BAR + frame * 4, val: u);
349 mcam_reg_write(cam, REG_V0BAR + frame * 4, val: v);
350 }
351}
352
353/* ------------------------------------------------------------------- */
354
355#ifdef MCAM_MODE_VMALLOC
356/*
357 * Code specific to the vmalloc buffer mode.
358 */
359
360/*
361 * Allocate in-kernel DMA buffers for vmalloc mode.
362 */
363static int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
364{
365 int i;
366
367 mcam_set_config_needed(cam, needed: 1);
368 if (loadtime)
369 cam->dma_buf_size = dma_buf_size;
370 else
371 cam->dma_buf_size = cam->pix_format.sizeimage;
372 if (n_dma_bufs > 3)
373 n_dma_bufs = 3;
374
375 cam->nbufs = 0;
376 for (i = 0; i < n_dma_bufs; i++) {
377 cam->dma_bufs[i] = dma_alloc_coherent(dev: cam->dev,
378 size: cam->dma_buf_size, dma_handle: cam->dma_handles + i,
379 GFP_KERNEL);
380 if (cam->dma_bufs[i] == NULL) {
381 cam_warn(cam, "Failed to allocate DMA buffer\n");
382 break;
383 }
384 (cam->nbufs)++;
385 }
386
387 switch (cam->nbufs) {
388 case 1:
389 dma_free_coherent(dev: cam->dev, size: cam->dma_buf_size,
390 cpu_addr: cam->dma_bufs[0], dma_handle: cam->dma_handles[0]);
391 cam->nbufs = 0;
392 fallthrough;
393 case 0:
394 cam_err(cam, "Insufficient DMA buffers, cannot operate\n");
395 return -ENOMEM;
396
397 case 2:
398 if (n_dma_bufs > 2)
399 cam_warn(cam, "Will limp along with only 2 buffers\n");
400 break;
401 }
402 return 0;
403}
404
405static void mcam_free_dma_bufs(struct mcam_camera *cam)
406{
407 int i;
408
409 for (i = 0; i < cam->nbufs; i++) {
410 dma_free_coherent(dev: cam->dev, size: cam->dma_buf_size,
411 cpu_addr: cam->dma_bufs[i], dma_handle: cam->dma_handles[i]);
412 cam->dma_bufs[i] = NULL;
413 }
414 cam->nbufs = 0;
415}
416
417
418/*
419 * Set up DMA buffers when operating in vmalloc mode
420 */
421static void mcam_ctlr_dma_vmalloc(struct mcam_camera *cam)
422{
423 /*
424 * Store the first two YUV buffers. Then either
425 * set the third if it exists, or tell the controller
426 * to just use two.
427 */
428 mcam_write_yuv_bases(cam, frame: 0, base: cam->dma_handles[0]);
429 mcam_write_yuv_bases(cam, frame: 1, base: cam->dma_handles[1]);
430 if (cam->nbufs > 2) {
431 mcam_write_yuv_bases(cam, frame: 2, base: cam->dma_handles[2]);
432 mcam_reg_clear_bit(cam, REG_CTRL1, C1_TWOBUFS);
433 } else
434 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
435 if (cam->chip_id == MCAM_CAFE)
436 mcam_reg_write(cam, REG_UBAR, val: 0); /* 32 bits only */
437}
438
439/*
440 * Copy data out to user space in the vmalloc case
441 */
442static void mcam_frame_tasklet(struct tasklet_struct *t)
443{
444 struct mcam_camera *cam = from_tasklet(cam, t, s_tasklet);
445 int i;
446 unsigned long flags;
447 struct mcam_vb_buffer *buf;
448
449 spin_lock_irqsave(&cam->dev_lock, flags);
450 for (i = 0; i < cam->nbufs; i++) {
451 int bufno = cam->next_buf;
452
453 if (cam->state != S_STREAMING || bufno < 0)
454 break; /* I/O got stopped */
455 if (++(cam->next_buf) >= cam->nbufs)
456 cam->next_buf = 0;
457 if (!test_bit(bufno, &cam->flags))
458 continue;
459 if (list_empty(head: &cam->buffers)) {
460 cam->frame_state.singles++;
461 break; /* Leave it valid, hope for better later */
462 }
463 cam->frame_state.delivered++;
464 clear_bit(nr: bufno, addr: &cam->flags);
465 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
466 queue);
467 list_del_init(entry: &buf->queue);
468 /*
469 * Drop the lock during the big copy. This *should* be safe...
470 */
471 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
472 memcpy(vb2_plane_vaddr(&buf->vb_buf.vb2_buf, 0),
473 cam->dma_bufs[bufno],
474 cam->pix_format.sizeimage);
475 mcam_buffer_done(cam, frame: bufno, vbuf: &buf->vb_buf);
476 spin_lock_irqsave(&cam->dev_lock, flags);
477 }
478 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
479}
480
481
482/*
483 * Make sure our allocated buffers are up to the task.
484 */
485static int mcam_check_dma_buffers(struct mcam_camera *cam)
486{
487 if (cam->nbufs > 0 && cam->dma_buf_size < cam->pix_format.sizeimage)
488 mcam_free_dma_bufs(cam);
489 if (cam->nbufs == 0)
490 return mcam_alloc_dma_bufs(cam, loadtime: 0);
491 return 0;
492}
493
494static void mcam_vmalloc_done(struct mcam_camera *cam, int frame)
495{
496 tasklet_schedule(t: &cam->s_tasklet);
497}
498
499#else /* MCAM_MODE_VMALLOC */
500
501static inline int mcam_alloc_dma_bufs(struct mcam_camera *cam, int loadtime)
502{
503 return 0;
504}
505
506static inline void mcam_free_dma_bufs(struct mcam_camera *cam)
507{
508 return;
509}
510
511static inline int mcam_check_dma_buffers(struct mcam_camera *cam)
512{
513 return 0;
514}
515
516
517
518#endif /* MCAM_MODE_VMALLOC */
519
520
521#ifdef MCAM_MODE_DMA_CONTIG
522/* ---------------------------------------------------------------------- */
523/*
524 * DMA-contiguous code.
525 */
526
527/*
528 * Set up a contiguous buffer for the given frame. Here also is where
529 * the underrun strategy is set: if there is no buffer available, reuse
530 * the buffer from the other BAR and set the CF_SINGLE_BUFFER flag to
531 * keep the interrupt handler from giving that buffer back to user
532 * space. In this way, we always have a buffer to DMA to and don't
533 * have to try to play games stopping and restarting the controller.
534 */
535static void mcam_set_contig_buffer(struct mcam_camera *cam, int frame)
536{
537 struct mcam_vb_buffer *buf;
538 dma_addr_t dma_handle;
539 struct vb2_v4l2_buffer *vb;
540
541 /*
542 * If there are no available buffers, go into single mode
543 */
544 if (list_empty(head: &cam->buffers)) {
545 buf = cam->vb_bufs[frame ^ 0x1];
546 set_bit(CF_SINGLE_BUFFER, addr: &cam->flags);
547 cam->frame_state.singles++;
548 } else {
549 /*
550 * OK, we have a buffer we can use.
551 */
552 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer,
553 queue);
554 list_del_init(entry: &buf->queue);
555 clear_bit(CF_SINGLE_BUFFER, addr: &cam->flags);
556 }
557
558 cam->vb_bufs[frame] = buf;
559 vb = &buf->vb_buf;
560
561 dma_handle = vb2_dma_contig_plane_dma_addr(vb: &vb->vb2_buf, plane_no: 0);
562 mcam_write_yuv_bases(cam, frame, base: dma_handle);
563}
564
565/*
566 * Initial B_DMA_contig setup.
567 */
568static void mcam_ctlr_dma_contig(struct mcam_camera *cam)
569{
570 mcam_reg_set_bit(cam, REG_CTRL1, C1_TWOBUFS);
571 cam->nbufs = 2;
572 mcam_set_contig_buffer(cam, frame: 0);
573 mcam_set_contig_buffer(cam, frame: 1);
574}
575
576/*
577 * Frame completion handling.
578 */
579static void mcam_dma_contig_done(struct mcam_camera *cam, int frame)
580{
581 struct mcam_vb_buffer *buf = cam->vb_bufs[frame];
582
583 if (!test_bit(CF_SINGLE_BUFFER, &cam->flags)) {
584 cam->frame_state.delivered++;
585 cam->vb_bufs[frame] = NULL;
586 mcam_buffer_done(cam, frame, vbuf: &buf->vb_buf);
587 }
588 mcam_set_contig_buffer(cam, frame);
589}
590
591#endif /* MCAM_MODE_DMA_CONTIG */
592
593#ifdef MCAM_MODE_DMA_SG
594/* ---------------------------------------------------------------------- */
595/*
596 * Scatter/gather-specific code.
597 */
598
599/*
600 * Set up the next buffer for S/G I/O; caller should be sure that
601 * the controller is stopped and a buffer is available.
602 */
603static void mcam_sg_next_buffer(struct mcam_camera *cam)
604{
605 struct mcam_vb_buffer *buf;
606 struct sg_table *sg_table;
607
608 buf = list_first_entry(&cam->buffers, struct mcam_vb_buffer, queue);
609 list_del_init(entry: &buf->queue);
610 sg_table = vb2_dma_sg_plane_desc(vb: &buf->vb_buf.vb2_buf, plane_no: 0);
611 /*
612 * Very Bad Not Good Things happen if you don't clear
613 * C1_DESC_ENA before making any descriptor changes.
614 */
615 mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_ENA);
616 mcam_reg_write(cam, REG_DMA_DESC_Y, val: buf->dma_desc_pa);
617 mcam_reg_write(cam, REG_DESC_LEN_Y,
618 val: sg_table->nents * sizeof(struct mcam_dma_desc));
619 mcam_reg_write(cam, REG_DESC_LEN_U, val: 0);
620 mcam_reg_write(cam, REG_DESC_LEN_V, val: 0);
621 mcam_reg_set_bit(cam, REG_CTRL1, C1_DESC_ENA);
622 cam->vb_bufs[0] = buf;
623}
624
625/*
626 * Initial B_DMA_sg setup
627 */
628static void mcam_ctlr_dma_sg(struct mcam_camera *cam)
629{
630 /*
631 * The list-empty condition can hit us at resume time
632 * if the buffer list was empty when the system was suspended.
633 */
634 if (list_empty(head: &cam->buffers)) {
635 set_bit(CF_SG_RESTART, addr: &cam->flags);
636 return;
637 }
638
639 mcam_reg_clear_bit(cam, REG_CTRL1, C1_DESC_3WORD);
640 mcam_sg_next_buffer(cam);
641 cam->nbufs = 3;
642}
643
644
645/*
646 * Frame completion with S/G is trickier. We can't muck with
647 * a descriptor chain on the fly, since the controller buffers it
648 * internally. So we have to actually stop and restart; Marvell
649 * says this is the way to do it.
650 *
651 * Of course, stopping is easier said than done; experience shows
652 * that the controller can start a frame *after* C0_ENABLE has been
653 * cleared. So when running in S/G mode, the controller is "stopped"
654 * on receipt of the start-of-frame interrupt. That means we can
655 * safely change the DMA descriptor array here and restart things
656 * (assuming there's another buffer waiting to go).
657 */
658static void mcam_dma_sg_done(struct mcam_camera *cam, int frame)
659{
660 struct mcam_vb_buffer *buf = cam->vb_bufs[0];
661
662 /*
663 * If we're no longer supposed to be streaming, don't do anything.
664 */
665 if (cam->state != S_STREAMING)
666 return;
667 /*
668 * If we have another buffer available, put it in and
669 * restart the engine.
670 */
671 if (!list_empty(head: &cam->buffers)) {
672 mcam_sg_next_buffer(cam);
673 mcam_ctlr_start(cam);
674 /*
675 * Otherwise set CF_SG_RESTART and the controller will
676 * be restarted once another buffer shows up.
677 */
678 } else {
679 set_bit(CF_SG_RESTART, addr: &cam->flags);
680 cam->frame_state.singles++;
681 cam->vb_bufs[0] = NULL;
682 }
683 /*
684 * Now we can give the completed frame back to user space.
685 */
686 cam->frame_state.delivered++;
687 mcam_buffer_done(cam, frame, vbuf: &buf->vb_buf);
688}
689
690
691/*
692 * Scatter/gather mode requires stopping the controller between
693 * frames so we can put in a new DMA descriptor array. If no new
694 * buffer exists at frame completion, the controller is left stopped;
695 * this function is charged with getting things going again.
696 */
697static void mcam_sg_restart(struct mcam_camera *cam)
698{
699 mcam_ctlr_dma_sg(cam);
700 mcam_ctlr_start(cam);
701 clear_bit(CF_SG_RESTART, addr: &cam->flags);
702}
703
704#else /* MCAM_MODE_DMA_SG */
705
706static inline void mcam_sg_restart(struct mcam_camera *cam)
707{
708 return;
709}
710
711#endif /* MCAM_MODE_DMA_SG */
712
713/* ---------------------------------------------------------------------- */
714/*
715 * Buffer-mode-independent controller code.
716 */
717
718/*
719 * Image format setup
720 */
721static void mcam_ctlr_image(struct mcam_camera *cam)
722{
723 struct v4l2_pix_format *fmt = &cam->pix_format;
724 u32 widthy = 0, widthuv = 0, imgsz_h, imgsz_w;
725
726 cam_dbg(cam, "camera: bytesperline = %d; height = %d\n",
727 fmt->bytesperline, fmt->sizeimage / fmt->bytesperline);
728 imgsz_h = (fmt->height << IMGSZ_V_SHIFT) & IMGSZ_V_MASK;
729 imgsz_w = (fmt->width * 2) & IMGSZ_H_MASK;
730
731 switch (fmt->pixelformat) {
732 case V4L2_PIX_FMT_YUYV:
733 case V4L2_PIX_FMT_YVYU:
734 widthy = fmt->width * 2;
735 widthuv = 0;
736 break;
737 case V4L2_PIX_FMT_YUV420:
738 case V4L2_PIX_FMT_YVU420:
739 widthy = fmt->width;
740 widthuv = fmt->width / 2;
741 break;
742 default:
743 widthy = fmt->bytesperline;
744 widthuv = 0;
745 break;
746 }
747
748 mcam_reg_write_mask(cam, REG_IMGPITCH, val: widthuv << 16 | widthy,
749 IMGP_YP_MASK | IMGP_UVP_MASK);
750 mcam_reg_write(cam, REG_IMGSIZE, val: imgsz_h | imgsz_w);
751 mcam_reg_write(cam, REG_IMGOFFSET, val: 0x0);
752
753 /*
754 * Tell the controller about the image format we are using.
755 */
756 switch (fmt->pixelformat) {
757 case V4L2_PIX_FMT_YUV420:
758 case V4L2_PIX_FMT_YVU420:
759 mcam_reg_write_mask(cam, REG_CTRL0,
760 C0_DF_YUV | C0_YUV_420PL | C0_YUVE_VYUY, C0_DF_MASK);
761 break;
762 case V4L2_PIX_FMT_YUYV:
763 mcam_reg_write_mask(cam, REG_CTRL0,
764 C0_DF_YUV | C0_YUV_PACKED | C0_YUVE_NOSWAP, C0_DF_MASK);
765 break;
766 case V4L2_PIX_FMT_YVYU:
767 mcam_reg_write_mask(cam, REG_CTRL0,
768 C0_DF_YUV | C0_YUV_PACKED | C0_YUVE_SWAP24, C0_DF_MASK);
769 break;
770 case V4L2_PIX_FMT_XRGB444:
771 mcam_reg_write_mask(cam, REG_CTRL0,
772 C0_DF_RGB | C0_RGBF_444 | C0_RGB4_XBGR, C0_DF_MASK);
773 break;
774 case V4L2_PIX_FMT_RGB565:
775 mcam_reg_write_mask(cam, REG_CTRL0,
776 C0_DF_RGB | C0_RGBF_565 | C0_RGB5_BGGR, C0_DF_MASK);
777 break;
778 case V4L2_PIX_FMT_SBGGR8:
779 mcam_reg_write_mask(cam, REG_CTRL0,
780 C0_DF_RGB | C0_RGB5_GRBG, C0_DF_MASK);
781 break;
782 default:
783 cam_err(cam, "camera: unknown format: %#x\n", fmt->pixelformat);
784 break;
785 }
786
787 /*
788 * Make sure it knows we want to use hsync/vsync.
789 */
790 mcam_reg_write_mask(cam, REG_CTRL0, C0_SIF_HVSYNC, C0_SIFM_MASK);
791}
792
793
794/*
795 * Configure the controller for operation; caller holds the
796 * device mutex.
797 */
798static int mcam_ctlr_configure(struct mcam_camera *cam)
799{
800 unsigned long flags;
801
802 spin_lock_irqsave(&cam->dev_lock, flags);
803 clear_bit(CF_SG_RESTART, addr: &cam->flags);
804 cam->dma_setup(cam);
805 mcam_ctlr_image(cam);
806 mcam_set_config_needed(cam, needed: 0);
807 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
808 return 0;
809}
810
811static void mcam_ctlr_irq_enable(struct mcam_camera *cam)
812{
813 /*
814 * Clear any pending interrupts, since we do not
815 * expect to have I/O active prior to enabling.
816 */
817 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS);
818 mcam_reg_set_bit(cam, REG_IRQMASK, FRAMEIRQS);
819}
820
821static void mcam_ctlr_irq_disable(struct mcam_camera *cam)
822{
823 mcam_reg_clear_bit(cam, REG_IRQMASK, FRAMEIRQS);
824}
825
826/*
827 * Stop the controller, and don't return until we're really sure that no
828 * further DMA is going on.
829 */
830static void mcam_ctlr_stop_dma(struct mcam_camera *cam)
831{
832 unsigned long flags;
833
834 /*
835 * Theory: stop the camera controller (whether it is operating
836 * or not). Delay briefly just in case we race with the SOF
837 * interrupt, then wait until no DMA is active.
838 */
839 spin_lock_irqsave(&cam->dev_lock, flags);
840 clear_bit(CF_SG_RESTART, addr: &cam->flags);
841 mcam_ctlr_stop(cam);
842 cam->state = S_IDLE;
843 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
844 /*
845 * This is a brutally long sleep, but experience shows that
846 * it can take the controller a while to get the message that
847 * it needs to stop grabbing frames. In particular, we can
848 * sometimes (on mmp) get a frame at the end WITHOUT the
849 * start-of-frame indication.
850 */
851 msleep(msecs: 150);
852 if (test_bit(CF_DMA_ACTIVE, &cam->flags))
853 cam_err(cam, "Timeout waiting for DMA to end\n");
854 /* This would be bad news - what now? */
855 spin_lock_irqsave(&cam->dev_lock, flags);
856 mcam_ctlr_irq_disable(cam);
857 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
858}
859
860/*
861 * Power up and down.
862 */
863static int mcam_ctlr_power_up(struct mcam_camera *cam)
864{
865 unsigned long flags;
866 int ret;
867
868 spin_lock_irqsave(&cam->dev_lock, flags);
869 if (cam->plat_power_up) {
870 ret = cam->plat_power_up(cam);
871 if (ret) {
872 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
873 return ret;
874 }
875 }
876 mcam_reg_clear_bit(cam, REG_CTRL1, C1_PWRDWN);
877 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
878 return 0;
879}
880
881static void mcam_ctlr_power_down(struct mcam_camera *cam)
882{
883 unsigned long flags;
884
885 spin_lock_irqsave(&cam->dev_lock, flags);
886 /*
887 * School of hard knocks department: be sure we do any register
888 * twiddling on the controller *before* calling the platform
889 * power down routine.
890 */
891 mcam_reg_set_bit(cam, REG_CTRL1, C1_PWRDWN);
892 if (cam->plat_power_down)
893 cam->plat_power_down(cam);
894 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
895}
896
897/* ---------------------------------------------------------------------- */
898/*
899 * Master sensor clock.
900 */
901static int mclk_prepare(struct clk_hw *hw)
902{
903 struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
904
905 clk_prepare(clk: cam->clk[0]);
906 return 0;
907}
908
909static void mclk_unprepare(struct clk_hw *hw)
910{
911 struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
912
913 clk_unprepare(clk: cam->clk[0]);
914}
915
916static int mclk_enable(struct clk_hw *hw)
917{
918 struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
919 int mclk_src;
920 int mclk_div;
921 int ret;
922
923 /*
924 * Clock the sensor appropriately. Controller clock should
925 * be 48MHz, sensor "typical" value is half that.
926 */
927 if (cam->bus_type == V4L2_MBUS_CSI2_DPHY) {
928 mclk_src = cam->mclk_src;
929 mclk_div = cam->mclk_div;
930 } else {
931 mclk_src = 3;
932 mclk_div = 2;
933 }
934
935 ret = pm_runtime_resume_and_get(dev: cam->dev);
936 if (ret < 0)
937 return ret;
938 clk_enable(clk: cam->clk[0]);
939 mcam_reg_write(cam, REG_CLKCTRL, val: (mclk_src << 29) | mclk_div);
940 mcam_ctlr_power_up(cam);
941
942 return 0;
943}
944
945static void mclk_disable(struct clk_hw *hw)
946{
947 struct mcam_camera *cam = container_of(hw, struct mcam_camera, mclk_hw);
948
949 mcam_ctlr_power_down(cam);
950 clk_disable(clk: cam->clk[0]);
951 pm_runtime_put(dev: cam->dev);
952}
953
954static unsigned long mclk_recalc_rate(struct clk_hw *hw,
955 unsigned long parent_rate)
956{
957 return 48000000;
958}
959
960static const struct clk_ops mclk_ops = {
961 .prepare = mclk_prepare,
962 .unprepare = mclk_unprepare,
963 .enable = mclk_enable,
964 .disable = mclk_disable,
965 .recalc_rate = mclk_recalc_rate,
966};
967
968/* -------------------------------------------------------------------- */
969/*
970 * Communications with the sensor.
971 */
972
973static int __mcam_cam_reset(struct mcam_camera *cam)
974{
975 return sensor_call(cam, core, reset, 0);
976}
977
978/*
979 * We have found the sensor on the i2c. Let's try to have a
980 * conversation.
981 */
982static int mcam_cam_init(struct mcam_camera *cam)
983{
984 int ret;
985
986 if (cam->state != S_NOTREADY)
987 cam_warn(cam, "Cam init with device in funky state %d",
988 cam->state);
989 ret = __mcam_cam_reset(cam);
990 /* Get/set parameters? */
991 cam->state = S_IDLE;
992 return ret;
993}
994
995/*
996 * Configure the sensor to match the parameters we have. Caller should
997 * hold s_mutex
998 */
999static int mcam_cam_set_flip(struct mcam_camera *cam)
1000{
1001 struct v4l2_control ctrl;
1002
1003 memset(&ctrl, 0, sizeof(ctrl));
1004 ctrl.id = V4L2_CID_VFLIP;
1005 ctrl.value = flip;
1006 return v4l2_s_ctrl(NULL, hdl: cam->sensor->ctrl_handler, ctrl: &ctrl);
1007}
1008
1009
1010static int mcam_cam_configure(struct mcam_camera *cam)
1011{
1012 struct v4l2_subdev_format format = {
1013 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1014 };
1015 int ret;
1016
1017 v4l2_fill_mbus_format(mbus_fmt: &format.format, pix_fmt: &cam->pix_format, code: cam->mbus_code);
1018 ret = sensor_call(cam, core, init, 0);
1019 if (ret == 0)
1020 ret = sensor_call(cam, pad, set_fmt, NULL, &format);
1021 /*
1022 * OV7670 does weird things if flip is set *before* format...
1023 */
1024 ret += mcam_cam_set_flip(cam);
1025 return ret;
1026}
1027
1028/*
1029 * Get everything ready, and start grabbing frames.
1030 */
1031static int mcam_read_setup(struct mcam_camera *cam)
1032{
1033 int ret;
1034 unsigned long flags;
1035
1036 /*
1037 * Configuration. If we still don't have DMA buffers,
1038 * make one last, desperate attempt.
1039 */
1040 if (cam->buffer_mode == B_vmalloc && cam->nbufs == 0 &&
1041 mcam_alloc_dma_bufs(cam, loadtime: 0))
1042 return -ENOMEM;
1043
1044 if (mcam_needs_config(cam)) {
1045 mcam_cam_configure(cam);
1046 ret = mcam_ctlr_configure(cam);
1047 if (ret)
1048 return ret;
1049 }
1050
1051 /*
1052 * Turn it loose.
1053 */
1054 spin_lock_irqsave(&cam->dev_lock, flags);
1055 clear_bit(CF_DMA_ACTIVE, addr: &cam->flags);
1056 mcam_reset_buffers(cam);
1057 if (cam->bus_type == V4L2_MBUS_CSI2_DPHY)
1058 mcam_enable_mipi(mcam: cam);
1059 else
1060 mcam_disable_mipi(mcam: cam);
1061 mcam_ctlr_irq_enable(cam);
1062 cam->state = S_STREAMING;
1063 if (!test_bit(CF_SG_RESTART, &cam->flags))
1064 mcam_ctlr_start(cam);
1065 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
1066 return 0;
1067}
1068
1069/* ----------------------------------------------------------------------- */
1070/*
1071 * Videobuf2 interface code.
1072 */
1073
1074static int mcam_vb_queue_setup(struct vb2_queue *vq,
1075 unsigned int *nbufs,
1076 unsigned int *num_planes, unsigned int sizes[],
1077 struct device *alloc_devs[])
1078{
1079 struct mcam_camera *cam = vb2_get_drv_priv(q: vq);
1080 int minbufs = (cam->buffer_mode == B_DMA_contig) ? 3 : 2;
1081 unsigned size = cam->pix_format.sizeimage;
1082
1083 if (*nbufs < minbufs)
1084 *nbufs = minbufs;
1085
1086 if (*num_planes)
1087 return sizes[0] < size ? -EINVAL : 0;
1088 sizes[0] = size;
1089 *num_planes = 1; /* Someday we have to support planar formats... */
1090 return 0;
1091}
1092
1093
1094static void mcam_vb_buf_queue(struct vb2_buffer *vb)
1095{
1096 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1097 struct mcam_vb_buffer *mvb = vb_to_mvb(vb: vbuf);
1098 struct mcam_camera *cam = vb2_get_drv_priv(q: vb->vb2_queue);
1099 unsigned long flags;
1100 int start;
1101
1102 spin_lock_irqsave(&cam->dev_lock, flags);
1103 start = (cam->state == S_BUFWAIT) && !list_empty(head: &cam->buffers);
1104 list_add(new: &mvb->queue, head: &cam->buffers);
1105 if (cam->state == S_STREAMING && test_bit(CF_SG_RESTART, &cam->flags))
1106 mcam_sg_restart(cam);
1107 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
1108 if (start)
1109 mcam_read_setup(cam);
1110}
1111
1112static void mcam_vb_requeue_bufs(struct vb2_queue *vq,
1113 enum vb2_buffer_state state)
1114{
1115 struct mcam_camera *cam = vb2_get_drv_priv(q: vq);
1116 struct mcam_vb_buffer *buf, *node;
1117 unsigned long flags;
1118 unsigned i;
1119
1120 spin_lock_irqsave(&cam->dev_lock, flags);
1121 list_for_each_entry_safe(buf, node, &cam->buffers, queue) {
1122 vb2_buffer_done(vb: &buf->vb_buf.vb2_buf, state);
1123 list_del(entry: &buf->queue);
1124 }
1125 for (i = 0; i < MAX_DMA_BUFS; i++) {
1126 buf = cam->vb_bufs[i];
1127
1128 if (buf) {
1129 vb2_buffer_done(vb: &buf->vb_buf.vb2_buf, state);
1130 cam->vb_bufs[i] = NULL;
1131 }
1132 }
1133 spin_unlock_irqrestore(lock: &cam->dev_lock, flags);
1134}
1135
1136/*
1137 * These need to be called with the mutex held from vb2
1138 */
1139static int mcam_vb_start_streaming(struct vb2_queue *vq, unsigned int count)
1140{
1141 struct mcam_camera *cam = vb2_get_drv_priv(q: vq);
1142 unsigned int frame;
1143 int ret;
1144
1145 if (cam->state != S_IDLE) {
1146 mcam_vb_requeue_bufs(vq, state: VB2_BUF_STATE_QUEUED);
1147 return -EINVAL;
1148 }
1149 cam->frame_state.frames = 0;
1150 cam->frame_state.singles = 0;
1151 cam->frame_state.delivered = 0;
1152 cam->sequence = 0;
1153 /*
1154 * Videobuf2 sneakily hoards all the buffers and won't
1155 * give them to us until *after* streaming starts. But
1156 * we can't actually start streaming until we have a
1157 * destination. So go into a wait state and hope they
1158 * give us buffers soon.
1159 */
1160 if (cam->buffer_mode != B_vmalloc && list_empty(head: &cam->buffers)) {
1161 cam->state = S_BUFWAIT;
1162 return 0;
1163 }
1164
1165 /*
1166 * Ensure clear the left over frame flags
1167 * before every really start streaming
1168 */
1169 for (frame = 0; frame < cam->nbufs; frame++)
1170 clear_bit(CF_FRAME_SOF0 + frame, addr: &cam->flags);
1171
1172 ret = mcam_read_setup(cam);
1173 if (ret)
1174 mcam_vb_requeue_bufs(vq, state: VB2_BUF_STATE_QUEUED);
1175 return ret;
1176}
1177
1178static void mcam_vb_stop_streaming(struct vb2_queue *vq)
1179{
1180 struct mcam_camera *cam = vb2_get_drv_priv(q: vq);
1181
1182 cam_dbg(cam, "stop_streaming: %d frames, %d singles, %d delivered\n",
1183 cam->frame_state.frames, cam->frame_state.singles,
1184 cam->frame_state.delivered);
1185 if (cam->state == S_BUFWAIT) {
1186 /* They never gave us buffers */
1187 cam->state = S_IDLE;
1188 return;
1189 }
1190 if (cam->state != S_STREAMING)
1191 return;
1192 mcam_ctlr_stop_dma(cam);
1193 /*
1194 * VB2 reclaims the buffers, so we need to forget
1195 * about them.
1196 */
1197 mcam_vb_requeue_bufs(vq, state: VB2_BUF_STATE_ERROR);
1198}
1199
1200
1201static const struct vb2_ops mcam_vb2_ops = {
1202 .queue_setup = mcam_vb_queue_setup,
1203 .buf_queue = mcam_vb_buf_queue,
1204 .start_streaming = mcam_vb_start_streaming,
1205 .stop_streaming = mcam_vb_stop_streaming,
1206 .wait_prepare = vb2_ops_wait_prepare,
1207 .wait_finish = vb2_ops_wait_finish,
1208};
1209
1210
1211#ifdef MCAM_MODE_DMA_SG
1212/*
1213 * Scatter/gather mode uses all of the above functions plus a
1214 * few extras to deal with DMA mapping.
1215 */
1216static int mcam_vb_sg_buf_init(struct vb2_buffer *vb)
1217{
1218 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1219 struct mcam_vb_buffer *mvb = vb_to_mvb(vb: vbuf);
1220 struct mcam_camera *cam = vb2_get_drv_priv(q: vb->vb2_queue);
1221 int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1222
1223 mvb->dma_desc = dma_alloc_coherent(dev: cam->dev,
1224 size: ndesc * sizeof(struct mcam_dma_desc),
1225 dma_handle: &mvb->dma_desc_pa, GFP_KERNEL);
1226 if (mvb->dma_desc == NULL) {
1227 cam_err(cam, "Unable to get DMA descriptor array\n");
1228 return -ENOMEM;
1229 }
1230 return 0;
1231}
1232
1233static int mcam_vb_sg_buf_prepare(struct vb2_buffer *vb)
1234{
1235 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1236 struct mcam_vb_buffer *mvb = vb_to_mvb(vb: vbuf);
1237 struct sg_table *sg_table = vb2_dma_sg_plane_desc(vb, plane_no: 0);
1238 struct mcam_dma_desc *desc = mvb->dma_desc;
1239 struct scatterlist *sg;
1240 int i;
1241
1242 for_each_sg(sg_table->sgl, sg, sg_table->nents, i) {
1243 desc->dma_addr = sg_dma_address(sg);
1244 desc->segment_len = sg_dma_len(sg);
1245 desc++;
1246 }
1247 return 0;
1248}
1249
1250static void mcam_vb_sg_buf_cleanup(struct vb2_buffer *vb)
1251{
1252 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
1253 struct mcam_camera *cam = vb2_get_drv_priv(q: vb->vb2_queue);
1254 struct mcam_vb_buffer *mvb = vb_to_mvb(vb: vbuf);
1255 int ndesc = cam->pix_format.sizeimage/PAGE_SIZE + 1;
1256
1257 dma_free_coherent(dev: cam->dev, size: ndesc * sizeof(struct mcam_dma_desc),
1258 cpu_addr: mvb->dma_desc, dma_handle: mvb->dma_desc_pa);
1259}
1260
1261
1262static const struct vb2_ops mcam_vb2_sg_ops = {
1263 .queue_setup = mcam_vb_queue_setup,
1264 .buf_init = mcam_vb_sg_buf_init,
1265 .buf_prepare = mcam_vb_sg_buf_prepare,
1266 .buf_queue = mcam_vb_buf_queue,
1267 .buf_cleanup = mcam_vb_sg_buf_cleanup,
1268 .start_streaming = mcam_vb_start_streaming,
1269 .stop_streaming = mcam_vb_stop_streaming,
1270 .wait_prepare = vb2_ops_wait_prepare,
1271 .wait_finish = vb2_ops_wait_finish,
1272};
1273
1274#endif /* MCAM_MODE_DMA_SG */
1275
1276static int mcam_setup_vb2(struct mcam_camera *cam)
1277{
1278 struct vb2_queue *vq = &cam->vb_queue;
1279
1280 memset(vq, 0, sizeof(*vq));
1281 vq->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1282 vq->drv_priv = cam;
1283 vq->lock = &cam->s_mutex;
1284 vq->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1285 vq->io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ;
1286 vq->buf_struct_size = sizeof(struct mcam_vb_buffer);
1287 vq->dev = cam->dev;
1288 INIT_LIST_HEAD(list: &cam->buffers);
1289 switch (cam->buffer_mode) {
1290 case B_DMA_contig:
1291#ifdef MCAM_MODE_DMA_CONTIG
1292 vq->ops = &mcam_vb2_ops;
1293 vq->mem_ops = &vb2_dma_contig_memops;
1294 cam->dma_setup = mcam_ctlr_dma_contig;
1295 cam->frame_complete = mcam_dma_contig_done;
1296#endif
1297 break;
1298 case B_DMA_sg:
1299#ifdef MCAM_MODE_DMA_SG
1300 vq->ops = &mcam_vb2_sg_ops;
1301 vq->mem_ops = &vb2_dma_sg_memops;
1302 cam->dma_setup = mcam_ctlr_dma_sg;
1303 cam->frame_complete = mcam_dma_sg_done;
1304#endif
1305 break;
1306 case B_vmalloc:
1307#ifdef MCAM_MODE_VMALLOC
1308 tasklet_setup(t: &cam->s_tasklet, callback: mcam_frame_tasklet);
1309 vq->ops = &mcam_vb2_ops;
1310 vq->mem_ops = &vb2_vmalloc_memops;
1311 cam->dma_setup = mcam_ctlr_dma_vmalloc;
1312 cam->frame_complete = mcam_vmalloc_done;
1313#endif
1314 break;
1315 }
1316 return vb2_queue_init(q: vq);
1317}
1318
1319
1320/* ---------------------------------------------------------------------- */
1321/*
1322 * The long list of V4L2 ioctl() operations.
1323 */
1324
1325static int mcam_vidioc_querycap(struct file *file, void *priv,
1326 struct v4l2_capability *cap)
1327{
1328 struct mcam_camera *cam = video_drvdata(file);
1329
1330 strscpy(cap->driver, "marvell_ccic", sizeof(cap->driver));
1331 strscpy(cap->card, "marvell_ccic", sizeof(cap->card));
1332 strscpy(cap->bus_info, cam->bus_info, sizeof(cap->bus_info));
1333 return 0;
1334}
1335
1336
1337static int mcam_vidioc_enum_fmt_vid_cap(struct file *filp,
1338 void *priv, struct v4l2_fmtdesc *fmt)
1339{
1340 if (fmt->index >= N_MCAM_FMTS)
1341 return -EINVAL;
1342 fmt->pixelformat = mcam_formats[fmt->index].pixelformat;
1343 return 0;
1344}
1345
1346static int mcam_vidioc_try_fmt_vid_cap(struct file *filp, void *priv,
1347 struct v4l2_format *fmt)
1348{
1349 struct mcam_camera *cam = video_drvdata(file: filp);
1350 struct mcam_format_struct *f;
1351 struct v4l2_pix_format *pix = &fmt->fmt.pix;
1352 struct v4l2_subdev_pad_config pad_cfg;
1353 struct v4l2_subdev_state pad_state = {
1354 .pads = &pad_cfg,
1355 };
1356 struct v4l2_subdev_format format = {
1357 .which = V4L2_SUBDEV_FORMAT_TRY,
1358 };
1359 int ret;
1360
1361 f = mcam_find_format(pixelformat: pix->pixelformat);
1362 pix->pixelformat = f->pixelformat;
1363 v4l2_fill_mbus_format(mbus_fmt: &format.format, pix_fmt: pix, code: f->mbus_code);
1364 ret = sensor_call(cam, pad, set_fmt, &pad_state, &format);
1365 v4l2_fill_pix_format(pix_fmt: pix, mbus_fmt: &format.format);
1366 pix->bytesperline = pix->width * f->bpp;
1367 switch (f->pixelformat) {
1368 case V4L2_PIX_FMT_YUV420:
1369 case V4L2_PIX_FMT_YVU420:
1370 pix->sizeimage = pix->height * pix->bytesperline * 3 / 2;
1371 break;
1372 default:
1373 pix->sizeimage = pix->height * pix->bytesperline;
1374 break;
1375 }
1376 pix->colorspace = V4L2_COLORSPACE_SRGB;
1377 return ret;
1378}
1379
1380static int mcam_vidioc_s_fmt_vid_cap(struct file *filp, void *priv,
1381 struct v4l2_format *fmt)
1382{
1383 struct mcam_camera *cam = video_drvdata(file: filp);
1384 struct mcam_format_struct *f;
1385 int ret;
1386
1387 /*
1388 * Can't do anything if the device is not idle
1389 * Also can't if there are streaming buffers in place.
1390 */
1391 if (cam->state != S_IDLE || vb2_is_busy(q: &cam->vb_queue))
1392 return -EBUSY;
1393
1394 f = mcam_find_format(pixelformat: fmt->fmt.pix.pixelformat);
1395
1396 /*
1397 * See if the formatting works in principle.
1398 */
1399 ret = mcam_vidioc_try_fmt_vid_cap(filp, priv, fmt);
1400 if (ret)
1401 return ret;
1402 /*
1403 * Now we start to change things for real, so let's do it
1404 * under lock.
1405 */
1406 cam->pix_format = fmt->fmt.pix;
1407 cam->mbus_code = f->mbus_code;
1408
1409 /*
1410 * Make sure we have appropriate DMA buffers.
1411 */
1412 if (cam->buffer_mode == B_vmalloc) {
1413 ret = mcam_check_dma_buffers(cam);
1414 if (ret)
1415 goto out;
1416 }
1417 mcam_set_config_needed(cam, needed: 1);
1418out:
1419 return ret;
1420}
1421
1422/*
1423 * Return our stored notion of how the camera is/should be configured.
1424 * The V4l2 spec wants us to be smarter, and actually get this from
1425 * the camera (and not mess with it at open time). Someday.
1426 */
1427static int mcam_vidioc_g_fmt_vid_cap(struct file *filp, void *priv,
1428 struct v4l2_format *f)
1429{
1430 struct mcam_camera *cam = video_drvdata(file: filp);
1431
1432 f->fmt.pix = cam->pix_format;
1433 return 0;
1434}
1435
1436/*
1437 * We only have one input - the sensor - so minimize the nonsense here.
1438 */
1439static int mcam_vidioc_enum_input(struct file *filp, void *priv,
1440 struct v4l2_input *input)
1441{
1442 if (input->index != 0)
1443 return -EINVAL;
1444
1445 input->type = V4L2_INPUT_TYPE_CAMERA;
1446 strscpy(input->name, "Camera", sizeof(input->name));
1447 return 0;
1448}
1449
1450static int mcam_vidioc_g_input(struct file *filp, void *priv, unsigned int *i)
1451{
1452 *i = 0;
1453 return 0;
1454}
1455
1456static int mcam_vidioc_s_input(struct file *filp, void *priv, unsigned int i)
1457{
1458 if (i != 0)
1459 return -EINVAL;
1460 return 0;
1461}
1462
1463/*
1464 * G/S_PARM. Most of this is done by the sensor, but we are
1465 * the level which controls the number of read buffers.
1466 */
1467static int mcam_vidioc_g_parm(struct file *filp, void *priv,
1468 struct v4l2_streamparm *a)
1469{
1470 struct mcam_camera *cam = video_drvdata(file: filp);
1471 int ret;
1472
1473 ret = v4l2_g_parm_cap(vdev: video_devdata(file: filp), sd: cam->sensor, a);
1474 a->parm.capture.readbuffers = n_dma_bufs;
1475 return ret;
1476}
1477
1478static int mcam_vidioc_s_parm(struct file *filp, void *priv,
1479 struct v4l2_streamparm *a)
1480{
1481 struct mcam_camera *cam = video_drvdata(file: filp);
1482 int ret;
1483
1484 ret = v4l2_s_parm_cap(vdev: video_devdata(file: filp), sd: cam->sensor, a);
1485 a->parm.capture.readbuffers = n_dma_bufs;
1486 return ret;
1487}
1488
1489static int mcam_vidioc_enum_framesizes(struct file *filp, void *priv,
1490 struct v4l2_frmsizeenum *sizes)
1491{
1492 struct mcam_camera *cam = video_drvdata(file: filp);
1493 struct mcam_format_struct *f;
1494 struct v4l2_subdev_frame_size_enum fse = {
1495 .index = sizes->index,
1496 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1497 };
1498 int ret;
1499
1500 f = mcam_find_format(pixelformat: sizes->pixel_format);
1501 if (f->pixelformat != sizes->pixel_format)
1502 return -EINVAL;
1503 fse.code = f->mbus_code;
1504 ret = sensor_call(cam, pad, enum_frame_size, NULL, &fse);
1505 if (ret)
1506 return ret;
1507 if (fse.min_width == fse.max_width &&
1508 fse.min_height == fse.max_height) {
1509 sizes->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1510 sizes->discrete.width = fse.min_width;
1511 sizes->discrete.height = fse.min_height;
1512 return 0;
1513 }
1514 sizes->type = V4L2_FRMSIZE_TYPE_CONTINUOUS;
1515 sizes->stepwise.min_width = fse.min_width;
1516 sizes->stepwise.max_width = fse.max_width;
1517 sizes->stepwise.min_height = fse.min_height;
1518 sizes->stepwise.max_height = fse.max_height;
1519 sizes->stepwise.step_width = 1;
1520 sizes->stepwise.step_height = 1;
1521 return 0;
1522}
1523
1524static int mcam_vidioc_enum_frameintervals(struct file *filp, void *priv,
1525 struct v4l2_frmivalenum *interval)
1526{
1527 struct mcam_camera *cam = video_drvdata(file: filp);
1528 struct mcam_format_struct *f;
1529 struct v4l2_subdev_frame_interval_enum fie = {
1530 .index = interval->index,
1531 .width = interval->width,
1532 .height = interval->height,
1533 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
1534 };
1535 int ret;
1536
1537 f = mcam_find_format(pixelformat: interval->pixel_format);
1538 if (f->pixelformat != interval->pixel_format)
1539 return -EINVAL;
1540 fie.code = f->mbus_code;
1541 ret = sensor_call(cam, pad, enum_frame_interval, NULL, &fie);
1542 if (ret)
1543 return ret;
1544 interval->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1545 interval->discrete = fie.interval;
1546 return 0;
1547}
1548
1549#ifdef CONFIG_VIDEO_ADV_DEBUG
1550static int mcam_vidioc_g_register(struct file *file, void *priv,
1551 struct v4l2_dbg_register *reg)
1552{
1553 struct mcam_camera *cam = video_drvdata(file);
1554
1555 if (reg->reg > cam->regs_size - 4)
1556 return -EINVAL;
1557 reg->val = mcam_reg_read(cam, reg: reg->reg);
1558 reg->size = 4;
1559 return 0;
1560}
1561
1562static int mcam_vidioc_s_register(struct file *file, void *priv,
1563 const struct v4l2_dbg_register *reg)
1564{
1565 struct mcam_camera *cam = video_drvdata(file);
1566
1567 if (reg->reg > cam->regs_size - 4)
1568 return -EINVAL;
1569 mcam_reg_write(cam, reg: reg->reg, val: reg->val);
1570 return 0;
1571}
1572#endif
1573
1574static const struct v4l2_ioctl_ops mcam_v4l_ioctl_ops = {
1575 .vidioc_querycap = mcam_vidioc_querycap,
1576 .vidioc_enum_fmt_vid_cap = mcam_vidioc_enum_fmt_vid_cap,
1577 .vidioc_try_fmt_vid_cap = mcam_vidioc_try_fmt_vid_cap,
1578 .vidioc_s_fmt_vid_cap = mcam_vidioc_s_fmt_vid_cap,
1579 .vidioc_g_fmt_vid_cap = mcam_vidioc_g_fmt_vid_cap,
1580 .vidioc_enum_input = mcam_vidioc_enum_input,
1581 .vidioc_g_input = mcam_vidioc_g_input,
1582 .vidioc_s_input = mcam_vidioc_s_input,
1583 .vidioc_reqbufs = vb2_ioctl_reqbufs,
1584 .vidioc_create_bufs = vb2_ioctl_create_bufs,
1585 .vidioc_querybuf = vb2_ioctl_querybuf,
1586 .vidioc_qbuf = vb2_ioctl_qbuf,
1587 .vidioc_dqbuf = vb2_ioctl_dqbuf,
1588 .vidioc_expbuf = vb2_ioctl_expbuf,
1589 .vidioc_streamon = vb2_ioctl_streamon,
1590 .vidioc_streamoff = vb2_ioctl_streamoff,
1591 .vidioc_g_parm = mcam_vidioc_g_parm,
1592 .vidioc_s_parm = mcam_vidioc_s_parm,
1593 .vidioc_enum_framesizes = mcam_vidioc_enum_framesizes,
1594 .vidioc_enum_frameintervals = mcam_vidioc_enum_frameintervals,
1595 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1596 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1597#ifdef CONFIG_VIDEO_ADV_DEBUG
1598 .vidioc_g_register = mcam_vidioc_g_register,
1599 .vidioc_s_register = mcam_vidioc_s_register,
1600#endif
1601};
1602
1603/* ---------------------------------------------------------------------- */
1604/*
1605 * Our various file operations.
1606 */
1607static int mcam_v4l_open(struct file *filp)
1608{
1609 struct mcam_camera *cam = video_drvdata(file: filp);
1610 int ret;
1611
1612 mutex_lock(&cam->s_mutex);
1613 ret = v4l2_fh_open(filp);
1614 if (ret)
1615 goto out;
1616 if (v4l2_fh_is_singular_file(filp)) {
1617 ret = sensor_call(cam, core, s_power, 1);
1618 if (ret)
1619 goto out;
1620 ret = pm_runtime_resume_and_get(dev: cam->dev);
1621 if (ret < 0)
1622 goto out;
1623 __mcam_cam_reset(cam);
1624 mcam_set_config_needed(cam, needed: 1);
1625 }
1626out:
1627 mutex_unlock(lock: &cam->s_mutex);
1628 if (ret)
1629 v4l2_fh_release(filp);
1630 return ret;
1631}
1632
1633
1634static int mcam_v4l_release(struct file *filp)
1635{
1636 struct mcam_camera *cam = video_drvdata(file: filp);
1637 bool last_open;
1638
1639 mutex_lock(&cam->s_mutex);
1640 last_open = v4l2_fh_is_singular_file(filp);
1641 _vb2_fop_release(file: filp, NULL);
1642 if (last_open) {
1643 mcam_disable_mipi(mcam: cam);
1644 sensor_call(cam, core, s_power, 0);
1645 pm_runtime_put(dev: cam->dev);
1646 if (cam->buffer_mode == B_vmalloc && alloc_bufs_at_read)
1647 mcam_free_dma_bufs(cam);
1648 }
1649
1650 mutex_unlock(lock: &cam->s_mutex);
1651 return 0;
1652}
1653
1654static const struct v4l2_file_operations mcam_v4l_fops = {
1655 .owner = THIS_MODULE,
1656 .open = mcam_v4l_open,
1657 .release = mcam_v4l_release,
1658 .read = vb2_fop_read,
1659 .poll = vb2_fop_poll,
1660 .mmap = vb2_fop_mmap,
1661 .unlocked_ioctl = video_ioctl2,
1662};
1663
1664
1665/*
1666 * This template device holds all of those v4l2 methods; we
1667 * clone it for specific real devices.
1668 */
1669static const struct video_device mcam_v4l_template = {
1670 .name = "mcam",
1671 .fops = &mcam_v4l_fops,
1672 .ioctl_ops = &mcam_v4l_ioctl_ops,
1673 .release = video_device_release_empty,
1674 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
1675 V4L2_CAP_STREAMING,
1676};
1677
1678/* ---------------------------------------------------------------------- */
1679/*
1680 * Interrupt handler stuff
1681 */
1682static void mcam_frame_complete(struct mcam_camera *cam, int frame)
1683{
1684 /*
1685 * Basic frame housekeeping.
1686 */
1687 set_bit(nr: frame, addr: &cam->flags);
1688 clear_bit(CF_DMA_ACTIVE, addr: &cam->flags);
1689 cam->next_buf = frame;
1690 cam->buf_seq[frame] = cam->sequence++;
1691 cam->frame_state.frames++;
1692 /*
1693 * "This should never happen"
1694 */
1695 if (cam->state != S_STREAMING)
1696 return;
1697 /*
1698 * Process the frame and set up the next one.
1699 */
1700 cam->frame_complete(cam, frame);
1701}
1702
1703
1704/*
1705 * The interrupt handler; this needs to be called from the
1706 * platform irq handler with the lock held.
1707 */
1708int mccic_irq(struct mcam_camera *cam, unsigned int irqs)
1709{
1710 unsigned int frame, handled = 0;
1711
1712 mcam_reg_write(cam, REG_IRQSTAT, FRAMEIRQS); /* Clear'em all */
1713 /*
1714 * Handle any frame completions. There really should
1715 * not be more than one of these, or we have fallen
1716 * far behind.
1717 *
1718 * When running in S/G mode, the frame number lacks any
1719 * real meaning - there's only one descriptor array - but
1720 * the controller still picks a different one to signal
1721 * each time.
1722 */
1723 for (frame = 0; frame < cam->nbufs; frame++)
1724 if (irqs & (IRQ_EOF0 << frame) &&
1725 test_bit(CF_FRAME_SOF0 + frame, &cam->flags)) {
1726 mcam_frame_complete(cam, frame);
1727 handled = 1;
1728 clear_bit(CF_FRAME_SOF0 + frame, addr: &cam->flags);
1729 if (cam->buffer_mode == B_DMA_sg)
1730 break;
1731 }
1732 /*
1733 * If a frame starts, note that we have DMA active. This
1734 * code assumes that we won't get multiple frame interrupts
1735 * at once; may want to rethink that.
1736 */
1737 for (frame = 0; frame < cam->nbufs; frame++) {
1738 if (irqs & (IRQ_SOF0 << frame)) {
1739 set_bit(CF_FRAME_SOF0 + frame, addr: &cam->flags);
1740 handled = IRQ_HANDLED;
1741 }
1742 }
1743
1744 if (handled == IRQ_HANDLED) {
1745 set_bit(CF_DMA_ACTIVE, addr: &cam->flags);
1746 if (cam->buffer_mode == B_DMA_sg)
1747 mcam_ctlr_stop(cam);
1748 }
1749 return handled;
1750}
1751EXPORT_SYMBOL_GPL(mccic_irq);
1752
1753/* ---------------------------------------------------------------------- */
1754/*
1755 * Registration and such.
1756 */
1757
1758static int mccic_notify_bound(struct v4l2_async_notifier *notifier,
1759 struct v4l2_subdev *subdev, struct v4l2_async_connection *asd)
1760{
1761 struct mcam_camera *cam = notifier_to_mcam(notifier);
1762 int ret;
1763
1764 mutex_lock(&cam->s_mutex);
1765 if (cam->sensor) {
1766 cam_err(cam, "sensor already bound\n");
1767 ret = -EBUSY;
1768 goto out;
1769 }
1770
1771 v4l2_set_subdev_hostdata(sd: subdev, p: cam);
1772 cam->sensor = subdev;
1773
1774 ret = mcam_cam_init(cam);
1775 if (ret) {
1776 cam->sensor = NULL;
1777 goto out;
1778 }
1779
1780 ret = mcam_setup_vb2(cam);
1781 if (ret) {
1782 cam->sensor = NULL;
1783 goto out;
1784 }
1785
1786 cam->vdev = mcam_v4l_template;
1787 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1788 cam->vdev.lock = &cam->s_mutex;
1789 cam->vdev.queue = &cam->vb_queue;
1790 video_set_drvdata(vdev: &cam->vdev, data: cam);
1791 ret = video_register_device(vdev: &cam->vdev, type: VFL_TYPE_VIDEO, nr: -1);
1792 if (ret) {
1793 cam->sensor = NULL;
1794 goto out;
1795 }
1796
1797 cam_dbg(cam, "sensor %s bound\n", subdev->name);
1798out:
1799 mutex_unlock(lock: &cam->s_mutex);
1800 return ret;
1801}
1802
1803static void mccic_notify_unbind(struct v4l2_async_notifier *notifier,
1804 struct v4l2_subdev *subdev, struct v4l2_async_connection *asd)
1805{
1806 struct mcam_camera *cam = notifier_to_mcam(notifier);
1807
1808 mutex_lock(&cam->s_mutex);
1809 if (cam->sensor != subdev) {
1810 cam_err(cam, "sensor %s not bound\n", subdev->name);
1811 goto out;
1812 }
1813
1814 video_unregister_device(vdev: &cam->vdev);
1815 cam->sensor = NULL;
1816 cam_dbg(cam, "sensor %s unbound\n", subdev->name);
1817
1818out:
1819 mutex_unlock(lock: &cam->s_mutex);
1820}
1821
1822static int mccic_notify_complete(struct v4l2_async_notifier *notifier)
1823{
1824 struct mcam_camera *cam = notifier_to_mcam(notifier);
1825 int ret;
1826
1827 /*
1828 * Get the v4l2 setup done.
1829 */
1830 ret = v4l2_ctrl_handler_init(&cam->ctrl_handler, 10);
1831 if (!ret)
1832 cam->v4l2_dev.ctrl_handler = &cam->ctrl_handler;
1833
1834 return ret;
1835}
1836
1837static const struct v4l2_async_notifier_operations mccic_notify_ops = {
1838 .bound = mccic_notify_bound,
1839 .unbind = mccic_notify_unbind,
1840 .complete = mccic_notify_complete,
1841};
1842
1843int mccic_register(struct mcam_camera *cam)
1844{
1845 struct clk_init_data mclk_init = { };
1846 int ret;
1847
1848 /*
1849 * Validate the requested buffer mode.
1850 */
1851 if (buffer_mode >= 0)
1852 cam->buffer_mode = buffer_mode;
1853 if (cam->buffer_mode == B_DMA_sg &&
1854 cam->chip_id == MCAM_CAFE) {
1855 printk(KERN_ERR "marvell-cam: Cafe can't do S/G I/O, attempting vmalloc mode instead\n");
1856 cam->buffer_mode = B_vmalloc;
1857 }
1858
1859 if (!mcam_buffer_mode_supported(mode: cam->buffer_mode)) {
1860 printk(KERN_ERR "marvell-cam: buffer mode %d unsupported\n",
1861 cam->buffer_mode);
1862 ret = -EINVAL;
1863 goto out;
1864 }
1865
1866 mutex_init(&cam->s_mutex);
1867 cam->state = S_NOTREADY;
1868 mcam_set_config_needed(cam, needed: 1);
1869 cam->pix_format = mcam_def_pix_format;
1870 cam->mbus_code = mcam_def_mbus_code;
1871
1872 cam->notifier.ops = &mccic_notify_ops;
1873 ret = v4l2_async_nf_register(notifier: &cam->notifier);
1874 if (ret < 0) {
1875 cam_warn(cam, "failed to register a sensor notifier");
1876 goto out;
1877 }
1878
1879 /*
1880 * Register sensor master clock.
1881 */
1882 mclk_init.parent_names = NULL;
1883 mclk_init.num_parents = 0;
1884 mclk_init.ops = &mclk_ops;
1885 mclk_init.name = "mclk";
1886
1887 of_property_read_string(np: cam->dev->of_node, propname: "clock-output-names",
1888 out_string: &mclk_init.name);
1889
1890 cam->mclk_hw.init = &mclk_init;
1891
1892 cam->mclk = devm_clk_register(dev: cam->dev, hw: &cam->mclk_hw);
1893 if (IS_ERR(ptr: cam->mclk)) {
1894 ret = PTR_ERR(ptr: cam->mclk);
1895 dev_err(cam->dev, "can't register clock\n");
1896 goto out;
1897 }
1898
1899 /*
1900 * If so requested, try to get our DMA buffers now.
1901 */
1902 if (cam->buffer_mode == B_vmalloc && !alloc_bufs_at_read) {
1903 if (mcam_alloc_dma_bufs(cam, loadtime: 1))
1904 cam_warn(cam, "Unable to alloc DMA buffers at load will try again later.");
1905 }
1906
1907 return 0;
1908
1909out:
1910 v4l2_async_nf_unregister(notifier: &cam->notifier);
1911 v4l2_async_nf_cleanup(notifier: &cam->notifier);
1912 return ret;
1913}
1914EXPORT_SYMBOL_GPL(mccic_register);
1915
1916void mccic_shutdown(struct mcam_camera *cam)
1917{
1918 /*
1919 * If we have no users (and we really, really should have no
1920 * users) the device will already be powered down. Trying to
1921 * take it down again will wedge the machine, which is frowned
1922 * upon.
1923 */
1924 if (!list_empty(head: &cam->vdev.fh_list)) {
1925 cam_warn(cam, "Removing a device with users!\n");
1926 sensor_call(cam, core, s_power, 0);
1927 }
1928 if (cam->buffer_mode == B_vmalloc)
1929 mcam_free_dma_bufs(cam);
1930 v4l2_ctrl_handler_free(hdl: &cam->ctrl_handler);
1931 v4l2_async_nf_unregister(notifier: &cam->notifier);
1932 v4l2_async_nf_cleanup(notifier: &cam->notifier);
1933}
1934EXPORT_SYMBOL_GPL(mccic_shutdown);
1935
1936/*
1937 * Power management
1938 */
1939void mccic_suspend(struct mcam_camera *cam)
1940{
1941 mutex_lock(&cam->s_mutex);
1942 if (!list_empty(head: &cam->vdev.fh_list)) {
1943 enum mcam_state cstate = cam->state;
1944
1945 mcam_ctlr_stop_dma(cam);
1946 sensor_call(cam, core, s_power, 0);
1947 cam->state = cstate;
1948 }
1949 mutex_unlock(lock: &cam->s_mutex);
1950}
1951EXPORT_SYMBOL_GPL(mccic_suspend);
1952
1953int mccic_resume(struct mcam_camera *cam)
1954{
1955 int ret = 0;
1956
1957 mutex_lock(&cam->s_mutex);
1958 if (!list_empty(head: &cam->vdev.fh_list)) {
1959 ret = sensor_call(cam, core, s_power, 1);
1960 if (ret) {
1961 mutex_unlock(lock: &cam->s_mutex);
1962 return ret;
1963 }
1964 __mcam_cam_reset(cam);
1965 } else {
1966 sensor_call(cam, core, s_power, 0);
1967 }
1968 mutex_unlock(lock: &cam->s_mutex);
1969
1970 set_bit(CF_CONFIG_NEEDED, addr: &cam->flags);
1971 if (cam->state == S_STREAMING) {
1972 /*
1973 * If there was a buffer in the DMA engine at suspend
1974 * time, put it back on the queue or we'll forget about it.
1975 */
1976 if (cam->buffer_mode == B_DMA_sg && cam->vb_bufs[0])
1977 list_add(new: &cam->vb_bufs[0]->queue, head: &cam->buffers);
1978 ret = mcam_read_setup(cam);
1979 }
1980 return ret;
1981}
1982EXPORT_SYMBOL_GPL(mccic_resume);
1983
1984MODULE_LICENSE("GPL v2");
1985MODULE_AUTHOR("Jonathan Corbet <corbet@lwn.net>");
1986

source code of linux/drivers/media/platform/marvell/mcam-core.c