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
  21 struct rcar_fcp_device {
  22         struct list_head list;
  23         struct device *dev;
  24 };
  25
  26 static LIST_HEAD(fcp_devices);
  27 static 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  */
  43 struct 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
  59 done:
  60         mutex_unlock(&fcp_lock);
  61         return fcp;
  62 }
  63 EXPORT_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  */
  71 void rcar_fcp_put(struct rcar_fcp_device *fcp)
  72 {
  73         if (fcp)
  74                 put_device(fcp->dev);
  75 }
  76 EXPORT_SYMBOL_GPL(rcar_fcp_put);
  77
  78 struct device *rcar_fcp_get_device(struct rcar_fcp_device *fcp)
  79 {
  80         return fcp->dev;
  81 }
  82 EXPORT_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  */
  96 int 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 }
 109 EXPORT_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  */
 118 void rcar_fcp_disable(struct rcar_fcp_device *fcp)
 119 {
 120         if (fcp)
 121                 pm_runtime_put(fcp->dev);
 122 }
 123 EXPORT_SYMBOL_GPL(rcar_fcp_disable);
 124
 125 /* -----------------------------------------------------------------------------
 126  * Platform Driver
 127  */
 128
 129 static 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
 150 static 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
 163 static const struct of_device_id rcar_fcp_of_match[] = {
 164         { .compatible = "renesas,fcpf" },
 165         { .compatible = "renesas,fcpv" },
 166         { },
 167 };
 168 MODULE_DEVICE_TABLE(of, rcar_fcp_of_match);
 169
 170 static 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
 180 module_platform_driver(rcar_fcp_platform_driver);
 181
 182 MODULE_ALIAS("rcar-fcp");
 183 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
 184 MODULE_DESCRIPTION("Renesas FCP Driver");
 185 MODULE_LICENSE("GPL");