d8b4ff1d4d583ad3954a9a0475571dd4d963702d
[linux-3.10.git] / drivers / media / platform / soc_camera / tegra_camera / common.c
1 /*
2  * Copyright (c) 2013-2015, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms and conditions of the GNU General Public License,
6  * version 2, as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope it will be useful, but WITHOUT
9  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
11  * more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
15  */
16
17 #include <linux/delay.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/nvhost.h>
22 #include <linux/of.h>
23 #include <linux/of_device.h>
24 #include <linux/of_platform.h>
25 #include <linux/tegra_pm_domains.h>
26
27 #include <mach/powergate.h>
28
29 #include <media/soc_camera.h>
30 #include <media/soc_mediabus.h>
31 #include <media/videobuf2-dma-contig.h>
32 #include <media/tegra_v4l2_camera.h>
33
34 #include "dev.h"
35 #include "bus_client.h"
36 #include "nvhost_acm.h"
37 #include "t124/t124.h"
38
39 #include "common.h"
40
41 static int tpg_mode;
42 module_param(tpg_mode, int, 0644);
43
44 #define TEGRA_CAM_DRV_NAME "vi"
45 #define TEGRA_CAM_VERSION_CODE KERNEL_VERSION(0, 0, 5)
46
47 #define TEGRA_SYNCPT_RETRY_COUNT        10
48
49 static const struct soc_mbus_pixelfmt tegra_camera_yuv_formats[] = {
50         {
51                 .fourcc                 = V4L2_PIX_FMT_UYVY,
52                 .name                   = "YUV422 (UYVY) packed",
53                 .bits_per_sample        = 16,
54                 .packing                = SOC_MBUS_PACKING_NONE,
55                 .order                  = SOC_MBUS_ORDER_LE,
56         },
57         {
58                 .fourcc                 = V4L2_PIX_FMT_VYUY,
59                 .name                   = "YUV422 (VYUY) packed",
60                 .bits_per_sample        = 16,
61                 .packing                = SOC_MBUS_PACKING_NONE,
62                 .order                  = SOC_MBUS_ORDER_LE,
63         },
64         {
65                 .fourcc                 = V4L2_PIX_FMT_YUYV,
66                 .name                   = "YUV422 (YUYV) packed",
67                 .bits_per_sample        = 16,
68                 .packing                = SOC_MBUS_PACKING_NONE,
69                 .order                  = SOC_MBUS_ORDER_LE,
70         },
71         {
72                 .fourcc                 = V4L2_PIX_FMT_YVYU,
73                 .name                   = "YUV422 (YVYU) packed",
74                 .bits_per_sample        = 16,
75                 .packing                = SOC_MBUS_PACKING_NONE,
76                 .order                  = SOC_MBUS_ORDER_LE,
77         },
78         {
79                 .fourcc                 = V4L2_PIX_FMT_YUV420,
80                 .name                   = "YUV420 (YU12) planar",
81                 .bits_per_sample        = 12,
82                 .packing                = SOC_MBUS_PACKING_NONE,
83                 .order                  = SOC_MBUS_ORDER_LE,
84         },
85         {
86                 .fourcc                 = V4L2_PIX_FMT_YVU420,
87                 .name                   = "YVU420 (YV12) planar",
88                 .bits_per_sample        = 12,
89                 .packing                = SOC_MBUS_PACKING_NONE,
90                 .order                  = SOC_MBUS_ORDER_LE,
91         },
92 };
93
94 static const struct soc_mbus_pixelfmt tegra_camera_bayer_formats[] = {
95         {
96                 .fourcc                 = V4L2_PIX_FMT_SBGGR8,
97                 .name                   = "Bayer 8 BGBG.. GRGR..",
98                 .bits_per_sample        = 8,
99                 .packing                = SOC_MBUS_PACKING_NONE,
100                 .order                  = SOC_MBUS_ORDER_LE,
101         },
102         {
103                 .fourcc                 = V4L2_PIX_FMT_SGBRG8,
104                 .name                   = "Bayer 8 GBGB.. RGRG..",
105                 .bits_per_sample        = 8,
106                 .packing                = SOC_MBUS_PACKING_NONE,
107                 .order                  = SOC_MBUS_ORDER_LE,
108         },
109         {
110                 .fourcc                 = V4L2_PIX_FMT_SBGGR10,
111                 .name                   = "Bayer 10 BGBG.. GRGR..",
112                 .bits_per_sample        = 16,
113                 .packing                = SOC_MBUS_PACKING_EXTEND16,
114                 .order                  = SOC_MBUS_ORDER_LE,
115         },
116         {
117                 .fourcc                 = V4L2_PIX_FMT_SRGGB10,
118                 .name                   = "Bayer 10 RGRG.. GBGB..",
119                 .bits_per_sample        = 16,
120                 .packing                = SOC_MBUS_PACKING_EXTEND16,
121                 .order                  = SOC_MBUS_ORDER_LE,
122         },
123 };
124
125 static const struct soc_mbus_pixelfmt tegra_camera_rgb_formats[] = {
126         {
127                 .fourcc                 = V4L2_PIX_FMT_RGB32,
128                 .name                   = "RGBA 8-8-8-8",
129                 .bits_per_sample        = 32,
130                 .packing                = SOC_MBUS_PACKING_NONE,
131                 .order                  = SOC_MBUS_ORDER_LE,
132         },
133 };
134
135 static int tegra_camera_activate(struct tegra_camera_dev *cam,
136                                  struct soc_camera_device *icd)
137 {
138         struct tegra_camera_ops *cam_ops = cam->ops;
139         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
140         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
141         int port = pdata->port;
142         int ret;
143
144         ret = nvhost_module_busy_ext(cam->ndev);
145         if (ret) {
146                 dev_err(&cam->ndev->dev, "nvhost module is busy\n");
147                 return ret;
148         }
149
150         /* Enable external power */
151         if (cam->reg) {
152                 ret = regulator_enable(cam->reg);
153                 if (ret)
154                         dev_err(&cam->ndev->dev, "enabling regulator failed\n");
155         }
156
157         if (cam_ops->activate)
158                 cam_ops->activate(cam);
159
160         /* Unpowergate VE */
161         tegra_unpowergate_partition(TEGRA_POWERGATE_VENC);
162
163         /* Init Clocks */
164         if (cam_ops->clks_init)
165                 cam_ops->clks_init(cam, port);
166
167         if (cam_ops->clks_enable)
168                 cam_ops->clks_enable(cam);
169
170         if (cam_ops->capture_clean)
171                 cam_ops->capture_clean(cam);
172
173         cam->sof = 1;
174
175         return 0;
176 }
177
178 static void tegra_camera_deactivate(struct tegra_camera_dev *cam)
179 {
180         struct tegra_camera_ops *cam_ops = cam->ops;
181
182         if (cam_ops->clks_disable)
183                 cam_ops->clks_disable(cam);
184
185         if (cam->ops->clks_deinit)
186                 cam->ops->clks_deinit(cam);
187
188         if (cam_ops->deactivate)
189                 cam_ops->deactivate(cam);
190
191         /* Powergate VE */
192         tegra_powergate_partition(TEGRA_POWERGATE_VENC);
193
194         /* Disable external power */
195         if (cam->reg)
196                 regulator_disable(cam->reg);
197
198         nvhost_module_idle_ext(cam->ndev);
199
200         cam->sof = 0;
201         cam->cal_done = 0;
202 }
203
204 static int tegra_camera_capture_frame(struct tegra_camera_dev *cam)
205 {
206         struct vb2_buffer *vb = cam->active;
207         struct tegra_camera_buffer *buf = to_tegra_vb(vb);
208         struct soc_camera_device *icd = buf->icd;
209         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
210         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
211         int port = pdata->port;
212         int retry = TEGRA_SYNCPT_RETRY_COUNT;
213         int err;
214
215         /* Setup capture registers */
216         cam->ops->capture_setup(cam);
217
218         cam->ops->incr_syncpts(cam);
219
220         /* MIPI CSI pads calibration after starting capture */
221         if (cam->ops->mipi_calibration && !cam->cal_done) {
222                 err = cam->ops->mipi_calibration(cam);
223                 if (!err)
224                         cam->cal_done = 1;
225         }
226
227         while (retry) {
228                 err = cam->ops->capture_start(cam, buf);
229                 if (err) {
230                         retry--;
231
232                         cam->ops->incr_syncpts(cam);
233                         if (cam->ops->save_syncpts)
234                                 cam->ops->save_syncpts(cam);
235
236                         continue;
237                 }
238                 break;
239         }
240
241         /* Reset hardware for too many errors */
242         if (!retry) {
243                 tegra_camera_deactivate(cam);
244                 mdelay(5);
245                 tegra_camera_activate(cam, icd);
246                 if (cam->active)
247                         cam->ops->capture_setup(cam);
248         }
249
250         spin_lock_irq(&cam->videobuf_queue_lock);
251
252         vb = cam->active;
253         do_gettimeofday(&vb->v4l2_buf.timestamp);
254         vb->v4l2_buf.field = cam->field;
255         if (port == TEGRA_CAMERA_PORT_CSI_A)
256                 vb->v4l2_buf.sequence = cam->sequence_a++;
257         else if (port == TEGRA_CAMERA_PORT_CSI_B)
258                 vb->v4l2_buf.sequence = cam->sequence_b++;
259
260         vb2_buffer_done(vb, err < 0 ? VB2_BUF_STATE_ERROR : VB2_BUF_STATE_DONE);
261         list_del_init(&buf->queue);
262
263         cam->num_frames++;
264
265         spin_unlock_irq(&cam->videobuf_queue_lock);
266
267         return err;
268 }
269
270 static void tegra_camera_work(struct work_struct *work)
271 {
272         struct tegra_camera_dev *cam =
273                 container_of(work, struct tegra_camera_dev, work);
274         struct tegra_camera_buffer *buf;
275
276         while (1) {
277                 mutex_lock(&cam->work_mutex);
278
279                 spin_lock_irq(&cam->videobuf_queue_lock);
280                 if (list_empty(&cam->capture)) {
281                         cam->active = NULL;
282                         spin_unlock_irq(&cam->videobuf_queue_lock);
283                         mutex_unlock(&cam->work_mutex);
284                         return;
285                 }
286
287                 buf = list_entry(cam->capture.next, struct tegra_camera_buffer,
288                                 queue);
289                 cam->active = &buf->vb;
290                 spin_unlock_irq(&cam->videobuf_queue_lock);
291
292                 tegra_camera_capture_frame(cam);
293
294                 mutex_unlock(&cam->work_mutex);
295         }
296 }
297
298 static int tegra_camera_init_buffer(struct tegra_camera_buffer *buf)
299 {
300         struct soc_camera_device *icd = buf->icd;
301         int bytes_per_line = soc_mbus_bytes_per_line(icd->user_width,
302                                                 icd->current_fmt->host_fmt);
303         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
304         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
305
306         switch (icd->current_fmt->host_fmt->fourcc) {
307         case V4L2_PIX_FMT_UYVY:
308         case V4L2_PIX_FMT_VYUY:
309         case V4L2_PIX_FMT_YUYV:
310         case V4L2_PIX_FMT_YVYU:
311         case V4L2_PIX_FMT_SBGGR8:
312         case V4L2_PIX_FMT_SGBRG8:
313         case V4L2_PIX_FMT_SBGGR10:
314         case V4L2_PIX_FMT_SRGGB10:
315         case V4L2_PIX_FMT_RGB32:
316                 buf->buffer_addr = vb2_dma_contig_plane_dma_addr(&buf->vb, 0);
317                 buf->start_addr = buf->buffer_addr;
318
319                 if (pdata->flip_v)
320                         buf->start_addr += bytes_per_line *
321                                            (icd->user_height-1);
322
323                 if (pdata->flip_h)
324                         buf->start_addr += bytes_per_line - 1;
325
326                 break;
327
328         case V4L2_PIX_FMT_YUV420:
329         case V4L2_PIX_FMT_YVU420:
330                 buf->buffer_addr = vb2_dma_contig_plane_dma_addr(&buf->vb, 0);
331                 buf->buffer_addr_u = buf->buffer_addr +
332                                      icd->user_width * icd->user_height;
333                 buf->buffer_addr_v = buf->buffer_addr_u +
334                                      (icd->user_width * icd->user_height) / 4;
335
336                 /* For YVU420, we swap the locations of the U and V planes. */
337                 if (icd->current_fmt->host_fmt->fourcc == V4L2_PIX_FMT_YVU420) {
338                         dma_addr_t temp = buf->buffer_addr_u;
339                         buf->buffer_addr_u = buf->buffer_addr_v;
340                         buf->buffer_addr_v = temp;
341                 }
342
343                 buf->start_addr = buf->buffer_addr;
344                 buf->start_addr_u = buf->buffer_addr_u;
345                 buf->start_addr_v = buf->buffer_addr_v;
346
347                 if (pdata->flip_v) {
348                         buf->start_addr += icd->user_width *
349                                            (icd->user_height - 1);
350
351                         buf->start_addr_u += ((icd->user_width/2) *
352                                               ((icd->user_height/2) - 1));
353
354                         buf->start_addr_v += ((icd->user_width/2) *
355                                               ((icd->user_height/2) - 1));
356                 }
357
358                 if (pdata->flip_h) {
359                         buf->start_addr += icd->user_width - 1;
360
361                         buf->start_addr_u += (icd->user_width/2) - 1;
362
363                         buf->start_addr_v += (icd->user_width/2) - 1;
364                 }
365
366                 break;
367
368         default:
369                 dev_err(icd->parent, "Wrong host format %d\n",
370                         icd->current_fmt->host_fmt->fourcc);
371                 return -EINVAL;
372         }
373
374         return 0;
375 }
376
377 /*
378  *  Videobuf operations
379  */
380 static int tegra_camera_videobuf_setup(struct vb2_queue *vq,
381                                        const struct v4l2_format *fmt,
382                                        unsigned int *num_buffers,
383                                        unsigned int *num_planes,
384                                        unsigned int sizes[],
385                                        void *alloc_ctxs[])
386 {
387         struct soc_camera_device *icd = container_of(vq,
388                                                      struct soc_camera_device,
389                                                      vb2_vidq);
390         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
391         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
392         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
393         struct tegra_camera_dev *cam = ici->priv;
394         int bytes_per_line = soc_mbus_bytes_per_line(icd->user_width,
395                                                 icd->current_fmt->host_fmt);
396         if (bytes_per_line < 0)
397                 return bytes_per_line;
398
399         *num_planes = 1;
400
401         if (pdata->port == TEGRA_CAMERA_PORT_CSI_A)
402                 cam->sequence_a = 0;
403         else if (pdata->port == TEGRA_CAMERA_PORT_CSI_B)
404                 cam->sequence_b = 0;
405         sizes[0] = bytes_per_line * icd->user_height;
406         alloc_ctxs[0] = cam->alloc_ctx;
407
408         if (!*num_buffers)
409                 *num_buffers = 2;
410
411         return 0;
412 }
413
414 static int tegra_camera_videobuf_prepare(struct vb2_buffer *vb)
415 {
416         struct soc_camera_device *icd = container_of(vb->vb2_queue,
417                                                      struct soc_camera_device,
418                                                      vb2_vidq);
419         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
420         struct tegra_camera_dev *cam = ici->priv;
421         struct tegra_camera_buffer *buf = to_tegra_vb(vb);
422         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
423         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
424         int bytes_per_line = soc_mbus_bytes_per_line(icd->user_width,
425                                                 icd->current_fmt->host_fmt);
426         unsigned long size;
427
428         if (bytes_per_line < 0)
429                 return bytes_per_line;
430
431         buf->icd = icd;
432
433         if (!pdata) {
434                 dev_err(icd->parent, "No platform data for this device!\n");
435                 return -EINVAL;
436         }
437
438         if (!cam->ops->port_is_valid(pdata->port)) {
439                 dev_err(icd->parent,
440                         "Invalid camera port %d in platform data\n",
441                         pdata->port);
442                 return -EINVAL;
443         }
444
445 #ifdef PREFILL_BUFFER
446         dev_info(icd->parent, "%s (vb=0x%p) 0x%p %lu\n", __func__,
447                 vb, vb2_plane_vaddr(vb, 0), vb2_plane_size(vb, 0));
448
449         /*
450          * This can be useful if you want to see if we actually fill
451          * the buffer with something
452          */
453         if (vb2_plane_vaddr(vb, 0))
454                 memset(vb2_plane_vaddr(vb, 0), 0xbd, vb2_plane_size(vb, 0));
455 #endif
456
457         if (!icd->current_fmt) {
458                 dev_err(icd->parent, "%s NULL format point\n", __func__);
459                 return -EINVAL;
460         }
461
462         size = icd->user_height * bytes_per_line;
463
464         if (vb2_plane_size(vb, 0) < size) {
465                 dev_err(icd->parent, "Buffer too small (%lu < %lu)\n",
466                         vb2_plane_size(vb, 0), size);
467                 return -ENOBUFS;
468         }
469
470         vb2_set_plane_payload(vb, 0, size);
471
472         return tegra_camera_init_buffer(buf);
473 }
474
475 static void tegra_camera_videobuf_queue(struct vb2_buffer *vb)
476 {
477         struct soc_camera_device *icd = container_of(vb->vb2_queue,
478                                                      struct soc_camera_device,
479                                                      vb2_vidq);
480         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
481         struct tegra_camera_dev *cam = ici->priv;
482         struct tegra_camera_buffer *buf = to_tegra_vb(vb);
483
484         spin_lock_irq(&cam->videobuf_queue_lock);
485         list_add_tail(&buf->queue, &cam->capture);
486         schedule_work(&cam->work);
487         spin_unlock_irq(&cam->videobuf_queue_lock);
488 }
489
490 static void tegra_camera_videobuf_release(struct vb2_buffer *vb)
491 {
492         struct soc_camera_device *icd = container_of(vb->vb2_queue,
493                                                      struct soc_camera_device,
494                                                      vb2_vidq);
495         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
496         struct tegra_camera_buffer *buf = to_tegra_vb(vb);
497         struct tegra_camera_dev *cam = ici->priv;
498
499         mutex_lock(&cam->work_mutex);
500
501         spin_lock_irq(&cam->videobuf_queue_lock);
502
503         if (cam->active == vb)
504                 cam->active = NULL;
505
506         /*
507          * Doesn't hurt also if the list is empty, but it hurts, if queuing the
508          * buffer failed, and .buf_init() hasn't been called
509          */
510         if (buf->queue.next)
511                 list_del_init(&buf->queue);
512
513         spin_unlock_irq(&cam->videobuf_queue_lock);
514
515         mutex_unlock(&cam->work_mutex);
516 }
517
518 static int tegra_camera_videobuf_init(struct vb2_buffer *vb)
519 {
520         /* This is for locking debugging only */
521         INIT_LIST_HEAD(&to_tegra_vb(vb)->queue);
522
523         return 0;
524 }
525
526 static int tegra_camera_stop_streaming(struct vb2_queue *q)
527 {
528         struct soc_camera_device *icd = container_of(q,
529                                                      struct soc_camera_device,
530                                                      vb2_vidq);
531         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
532         struct tegra_camera_dev *cam = ici->priv;
533         struct soc_camera_subdev_desc *ssdesc = &icd->sdesc->subdev_desc;
534         struct tegra_camera_platform_data *pdata = ssdesc->drv_priv;
535         int port = pdata->port;
536
537         mutex_lock(&cam->work_mutex);
538         cam->ops->capture_stop(cam, port);
539         mutex_unlock(&cam->work_mutex);
540
541         return 0;
542 }
543
544 static struct vb2_ops tegra_camera_videobuf_ops = {
545         .queue_setup    = tegra_camera_videobuf_setup,
546         .buf_prepare    = tegra_camera_videobuf_prepare,
547         .buf_queue      = tegra_camera_videobuf_queue,
548         .buf_cleanup    = tegra_camera_videobuf_release,
549         .buf_init       = tegra_camera_videobuf_init,
550         .wait_prepare   = soc_camera_unlock,
551         .wait_finish    = soc_camera_lock,
552         .stop_streaming = tegra_camera_stop_streaming,
553 };
554
555 /*
556  *  SOC camera host operations
557  */
558 static int tegra_camera_init_videobuf(struct vb2_queue *q,
559                                       struct soc_camera_device *icd)
560 {
561         q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
562         q->io_modes = VB2_MMAP | VB2_USERPTR;
563         q->drv_priv = icd;
564         q->ops = &tegra_camera_videobuf_ops;
565         q->mem_ops = &vb2_dma_contig_memops;
566         q->buf_struct_size = sizeof(struct tegra_camera_buffer);
567         q->timestamp_type = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
568
569         return vb2_queue_init(q);
570 }
571
572 /*
573  * Called with .video_lock held
574  */
575 static int tegra_camera_add_device(struct soc_camera_device *icd)
576 {
577         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
578         struct tegra_camera_dev *cam = ici->priv;
579         int ret;
580
581         if (!cam->enable_refcnt) {
582                 ret = tegra_camera_activate(cam, icd);
583                 if (ret)
584                         return ret;
585                 cam->num_frames = 0;
586         }
587         cam->enable_refcnt++;
588
589         return 0;
590 }
591
592 /* Called with .video_lock held */
593 static void tegra_camera_remove_device(struct soc_camera_device *icd)
594 {
595         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
596         struct tegra_camera_dev *cam = ici->priv;
597
598         cam->enable_refcnt--;
599         if (!cam->enable_refcnt) {
600                 cancel_work_sync(&cam->work);
601                 tegra_camera_deactivate(cam);
602         }
603 }
604
605 static int tegra_camera_set_bus_param(struct soc_camera_device *icd)
606 {
607         return 0;
608 }
609
610 static int tegra_camera_get_formats(struct soc_camera_device *icd,
611                                     unsigned int idx,
612                                     struct soc_camera_format_xlate *xlate)
613 {
614         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
615         struct device *dev = icd->parent;
616         struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
617         struct tegra_camera_dev *cam = ici->priv;
618         int num_formats;
619         const struct soc_mbus_pixelfmt *formats;
620         int ret;
621         enum v4l2_mbus_pixelcode code;
622         int k;
623
624         /*
625          * If we're in test pattern mode, ignore the subdev's formats, and
626          * pick a format that the test pattern mode can handle.
627          */
628         if (!cam->tpg_mode) {
629                 ret = v4l2_subdev_call(sd, video, enum_mbus_fmt, idx, &code);
630                 if (ret != 0)
631                         /* No more formats */
632                         return 0;
633         } else
634                 code = V4L2_MBUS_FMT_RGBA8888_4X8_LE;
635
636         switch (code) {
637         case V4L2_MBUS_FMT_UYVY8_2X8:
638         case V4L2_MBUS_FMT_VYUY8_2X8:
639         case V4L2_MBUS_FMT_YUYV8_2X8:
640         case V4L2_MBUS_FMT_YVYU8_2X8:
641                 formats = tegra_camera_yuv_formats;
642                 num_formats = ARRAY_SIZE(tegra_camera_yuv_formats);
643                 break;
644         case V4L2_MBUS_FMT_SBGGR8_1X8:
645         case V4L2_MBUS_FMT_SGBRG8_1X8:
646         case V4L2_MBUS_FMT_SBGGR10_1X10:
647         case V4L2_MBUS_FMT_SRGGB10_1X10:
648                 formats = tegra_camera_bayer_formats;
649                 num_formats = ARRAY_SIZE(tegra_camera_bayer_formats);
650                 break;
651         case V4L2_MBUS_FMT_RGBA8888_4X8_LE:
652                 formats = tegra_camera_rgb_formats;
653                 num_formats = ARRAY_SIZE(tegra_camera_rgb_formats);
654                 break;
655         default:
656                 dev_notice(dev, "Not supporting mbus format code 0x%04x\n",
657                            code);
658                 formats = NULL;
659                 num_formats = 0;
660         }
661
662         for (k = 0; xlate && (k < num_formats); k++) {
663                 xlate->host_fmt = &formats[k];
664                 xlate->code     = code;
665                 xlate++;
666
667                 dev_notice(dev, "Supporting mbus format code 0x%04x using %s\n",
668                            code, formats[k].name);
669         }
670
671         return num_formats;
672 }
673
674 static void tegra_camera_put_formats(struct soc_camera_device *icd)
675 {
676         kfree(icd->host_priv);
677         icd->host_priv = NULL;
678 }
679
680 static int tegra_camera_set_fmt(struct soc_camera_device *icd,
681                               struct v4l2_format *f)
682 {
683         struct device *dev = icd->parent;
684         struct soc_camera_host *ici = to_soc_camera_host(dev);
685         struct tegra_camera_dev *cam = ici->priv;
686         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
687         const struct soc_camera_format_xlate *xlate = NULL;
688         struct v4l2_pix_format *pix = &f->fmt.pix;
689         struct v4l2_mbus_framefmt mf;
690         int ret = 0;
691
692         xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
693         if (!xlate) {
694                 dev_warn(dev, "Format %x not found\n", pix->pixelformat);
695                 return -EINVAL;
696         }
697
698         mf.width        = pix->width;
699         mf.height       = pix->height;
700         mf.field        = pix->field;
701         mf.colorspace   = pix->colorspace;
702         mf.code         = xlate->code;
703
704         if (!cam->tpg_mode) {
705                 ret = v4l2_subdev_call(sd, video, s_mbus_fmt, &mf);
706                 if (IS_ERR_VALUE(ret)) {
707                         dev_warn(dev, "Failed to configure for format %x\n",
708                                  pix->pixelformat);
709                         return ret;
710                 }
711
712                 if (mf.code != xlate->code) {
713                         dev_warn(dev,
714                                  "mf.code = 0x%04x, xlate->code = 0x%04x, "
715                                  "mismatch\n", mf.code, xlate->code);
716                         return -EINVAL;
717                 }
718         }
719
720         icd->user_width         = mf.width;
721         icd->user_height        = mf.height;
722         icd->current_fmt        = xlate;
723
724         cam->field = pix->field;
725
726         return ret;
727 }
728
729 static int tegra_camera_try_fmt(struct soc_camera_device *icd,
730                                 struct v4l2_format *f)
731 {
732         struct device *dev = icd->parent;
733         struct soc_camera_host *ici = to_soc_camera_host(dev);
734         struct tegra_camera_dev *cam = ici->priv;
735         struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
736         const struct soc_camera_format_xlate *xlate;
737         struct v4l2_pix_format *pix = &f->fmt.pix;
738         struct v4l2_mbus_framefmt mf;
739         __u32 pixfmt = pix->pixelformat;
740         int ret = 0;
741
742         xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
743         if (!xlate) {
744                 dev_warn(icd->parent, "Format %x not found\n", pixfmt);
745                 return -EINVAL;
746         }
747
748         pix->bytesperline = soc_mbus_bytes_per_line(pix->width,
749                                                     xlate->host_fmt);
750         if (pix->bytesperline < 0)
751                 return pix->bytesperline;
752         pix->sizeimage = pix->height * pix->bytesperline;
753
754         /* limit to sensor capabilities */
755         mf.width        = pix->width;
756         mf.height       = pix->height;
757         mf.field        = pix->field;
758         mf.colorspace   = pix->colorspace;
759         mf.code         = xlate->code;
760
761         if (!cam->tpg_mode) {
762                 ret = v4l2_subdev_call(sd, video, try_mbus_fmt, &mf);
763                 if (IS_ERR_VALUE(ret))
764                         return ret;
765         }
766
767         pix->width      = mf.width;
768         pix->height     = mf.height;
769         pix->colorspace = mf.colorspace;
770         /*
771          * width and height could have been changed, therefore update the
772          * bytesperline and sizeimage here.
773          */
774         pix->bytesperline = soc_mbus_bytes_per_line(pix->width,
775                                                     xlate->host_fmt);
776         pix->sizeimage = pix->height * pix->bytesperline;
777
778         switch (mf.field) {
779         case V4L2_FIELD_ANY:
780         case V4L2_FIELD_NONE:
781                 pix->field      = V4L2_FIELD_NONE;
782                 break;
783         default:
784                 /* TODO: support interlaced at least in pass-through mode */
785                 dev_err(icd->parent, "Field type %d unsupported.\n",
786                         mf.field);
787                 return -EINVAL;
788         }
789
790         return ret;
791 }
792
793 static int tegra_camera_reqbufs(struct soc_camera_device *icd,
794                                 struct v4l2_requestbuffers *p)
795 {
796         return 0;
797 }
798
799 static unsigned int tegra_camera_poll(struct file *file, poll_table *pt)
800 {
801         struct soc_camera_device *icd = file->private_data;
802
803         return vb2_poll(&icd->vb2_vidq, file, pt);
804 }
805
806 static int tegra_camera_querycap(struct soc_camera_host *ici,
807                                  struct v4l2_capability *cap)
808 {
809         strlcpy(cap->card, TEGRA_CAM_DRV_NAME, sizeof(cap->card));
810         cap->version = TEGRA_CAM_VERSION_CODE;
811         cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING;
812
813         return 0;
814 }
815
816 static struct soc_camera_host_ops tegra_soc_camera_host_ops = {
817         .owner          = THIS_MODULE,
818         .init_videobuf2 = tegra_camera_init_videobuf,
819         .add            = tegra_camera_add_device,
820         .remove         = tegra_camera_remove_device,
821         .set_bus_param  = tegra_camera_set_bus_param,
822         .get_formats    = tegra_camera_get_formats,
823         .put_formats    = tegra_camera_put_formats,
824         .set_fmt        = tegra_camera_set_fmt,
825         .try_fmt        = tegra_camera_try_fmt,
826         .reqbufs        = tegra_camera_reqbufs,
827         .poll           = tegra_camera_poll,
828         .querycap       = tegra_camera_querycap,
829 };
830
831 static struct of_device_id tegra_vi_of_match[] = {
832 #ifdef TEGRA_12X_OR_HIGHER_CONFIG
833         { .compatible = "nvidia,tegra124-vi",
834                 .data = (struct nvhost_device_data *)&t124_vi_info },
835 #endif
836         { },
837 };
838
839 static int tegra_camera_probe(struct platform_device *pdev)
840 {
841         struct tegra_camera_dev *cam;
842         struct nvhost_device_data *ndata = NULL;
843         int err = 0;
844
845         if (pdev->dev.of_node) {
846                 const struct of_device_id *match;
847
848                 match = of_match_device(tegra_vi_of_match, &pdev->dev);
849                 if (match) {
850                         ndata = (struct nvhost_device_data *) match->data;
851                         pdev->dev.platform_data = ndata;
852                 }
853
854                 /*
855                  * Device Tree will initialize this ID as -1
856                  * Set it to the right value for future usage
857                  */
858                 pdev->id = pdev->dev.id;
859         } else
860                 ndata = pdev->dev.platform_data;
861
862         if (!ndata) {
863                 dev_err(&pdev->dev, "No nvhost device data!\n");
864                 err = -EINVAL;
865                 goto exit;
866         }
867
868         /* vi.1 has to wait vi.0 initialized, so defer probing */
869         if (pdev->id && ndata->master) {
870                 struct nvhost_device_data *master_ndata =
871                         ndata->master->dev.platform_data;
872                 if (master_ndata == platform_get_drvdata(ndata->master))
873                         return -EPROBE_DEFER;
874         }
875
876         cam = devm_kzalloc(&pdev->dev, sizeof(struct tegra_camera_dev),
877                            GFP_KERNEL);
878         if (!cam) {
879                 dev_err(&pdev->dev, "couldn't allocate cam\n");
880                 err = -ENOMEM;
881                 goto exit;
882         }
883
884         cam->ndata = ndata;
885         cam->ndev = pdev;
886
887         cam->ici.priv = cam;
888         cam->ici.v4l2_dev.dev = &pdev->dev;
889         cam->ici.nr = pdev->id;
890         cam->ici.drv_name = dev_name(&pdev->dev);
891         cam->ici.ops = &tegra_soc_camera_host_ops;
892
893         cam->tpg_mode = tpg_mode;
894
895         INIT_LIST_HEAD(&cam->capture);
896         INIT_WORK(&cam->work, tegra_camera_work);
897         spin_lock_init(&cam->videobuf_queue_lock);
898         mutex_init(&cam->work_mutex);
899
900         if (pdev->dev.of_node) {
901                 int cplen;
902                 const char *compat;
903                 compat = of_get_property(pdev->dev.of_node,
904                                          "compatible", &cplen);
905
906                 if (!strcmp(compat, "nvidia,tegra124-vi"))
907                         vi2_register(cam);
908                 else
909                         vi_register(cam);
910         } else {
911 #ifdef TEGRA_12X_OR_HIGHER_CONFIG
912         /* Register VI/CSI or VI2/CSI2 structs */
913                 vi2_register(cam);
914 #else
915                 vi_register(cam);
916 #endif
917         }
918
919         /* Init Regulator */
920         cam->reg = devm_regulator_get(&pdev->dev, cam->regulator_name);
921         if (IS_ERR_OR_NULL(cam->reg)) {
922                 dev_err(&pdev->dev, "%s: couldn't get regulator %s, err %ld\n",
923                         __func__, cam->regulator_name, PTR_ERR(cam->reg));
924                 cam->reg = NULL;
925                 goto exit;
926         }
927
928         mutex_init(&ndata->lock);
929         platform_set_drvdata(pdev, ndata);
930         err = nvhost_client_device_get_resources(pdev);
931         if (err) {
932                 dev_err(&pdev->dev, "%s: nvhost get resources failed %d\n",
933                                 __func__, err);
934                 goto exit;
935         }
936
937         /* Init syncpts */
938         cam->ops->init_syncpts(cam);
939
940         if (!ndata->aperture[0]) {
941                 if (ndata->master) {
942                         struct nvhost_device_data *master_ndata =
943                                 ndata->master->dev.platform_data;
944                         ndata->aperture[0] = master_ndata->aperture[0];
945                 } else {
946                         dev_err(&pdev->dev, "%s: failed to map register base\n",
947                                 __func__);
948                         err = -ENXIO;
949                         goto exit_free_syncpts;
950                 }
951         }
952         cam->reg_base = ndata->aperture[0];
953
954         /* Match the nvhost_module_init VENC powergating */
955         tegra_unpowergate_partition(TEGRA_POWERGATE_VENC);
956         nvhost_module_init(pdev);
957
958         err = nvhost_client_device_init(pdev);
959         if (err) {
960                 dev_err(&pdev->dev, "%s: nvhost init failed %d\n",
961                                 __func__, err);
962                 goto exit_free_syncpts;
963         }
964
965         cam->alloc_ctx = vb2_dma_contig_init_ctx(&pdev->dev);
966         if (IS_ERR(cam->alloc_ctx)) {
967                 err = PTR_ERR(cam->alloc_ctx);
968                 goto exit_free_syncpts;
969         }
970
971         platform_set_drvdata(pdev, cam);
972         err = soc_camera_host_register(&cam->ici);
973         if (IS_ERR_VALUE(err))
974                 goto exit_cleanup_alloc_ctx;
975
976         dev_notice(&pdev->dev, "Tegra camera driver loaded.\n");
977
978         return err;
979
980 exit_cleanup_alloc_ctx:
981         platform_set_drvdata(pdev, cam->ndata);
982         vb2_dma_contig_cleanup_ctx(cam->alloc_ctx);
983 exit_free_syncpts:
984         cam->ops->free_syncpts(cam);
985 exit:
986         return err;
987 }
988
989 static int tegra_camera_remove(struct platform_device *pdev)
990 {
991         struct soc_camera_host *ici = to_soc_camera_host(&pdev->dev);
992         struct tegra_camera_dev *cam = container_of(ici,
993                                         struct tegra_camera_dev, ici);
994
995         soc_camera_host_unregister(ici);
996
997         platform_set_drvdata(pdev, cam->ndata);
998         nvhost_client_device_release(pdev);
999         cam->ndata->aperture[0] = NULL;
1000
1001         vb2_dma_contig_cleanup_ctx(cam->alloc_ctx);
1002
1003         if (cam->ops)
1004                 cam->ops->free_syncpts(cam);
1005
1006         dev_notice(&pdev->dev, "Tegra camera host driver unloaded\n");
1007
1008         return 0;
1009 }
1010
1011 static struct platform_driver tegra_camera_driver = {
1012         .driver = {
1013                 .name   = TEGRA_CAM_DRV_NAME,
1014                 .owner  = THIS_MODULE,
1015 #ifdef CONFIG_OF
1016                 .of_match_table = tegra_vi_of_match,
1017 #endif
1018         },
1019         .probe          = tegra_camera_probe,
1020         .remove         = tegra_camera_remove,
1021 };
1022
1023 static int __init tegra_camera_init(void)
1024 {
1025         return platform_driver_register(&tegra_camera_driver);
1026 }
1027
1028 static void __exit tegra_camera_exit(void)
1029 {
1030         platform_driver_unregister(&tegra_camera_driver);
1031 }
1032
1033 module_init(tegra_camera_init);
1034 module_exit(tegra_camera_exit);
1035
1036 MODULE_DESCRIPTION("TEGRA SoC Camera Host driver");
1037 MODULE_AUTHOR("Bryan Wu <pengw@nvidia.com>");
1038 MODULE_LICENSE("GPL v2");
1039 MODULE_ALIAS("nvhost:" TEGRA_CAM_DRV_NAME);