drivers/media/pci/mgb4/mgb4_vin.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2021-2023 Digiteq Automotive
   4  *     author: Martin Tuma <[email protected]>
   5  *
   6  * This is the v4l2 input device module. It initializes the signal deserializers
   7  * and creates the v4l2 video devices. The input signal can change at any time
   8  * which is handled by the "timings" callbacks and an IRQ based watcher, that
   9  * emits the V4L2_EVENT_SOURCE_CHANGE event in case of a signal source change.
  10  *
  11  * When the device is in loopback mode (a direct, in HW, in->out frame passing
  12  * mode) the card's frame queue must be running regardless of whether a v4l2
  13  * stream is running and the output parameters like frame buffers padding must
  14  * be in sync with the input parameters.
  15  */
  16
  17 #include <linux/pci.h>
  18 #include <linux/workqueue.h>
  19 #include <linux/align.h>
  20 #include <linux/dma/amd_xdma.h>
  21 #include <media/v4l2-ioctl.h>
  22 #include <media/videobuf2-v4l2.h>
  23 #include <media/videobuf2-dma-sg.h>
  24 #include <media/v4l2-dv-timings.h>
  25 #include <media/v4l2-event.h>
  26 #include "mgb4_core.h"
  27 #include "mgb4_dma.h"
  28 #include "mgb4_sysfs.h"
  29 #include "mgb4_io.h"
  30 #include "mgb4_vout.h"
  31 #include "mgb4_vin.h"
  32
  33 ATTRIBUTE_GROUPS(mgb4_fpdl3_in);
  34 ATTRIBUTE_GROUPS(mgb4_gmsl_in);
  35
  36 static const struct mgb4_vin_config vin_cfg[] = {
  37         {0, 0, 0, 6, {0x10, 0x00, 0x04, 0x08, 0x1C, 0x14, 0x18, 0x20, 0x24, 0x28}},
  38         {1, 1, 1, 7, {0x40, 0x30, 0x34, 0x38, 0x4C, 0x44, 0x48, 0x50, 0x54, 0x58}}
  39 };
  40
  41 static const struct i2c_board_info fpdl3_deser_info[] = {
  42         {I2C_BOARD_INFO("deserializer1", 0x38)},
  43         {I2C_BOARD_INFO("deserializer2", 0x36)},
  44 };
  45
  46 static const struct i2c_board_info gmsl_deser_info[] = {
  47         {I2C_BOARD_INFO("deserializer1", 0x4C)},
  48         {I2C_BOARD_INFO("deserializer2", 0x2A)},
  49 };
  50
  51 static const struct mgb4_i2c_kv fpdl3_i2c[] = {
  52         {0x06, 0xFF, 0x04}, {0x07, 0xFF, 0x01}, {0x45, 0xFF, 0xE8},
  53         {0x49, 0xFF, 0x00}, {0x34, 0xFF, 0x00}, {0x23, 0xFF, 0x00}
  54 };
  55
  56 static const struct mgb4_i2c_kv gmsl_i2c[] = {
  57         {0x01, 0x03, 0x03}, {0x300, 0x0C, 0x0C}, {0x03, 0xC0, 0xC0},
  58         {0x1CE, 0x0E, 0x0E}, {0x11, 0x05, 0x00}, {0x05, 0xC0, 0x40},
  59         {0x307, 0x0F, 0x00}, {0xA0, 0x03, 0x00}, {0x3E0, 0x07, 0x07},
  60         {0x308, 0x01, 0x01}, {0x10, 0x20, 0x20}, {0x300, 0x40, 0x40}
  61 };
  62
  63 static const struct v4l2_dv_timings_cap video_timings_cap = {
  64         .type = V4L2_DV_BT_656_1120,
  65         .bt = {
  66                 .min_width = 320,
  67                 .max_width = 4096,
  68                 .min_height = 240,
  69                 .max_height = 2160,
  70                 .min_pixelclock = 1843200, /* 320 x 240 x 24Hz */
  71                 .max_pixelclock = 530841600, /* 4096 x 2160 x 60Hz */
  72                 .standards = V4L2_DV_BT_STD_CEA861 | V4L2_DV_BT_STD_DMT |
  73                         V4L2_DV_BT_STD_CVT | V4L2_DV_BT_STD_GTF,
  74                 .capabilities = V4L2_DV_BT_CAP_PROGRESSIVE |
  75                         V4L2_DV_BT_CAP_CUSTOM,
  76         },
  77 };
  78
  79 /*
  80  * Returns the video output connected with the given video input if the input
  81  * is in loopback mode.
  82  */
  83 static struct mgb4_vout_dev *loopback_dev(struct mgb4_vin_dev *vindev, int i)
  84 {
  85         struct mgb4_vout_dev *voutdev;
  86         u32 config;
  87
  88         voutdev = vindev->mgbdev->vout[i];
  89         if (!voutdev)
  90                 return NULL;
  91
  92         config = mgb4_read_reg(&voutdev->mgbdev->video,
  93                                voutdev->config->regs.config);
  94         if ((config & 0xc) >> 2 == vindev->config->id)
  95                 return voutdev;
  96
  97         return NULL;
  98 }
  99
 100 /*
 101  * Check, whether the loopback mode - a HW INPUT->OUTPUT transmission - is
 102  * enabled on the given input.
 103  */
 104 static int loopback_active(struct mgb4_vin_dev *vindev)
 105 {
 106         int i;
 107
 108         for (i = 0; i < MGB4_VOUT_DEVICES; i++)
 109                 if (loopback_dev(vindev, i))
 110                         return 1;
 111
 112         return 0;
 113 }
 114
 115 /*
 116  * Set the output frame buffer padding of all outputs connected with the given
 117  * input when the video input is set to loopback mode. The paddings must be
 118  * the same for the loopback to work properly.
 119  */
 120 static void set_loopback_padding(struct mgb4_vin_dev *vindev, u32 padding)
 121 {
 122         struct mgb4_regs *video = &vindev->mgbdev->video;
 123         struct mgb4_vout_dev *voutdev;
 124         int i;
 125
 126         for (i = 0; i < MGB4_VOUT_DEVICES; i++) {
 127                 voutdev = loopback_dev(vindev, i);
 128                 if (voutdev)
 129                         mgb4_write_reg(video, voutdev->config->regs.padding,
 130                                        padding);
 131         }
 132 }
 133
 134 static int get_timings(struct mgb4_vin_dev *vindev,
 135                        struct v4l2_dv_timings *timings)
 136 {
 137         struct mgb4_regs *video = &vindev->mgbdev->video;
 138         const struct mgb4_vin_regs *regs = &vindev->config->regs;
 139
 140         u32 status = mgb4_read_reg(video, regs->status);
 141         u32 pclk = mgb4_read_reg(video, regs->pclk);
 142         u32 signal = mgb4_read_reg(video, regs->signal);
 143         u32 signal2 = mgb4_read_reg(video, regs->signal2);
 144         u32 resolution = mgb4_read_reg(video, regs->resolution);
 145
 146         if (!(status & (1U << 2)))
 147                 return -ENOLCK;
 148         if (!(status & (3 << 9)))
 149                 return -ENOLINK;
 150
 151         memset(timings, 0, sizeof(*timings));
 152         timings->type = V4L2_DV_BT_656_1120;
 153         timings->bt.width = resolution >> 16;
 154         timings->bt.height = resolution & 0xFFFF;
 155         if (status & (1U << 12))
 156                 timings->bt.polarities |= V4L2_DV_HSYNC_POS_POL;
 157         if (status & (1U << 13))
 158                 timings->bt.polarities |= V4L2_DV_VSYNC_POS_POL;
 159         timings->bt.pixelclock = pclk * 1000;
 160         timings->bt.hsync = (signal & 0x00FF0000) >> 16;
 161         timings->bt.vsync = (signal2 & 0x00FF0000) >> 16;
 162         timings->bt.hbackporch = (signal & 0x0000FF00) >> 8;
 163         timings->bt.hfrontporch = signal & 0x000000FF;
 164         timings->bt.vbackporch = (signal2 & 0x0000FF00) >> 8;
 165         timings->bt.vfrontporch = signal2 & 0x000000FF;
 166
 167         return 0;
 168 }
 169
 170 static void return_all_buffers(struct mgb4_vin_dev *vindev,
 171                                enum vb2_buffer_state state)
 172 {
 173         struct mgb4_frame_buffer *buf, *node;
 174         unsigned long flags;
 175
 176         spin_lock_irqsave(&vindev->qlock, flags);
 177         list_for_each_entry_safe(buf, node, &vindev->buf_list, list) {
 178                 vb2_buffer_done(&buf->vb.vb2_buf, state);
 179                 list_del(&buf->list);
 180         }
 181         spin_unlock_irqrestore(&vindev->qlock, flags);
 182 }
 183
 184 static int queue_setup(struct vb2_queue *q, unsigned int *nbuffers,
 185                        unsigned int *nplanes, unsigned int sizes[],
 186                        struct device *alloc_devs[])
 187 {
 188         struct mgb4_vin_dev *vindev = vb2_get_drv_priv(q);
 189         unsigned int size = (vindev->timings.bt.width + vindev->padding)
 190          * vindev->timings.bt.height * 4;
 191
 192         /*
 193          * If I/O reconfiguration is in process, do not allow to start
 194          * the queue. See video_source_store() in mgb4_sysfs_out.c for
 195          * details.
 196          */
 197         if (test_bit(0, &vindev->mgbdev->io_reconfig))
 198                 return -EBUSY;
 199
 200         if (!size)
 201                 return -EINVAL;
 202         if (*nplanes)
 203                 return sizes[0] < size ? -EINVAL : 0;
 204         *nplanes = 1;
 205         sizes[0] = size;
 206
 207         return 0;
 208 }
 209
 210 static int buffer_init(struct vb2_buffer *vb)
 211 {
 212         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 213         struct mgb4_frame_buffer *buf = to_frame_buffer(vbuf);
 214
 215         INIT_LIST_HEAD(&buf->list);
 216
 217         return 0;
 218 }
 219
 220 static int buffer_prepare(struct vb2_buffer *vb)
 221 {
 222         struct mgb4_vin_dev *vindev = vb2_get_drv_priv(vb->vb2_queue);
 223         struct device *dev = &vindev->mgbdev->pdev->dev;
 224         unsigned int size = (vindev->timings.bt.width + vindev->padding)
 225          * vindev->timings.bt.height * 4;
 226
 227         if (vb2_plane_size(vb, 0) < size) {
 228                 dev_err(dev, "buffer too small (%lu < %u)\n",
 229                         vb2_plane_size(vb, 0), size);
 230                 return -EINVAL;
 231         }
 232
 233         vb2_set_plane_payload(vb, 0, size);
 234
 235         return 0;
 236 }
 237
 238 static void buffer_queue(struct vb2_buffer *vb)
 239 {
 240         struct mgb4_vin_dev *vindev = vb2_get_drv_priv(vb->vb2_queue);
 241         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 242         struct mgb4_frame_buffer *buf = to_frame_buffer(vbuf);
 243         unsigned long flags;
 244
 245         spin_lock_irqsave(&vindev->qlock, flags);
 246         list_add_tail(&buf->list, &vindev->buf_list);
 247         spin_unlock_irqrestore(&vindev->qlock, flags);
 248 }
 249
 250 static void stop_streaming(struct vb2_queue *vq)
 251 {
 252         struct mgb4_vin_dev *vindev = vb2_get_drv_priv(vq);
 253         const struct mgb4_vin_config *config = vindev->config;
 254         int irq = xdma_get_user_irq(vindev->mgbdev->xdev, config->vin_irq);
 255
 256         xdma_disable_user_irq(vindev->mgbdev->xdev, irq);
 257
 258         /*
 259          * In loopback mode, the HW frame queue must be left running for
 260          * the IN->OUT transmission to work!
 261          */
 262         if (!loopback_active(vindev))
 263                 mgb4_mask_reg(&vindev->mgbdev->video, config->regs.config, 0x2,
 264                               0x0);
 265
 266         cancel_work_sync(&vindev->dma_work);
 267         return_all_buffers(vindev, VB2_BUF_STATE_ERROR);
 268 }
 269
 270 static int start_streaming(struct vb2_queue *vq, unsigned int count)
 271 {
 272         struct mgb4_vin_dev *vindev = vb2_get_drv_priv(vq);
 273         const struct mgb4_vin_config *config = vindev->config;
 274         int irq = xdma_get_user_irq(vindev->mgbdev->xdev, config->vin_irq);
 275
 276         vindev->sequence = 0;
 277
 278         /*
 279          * In loopback mode, the HW frame queue is already running.
 280          */
 281         if (!loopback_active(vindev))
 282                 mgb4_mask_reg(&vindev->mgbdev->video, config->regs.config, 0x2,
 283                               0x2);
 284
 285         xdma_enable_user_irq(vindev->mgbdev->xdev, irq);
 286
 287         return 0;
 288 }
 289
 290 static const struct vb2_ops queue_ops = {
 291         .queue_setup = queue_setup,
 292         .buf_init = buffer_init,
 293         .buf_prepare = buffer_prepare,
 294         .buf_queue = buffer_queue,
 295         .start_streaming = start_streaming,
 296         .stop_streaming = stop_streaming,
 297         .wait_prepare = vb2_ops_wait_prepare,
 298         .wait_finish = vb2_ops_wait_finish
 299 };
 300
 301 static int fh_open(struct file *file)
 302 {
 303         struct mgb4_vin_dev *vindev = video_drvdata(file);
 304         int rv;
 305
 306         mutex_lock(&vindev->lock);
 307
 308         rv = v4l2_fh_open(file);
 309         if (rv)
 310                 goto out;
 311
 312         if (!v4l2_fh_is_singular_file(file))
 313                 goto out;
 314
 315         get_timings(vindev, &vindev->timings);
 316         set_loopback_padding(vindev, vindev->padding);
 317
 318 out:
 319         mutex_unlock(&vindev->lock);
 320         return rv;
 321 }
 322
 323 static int fh_release(struct file *file)
 324 {
 325         struct mgb4_vin_dev *vindev = video_drvdata(file);
 326         int rv;
 327
 328         mutex_lock(&vindev->lock);
 329
 330         if (v4l2_fh_is_singular_file(file))
 331                 set_loopback_padding(vindev, 0);
 332
 333         rv = _vb2_fop_release(file, NULL);
 334
 335         mutex_unlock(&vindev->lock);
 336
 337         return rv;
 338 }
 339
 340 static const struct v4l2_file_operations video_fops = {
 341         .owner = THIS_MODULE,
 342         .open = fh_open,
 343         .release = fh_release,
 344         .unlocked_ioctl = video_ioctl2,
 345         .read = vb2_fop_read,
 346         .mmap = vb2_fop_mmap,
 347         .poll = vb2_fop_poll,
 348 };
 349
 350 static int vidioc_querycap(struct file *file, void *priv,
 351                            struct v4l2_capability *cap)
 352 {
 353         strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
 354         strscpy(cap->card, "MGB4 PCIe Card", sizeof(cap->card));
 355
 356         return 0;
 357 }
 358
 359 static int vidioc_enum_fmt(struct file *file, void *priv,
 360                            struct v4l2_fmtdesc *f)
 361 {
 362         if (f->index != 0)
 363                 return -EINVAL;
 364
 365         f->pixelformat = V4L2_PIX_FMT_ABGR32;
 366
 367         return 0;
 368 }
 369
 370 static int vidioc_enum_frameintervals(struct file *file, void *priv,
 371                                       struct v4l2_frmivalenum *ival)
 372 {
 373         struct mgb4_vin_dev *vindev = video_drvdata(file);
 374
 375         if (ival->index != 0)
 376                 return -EINVAL;
 377         if (ival->pixel_format != V4L2_PIX_FMT_ABGR32)
 378                 return -EINVAL;
 379         if (ival->width != vindev->timings.bt.width ||
 380             ival->height != vindev->timings.bt.height)
 381                 return -EINVAL;
 382
 383         ival->type = V4L2_FRMIVAL_TYPE_CONTINUOUS;
 384         ival->stepwise.min.denominator = 60;
 385         ival->stepwise.min.numerator = 1;
 386         ival->stepwise.max.denominator = 1;
 387         ival->stepwise.max.numerator = 1;
 388         ival->stepwise.step = ival->stepwise.max;
 389
 390         return 0;
 391 }
 392
 393 static int vidioc_g_fmt(struct file *file, void *priv, struct v4l2_format *f)
 394 {
 395         struct mgb4_vin_dev *vindev = video_drvdata(file);
 396
 397         f->fmt.pix.pixelformat = V4L2_PIX_FMT_ABGR32;
 398         f->fmt.pix.width = vindev->timings.bt.width;
 399         f->fmt.pix.height = vindev->timings.bt.height;
 400         f->fmt.pix.field = V4L2_FIELD_NONE;
 401         f->fmt.pix.colorspace = V4L2_COLORSPACE_RAW;
 402         f->fmt.pix.bytesperline = (f->fmt.pix.width + vindev->padding) * 4;
 403         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
 404
 405         return 0;
 406 }
 407
 408 static int vidioc_try_fmt(struct file *file, void *priv, struct v4l2_format *f)
 409 {
 410         struct mgb4_vin_dev *vindev = video_drvdata(file);
 411
 412         f->fmt.pix.pixelformat = V4L2_PIX_FMT_ABGR32;
 413         f->fmt.pix.width = vindev->timings.bt.width;
 414         f->fmt.pix.height = vindev->timings.bt.height;
 415         f->fmt.pix.field = V4L2_FIELD_NONE;
 416         f->fmt.pix.colorspace = V4L2_COLORSPACE_RAW;
 417         f->fmt.pix.bytesperline = max(f->fmt.pix.width * 4,
 418                                       ALIGN_DOWN(f->fmt.pix.bytesperline, 4));
 419         f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
 420
 421         return 0;
 422 }
 423
 424 static int vidioc_s_fmt(struct file *file, void *priv, struct v4l2_format *f)
 425 {
 426         struct mgb4_vin_dev *vindev = video_drvdata(file);
 427         struct mgb4_regs *video = &vindev->mgbdev->video;
 428
 429         if (vb2_is_busy(&vindev->queue))
 430                 return -EBUSY;
 431
 432         vidioc_try_fmt(file, priv, f);
 433
 434         vindev->padding = (f->fmt.pix.bytesperline - (f->fmt.pix.width * 4)) / 4;
 435         mgb4_write_reg(video, vindev->config->regs.padding, vindev->padding);
 436         set_loopback_padding(vindev, vindev->padding);
 437
 438         return 0;
 439 }
 440
 441 static int vidioc_enum_input(struct file *file, void *priv,
 442                              struct v4l2_input *i)
 443 {
 444         struct mgb4_vin_dev *vindev = video_drvdata(file);
 445         struct mgb4_regs *video = &vindev->mgbdev->video;
 446         u32 status;
 447
 448         if (i->index != 0)
 449                 return -EINVAL;
 450
 451         strscpy(i->name, "MGB4", sizeof(i->name));
 452         i->type = V4L2_INPUT_TYPE_CAMERA;
 453         i->capabilities = V4L2_IN_CAP_DV_TIMINGS;
 454         i->status = 0;
 455
 456         status = mgb4_read_reg(video, vindev->config->regs.status);
 457         if (!(status & (1U << 2)))
 458                 i->status |= V4L2_IN_ST_NO_SYNC;
 459         if (!(status & (3 << 9)))
 460                 i->status |= V4L2_IN_ST_NO_SIGNAL;
 461
 462         return 0;
 463 }
 464
 465 static int vidioc_enum_framesizes(struct file *file, void *fh,
 466                                   struct v4l2_frmsizeenum *fsize)
 467 {
 468         struct mgb4_vin_dev *vindev = video_drvdata(file);
 469
 470         if (fsize->index != 0 || fsize->pixel_format != V4L2_PIX_FMT_ABGR32)
 471                 return -EINVAL;
 472
 473         fsize->discrete.width = vindev->timings.bt.width;
 474         fsize->discrete.height = vindev->timings.bt.height;
 475         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 476
 477         return 0;
 478 }
 479
 480 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
 481 {
 482         return (i == 0) ? 0 : -EINVAL;
 483 }
 484
 485 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 486 {
 487         *i = 0;
 488         return 0;
 489 }
 490
 491 static int vidioc_parm(struct file *file, void *priv,
 492                        struct v4l2_streamparm *parm)
 493 {
 494         struct mgb4_vin_dev *vindev = video_drvdata(file);
 495         struct mgb4_regs *video = &vindev->mgbdev->video;
 496         const struct mgb4_vin_regs *regs = &vindev->config->regs;
 497         struct v4l2_fract timeperframe = {
 498                 .numerator = mgb4_read_reg(video, regs->frame_period),
 499                 .denominator = 125000000,
 500         };
 501
 502         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
 503                 return -EINVAL;
 504
 505         parm->parm.capture.readbuffers = 2;
 506         parm->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
 507         parm->parm.capture.timeperframe = timeperframe;
 508
 509         return 0;
 510 }
 511
 512 static int vidioc_s_dv_timings(struct file *file, void *fh,
 513                                struct v4l2_dv_timings *timings)
 514 {
 515         struct mgb4_vin_dev *vindev = video_drvdata(file);
 516
 517         if (timings->bt.width < video_timings_cap.bt.min_width ||
 518             timings->bt.width > video_timings_cap.bt.max_width ||
 519             timings->bt.height < video_timings_cap.bt.min_height ||
 520             timings->bt.height > video_timings_cap.bt.max_height)
 521                 return -EINVAL;
 522         if (timings->bt.width == vindev->timings.bt.width &&
 523             timings->bt.height == vindev->timings.bt.height)
 524                 return 0;
 525         if (vb2_is_busy(&vindev->queue))
 526                 return -EBUSY;
 527
 528         vindev->timings = *timings;
 529
 530         return 0;
 531 }
 532
 533 static int vidioc_g_dv_timings(struct file *file, void *fh,
 534                                struct v4l2_dv_timings *timings)
 535 {
 536         struct mgb4_vin_dev *vindev = video_drvdata(file);
 537         *timings = vindev->timings;
 538
 539         return 0;
 540 }
 541
 542 static int vidioc_query_dv_timings(struct file *file, void *fh,
 543                                    struct v4l2_dv_timings *timings)
 544 {
 545         struct mgb4_vin_dev *vindev = video_drvdata(file);
 546
 547         return get_timings(vindev, timings);
 548 }
 549
 550 static int vidioc_enum_dv_timings(struct file *file, void *fh,
 551                                   struct v4l2_enum_dv_timings *timings)
 552 {
 553         return v4l2_enum_dv_timings_cap(timings, &video_timings_cap, NULL, NULL);
 554 }
 555
 556 static int vidioc_dv_timings_cap(struct file *file, void *fh,
 557                                  struct v4l2_dv_timings_cap *cap)
 558 {
 559         *cap = video_timings_cap;
 560
 561         return 0;
 562 }
 563
 564 static int vidioc_subscribe_event(struct v4l2_fh *fh,
 565                                   const struct v4l2_event_subscription *sub)
 566 {
 567         switch (sub->type) {
 568         case V4L2_EVENT_SOURCE_CHANGE:
 569                 return v4l2_src_change_event_subscribe(fh, sub);
 570         }
 571
 572         return v4l2_ctrl_subscribe_event(fh, sub);
 573 }
 574
 575 static const struct v4l2_ioctl_ops video_ioctl_ops = {
 576         .vidioc_querycap = vidioc_querycap,
 577         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt,
 578         .vidioc_try_fmt_vid_cap = vidioc_try_fmt,
 579         .vidioc_s_fmt_vid_cap = vidioc_s_fmt,
 580         .vidioc_g_fmt_vid_cap = vidioc_g_fmt,
 581         .vidioc_enum_framesizes = vidioc_enum_framesizes,
 582         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
 583         .vidioc_enum_input = vidioc_enum_input,
 584         .vidioc_g_input = vidioc_g_input,
 585         .vidioc_s_input = vidioc_s_input,
 586         .vidioc_reqbufs = vb2_ioctl_reqbufs,
 587         .vidioc_create_bufs = vb2_ioctl_create_bufs,
 588         .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
 589         .vidioc_querybuf = vb2_ioctl_querybuf,
 590         .vidioc_qbuf = vb2_ioctl_qbuf,
 591         .vidioc_dqbuf = vb2_ioctl_dqbuf,
 592         .vidioc_expbuf = vb2_ioctl_expbuf,
 593         .vidioc_streamon = vb2_ioctl_streamon,
 594         .vidioc_streamoff = vb2_ioctl_streamoff,
 595         .vidioc_g_parm = vidioc_parm,
 596         .vidioc_s_parm = vidioc_parm,
 597         .vidioc_dv_timings_cap = vidioc_dv_timings_cap,
 598         .vidioc_enum_dv_timings = vidioc_enum_dv_timings,
 599         .vidioc_g_dv_timings = vidioc_g_dv_timings,
 600         .vidioc_s_dv_timings = vidioc_s_dv_timings,
 601         .vidioc_query_dv_timings = vidioc_query_dv_timings,
 602         .vidioc_subscribe_event = vidioc_subscribe_event,
 603         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
 604 };
 605
 606 static void dma_transfer(struct work_struct *work)
 607 {
 608         struct mgb4_vin_dev *vindev = container_of(work, struct mgb4_vin_dev,
 609                                                    dma_work);
 610         struct mgb4_regs *video = &vindev->mgbdev->video;
 611         struct device *dev = &vindev->mgbdev->pdev->dev;
 612         struct mgb4_frame_buffer *buf = NULL;
 613         unsigned long flags;
 614         u32 addr;
 615         int rv;
 616
 617         spin_lock_irqsave(&vindev->qlock, flags);
 618         if (!list_empty(&vindev->buf_list)) {
 619                 buf = list_first_entry(&vindev->buf_list,
 620                                        struct mgb4_frame_buffer, list);
 621                 list_del_init(vindev->buf_list.next);
 622         }
 623         spin_unlock_irqrestore(&vindev->qlock, flags);
 624
 625         if (!buf)
 626                 return;
 627
 628         addr = mgb4_read_reg(video, vindev->config->regs.address);
 629         if (addr >= MGB4_ERR_QUEUE_FULL) {
 630                 dev_dbg(dev, "frame queue error (%d)\n", (int)addr);
 631                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 632                 return;
 633         }
 634
 635         rv = mgb4_dma_transfer(vindev->mgbdev, vindev->config->dma_channel,
 636                                false, addr,
 637                                vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0));
 638         if (rv < 0) {
 639                 dev_warn(dev, "DMA transfer error\n");
 640                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
 641         } else {
 642                 buf->vb.vb2_buf.timestamp = ktime_get_ns();
 643                 buf->vb.sequence = vindev->sequence++;
 644                 buf->vb.field = V4L2_FIELD_NONE;
 645                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 646         }
 647 }
 648
 649 static void signal_change(struct work_struct *work)
 650 {
 651         struct mgb4_vin_dev *vindev = container_of(work, struct mgb4_vin_dev,
 652                                                    err_work);
 653         struct mgb4_regs *video = &vindev->mgbdev->video;
 654         struct v4l2_bt_timings *timings = &vindev->timings.bt;
 655         struct device *dev = &vindev->mgbdev->pdev->dev;
 656
 657         u32 resolution = mgb4_read_reg(video, vindev->config->regs.resolution);
 658         u32 width = resolution >> 16;
 659         u32 height = resolution & 0xFFFF;
 660
 661         if (timings->width != width || timings->height != height) {
 662                 static const struct v4l2_event ev = {
 663                         .type = V4L2_EVENT_SOURCE_CHANGE,
 664                         .u.src_change.changes = V4L2_EVENT_SRC_CH_RESOLUTION,
 665                 };
 666
 667                 v4l2_event_queue(&vindev->vdev, &ev);
 668
 669                 if (vb2_is_streaming(&vindev->queue))
 670                         vb2_queue_error(&vindev->queue);
 671         }
 672
 673         dev_dbg(dev, "stream changed to %ux%u\n", width, height);
 674 }
 675
 676 static irqreturn_t vin_handler(int irq, void *ctx)
 677 {
 678         struct mgb4_vin_dev *vindev = (struct mgb4_vin_dev *)ctx;
 679         struct mgb4_regs *video = &vindev->mgbdev->video;
 680
 681         schedule_work(&vindev->dma_work);
 682
 683         mgb4_write_reg(video, 0xB4, 1U << vindev->config->vin_irq);
 684
 685         return IRQ_HANDLED;
 686 }
 687
 688 static irqreturn_t err_handler(int irq, void *ctx)
 689 {
 690         struct mgb4_vin_dev *vindev = (struct mgb4_vin_dev *)ctx;
 691         struct mgb4_regs *video = &vindev->mgbdev->video;
 692
 693         schedule_work(&vindev->err_work);
 694
 695         mgb4_write_reg(video, 0xB4, 1U << vindev->config->err_irq);
 696
 697         return IRQ_HANDLED;
 698 }
 699
 700 static int deser_init(struct mgb4_vin_dev *vindev, int id)
 701 {
 702         int rv, addr_size;
 703         size_t values_count;
 704         const struct mgb4_i2c_kv *values;
 705         const struct i2c_board_info *info;
 706         struct device *dev = &vindev->mgbdev->pdev->dev;
 707
 708         if (MGB4_IS_GMSL(vindev->mgbdev)) {
 709                 info = &gmsl_deser_info[id];
 710                 addr_size = 16;
 711                 values = gmsl_i2c;
 712                 values_count = ARRAY_SIZE(gmsl_i2c);
 713         } else {
 714                 info = &fpdl3_deser_info[id];
 715                 addr_size = 8;
 716                 values = fpdl3_i2c;
 717                 values_count = ARRAY_SIZE(fpdl3_i2c);
 718         }
 719
 720         rv = mgb4_i2c_init(&vindev->deser, vindev->mgbdev->i2c_adap, info,
 721                            addr_size);
 722         if (rv < 0) {
 723                 dev_err(dev, "failed to create deserializer\n");
 724                 return rv;
 725         }
 726         rv = mgb4_i2c_configure(&vindev->deser, values, values_count);
 727         if (rv < 0) {
 728                 dev_err(dev, "failed to configure deserializer\n");
 729                 goto err_i2c_dev;
 730         }
 731
 732         return 0;
 733
 734 err_i2c_dev:
 735         mgb4_i2c_free(&vindev->deser);
 736
 737         return rv;
 738 }
 739
 740 static void fpga_init(struct mgb4_vin_dev *vindev)
 741 {
 742         struct mgb4_regs *video = &vindev->mgbdev->video;
 743         const struct mgb4_vin_regs *regs = &vindev->config->regs;
 744
 745         mgb4_write_reg(video, regs->config, 0x00000001);
 746         mgb4_write_reg(video, regs->sync, 0x03E80002);
 747         mgb4_write_reg(video, regs->padding, 0x00000000);
 748         mgb4_write_reg(video, regs->config, 1U << 9);
 749 }
 750
 751 #ifdef CONFIG_DEBUG_FS
 752 static void debugfs_init(struct mgb4_vin_dev *vindev)
 753 {
 754         struct mgb4_regs *video = &vindev->mgbdev->video;
 755
 756         vindev->debugfs = debugfs_create_dir(vindev->vdev.name,
 757                                              vindev->mgbdev->debugfs);
 758         if (!vindev->debugfs)
 759                 return;
 760
 761         vindev->regs[0].name = "CONFIG";
 762         vindev->regs[0].offset = vindev->config->regs.config;
 763         vindev->regs[1].name = "STATUS";
 764         vindev->regs[1].offset = vindev->config->regs.status;
 765         vindev->regs[2].name = "RESOLUTION";
 766         vindev->regs[2].offset = vindev->config->regs.resolution;
 767         vindev->regs[3].name = "FRAME_PERIOD";
 768         vindev->regs[3].offset = vindev->config->regs.frame_period;
 769         vindev->regs[4].name = "HS_VS_GENER_SETTINGS";
 770         vindev->regs[4].offset = vindev->config->regs.sync;
 771         vindev->regs[5].name = "PCLK_FREQUENCY";
 772         vindev->regs[5].offset = vindev->config->regs.pclk;
 773         vindev->regs[6].name = "VIDEO_PARAMS_1";
 774         vindev->regs[6].offset = vindev->config->regs.signal;
 775         vindev->regs[7].name = "VIDEO_PARAMS_2";
 776         vindev->regs[7].offset = vindev->config->regs.signal2;
 777         vindev->regs[8].name = "PADDING_PIXELS";
 778         vindev->regs[8].offset = vindev->config->regs.padding;
 779
 780         vindev->regset.base = video->membase;
 781         vindev->regset.regs = vindev->regs;
 782         vindev->regset.nregs = ARRAY_SIZE(vindev->regs);
 783
 784         debugfs_create_regset32("registers", 0444, vindev->debugfs,
 785                                 &vindev->regset);
 786 }
 787 #endif
 788
 789 struct mgb4_vin_dev *mgb4_vin_create(struct mgb4_dev *mgbdev, int id)
 790 {
 791         int rv;
 792         const struct attribute_group **groups;
 793         struct mgb4_vin_dev *vindev;
 794         struct pci_dev *pdev = mgbdev->pdev;
 795         struct device *dev = &pdev->dev;
 796         int vin_irq, err_irq;
 797
 798         vindev = kzalloc(sizeof(*vindev), GFP_KERNEL);
 799         if (!vindev)
 800                 return NULL;
 801
 802         vindev->mgbdev = mgbdev;
 803         vindev->config = &vin_cfg[id];
 804
 805         /* Frame queue*/
 806         INIT_LIST_HEAD(&vindev->buf_list);
 807         spin_lock_init(&vindev->qlock);
 808
 809         /* Work queues */
 810         INIT_WORK(&vindev->dma_work, dma_transfer);
 811         INIT_WORK(&vindev->err_work, signal_change);
 812
 813         /* IRQ callback */
 814         vin_irq = xdma_get_user_irq(mgbdev->xdev, vindev->config->vin_irq);
 815         rv = request_irq(vin_irq, vin_handler, 0, "mgb4-vin", vindev);
 816         if (rv) {
 817                 dev_err(dev, "failed to register vin irq handler\n");
 818                 goto err_alloc;
 819         }
 820         /* Error IRQ callback */
 821         err_irq = xdma_get_user_irq(mgbdev->xdev, vindev->config->err_irq);
 822         rv = request_irq(err_irq, err_handler, 0, "mgb4-err", vindev);
 823         if (rv) {
 824                 dev_err(dev, "failed to register err irq handler\n");
 825                 goto err_vin_irq;
 826         }
 827
 828         /* Set the FPGA registers default values */
 829         fpga_init(vindev);
 830
 831         /* Set the deserializer default values */
 832         rv = deser_init(vindev, id);
 833         if (rv)
 834                 goto err_err_irq;
 835
 836         /* V4L2 stuff init */
 837         rv = v4l2_device_register(dev, &vindev->v4l2dev);
 838         if (rv) {
 839                 dev_err(dev, "failed to register v4l2 device\n");
 840                 goto err_err_irq;
 841         }
 842
 843         mutex_init(&vindev->lock);
 844
 845         vindev->queue.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 846         vindev->queue.io_modes = VB2_MMAP | VB2_DMABUF | VB2_READ;
 847         vindev->queue.buf_struct_size = sizeof(struct mgb4_frame_buffer);
 848         vindev->queue.ops = &queue_ops;
 849         vindev->queue.mem_ops = &vb2_dma_sg_memops;
 850         vindev->queue.gfp_flags = GFP_DMA32;
 851         vindev->queue.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
 852         vindev->queue.min_queued_buffers = 2;
 853         vindev->queue.drv_priv = vindev;
 854         vindev->queue.lock = &vindev->lock;
 855         vindev->queue.dev = dev;
 856         rv = vb2_queue_init(&vindev->queue);
 857         if (rv) {
 858                 dev_err(dev, "failed to initialize vb2 queue\n");
 859                 goto err_v4l2_dev;
 860         }
 861
 862         snprintf(vindev->vdev.name, sizeof(vindev->vdev.name), "mgb4-in%d",
 863                  id + 1);
 864         vindev->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE
 865           | V4L2_CAP_STREAMING;
 866         vindev->vdev.fops = &video_fops;
 867         vindev->vdev.ioctl_ops = &video_ioctl_ops;
 868         vindev->vdev.release = video_device_release_empty;
 869         vindev->vdev.v4l2_dev = &vindev->v4l2dev;
 870         vindev->vdev.lock = &vindev->lock;
 871         vindev->vdev.queue = &vindev->queue;
 872         video_set_drvdata(&vindev->vdev, vindev);
 873
 874         /* Enable the video signal change watcher */
 875         xdma_enable_user_irq(vindev->mgbdev->xdev, err_irq);
 876
 877         /* Register the video device */
 878         rv = video_register_device(&vindev->vdev, VFL_TYPE_VIDEO, -1);
 879         if (rv) {
 880                 dev_err(dev, "failed to register video device\n");
 881                 goto err_v4l2_dev;
 882         }
 883
 884         /* Module sysfs attributes */
 885         groups = MGB4_IS_GMSL(mgbdev)
 886           ? mgb4_gmsl_in_groups : mgb4_fpdl3_in_groups;
 887         rv = device_add_groups(&vindev->vdev.dev, groups);
 888         if (rv) {
 889                 dev_err(dev, "failed to create sysfs attributes\n");
 890                 goto err_video_dev;
 891         }
 892
 893 #ifdef CONFIG_DEBUG_FS
 894         debugfs_init(vindev);
 895 #endif
 896
 897         return vindev;
 898
 899 err_video_dev:
 900         video_unregister_device(&vindev->vdev);
 901 err_v4l2_dev:
 902         v4l2_device_unregister(&vindev->v4l2dev);
 903 err_err_irq:
 904         free_irq(err_irq, vindev);
 905 err_vin_irq:
 906         free_irq(vin_irq, vindev);
 907 err_alloc:
 908         kfree(vindev);
 909
 910         return NULL;
 911 }
 912
 913 void mgb4_vin_free(struct mgb4_vin_dev *vindev)
 914 {
 915         const struct attribute_group **groups;
 916         int vin_irq = xdma_get_user_irq(vindev->mgbdev->xdev,
 917                                         vindev->config->vin_irq);
 918         int err_irq = xdma_get_user_irq(vindev->mgbdev->xdev,
 919                                         vindev->config->err_irq);
 920
 921         xdma_disable_user_irq(vindev->mgbdev->xdev, err_irq);
 922
 923         free_irq(vin_irq, vindev);
 924         free_irq(err_irq, vindev);
 925
 926 #ifdef CONFIG_DEBUG_FS
 927         debugfs_remove_recursive(vindev->debugfs);
 928 #endif
 929
 930         groups = MGB4_IS_GMSL(vindev->mgbdev)
 931           ? mgb4_gmsl_in_groups : mgb4_fpdl3_in_groups;
 932         device_remove_groups(&vindev->vdev.dev, groups);
 933
 934         mgb4_i2c_free(&vindev->deser);
 935         video_unregister_device(&vindev->vdev);
 936         v4l2_device_unregister(&vindev->v4l2dev);
 937
 938         kfree(vindev);
 939 }