Quelle  mgb4_sysfs_out.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2021-2023 Digiteq Automotive
 *     author: Martin Tuma <martin.tuma@digiteqautomotive.com>
 *
 * This module handles all the sysfs info/configuration that is related to the
 * v4l2 output devices.
 */

#include <linux/device.h>
#include <linux/nospec.h>
#include "mgb4_core.h"
#include "mgb4_i2c.h"
#include "mgb4_vout.h"
#include "mgb4_vin.h"
#include "mgb4_cmt.h"
#include "mgb4_sysfs.h"

static int loopin_cnt(struct mgb4_vin_dev *vindev)
{
 struct mgb4_vout_dev *voutdev;
 u32 config;
 int i, cnt = 0;

 for (i = 0; i < MGB4_VOUT_DEVICES; i++) {
  voutdev = vindev->mgbdev->vout[i];
  if (!voutdev)
   continue;

  config = mgb4_read_reg(&voutdev->mgbdev->video,
           voutdev->config->regs.config);
  if ((config & 0xc) >> 2 == vindev->config->id)
   cnt++;
 }

 return cnt;
}

static bool is_busy(struct video_device *dev)
{
 bool ret;

 mutex_lock(dev->lock);
 ret = vb2_is_busy(dev->queue);
 mutex_unlock(dev->lock);

 return ret;
}

/* Common for both FPDL3 and GMSL */

static ssize_t output_id_show(struct device *dev,
         struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);

 return sprintf(buf, "%d\n", voutdev->config->id);
}

static ssize_t video_source_show(struct device *dev,
     struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.config);

 return sprintf(buf, "%u\n", (config & 0xc) >> 2);
}

/*
 * Video source change may affect the buffer queue of ANY video input/output on
 * the card thus if any of the inputs/outputs is in use, we do not allow
 * the change.
 *
 * As we do not want to lock all the video devices at the same time, a two-stage
 * locking strategy is used. In addition to the video device locking there is
 * a global (PCI device) variable "io_reconfig" atomically checked/set when
 * the reconfiguration is running. All the video devices check the variable in
 * their queue_setup() functions and do not allow to start the queue when
 * the reconfiguration has started.
 */
static ssize_t video_source_store(struct device *dev,
      struct device_attribute *attr,
      const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 struct mgb4_dev *mgbdev = voutdev->mgbdev;
 struct mgb4_vin_dev *loopin_new = NULL, *loopin_old = NULL;
 unsigned long val;
 ssize_t ret;
 u32 config;
 int i;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 3)
  return -EINVAL;

 if (test_and_set_bit(0, &mgbdev->io_reconfig))
  return -EBUSY;

 ret = -EBUSY;
 for (i = 0; i < MGB4_VIN_DEVICES; i++)
  if (mgbdev->vin[i] && is_busy(&mgbdev->vin[i]->vdev))
   goto end;
 for (i = 0; i < MGB4_VOUT_DEVICES; i++)
  if (mgbdev->vout[i] && is_busy(&mgbdev->vout[i]->vdev))
   goto end;

 config = mgb4_read_reg(&mgbdev->video, voutdev->config->regs.config);

 if (((config & 0xc) >> 2) < MGB4_VIN_DEVICES)
  loopin_old = mgbdev->vin[(config & 0xc) >> 2];
 if (val < MGB4_VIN_DEVICES) {
  val = array_index_nospec(val, MGB4_VIN_DEVICES);
  loopin_new = mgbdev->vin[val];
 }
 if (loopin_old && loopin_cnt(loopin_old) == 1)
  mgb4_mask_reg(&mgbdev->video, loopin_old->config->regs.config,
         0x2, 0x0);
 if (loopin_new)
  mgb4_mask_reg(&mgbdev->video, loopin_new->config->regs.config,
         0x2, 0x2);

 if (val == voutdev->config->id + MGB4_VIN_DEVICES)
  mgb4_write_reg(&mgbdev->video, voutdev->config->regs.config,
          config & ~(1 << 1));
 else
  mgb4_write_reg(&mgbdev->video, voutdev->config->regs.config,
          config | (1U << 1));

 mgb4_mask_reg(&mgbdev->video, voutdev->config->regs.config, 0xc,
        val << 2);

 ret = count;
end:
 clear_bit(0, &mgbdev->io_reconfig);

 return ret;
}

static ssize_t display_width_show(struct device *dev,
      struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.resolution);

 return sprintf(buf, "%u\n", config >> 16);
}

static ssize_t display_width_store(struct device *dev,
       struct device_attribute *attr,
       const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFFFF)
  return -EINVAL;

 mutex_lock(voutdev->vdev.lock);
 if (vb2_is_busy(voutdev->vdev.queue)) {
  mutex_unlock(voutdev->vdev.lock);
  return -EBUSY;
 }

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.resolution,
        0xFFFF0000, val << 16);

 mutex_unlock(voutdev->vdev.lock);

 return count;
}

static ssize_t display_height_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.resolution);

 return sprintf(buf, "%u\n", config & 0xFFFF);
}

static ssize_t display_height_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFFFF)
  return -EINVAL;

 mutex_lock(voutdev->vdev.lock);
 if (vb2_is_busy(voutdev->vdev.queue)) {
  mutex_unlock(voutdev->vdev.lock);
  return -EBUSY;
 }

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.resolution,
        0xFFFF, val);

 mutex_unlock(voutdev->vdev.lock);

 return count;
}

static ssize_t frame_rate_show(struct device *dev,
          struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 period = mgb4_read_reg(&voutdev->mgbdev->video,
       voutdev->config->regs.frame_limit);

 return sprintf(buf, "%u\n", period ? MGB4_HW_FREQ / period : 0);
}

/*
 * Frame rate change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t frame_rate_store(struct device *dev,
    struct device_attribute *attr, const char *buf,
    size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int limit, ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;

 limit = val ? MGB4_HW_FREQ / val : 0;
 mgb4_write_reg(&voutdev->mgbdev->video,
         voutdev->config->regs.frame_limit, limit);

 return count;
}

static ssize_t hsync_width_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.hsync);

 return sprintf(buf, "%u\n", (sig & 0x00FF0000) >> 16);
}

/*
 * HSYNC width change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t hsync_width_store(struct device *dev,
     struct device_attribute *attr, const char *buf,
     size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
        0x00FF0000, val << 16);

 return count;
}

static ssize_t vsync_width_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.vsync);

 return sprintf(buf, "%u\n", (sig & 0x00FF0000) >> 16);
}

/*
 * VSYNC vidth change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t vsync_width_store(struct device *dev,
     struct device_attribute *attr, const char *buf,
     size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
        0x00FF0000, val << 16);

 return count;
}

static ssize_t hback_porch_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.hsync);

 return sprintf(buf, "%u\n", (sig & 0x0000FF00) >> 8);
}

/*
 * hback porch change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t hback_porch_store(struct device *dev,
     struct device_attribute *attr, const char *buf,
     size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
        0x0000FF00, val << 8);

 return count;
}

static ssize_t vback_porch_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.vsync);

 return sprintf(buf, "%u\n", (sig & 0x0000FF00) >> 8);
}

/*
 * vback porch change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t vback_porch_store(struct device *dev,
     struct device_attribute *attr, const char *buf,
     size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
        0x0000FF00, val << 8);

 return count;
}

static ssize_t hfront_porch_show(struct device *dev,
     struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.hsync);

 return sprintf(buf, "%u\n", (sig & 0x000000FF));
}

/*
 * hfront porch change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t hfront_porch_store(struct device *dev,
      struct device_attribute *attr,
      const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
        0x000000FF, val);

 return count;
}

static ssize_t vfront_porch_show(struct device *dev,
     struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 sig = mgb4_read_reg(&voutdev->mgbdev->video,
    voutdev->config->regs.vsync);

 return sprintf(buf, "%u\n", (sig & 0x000000FF));
}

/*
 * vfront porch change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t vfront_porch_store(struct device *dev,
      struct device_attribute *attr, const char *buf,
      size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 0xFF)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
        0x000000FF, val);

 return count;
}

/* FPDL3 only */

static ssize_t hsync_polarity_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.hsync);

 return sprintf(buf, "%u\n", (config & (1U << 31)) >> 31);
}

/*
 * HSYNC polarity change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t hsync_polarity_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 1)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.hsync,
        (1U << 31), val << 31);

 return count;
}

static ssize_t vsync_polarity_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.vsync);

 return sprintf(buf, "%u\n", (config & (1U << 31)) >> 31);
}

/*
 * VSYNC polarity change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t vsync_polarity_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 1)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
        (1U << 31), val << 31);

 return count;
}

static ssize_t de_polarity_show(struct device *dev,
    struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u32 config = mgb4_read_reg(&voutdev->mgbdev->video,
   voutdev->config->regs.vsync);

 return sprintf(buf, "%u\n", (config & (1U << 30)) >> 30);
}

/*
 * DE polarity change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t de_polarity_store(struct device *dev,
     struct device_attribute *attr, const char *buf,
     size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;
 if (val > 1)
  return -EINVAL;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.vsync,
        (1U << 30), val << 30);

 return count;
}

static ssize_t fpdl3_output_width_show(struct device *dev,
           struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 s32 ret;

 mutex_lock(&voutdev->mgbdev->i2c_lock);
 ret = mgb4_i2c_read_byte(&voutdev->ser, 0x5B);
 mutex_unlock(&voutdev->mgbdev->i2c_lock);
 if (ret < 0)
  return -EIO;

 switch ((u8)ret & 0x03) {
 case 0:
  return sprintf(buf, "0\n");
 case 1:
  return sprintf(buf, "1\n");
 case 3:
  return sprintf(buf, "2\n");
 default:
  return -EINVAL;
 }
}

/*
 * FPD-Link width change is expected to be called on live streams. Video device
 * locking/queue check is not needed.
 */
static ssize_t fpdl3_output_width_store(struct device *dev,
     struct device_attribute *attr,
     const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 u8 i2c_data;
 unsigned long val;
 int ret;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;

 switch (val) {
 case 0: /* auto */
  i2c_data = 0x00;
  break;
 case 1: /* single */
  i2c_data = 0x01;
  break;
 case 2: /* dual */
  i2c_data = 0x03;
  break;
 default:
  return -EINVAL;
 }

 mutex_lock(&voutdev->mgbdev->i2c_lock);
 ret = mgb4_i2c_mask_byte(&voutdev->ser, 0x5B, 0x03, i2c_data);
 mutex_unlock(&voutdev->mgbdev->i2c_lock);
 if (ret < 0)
  return -EIO;

 return count;
}

static ssize_t pclk_frequency_show(struct device *dev,
       struct device_attribute *attr, char *buf)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);

 return sprintf(buf, "%u\n", voutdev->freq);
}

static ssize_t pclk_frequency_store(struct device *dev,
        struct device_attribute *attr,
        const char *buf, size_t count)
{
 struct video_device *vdev = to_video_device(dev);
 struct mgb4_vout_dev *voutdev = video_get_drvdata(vdev);
 unsigned long val;
 int ret;
 unsigned int dp;

 ret = kstrtoul(buf, 10, &val);
 if (ret)
  return ret;

 mutex_lock(voutdev->vdev.lock);
 if (vb2_is_busy(voutdev->vdev.queue)) {
  mutex_unlock(voutdev->vdev.lock);
  return -EBUSY;
 }

 dp = (val > 50000) ? 1 : 0;
 voutdev->freq = mgb4_cmt_set_vout_freq(voutdev, val >> dp) << dp;

 mgb4_mask_reg(&voutdev->mgbdev->video, voutdev->config->regs.config,
        0x10, dp << 4);
 mutex_lock(&voutdev->mgbdev->i2c_lock);
 ret = mgb4_i2c_mask_byte(&voutdev->ser, 0x4F, 1 << 6, ((~dp) & 1) << 6);
 mutex_unlock(&voutdev->mgbdev->i2c_lock);

 mutex_unlock(voutdev->vdev.lock);

 return (ret < 0) ? -EIO : count;
}

static DEVICE_ATTR_RO(output_id);
static DEVICE_ATTR_RW(video_source);
static DEVICE_ATTR_RW(display_width);
static DEVICE_ATTR_RW(display_height);
static DEVICE_ATTR_RW(frame_rate);
static DEVICE_ATTR_RW(hsync_polarity);
static DEVICE_ATTR_RW(vsync_polarity);
static DEVICE_ATTR_RW(de_polarity);
static DEVICE_ATTR_RW(pclk_frequency);
static DEVICE_ATTR_RW(hsync_width);
static DEVICE_ATTR_RW(vsync_width);
static DEVICE_ATTR_RW(hback_porch);
static DEVICE_ATTR_RW(hfront_porch);
static DEVICE_ATTR_RW(vback_porch);
static DEVICE_ATTR_RW(vfront_porch);

static DEVICE_ATTR_RW(fpdl3_output_width);

struct attribute *mgb4_fpdl3_out_attrs[] = {
 &dev_attr_output_id.attr,
 &dev_attr_video_source.attr,
 &dev_attr_display_width.attr,
 &dev_attr_display_height.attr,
 &dev_attr_frame_rate.attr,
 &dev_attr_hsync_polarity.attr,
 &dev_attr_vsync_polarity.attr,
 &dev_attr_de_polarity.attr,
 &dev_attr_pclk_frequency.attr,
 &dev_attr_hsync_width.attr,
 &dev_attr_vsync_width.attr,
 &dev_attr_hback_porch.attr,
 &dev_attr_hfront_porch.attr,
 &dev_attr_vback_porch.attr,
 &dev_attr_vfront_porch.attr,
 &dev_attr_fpdl3_output_width.attr,
 NULL
};

struct attribute *mgb4_gmsl_out_attrs[] = {
 &dev_attr_output_id.attr,
 &dev_attr_video_source.attr,
 &dev_attr_display_width.attr,
 &dev_attr_display_height.attr,
 &dev_attr_frame_rate.attr,
 NULL
};