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");