This source file includes following definitions.
- isc_parse_dt
- atmel_isc_probe
- atmel_isc_remove
- isc_runtime_suspend
- isc_runtime_resume
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26 #include <linux/clk.h>
27 #include <linux/clkdev.h>
28 #include <linux/clk-provider.h>
29 #include <linux/delay.h>
30 #include <linux/interrupt.h>
31 #include <linux/math64.h>
32 #include <linux/module.h>
33 #include <linux/of.h>
34 #include <linux/of_graph.h>
35 #include <linux/platform_device.h>
36 #include <linux/pm_runtime.h>
37 #include <linux/regmap.h>
38 #include <linux/videodev2.h>
39
40 #include <media/v4l2-ctrls.h>
41 #include <media/v4l2-device.h>
42 #include <media/v4l2-event.h>
43 #include <media/v4l2-image-sizes.h>
44 #include <media/v4l2-ioctl.h>
45 #include <media/v4l2-fwnode.h>
46 #include <media/v4l2-subdev.h>
47 #include <media/videobuf2-dma-contig.h>
48
49 #include "atmel-isc-regs.h"
50 #include "atmel-isc.h"
51
52 #define ISC_MAX_SUPPORT_WIDTH 2592
53 #define ISC_MAX_SUPPORT_HEIGHT 1944
54
55 #define ISC_CLK_MAX_DIV 255
56
57 static int isc_parse_dt(struct device *dev, struct isc_device *isc)
58 {
59 struct device_node *np = dev->of_node;
60 struct device_node *epn = NULL, *rem;
61 struct isc_subdev_entity *subdev_entity;
62 unsigned int flags;
63 int ret;
64
65 INIT_LIST_HEAD(&isc->subdev_entities);
66
67 while (1) {
68 struct v4l2_fwnode_endpoint v4l2_epn = { .bus_type = 0 };
69
70 epn = of_graph_get_next_endpoint(np, epn);
71 if (!epn)
72 return 0;
73
74 rem = of_graph_get_remote_port_parent(epn);
75 if (!rem) {
76 dev_notice(dev, "Remote device at %pOF not found\n",
77 epn);
78 continue;
79 }
80
81 ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(epn),
82 &v4l2_epn);
83 if (ret) {
84 of_node_put(rem);
85 ret = -EINVAL;
86 dev_err(dev, "Could not parse the endpoint\n");
87 break;
88 }
89
90 subdev_entity = devm_kzalloc(dev, sizeof(*subdev_entity),
91 GFP_KERNEL);
92 if (!subdev_entity) {
93 of_node_put(rem);
94 ret = -ENOMEM;
95 break;
96 }
97
98
99
100
101 subdev_entity->asd = kzalloc(sizeof(*subdev_entity->asd),
102 GFP_KERNEL);
103 if (!subdev_entity->asd) {
104 of_node_put(rem);
105 ret = -ENOMEM;
106 break;
107 }
108
109 flags = v4l2_epn.bus.parallel.flags;
110
111 if (flags & V4L2_MBUS_HSYNC_ACTIVE_LOW)
112 subdev_entity->pfe_cfg0 = ISC_PFE_CFG0_HPOL_LOW;
113
114 if (flags & V4L2_MBUS_VSYNC_ACTIVE_LOW)
115 subdev_entity->pfe_cfg0 |= ISC_PFE_CFG0_VPOL_LOW;
116
117 if (flags & V4L2_MBUS_PCLK_SAMPLE_FALLING)
118 subdev_entity->pfe_cfg0 |= ISC_PFE_CFG0_PPOL_LOW;
119
120 if (v4l2_epn.bus_type == V4L2_MBUS_BT656)
121 subdev_entity->pfe_cfg0 |= ISC_PFE_CFG0_CCIR_CRC |
122 ISC_PFE_CFG0_CCIR656;
123
124 subdev_entity->asd->match_type = V4L2_ASYNC_MATCH_FWNODE;
125 subdev_entity->asd->match.fwnode = of_fwnode_handle(rem);
126 list_add_tail(&subdev_entity->list, &isc->subdev_entities);
127 }
128
129 of_node_put(epn);
130 return ret;
131 }
132
133 static int atmel_isc_probe(struct platform_device *pdev)
134 {
135 struct device *dev = &pdev->dev;
136 struct isc_device *isc;
137 struct resource *res;
138 void __iomem *io_base;
139 struct isc_subdev_entity *subdev_entity;
140 int irq;
141 int ret;
142
143 isc = devm_kzalloc(dev, sizeof(*isc), GFP_KERNEL);
144 if (!isc)
145 return -ENOMEM;
146
147 platform_set_drvdata(pdev, isc);
148 isc->dev = dev;
149
150 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
151 io_base = devm_ioremap_resource(dev, res);
152 if (IS_ERR(io_base))
153 return PTR_ERR(io_base);
154
155 isc->regmap = devm_regmap_init_mmio(dev, io_base, &isc_regmap_config);
156 if (IS_ERR(isc->regmap)) {
157 ret = PTR_ERR(isc->regmap);
158 dev_err(dev, "failed to init register map: %d\n", ret);
159 return ret;
160 }
161
162 irq = platform_get_irq(pdev, 0);
163 if (irq < 0)
164 return irq;
165
166 ret = devm_request_irq(dev, irq, isc_interrupt, 0,
167 ATMEL_ISC_NAME, isc);
168 if (ret < 0) {
169 dev_err(dev, "can't register ISR for IRQ %u (ret=%i)\n",
170 irq, ret);
171 return ret;
172 }
173
174 ret = isc_pipeline_init(isc);
175 if (ret)
176 return ret;
177
178 isc->hclock = devm_clk_get(dev, "hclock");
179 if (IS_ERR(isc->hclock)) {
180 ret = PTR_ERR(isc->hclock);
181 dev_err(dev, "failed to get hclock: %d\n", ret);
182 return ret;
183 }
184
185 ret = clk_prepare_enable(isc->hclock);
186 if (ret) {
187 dev_err(dev, "failed to enable hclock: %d\n", ret);
188 return ret;
189 }
190
191 ret = isc_clk_init(isc);
192 if (ret) {
193 dev_err(dev, "failed to init isc clock: %d\n", ret);
194 goto unprepare_hclk;
195 }
196
197 isc->ispck = isc->isc_clks[ISC_ISPCK].clk;
198
199 ret = clk_prepare_enable(isc->ispck);
200 if (ret) {
201 dev_err(dev, "failed to enable ispck: %d\n", ret);
202 goto unprepare_hclk;
203 }
204
205
206 ret = clk_set_rate(isc->ispck, clk_get_rate(isc->hclock));
207 if (ret) {
208 dev_err(dev, "failed to set ispck rate: %d\n", ret);
209 goto unprepare_clk;
210 }
211
212 ret = v4l2_device_register(dev, &isc->v4l2_dev);
213 if (ret) {
214 dev_err(dev, "unable to register v4l2 device.\n");
215 goto unprepare_clk;
216 }
217
218 ret = isc_parse_dt(dev, isc);
219 if (ret) {
220 dev_err(dev, "fail to parse device tree\n");
221 goto unregister_v4l2_device;
222 }
223
224 if (list_empty(&isc->subdev_entities)) {
225 dev_err(dev, "no subdev found\n");
226 ret = -ENODEV;
227 goto unregister_v4l2_device;
228 }
229
230 list_for_each_entry(subdev_entity, &isc->subdev_entities, list) {
231 v4l2_async_notifier_init(&subdev_entity->notifier);
232
233 ret = v4l2_async_notifier_add_subdev(&subdev_entity->notifier,
234 subdev_entity->asd);
235 if (ret) {
236 fwnode_handle_put(subdev_entity->asd->match.fwnode);
237 kfree(subdev_entity->asd);
238 goto cleanup_subdev;
239 }
240
241 subdev_entity->notifier.ops = &isc_async_ops;
242
243 ret = v4l2_async_notifier_register(&isc->v4l2_dev,
244 &subdev_entity->notifier);
245 if (ret) {
246 dev_err(dev, "fail to register async notifier\n");
247 goto cleanup_subdev;
248 }
249
250 if (video_is_registered(&isc->video_dev))
251 break;
252 }
253
254 pm_runtime_set_active(dev);
255 pm_runtime_enable(dev);
256 pm_request_idle(dev);
257
258 return 0;
259
260 cleanup_subdev:
261 isc_subdev_cleanup(isc);
262
263 unregister_v4l2_device:
264 v4l2_device_unregister(&isc->v4l2_dev);
265
266 unprepare_clk:
267 clk_disable_unprepare(isc->ispck);
268 unprepare_hclk:
269 clk_disable_unprepare(isc->hclock);
270
271 isc_clk_cleanup(isc);
272
273 return ret;
274 }
275
276 static int atmel_isc_remove(struct platform_device *pdev)
277 {
278 struct isc_device *isc = platform_get_drvdata(pdev);
279
280 pm_runtime_disable(&pdev->dev);
281
282 isc_subdev_cleanup(isc);
283
284 v4l2_device_unregister(&isc->v4l2_dev);
285
286 clk_disable_unprepare(isc->ispck);
287 clk_disable_unprepare(isc->hclock);
288
289 isc_clk_cleanup(isc);
290
291 return 0;
292 }
293
294 static int __maybe_unused isc_runtime_suspend(struct device *dev)
295 {
296 struct isc_device *isc = dev_get_drvdata(dev);
297
298 clk_disable_unprepare(isc->ispck);
299 clk_disable_unprepare(isc->hclock);
300
301 return 0;
302 }
303
304 static int __maybe_unused isc_runtime_resume(struct device *dev)
305 {
306 struct isc_device *isc = dev_get_drvdata(dev);
307 int ret;
308
309 ret = clk_prepare_enable(isc->hclock);
310 if (ret)
311 return ret;
312
313 ret = clk_prepare_enable(isc->ispck);
314 if (ret)
315 clk_disable_unprepare(isc->hclock);
316
317 return ret;
318 }
319
320 static const struct dev_pm_ops atmel_isc_dev_pm_ops = {
321 SET_RUNTIME_PM_OPS(isc_runtime_suspend, isc_runtime_resume, NULL)
322 };
323
324 static const struct of_device_id atmel_isc_of_match[] = {
325 { .compatible = "atmel,sama5d2-isc" },
326 { }
327 };
328 MODULE_DEVICE_TABLE(of, atmel_isc_of_match);
329
330 static struct platform_driver atmel_isc_driver = {
331 .probe = atmel_isc_probe,
332 .remove = atmel_isc_remove,
333 .driver = {
334 .name = ATMEL_ISC_NAME,
335 .pm = &atmel_isc_dev_pm_ops,
336 .of_match_table = of_match_ptr(atmel_isc_of_match),
337 },
338 };
339
340 module_platform_driver(atmel_isc_driver);
341
342 MODULE_AUTHOR("Songjun Wu");
343 MODULE_DESCRIPTION("The V4L2 driver for Atmel-ISC");
344 MODULE_LICENSE("GPL v2");
345 MODULE_SUPPORTED_DEVICE("video");