LXR linux/drivers/media/platform/rcar-fcp.c

   1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 * rcar-fcp.c  --  R-Car Frame Compression Processor Driver
   4 *
   5 * Copyright (C) 2016 Renesas Electronics Corporation
   6 *
   7 * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
   8 */
   9
  10#include <linux/device.h>
  11#include <linux/list.h>
  12#include <linux/module.h>
  13#include <linux/mod_devicetable.h>
  14#include <linux/mutex.h>
  15#include <linux/platform_device.h>
  16#include <linux/pm_runtime.h>
  17#include <linux/slab.h>
  18
  19#include <media/rcar-fcp.h>
  20
  21struct rcar_fcp_device {
  22        struct list_head list;
  23        struct device *dev;
  24};
  25
  26static LIST_HEAD(fcp_devices);
  27static DEFINE_MUTEX(fcp_lock);
  28
  29/* -----------------------------------------------------------------------------
  30 * Public API
  31 */
  32
  33/**
  34 * rcar_fcp_get - Find and acquire a reference to an FCP instance
  35 * @np: Device node of the FCP instance
  36 *
  37 * Search the list of registered FCP instances for the instance corresponding to
  38 * the given device node.
  39 *
  40 * Return a pointer to the FCP instance, or an ERR_PTR if the instance can't be
  41 * found.
  42 */
  43struct rcar_fcp_device *rcar_fcp_get(const struct device_node *np)
  44{
  45        struct rcar_fcp_device *fcp;
  46
  47        mutex_lock(&fcp_lock);
  48
  49        list_for_each_entry(fcp, &fcp_devices, list) {
  50                if (fcp->dev->of_node != np)
  51                        continue;
  52
  53                get_device(fcp->dev);
  54                goto done;
  55        }
  56
  57        fcp = ERR_PTR(-EPROBE_DEFER);
  58
  59done:
  60        mutex_unlock(&fcp_lock);
  61        return fcp;
  62}
  63EXPORT_SYMBOL_GPL(rcar_fcp_get);
  64
  65/**
  66 * rcar_fcp_put - Release a reference to an FCP instance
  67 * @fcp: The FCP instance
  68 *
  69 * Release the FCP instance acquired by a call to rcar_fcp_get().
  70 */
  71void rcar_fcp_put(struct rcar_fcp_device *fcp)
  72{
  73        if (fcp)
  74                put_device(fcp->dev);
  75}
  76EXPORT_SYMBOL_GPL(rcar_fcp_put);
  77
  78struct device *rcar_fcp_get_device(struct rcar_fcp_device *fcp)
  79{
  80        return fcp->dev;
  81}
  82EXPORT_SYMBOL_GPL(rcar_fcp_get_device);
  83
  84/**
  85 * rcar_fcp_enable - Enable an FCP
  86 * @fcp: The FCP instance
  87 *
  88 * Before any memory access through an FCP is performed by a module, the FCP
  89 * must be enabled by a call to this function. The enable calls are reference
  90 * counted, each successful call must be followed by one rcar_fcp_disable()
  91 * call when no more memory transfer can occur through the FCP.
  92 *
  93 * Return 0 on success or a negative error code if an error occurs. The enable
  94 * reference count isn't increased when this function returns an error.
  95 */
  96int rcar_fcp_enable(struct rcar_fcp_device *fcp)
  97{
  98        int ret;
  99
 100        if (!fcp)
 101                return 0;
 102
 103        ret = pm_runtime_get_sync(fcp->dev);
 104        if (ret < 0)
 105                return ret;
 106
 107        return 0;
 108}
 109EXPORT_SYMBOL_GPL(rcar_fcp_enable);
 110
 111/**
 112 * rcar_fcp_disable - Disable an FCP
 113 * @fcp: The FCP instance
 114 *
 115 * This function is the counterpart of rcar_fcp_enable(). As enable calls are
 116 * reference counted a disable call may not disable the FCP synchronously.
 117 */
 118void rcar_fcp_disable(struct rcar_fcp_device *fcp)
 119{
 120        if (fcp)
 121                pm_runtime_put(fcp->dev);
 122}
 123EXPORT_SYMBOL_GPL(rcar_fcp_disable);
 124
 125/* -----------------------------------------------------------------------------
 126 * Platform Driver
 127 */
 128
 129static int rcar_fcp_probe(struct platform_device *pdev)
 130{
 131        struct rcar_fcp_device *fcp;
 132
 133        fcp = devm_kzalloc(&pdev->dev, sizeof(*fcp), GFP_KERNEL);
 134        if (fcp == NULL)
 135                return -ENOMEM;
 136
 137        fcp->dev = &pdev->dev;
 138
 139        pm_runtime_enable(&pdev->dev);
 140
 141        mutex_lock(&fcp_lock);
 142        list_add_tail(&fcp->list, &fcp_devices);
 143        mutex_unlock(&fcp_lock);
 144
 145        platform_set_drvdata(pdev, fcp);
 146
 147        return 0;
 148}
 149
 150static int rcar_fcp_remove(struct platform_device *pdev)
 151{
 152        struct rcar_fcp_device *fcp = platform_get_drvdata(pdev);
 153
 154        mutex_lock(&fcp_lock);
 155        list_del(&fcp->list);
 156        mutex_unlock(&fcp_lock);
 157
 158        pm_runtime_disable(&pdev->dev);
 159
 160        return 0;
 161}
 162
 163static const struct of_device_id rcar_fcp_of_match[] = {
 164        { .compatible = "renesas,fcpf" },
 165        { .compatible = "renesas,fcpv" },
 166        { },
 167};
 168MODULE_DEVICE_TABLE(of, rcar_fcp_of_match);
 169
 170static struct platform_driver rcar_fcp_platform_driver = {
 171        .probe          = rcar_fcp_probe,
 172        .remove         = rcar_fcp_remove,
 173        .driver         = {
 174                .name   = "rcar-fcp",
 175                .of_match_table = rcar_fcp_of_match,
 176                .suppress_bind_attrs = true,
 177        },
 178};
 179
 180module_platform_driver(rcar_fcp_platform_driver);
 181
 182MODULE_ALIAS("rcar-fcp");
 183MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
 184MODULE_DESCRIPTION("Renesas FCP Driver");
 185MODULE_LICENSE("GPL");
 186