1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019 Rockchip Electronics Co., Ltd */
3
4 #include <linux/clk.h>
5 #include <linux/delay.h>
6 #include <linux/interrupt.h>
7 #include <linux/io.h>
8 #include <linux/module.h>
9 #include <linux/of.h>
10 #include <linux/of_graph.h>
11 #include <linux/of_platform.h>
12 #include <linux/of_reserved_mem.h>
13 #include <linux/pinctrl/consumer.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/reset.h>
16 #include <linux/regmap.h>
17 #include <media/videobuf2-dma-contig.h>
18 #include <media/v4l2-fwnode.h>
19
20 #include "dev.h"
21 #include "regs.h"
22 #include "version.h"
23
24 #define RKISPP_VERNO_LEN 10
25
26 int rkispp_debug;
27 module_param_named(debug, rkispp_debug, int, 0644);
28 MODULE_PARM_DESC(debug, "Debug level (0-3)");
29
30 static bool rkispp_clk_dbg;
31 module_param_named(clk_dbg, rkispp_clk_dbg, bool, 0644);
32 MODULE_PARM_DESC(clk_dbg, "rkispp clk set by user");
33
34 bool rkispp_monitor;
35 module_param_named(monitor, rkispp_monitor, bool, 0644);
36 MODULE_PARM_DESC(monitor, "rkispp abnormal restart monitor");
37
38 static int rkisp_ispp_mode = ISP_ISPP_FBC;
39 module_param_named(mode, rkisp_ispp_mode, int, 0644);
40 MODULE_PARM_DESC(mode, "isp->ispp mode: bit0 fbc, bit1 yuv422, bit2 quick");
41
42 static bool rkispp_stream_sync;
43 module_param_named(stream_sync, rkispp_stream_sync, bool, 0644);
44 MODULE_PARM_DESC(stream_sync, "rkispp stream sync output");
45
46 static char rkispp_version[RKISPP_VERNO_LEN];
47 module_param_string(version, rkispp_version, RKISPP_VERNO_LEN, 0444);
48 MODULE_PARM_DESC(version, "version number");
49
50 bool rkispp_reg_withstream;
51 module_param_named(sendreg_withstream, rkispp_reg_withstream, bool, 0644);
52 MODULE_PARM_DESC(sendreg_withstream, "rkispp send reg out with stream");
53
54 char rkispp_reg_withstream_video_name[RKISPP_VIDEO_NAME_LEN];
55 module_param_string(sendreg_withstream_video_name, rkispp_reg_withstream_video_name,
56 RKISPP_VIDEO_NAME_LEN, 0644);
57 MODULE_PARM_DESC(sendreg_withstream, "rkispp video send reg out with stream");
58
59 unsigned int rkispp_debug_reg = 0x1F;
60 module_param_named(debug_reg, rkispp_debug_reg, uint, 0644);
61 MODULE_PARM_DESC(debug_reg, "rkispp debug register");
62
63 static unsigned int rkispp_wait_line;
64 module_param_named(wait_line, rkispp_wait_line, uint, 0644);
65 MODULE_PARM_DESC(wait_line, "rkispp wait line to buf done early");
66
67 char rkispp_dump_path[128];
68 module_param_string(dump_path, rkispp_dump_path, sizeof(rkispp_dump_path), 0644);
69 MODULE_PARM_DESC(dump_path, "rkispp dump debug file path");
70
rkispp_set_clk_rate(struct clk * clk,unsigned long rate)71 void rkispp_set_clk_rate(struct clk *clk, unsigned long rate)
72 {
73 if (rkispp_clk_dbg)
74 return;
75
76 clk_set_rate(clk, rate);
77 }
78
get_remote_node_dev(struct rkispp_device * ispp_dev)79 static void get_remote_node_dev(struct rkispp_device *ispp_dev)
80 {
81 struct device *dev = ispp_dev->dev;
82 struct device_node *parent = dev->of_node;
83 struct platform_device *remote_dev = NULL;
84 struct device_node *remote = NULL;
85 struct v4l2_subdev *sd = NULL;
86 int i;
87
88 for (i = 0; i < 2; i++) {
89 remote = of_graph_get_remote_node(parent, 0, i);
90 if (!remote)
91 continue;
92 remote_dev = of_find_device_by_node(remote);
93 of_node_put(remote);
94 if (!remote_dev) {
95 dev_err(dev, "Failed to get remote device(%s)\n",
96 of_node_full_name(remote));
97 continue;
98 } else {
99 rkisp_get_bridge_sd(remote_dev, &sd);
100 if (!sd) {
101 dev_err(dev, "Failed to get isp bridge sd\n");
102 } else {
103 ispp_dev->ispp_sdev.remote_sd = sd;
104 v4l2_set_subdev_hostdata(sd, &ispp_dev->ispp_sdev.sd);
105 if (ispp_dev->hw_dev->max_in.w && ispp_dev->hw_dev->max_in.h)
106 v4l2_subdev_call(sd, core, ioctl, RKISP_ISPP_CMD_SET_FMT,
107 &ispp_dev->hw_dev->max_in);
108 break;
109 }
110 }
111 }
112 }
113
rkispp_create_links(struct rkispp_device * ispp_dev)114 static int rkispp_create_links(struct rkispp_device *ispp_dev)
115 {
116 struct rkispp_stream_vdev *stream_vdev;
117 struct media_entity *source, *sink;
118 struct rkispp_stream *stream;
119 unsigned int flags = 0;
120 int ret;
121
122 stream_vdev = &ispp_dev->stream_vdev;
123 stream = &stream_vdev->stream[STREAM_II];
124 /* input stream links */
125 sink = &ispp_dev->ispp_sdev.sd.entity;
126 get_remote_node_dev(ispp_dev);
127 if (ispp_dev->ispp_sdev.remote_sd) {
128 ispp_dev->inp = INP_ISP;
129 } else {
130 flags = MEDIA_LNK_FL_ENABLED;
131 ispp_dev->inp = INP_DDR;
132 stream->linked = true;
133 }
134 source = &stream->vnode.vdev.entity;
135 ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK, flags);
136 if (ret < 0)
137 return ret;
138
139 /* params links */
140 flags = MEDIA_LNK_FL_ENABLED;
141 source = &ispp_dev->params_vdev[PARAM_VDEV_FEC].vnode.vdev.entity;
142 ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
143 if (ret < 0)
144 return ret;
145 ispp_dev->stream_vdev.module_ens = ISPP_MODULE_FEC;
146 if (ispp_dev->ispp_ver == ISPP_V10) {
147 /* params links */
148 source = &ispp_dev->params_vdev[PARAM_VDEV_TNR].vnode.vdev.entity;
149 ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
150 if (ret < 0)
151 return ret;
152 source = &ispp_dev->params_vdev[PARAM_VDEV_NR].vnode.vdev.entity;
153 ret = media_create_pad_link(source, 0, sink, RKISPP_PAD_SINK_PARAMS, flags);
154 if (ret < 0)
155 return ret;
156
157 /* stats links */
158 source = &ispp_dev->ispp_sdev.sd.entity;
159 sink = &ispp_dev->stats_vdev[STATS_VDEV_TNR].vnode.vdev.entity;
160 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE_STATS, sink, 0, flags);
161 if (ret < 0)
162 return ret;
163 sink = &ispp_dev->stats_vdev[STATS_VDEV_NR].vnode.vdev.entity;
164 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE_STATS, sink, 0, flags);
165 if (ret < 0)
166 return ret;
167
168 /* output stream links */
169 stream = &stream_vdev->stream[STREAM_S0];
170 stream->linked = flags;
171 sink = &stream->vnode.vdev.entity;
172 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
173 if (ret < 0)
174 return ret;
175
176 stream = &stream_vdev->stream[STREAM_S1];
177 stream->linked = flags;
178 sink = &stream->vnode.vdev.entity;
179 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
180 if (ret < 0)
181 return ret;
182
183 stream = &stream_vdev->stream[STREAM_S2];
184 stream->linked = flags;
185 sink = &stream->vnode.vdev.entity;
186 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
187 if (ret < 0)
188 return ret;
189
190 ispp_dev->stream_vdev.module_ens = ISPP_MODULE_NR | ISPP_MODULE_SHP;
191 }
192
193 flags = rkispp_stream_sync ? 0 : MEDIA_LNK_FL_ENABLED;
194 stream = &stream_vdev->stream[STREAM_MB];
195 stream->linked = flags;
196 source = &ispp_dev->ispp_sdev.sd.entity;
197 sink = &stream->vnode.vdev.entity;
198 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
199 if (ret < 0)
200 return ret;
201
202 stream = &stream_vdev->stream[STREAM_VIR];
203 stream->linked = flags;
204 sink = &stream->vnode.vdev.entity;
205 ret = media_create_pad_link(source, RKISPP_PAD_SOURCE, sink, 0, flags);
206 if (ret < 0)
207 return ret;
208
209 return 0;
210 }
211
rkispp_register_platform_subdevs(struct rkispp_device * ispp_dev)212 static int rkispp_register_platform_subdevs(struct rkispp_device *ispp_dev)
213 {
214 int ret;
215
216 ret = rkispp_register_stream_vdevs(ispp_dev);
217 if (ret < 0)
218 return ret;
219
220 ret = rkispp_register_params_vdevs(ispp_dev);
221 if (ret < 0)
222 goto err_unreg_stream_vdevs;
223
224 ret = rkispp_register_stats_vdevs(ispp_dev);
225 if (ret < 0)
226 goto err_unreg_params_vdev;
227
228 ret = rkispp_register_subdev(ispp_dev, &ispp_dev->v4l2_dev);
229 if (ret < 0)
230 goto err_unreg_stats_vdev;
231
232 ret = rkispp_create_links(ispp_dev);
233 if (ret < 0)
234 goto err_unreg_ispp_subdev;
235 return ret;
236 err_unreg_ispp_subdev:
237 rkispp_unregister_subdev(ispp_dev);
238 err_unreg_stats_vdev:
239 rkispp_unregister_stats_vdevs(ispp_dev);
240 err_unreg_params_vdev:
241 rkispp_unregister_params_vdevs(ispp_dev);
242 err_unreg_stream_vdevs:
243 rkispp_unregister_stream_vdevs(ispp_dev);
244 return ret;
245 }
246
247 static const struct of_device_id rkispp_plat_of_match[] = {
248 {
249 .compatible = "rockchip,rv1126-rkispp-vir",
250 }, {
251 .compatible = "rockchip,rk3588-rkispp-vir",
252 },
253 {},
254 };
255
rkispp_plat_probe(struct platform_device * pdev)256 static int rkispp_plat_probe(struct platform_device *pdev)
257 {
258 struct device *dev = &pdev->dev;
259 struct v4l2_device *v4l2_dev;
260 struct rkispp_device *ispp_dev;
261 int ret;
262
263 sprintf(rkispp_version, "v%02x.%02x.%02x",
264 RKISPP_DRIVER_VERSION >> 16,
265 (RKISPP_DRIVER_VERSION & 0xff00) >> 8,
266 RKISPP_DRIVER_VERSION & 0x00ff);
267
268 dev_info(dev, "rkispp driver version: %s\n", rkispp_version);
269
270 ispp_dev = devm_kzalloc(dev, sizeof(*ispp_dev), GFP_KERNEL);
271 if (!ispp_dev)
272 return -ENOMEM;
273 ispp_dev->sw_base_addr = devm_kzalloc(dev, RKISP_ISPP_SW_MAX_SIZE, GFP_KERNEL);
274 if (!ispp_dev->sw_base_addr)
275 return -ENOMEM;
276
277 dev_set_drvdata(dev, ispp_dev);
278 ispp_dev->dev = dev;
279
280 ret = rkispp_attach_hw(ispp_dev);
281 if (ret)
282 return ret;
283
284 sprintf(ispp_dev->media_dev.model, "%s%d",
285 DRIVER_NAME, ispp_dev->dev_id);
286 ispp_dev->irq_hdl = rkispp_isr;
287 mutex_init(&ispp_dev->apilock);
288 mutex_init(&ispp_dev->iqlock);
289 init_waitqueue_head(&ispp_dev->sync_onoff);
290
291 strscpy(ispp_dev->name, dev_name(dev), sizeof(ispp_dev->name));
292 strscpy(ispp_dev->media_dev.driver_name, ispp_dev->name,
293 sizeof(ispp_dev->media_dev.driver_name));
294 ispp_dev->media_dev.dev = &pdev->dev;
295 v4l2_dev = &ispp_dev->v4l2_dev;
296 v4l2_dev->mdev = &ispp_dev->media_dev;
297 strlcpy(v4l2_dev->name, ispp_dev->name, sizeof(v4l2_dev->name));
298 v4l2_ctrl_handler_init(&ispp_dev->ctrl_handler, 5);
299 v4l2_dev->ctrl_handler = &ispp_dev->ctrl_handler;
300
301 ret = v4l2_device_register(ispp_dev->dev, v4l2_dev);
302 if (ret < 0) {
303 v4l2_err(v4l2_dev, "register v4l2 device failed:%d\n", ret);
304 return ret;
305 }
306 media_device_init(&ispp_dev->media_dev);
307 ret = media_device_register(&ispp_dev->media_dev);
308 if (ret < 0) {
309 v4l2_err(v4l2_dev, "register media device failed:%d\n", ret);
310 goto err_unreg_v4l2_dev;
311 }
312
313 ret = rkispp_register_platform_subdevs(ispp_dev);
314 if (ret < 0)
315 goto err_unreg_media_dev;
316
317 rkispp_wait_line = 0;
318 of_property_read_u32(pdev->dev.of_node, "wait-line",
319 &rkispp_wait_line);
320 rkispp_proc_init(ispp_dev);
321 pm_runtime_enable(&pdev->dev);
322
323 return 0;
324
325 err_unreg_media_dev:
326 media_device_unregister(&ispp_dev->media_dev);
327 err_unreg_v4l2_dev:
328 v4l2_device_unregister(&ispp_dev->v4l2_dev);
329 return ret;
330 }
331
rkispp_plat_remove(struct platform_device * pdev)332 static int rkispp_plat_remove(struct platform_device *pdev)
333 {
334 struct rkispp_device *ispp_dev = platform_get_drvdata(pdev);
335
336 pm_runtime_disable(&pdev->dev);
337
338 rkispp_proc_cleanup(ispp_dev);
339 rkispp_unregister_subdev(ispp_dev);
340 rkispp_unregister_stats_vdevs(ispp_dev);
341 rkispp_unregister_params_vdevs(ispp_dev);
342 rkispp_unregister_stream_vdevs(ispp_dev);
343
344 media_device_unregister(&ispp_dev->media_dev);
345 v4l2_device_unregister(&ispp_dev->v4l2_dev);
346 mutex_destroy(&ispp_dev->apilock);
347 mutex_destroy(&ispp_dev->iqlock);
348 return 0;
349 }
350
rkispp_runtime_suspend(struct device * dev)351 static int __maybe_unused rkispp_runtime_suspend(struct device *dev)
352 {
353 struct rkispp_device *ispp_dev = dev_get_drvdata(dev);
354 int ret;
355
356 mutex_lock(&ispp_dev->hw_dev->dev_lock);
357 ret = pm_runtime_put_sync(ispp_dev->hw_dev->dev);
358 mutex_unlock(&ispp_dev->hw_dev->dev_lock);
359 return (ret > 0) ? 0 : ret;
360 }
361
rkispp_runtime_resume(struct device * dev)362 static int __maybe_unused rkispp_runtime_resume(struct device *dev)
363 {
364 struct rkispp_device *ispp_dev = dev_get_drvdata(dev);
365 int ret;
366
367 ispp_dev->isp_mode = rkisp_ispp_mode;
368 ispp_dev->stream_sync = rkispp_stream_sync;
369 ispp_dev->stream_vdev.monitor.is_en = rkispp_monitor;
370 ispp_dev->stream_vdev.wait_line = rkispp_wait_line;
371
372 mutex_lock(&ispp_dev->hw_dev->dev_lock);
373 ret = pm_runtime_get_sync(ispp_dev->hw_dev->dev);
374 mutex_unlock(&ispp_dev->hw_dev->dev_lock);
375 return (ret > 0) ? 0 : ret;
376 }
377
378 static const struct dev_pm_ops rkispp_plat_pm_ops = {
379 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
380 pm_runtime_force_resume)
381 SET_RUNTIME_PM_OPS(rkispp_runtime_suspend,
382 rkispp_runtime_resume, NULL)
383 };
384
385 struct platform_driver rkispp_plat_drv = {
386 .driver = {
387 .name = DRIVER_NAME,
388 .of_match_table = of_match_ptr(rkispp_plat_of_match),
389 .pm = &rkispp_plat_pm_ops,
390 },
391 .probe = rkispp_plat_probe,
392 .remove = rkispp_plat_remove,
393 };
394
395 MODULE_AUTHOR("Rockchip Camera/ISP team");
396 MODULE_DESCRIPTION("Rockchip ISPP platform driver");
397 MODULE_LICENSE("GPL v2");
398 MODULE_IMPORT_NS(VFS_internal_I_am_really_a_filesystem_and_am_NOT_a_driver);
399