Quelle  dc-tc.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2024 NXP
 */

#include <linux/component.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>

#include "dc-drv.h"
#include "dc-de.h"

#define TCON_CTRL 0x410
#define  CTRL_RST_VAL 0x01401408

/* red: MAPBIT 29-20, green: MAPBIT 19-10, blue: MAPBIT 9-0 */
#define MAPBIT3_0 0x418
#define MAPBIT7_4 0x41c
#define MAPBIT11_8 0x420
#define MAPBIT15_12 0x424
#define MAPBIT19_16 0x428
#define MAPBIT23_20 0x42c
#define MAPBIT27_24 0x430
#define MAPBIT31_28 0x434

static const struct dc_subdev_info dc_tc_info[] = {
 { .reg_start = 0x5618c800, .id = 0, },
 { .reg_start = 0x5618e400, .id = 1, },
};

static const struct regmap_range dc_tc_regmap_ranges[] = {
 regmap_reg_range(TCON_CTRL, TCON_CTRL),
 regmap_reg_range(MAPBIT3_0, MAPBIT31_28),
};

static const struct regmap_access_table dc_tc_regmap_access_table = {
 .yes_ranges = dc_tc_regmap_ranges,
 .n_yes_ranges = ARRAY_SIZE(dc_tc_regmap_ranges),
};

static const struct regmap_config dc_tc_regmap_config = {
 .reg_bits = 32,
 .reg_stride = 4,
 .val_bits = 32,
 .fast_io = true,
 .wr_table = &dc_tc_regmap_access_table,
 .rd_table = &dc_tc_regmap_access_table,
 .max_register = MAPBIT31_28,
};

/*
 * The pixels reach TCON are always in 30-bit BGR format.
 * The first bridge always receives pixels in 30-bit RGB format.
 * So, map the format to MEDIA_BUS_FMT_RGB101010_1X30.
 */
static const u32 dc_tc_mapbit[] = {
 0x17161514, 0x1b1a1918, 0x0b0a1d1c, 0x0f0e0d0c,
 0x13121110, 0x03020100, 0x07060504, 0x00000908,
};

void dc_tc_init(struct dc_tc *tc)
{
 /* reset TCON_CTRL to POR default so that TCON works in bypass mode */
 regmap_write(tc->reg, TCON_CTRL, CTRL_RST_VAL);

 /* set format */
 regmap_bulk_write(tc->reg, MAPBIT3_0, dc_tc_mapbit,
     ARRAY_SIZE(dc_tc_mapbit));
}

static int dc_tc_bind(struct device *dev, struct device *master, void *data)
{
 struct platform_device *pdev = to_platform_device(dev);
 struct dc_drm_device *dc_drm = data;
 struct resource *res;
 void __iomem *base;
 struct dc_tc *tc;
 int id;

 tc = devm_kzalloc(dev, sizeof(*tc), GFP_KERNEL);
 if (!tc)
  return -ENOMEM;

 base = devm_platform_get_and_ioremap_resource(pdev, 0, &res);
 if (IS_ERR(base))
  return PTR_ERR(base);

 tc->reg = devm_regmap_init_mmio(dev, base, &dc_tc_regmap_config);
 if (IS_ERR(tc->reg))
  return PTR_ERR(tc->reg);

 id = dc_subdev_get_id(dc_tc_info, ARRAY_SIZE(dc_tc_info), res);
 if (id < 0) {
  dev_err(dev, "failed to get instance number: %d\n", id);
  return id;
 }

 tc->dev = dev;
 dc_drm->tc[id] = tc;

 return 0;
}

static const struct component_ops dc_tc_ops = {
 .bind = dc_tc_bind,
};

static int dc_tc_probe(struct platform_device *pdev)
{
 int ret;

 ret = component_add(&pdev->dev, &dc_tc_ops);
 if (ret)
  return dev_err_probe(&pdev->dev, ret,
         "failed to add component\n");

 return 0;
}

static void dc_tc_remove(struct platform_device *pdev)
{
 component_del(&pdev->dev, &dc_tc_ops);
}

static const struct of_device_id dc_tc_dt_ids[] = {
 { .compatible = "fsl,imx8qxp-dc-tcon" },
 { /* sentinel */ }
};
MODULE_DEVICE_TABLE(of, dc_tc_dt_ids);

struct platform_driver dc_tc_driver = {
 .probe = dc_tc_probe,
 .remove = dc_tc_remove,
 .driver = {
  .name = "imx8-dc-tcon",
  .suppress_bind_attrs = true,
  .of_match_table = dc_tc_dt_ids,
 },
};