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