1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) Rockchip Electronics Co., Ltd.
4 *
5 * Author: Huang Lee <Putin.li@rock-chips.com>
6 */
7
8 #define pr_fmt(fmt) "rve: " fmt
9
10 #include "rve_job.h"
11 #include "rve_fence.h"
12 #include "rve_debugger.h"
13 #include "rve_reg.h"
14
15 struct rve_drvdata_t *rve_drvdata;
16
17 /* set hrtimer */
18 static struct hrtimer timer;
19 static ktime_t kt;
20
21 static const struct rve_backend_ops rve_ops = {
22 .get_version = rve_get_version,
23 .set_reg = rve_set_reg,
24 .init_reg = rve_init_reg,
25 .soft_reset = rve_soft_reset
26 };
27
rve_ctx_set_debuf_info_cb(int id,void * ptr,void * data)28 static int rve_ctx_set_debuf_info_cb(int id, void *ptr, void *data)
29 {
30 struct rve_internal_ctx_t *ctx = ptr;
31 unsigned long flags;
32
33 spin_lock_irqsave(&ctx->lock, flags);
34
35 ctx->debug_info.max_cost_time_per_sec = 0;
36 ctx->debug_info.hw_time_total = 0;
37
38 spin_unlock_irqrestore(&ctx->lock, flags);
39
40 return 0;
41 }
42
hrtimer_handler(struct hrtimer * timer)43 static enum hrtimer_restart hrtimer_handler(struct hrtimer *timer)
44 {
45 struct rve_drvdata_t *rve = rve_drvdata;
46 struct rve_scheduler_t *scheduler = NULL;
47 struct rve_pending_ctx_manager *ctx_manager;
48 struct rve_job *job = NULL;
49 unsigned long flags;
50 int i;
51
52 ktime_t now = ktime_get();
53
54 for (i = 0; i < rve->num_of_scheduler; i++) {
55 scheduler = rve->scheduler[i];
56
57 spin_lock_irqsave(&scheduler->irq_lock, flags);
58
59 /* if timer action on job running */
60 job = scheduler->running_job;
61 if (job) {
62 scheduler->timer.busy_time += ktime_us_delta(now, job->hw_recoder_time);
63 job->hw_recoder_time = now;
64 }
65
66 scheduler->timer.busy_time_record = scheduler->timer.busy_time;
67 scheduler->timer.busy_time = 0;
68
69 /* monitor */
70 scheduler->session.rd_bandwidth = 0;
71 scheduler->session.wr_bandwidth = 0;
72 scheduler->session.cycle_cnt = 0;
73
74 for (i = 0; i < RVE_MAX_PID_INFO; i++) {
75 if (scheduler->session.pid_info[i].pid > 0)
76 scheduler->session.pid_info[i].hw_time_total = 0;
77 }
78
79 spin_unlock_irqrestore(&scheduler->irq_lock, flags);
80
81 ctx_manager = rve_drvdata->pend_ctx_manager;
82
83 spin_lock_irqsave(&ctx_manager->lock, flags);
84
85 idr_for_each(&ctx_manager->ctx_id_idr, &rve_ctx_set_debuf_info_cb, ctx_manager);
86
87 spin_unlock_irqrestore(&ctx_manager->lock, flags);
88 }
89
90 hrtimer_forward_now(timer, kt);
91 return HRTIMER_RESTART;
92 }
93
rve_init_timer(void)94 static void rve_init_timer(void)
95 {
96 kt = ktime_set(0, RVE_LOAD_INTERVAL);
97
98 hrtimer_init(&timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
99
100 timer.function = hrtimer_handler;
101
102 hrtimer_start(&timer, kt, HRTIMER_MODE_REL);
103 }
104
rve_cancel_timer(void)105 static void rve_cancel_timer(void)
106 {
107 hrtimer_cancel(&timer);
108 }
109
110 #ifndef RVE_PD_AWAYS_ON
rve_power_enable(struct rve_scheduler_t * scheduler)111 int rve_power_enable(struct rve_scheduler_t *scheduler)
112 {
113 int ret = -EINVAL;
114 int i;
115
116 pm_runtime_get_sync(scheduler->dev);
117 pm_stay_awake(scheduler->dev);
118
119 for (i = 0; i < scheduler->num_clks; i++) {
120 if (!IS_ERR(scheduler->clks[i])) {
121 ret = clk_prepare_enable(scheduler->clks[i]);
122 if (ret < 0)
123 goto err_enable_clk;
124 }
125 }
126
127 scheduler->session.pd_refcount++;
128
129 return 0;
130
131 err_enable_clk:
132 for (--i; i >= 0; --i)
133 if (!IS_ERR(scheduler->clks[i]))
134 clk_disable_unprepare(scheduler->clks[i]);
135
136 pm_relax(scheduler->dev);
137 pm_runtime_put_sync_suspend(scheduler->dev);
138
139 return ret;
140 }
141
rve_power_disable(struct rve_scheduler_t * scheduler)142 int rve_power_disable(struct rve_scheduler_t *scheduler)
143 {
144 int i;
145
146 for (i = scheduler->num_clks - 1; i >= 0; i--)
147 if (!IS_ERR(scheduler->clks[i]))
148 clk_disable_unprepare(scheduler->clks[i]);
149
150 pm_relax(scheduler->dev);
151 pm_runtime_put_sync_suspend(scheduler->dev);
152
153 scheduler->session.pd_refcount--;
154
155 return 0;
156 }
157
158 #endif //RVE_PD_AWAYS_ON
159
rve_session_manager_init(struct rve_session_manager ** session_manager_ptr)160 static int rve_session_manager_init(struct rve_session_manager **session_manager_ptr)
161 {
162 struct rve_session_manager *session_manager = NULL;
163
164 *session_manager_ptr = kzalloc(sizeof(struct rve_session_manager), GFP_KERNEL);
165 if (*session_manager_ptr == NULL) {
166 pr_err("can not kzalloc for rve_session_manager\n");
167 return -ENOMEM;
168 }
169
170 session_manager = *session_manager_ptr;
171
172 mutex_init(&session_manager->lock);
173
174 idr_init_base(&session_manager->ctx_id_idr, 1);
175
176 return 0;
177 }
178
179 /*
180 * Called at driver close to release the rve session's id references.
181 */
rve_session_free_remove_idr_cb(int id,void * ptr,void * data)182 static int rve_session_free_remove_idr_cb(int id, void *ptr, void *data)
183 {
184 struct rve_session *session = ptr;
185
186 idr_remove(&rve_drvdata->session_manager->ctx_id_idr, session->id);
187 kfree(session);
188
189 return 0;
190 }
191
rve_session_free_remove_idr(struct rve_session * session)192 static int rve_session_free_remove_idr(struct rve_session *session)
193 {
194 struct rve_session_manager *session_manager;
195
196 session_manager = rve_drvdata->session_manager;
197
198 mutex_lock(&session_manager->lock);
199
200 session_manager->session_cnt--;
201 idr_remove(&session_manager->ctx_id_idr, session->id);
202
203 mutex_unlock(&session_manager->lock);
204
205 return 0;
206 }
207
rve_session_manager_remove(struct rve_session_manager ** session_manager_ptr)208 static int rve_session_manager_remove(struct rve_session_manager **session_manager_ptr)
209 {
210 struct rve_session_manager *session_manager = *session_manager_ptr;
211
212 mutex_lock(&session_manager->lock);
213
214 idr_for_each(&session_manager->ctx_id_idr, &rve_session_free_remove_idr_cb, session_manager);
215 idr_destroy(&session_manager->ctx_id_idr);
216
217 mutex_unlock(&session_manager->lock);
218
219 kfree(*session_manager_ptr);
220
221 *session_manager_ptr = NULL;
222
223 return 0;
224 }
225
rve_session_init(void)226 static struct rve_session *rve_session_init(void)
227 {
228 struct rve_session_manager *session_manager = NULL;
229 struct rve_session *session = kzalloc(sizeof(*session), GFP_KERNEL);
230
231 session_manager = rve_drvdata->session_manager;
232 if (session_manager == NULL) {
233 pr_err("rve_session_manager is null!\n");
234 kfree(session);
235 return NULL;
236 }
237
238 mutex_lock(&session_manager->lock);
239
240 idr_preload(GFP_KERNEL);
241 session->id = idr_alloc(&session_manager->ctx_id_idr, session, 1, 0, GFP_ATOMIC);
242 session_manager->session_cnt++;
243 idr_preload_end();
244
245 mutex_unlock(&session_manager->lock);
246
247 session->tgid = current->tgid;
248
249 return session;
250 }
251
rve_session_deinit(struct rve_session * session)252 static int rve_session_deinit(struct rve_session *session)
253 {
254 int ctx_id;
255 struct rve_pending_ctx_manager *ctx_manager;
256 struct rve_internal_ctx_t *ctx;
257 unsigned long flags;
258
259 ctx_manager = rve_drvdata->pend_ctx_manager;
260
261 spin_lock_irqsave(&ctx_manager->lock, flags);
262
263 idr_for_each_entry(&ctx_manager->ctx_id_idr, ctx, ctx_id) {
264
265 spin_unlock_irqrestore(&ctx_manager->lock, flags);
266
267 if (session == ctx->session)
268 kref_put(&ctx->refcount, rve_internal_ctx_kref_release);
269
270 spin_lock_irqsave(&ctx_manager->lock, flags);
271 }
272
273 spin_unlock_irqrestore(&ctx_manager->lock, flags);
274
275 rve_job_session_destroy(session);
276
277 rve_session_free_remove_idr(session);
278 kfree(session);
279
280 return 0;
281 }
282
rve_ioctl_cmd_start(unsigned long arg,struct rve_session * session)283 static long rve_ioctl_cmd_start(unsigned long arg, struct rve_session *session)
284 {
285 int rve_user_ctx_id;
286 int ret = 0;
287
288 rve_user_ctx_id = rve_internal_ctx_alloc_to_get_idr_id(session);
289
290 if (copy_to_user((void *)arg, &rve_user_ctx_id, sizeof(int)))
291 ret = -EFAULT;
292
293 return ret;
294 }
295
rve_ioctl_cmd_config(unsigned long arg)296 static long rve_ioctl_cmd_config(unsigned long arg)
297 {
298 struct rve_user_ctx_t user_ctx;
299 int ret = 0;
300
301 if (unlikely(copy_from_user(&user_ctx, (struct rve_user_ctx_t *)arg,
302 sizeof(user_ctx)))) {
303 pr_err("rve_user_ctx copy_from_user failed!\n");
304 return -EFAULT;
305 }
306
307 /* TODO:
308 * if (rve_user_ctx.cmd_num > RVE_CMD_NUM_MAX) {
309 * pr_err("Cannot import more than %d buffers at a time!\n",
310 * RVE_CMD_NUM_MAX);
311 * return -EFBIG;
312 * }
313 */
314
315 if (user_ctx.id <= 0) {
316 pr_err("ctx id[%d] is invalid", user_ctx.id);
317 return -EINVAL;
318 }
319
320 if (DEBUGGER_EN(MSG))
321 pr_info("config cmd id = %d", user_ctx.id);
322
323 /* find internal_ctx to set cmd by user ctx (internal ctx id) */
324 ret = rve_job_config_by_user_ctx(&user_ctx);
325 if (ret < 0) {
326 pr_err("config ctx id[%d] failed!\n", user_ctx.id);
327 return -EFAULT;
328 }
329
330 return ret;
331 }
332
rve_ioctl_cmd_end(unsigned long arg)333 static long rve_ioctl_cmd_end(unsigned long arg)
334 {
335 struct rve_user_ctx_t rve_user_ctx;
336 int ret = 0;
337
338 if (unlikely(copy_from_user(&rve_user_ctx, (uint32_t *)arg,
339 sizeof(rve_user_ctx)))) {
340 pr_err("rve_user_ctx copy_from_user failed!\n");
341 return -EFAULT;
342 }
343
344 if (DEBUGGER_EN(MSG))
345 pr_info("config end id = %d", rve_user_ctx.id);
346
347 /* find internal_ctx to set cmd by user ctx (internal ctx id) */
348 ret = rve_job_commit_by_user_ctx(&rve_user_ctx);
349 if (ret < 0) {
350 pr_err("commit ctx id[%d] failed!\n", rve_user_ctx.id);
351 return -EFAULT;
352 }
353
354 if (copy_to_user((struct rve_user_ctx_t *)arg,
355 &rve_user_ctx, sizeof(struct rve_user_ctx_t))) {
356 pr_err("rve_user_ctx copy_to_user failed\n");
357 return -EFAULT;
358 }
359
360 return ret;
361 }
362
rve_ioctl_cmd_cancel(unsigned long arg)363 static long rve_ioctl_cmd_cancel(unsigned long arg)
364 {
365 uint32_t rve_user_ctx_id;
366 int ret = 0;
367
368 if (unlikely(copy_from_user(&rve_user_ctx_id, (uint32_t *)arg,
369 sizeof(uint32_t)))) {
370 pr_err("rve_user_ctx copy_from_user failed!\n");
371 return -EFAULT;
372 }
373
374 if (DEBUGGER_EN(MSG))
375 pr_info("config cancel id = %d", rve_user_ctx_id);
376
377 /* find internal_ctx to set cmd by user ctx (internal ctx id) */
378 ret = rve_job_cancel_by_user_ctx(rve_user_ctx_id);
379 if (ret < 0) {
380 pr_err("cancel ctx id[%d] failed!\n", rve_user_ctx_id);
381 return -EFAULT;
382 }
383
384 return ret;
385 }
386
rve_ioctl(struct file * file,uint32_t cmd,unsigned long arg)387 static long rve_ioctl(struct file *file, uint32_t cmd, unsigned long arg)
388 {
389 struct rve_drvdata_t *rve = rve_drvdata;
390
391 int ret = 0;
392 int i = 0;
393 struct rve_version_t driver_version;
394 struct rve_hw_versions_t hw_versions;
395 struct rve_session *session = file->private_data;
396
397 if (!rve) {
398 pr_err("rve_drvdata is null, rve is not init\n");
399 return -ENODEV;
400 }
401
402 //if (DEBUGGER_EN(NONUSE))
403 // return 0;
404
405 switch (cmd) {
406 case RVE_IOC_GET_HW_VER:
407 /* RVE hardware version */
408 hw_versions.size = rve->num_of_scheduler > RVE_HW_SIZE ?
409 RVE_HW_SIZE : rve->num_of_scheduler;
410
411 for (i = 0; i < hw_versions.size; i++) {
412 memcpy(&hw_versions.version[i], &rve->scheduler[i]->version,
413 sizeof(rve->scheduler[i]->version));
414 }
415
416 if (copy_to_user((void *)arg, &hw_versions, sizeof(hw_versions)))
417 ret = -EFAULT;
418 else
419 ret = true;
420
421 break;
422
423 case RVE_IOC_GET_VER:
424 /* Driver version */
425 driver_version.major = DRIVER_MAJOR_VERSION;
426 driver_version.minor = DRIVER_MINOR_VERSION;
427 driver_version.revision = DRIVER_REVISION_VERSION;
428 driver_version.prod_num = 0;
429 strncpy((char *)driver_version.str, DRIVER_VERSION, sizeof(driver_version.str));
430
431 if (copy_to_user((void *)arg, &driver_version, sizeof(driver_version)))
432 ret = -EFAULT;
433 else
434 ret = true;
435
436 break;
437
438 case RVE_IOC_START_CONFIG:
439 ret = rve_ioctl_cmd_start(arg, session);
440
441 break;
442
443 case RVE_IOC_END_CONFIG:
444 ret = rve_ioctl_cmd_end(arg);
445
446 break;
447
448 case RVE_IOC_CMD_CONFIG:
449 ret = rve_ioctl_cmd_config(arg);
450
451 break;
452
453 case RVE_IOC_CANCEL_CONFIG:
454 ret = rve_ioctl_cmd_cancel(arg);
455
456 break;
457
458 default:
459 pr_err("unknown ioctl cmd!\n");
460 ret = -EINVAL;
461 break;
462 }
463
464 return ret;
465 }
466
467 #ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
rve_debugger_init(struct rve_debugger ** debugger_p)468 static int rve_debugger_init(struct rve_debugger **debugger_p)
469 {
470 struct rve_debugger *debugger;
471
472 *debugger_p = kzalloc(sizeof(struct rve_debugger), GFP_KERNEL);
473 if (*debugger_p == NULL) {
474 pr_err("can not alloc for rve debugger\n");
475 return -ENOMEM;
476 }
477
478 debugger = *debugger_p;
479
480 #ifdef CONFIG_ROCKCHIP_RVE_DEBUG_FS
481 mutex_init(&debugger->debugfs_lock);
482 INIT_LIST_HEAD(&debugger->debugfs_entry_list);
483 #endif
484
485 #ifdef CONFIG_ROCKCHIP_RVE_PROC_FS
486 mutex_init(&debugger->procfs_lock);
487 INIT_LIST_HEAD(&debugger->procfs_entry_list);
488 #endif
489
490 rve_debugfs_init();
491 rve_procfs_init();
492
493 return 0;
494 }
495
rve_debugger_remove(struct rve_debugger ** debugger_p)496 static int rve_debugger_remove(struct rve_debugger **debugger_p)
497 {
498 rve_debugfs_remove();
499 rve_procfs_remove();
500
501 kfree(*debugger_p);
502 *debugger_p = NULL;
503
504 return 0;
505 }
506 #endif
507
rve_open(struct inode * inode,struct file * file)508 static int rve_open(struct inode *inode, struct file *file)
509 {
510 struct rve_session *session = NULL;
511
512 session = rve_session_init();
513 if (!session)
514 return -ENOMEM;
515
516 file->private_data = (void *)session;
517
518 return nonseekable_open(inode, file);
519 }
520
rve_release(struct inode * inode,struct file * file)521 static int rve_release(struct inode *inode, struct file *file)
522 {
523 struct rve_session *session = file->private_data;
524
525 rve_session_deinit(session);
526
527 return 0;
528 }
529
rve_irq_handler(int irq,void * data)530 static irqreturn_t rve_irq_handler(int irq, void *data)
531 {
532 struct rve_scheduler_t *scheduler = data;
533 u32 error_flag;
534
535 error_flag = rve_read(RVE_SWREG6_IVE_WORK_STA, scheduler);
536
537 if (error_flag & 0x6) {
538 pr_err("irq thread work_status[%x]\n", error_flag);
539
540 if (error_flag & 0x2)
541 pr_err("irq: bus error");
542 else if (error_flag & 0x4)
543 pr_err("irq: timeout error");
544
545 scheduler->ops->soft_reset(scheduler);
546 }
547
548 /* clear INT */
549 rve_write(0x30000, RVE_SWREG1_IVE_IRQ, scheduler);
550
551 return IRQ_WAKE_THREAD;
552 }
553
rve_irq_thread(int irq,void * data)554 static irqreturn_t rve_irq_thread(int irq, void *data)
555 {
556 struct rve_scheduler_t *scheduler = data;
557 struct rve_job *job;
558 u32 error_flag;
559
560 job = scheduler->running_job;
561 scheduler->session.total_int_cnt++;
562
563 if (!job) {
564 pr_err("running job is invalid on irq thread\n");
565 return IRQ_HANDLED;
566 }
567
568 error_flag = rve_read(RVE_SWREG6_IVE_WORK_STA, scheduler);
569
570 if (DEBUGGER_EN(INT_FLAG)) {
571 pr_err("irq thread work_status[%x]\n", error_flag);
572 if (error_flag & 0x6) {
573 if (error_flag & 0x2)
574 pr_err("irq: bus error");
575 else if (error_flag & 0x4)
576 pr_err("irq: timeout error");
577 }
578 }
579
580 /* if llp mode*/
581 if ((error_flag & RVE_LLP_MODE) &&
582 (!(error_flag & RVE_LLP_DONE))) {
583 if (DEBUGGER_EN(INT_FLAG))
584 pr_err("irq: llp mode need to skip rve_job_done");
585 goto skip_job_done;
586 }
587
588 rve_job_done(scheduler, 0);
589
590 skip_job_done:
591 return IRQ_HANDLED;
592 }
593
594 const struct file_operations rve_fops = {
595 .owner = THIS_MODULE,
596 .open = rve_open,
597 .release = rve_release,
598 .unlocked_ioctl = rve_ioctl,
599 #ifdef CONFIG_COMPAT
600 .compat_ioctl = rve_ioctl,
601 #endif
602 };
603
604 static struct miscdevice rve_dev = {
605 .minor = MISC_DYNAMIC_MINOR,
606 .name = "rve",
607 .fops = &rve_fops,
608 };
609
610 static const char *const rve_clks[] = {
611 "aclk_rve",
612 "hclk_rve",
613 };
614
615 static const struct rve_irqs_data_t rve_irqs[] = {
616 {"rve_irq", rve_irq_handler, rve_irq_thread}
617 };
618
619 static const struct rve_match_data_t rve_match_data = {
620 .clks = rve_clks,
621 .num_clks = ARRAY_SIZE(rve_clks),
622 .irqs = rve_irqs,
623 .num_irqs = ARRAY_SIZE(rve_irqs)
624 };
625
626 static const struct of_device_id rve_dt_ids[] = {
627 {
628 .compatible = "rockchip,rve",
629 .data = &rve_match_data,
630 },
631 {},
632 };
633
init_scheduler(struct rve_scheduler_t * scheduler,const char * name)634 static void init_scheduler(struct rve_scheduler_t *scheduler,
635 const char *name)
636 {
637 spin_lock_init(&scheduler->irq_lock);
638 INIT_LIST_HEAD(&scheduler->todo_list);
639 init_waitqueue_head(&scheduler->job_done_wq);
640
641 if (!strcmp(name, "rve")) {
642 scheduler->ops = &rve_ops;
643 scheduler->core = RVE_SCHEDULER_CORE0;
644 }
645 }
646
rve_drv_probe(struct platform_device * pdev)647 static int rve_drv_probe(struct platform_device *pdev)
648 {
649 struct rve_drvdata_t *data = rve_drvdata;
650 struct resource *res;
651 int ret = 0;
652 const struct of_device_id *match = NULL;
653 struct device *dev = &pdev->dev;
654 const struct rve_match_data_t *match_data;
655 int i = 0, irq;
656 struct rve_scheduler_t *scheduler = NULL;
657
658 if (!pdev->dev.of_node)
659 return -EINVAL;
660
661 if (!strcmp(dev_driver_string(dev), "rve"))
662 match = of_match_device(rve_dt_ids, dev);
663
664 if (!match) {
665 dev_err(dev, "%s missing DT entry!\n", dev_driver_string(dev));
666 return -EINVAL;
667 }
668
669 scheduler =
670 devm_kzalloc(&pdev->dev, sizeof(struct rve_scheduler_t),
671 GFP_KERNEL);
672 if (scheduler == NULL) {
673 pr_err("failed to allocate scheduler. dev name = %s\n",
674 dev_driver_string(dev));
675 return -ENOMEM;
676 }
677
678 init_scheduler(scheduler, dev_driver_string(dev));
679
680 scheduler->dev = &pdev->dev;
681
682 /* map the registers */
683 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
684 if (!res) {
685 pr_err("get memory resource failed.\n");
686 return -ENXIO;
687 }
688
689 scheduler->rve_base =
690 devm_ioremap(&pdev->dev, res->start, resource_size(res));
691 if (!scheduler->rve_base) {
692 pr_err("ioremap failed\n");
693 ret = -ENOENT;
694 return ret;
695 }
696
697 /* get the IRQ */
698 match_data = match->data;
699
700 /* there are irq names in dts */
701 irq = platform_get_irq(pdev, 0);
702 if (irq < 0) {
703 dev_err(dev, "no irq %s in dts\n", match_data->irqs[0].name);
704 return irq;
705 }
706
707 scheduler->irq = irq;
708
709 pr_info("%s, irq = %d, match scheduler\n",
710 match_data->irqs[0].name, irq);
711
712 ret = devm_request_threaded_irq(dev, irq,
713 match_data->irqs[0].irq_hdl,
714 match_data->irqs[0].irq_thread, IRQF_SHARED,
715 dev_driver_string(dev), scheduler);
716 if (ret < 0) {
717 pr_err("request irq name: %s failed: %d\n",
718 match_data->irqs[0].name, ret);
719 return ret;
720 }
721
722 #ifndef RVE_PD_AWAYS_ON
723 for (i = 0; i < match_data->num_clks; i++) {
724 struct clk *clk = devm_clk_get(dev, match_data->clks[i]);
725
726 if (IS_ERR(clk))
727 pr_err("failed to get %s\n", match_data->clks[i]);
728
729 scheduler->clks[i] = clk;
730 }
731 scheduler->num_clks = match_data->num_clks;
732 #endif
733
734 platform_set_drvdata(pdev, scheduler);
735
736 device_init_wakeup(dev, true);
737
738 /* PM init */
739 #ifndef RVE_PD_AWAYS_ON
740 pm_runtime_enable(&pdev->dev);
741
742 ret = pm_runtime_get_sync(scheduler->dev);
743 if (ret < 0) {
744 pr_err("failed to get pm runtime, ret = %d\n",
745 ret);
746 goto failed;
747 }
748
749 for (i = 0; i < scheduler->num_clks; i++) {
750 if (!IS_ERR(scheduler->clks[i])) {
751 ret = clk_prepare_enable(scheduler->clks[i]);
752 if (ret < 0) {
753 pr_err("failed to enable clk\n");
754 goto failed;
755 }
756 }
757 }
758 #endif //RVE_PD_AWAYS_ON
759
760 scheduler->ops->get_version(scheduler);
761 pr_info("Driver loaded successfully rve[%d] ver:%s\n", i,
762 scheduler->version.str);
763
764 data->scheduler[data->num_of_scheduler] = scheduler;
765
766 data->num_of_scheduler++;
767
768 #ifndef RVE_PD_AWAYS_ON
769 for (i = scheduler->num_clks - 1; i >= 0; i--)
770 if (!IS_ERR(scheduler->clks[i]))
771 clk_disable_unprepare(scheduler->clks[i]);
772
773 pm_runtime_put_sync(&pdev->dev);
774 #endif //RVE_PD_AWAYS_ON
775
776 pr_info("probe successfully\n");
777
778 return 0;
779
780 #ifndef RVE_PD_AWAYS_ON
781 failed:
782 device_init_wakeup(dev, false);
783 pm_runtime_disable(dev);
784
785 return ret;
786 #endif //RVE_PD_AWAYS_ON
787 }
788
rve_drv_remove(struct platform_device * pdev)789 static int rve_drv_remove(struct platform_device *pdev)
790 {
791 device_init_wakeup(&pdev->dev, false);
792 #ifndef RVE_PD_AWAYS_ON
793 pm_runtime_disable(&pdev->dev);
794 #endif //RVE_PD_AWAYS_ON
795
796 return 0;
797 }
798
799 static struct platform_driver rve_driver = {
800 .probe = rve_drv_probe,
801 .remove = rve_drv_remove,
802 .driver = {
803 .name = "rve",
804 .of_match_table = of_match_ptr(rve_dt_ids),
805 },
806 };
807
rve_init(void)808 static int __init rve_init(void)
809 {
810 int ret;
811
812 rve_drvdata = kzalloc(sizeof(struct rve_drvdata_t), GFP_KERNEL);
813 if (rve_drvdata == NULL) {
814 pr_err("failed to allocate driver data.\n");
815 return -ENOMEM;
816 }
817
818 mutex_init(&rve_drvdata->lock);
819
820 wake_lock_init(&rve_drvdata->wake_lock, WAKE_LOCK_SUSPEND, "rve");
821
822 ret = platform_driver_register(&rve_driver);
823 if (ret != 0) {
824 pr_err("Platform device rve register failed (%d).\n", ret);
825 return ret;
826 }
827
828 #ifdef CONFIG_SYNC_FILE
829 rve_drvdata->fence_ctx = rve_fence_context_alloc();
830 if (IS_ERR(rve_drvdata->fence_ctx)) {
831 pr_err("failed to allocate fence context for RVE\n");
832 ret = PTR_ERR(rve_drvdata->fence_ctx);
833 return ret;
834 }
835 #endif
836
837 ret = misc_register(&rve_dev);
838 if (ret) {
839 pr_err("cannot register miscdev (%d)\n", ret);
840 return ret;
841 }
842
843 rve_ctx_manager_init(&rve_drvdata->pend_ctx_manager);
844
845 rve_session_manager_init(&rve_drvdata->session_manager);
846
847 rve_init_timer();
848
849 #ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
850 rve_debugger_init(&rve_drvdata->debugger);
851 #endif
852
853 pr_info("Module initialized. v%s\n", DRIVER_VERSION);
854
855 return 0;
856 }
857
rve_exit(void)858 static void __exit rve_exit(void)
859 {
860 #ifdef CONFIG_ROCKCHIP_RVE_DEBUGGER
861 rve_debugger_remove(&rve_drvdata->debugger);
862 #endif
863
864 rve_ctx_manager_remove(&rve_drvdata->pend_ctx_manager);
865
866 rve_session_manager_remove(&rve_drvdata->session_manager);
867
868 wake_lock_destroy(&rve_drvdata->wake_lock);
869
870 #ifdef CONFIG_SYNC_FILE
871 rve_fence_context_free(rve_drvdata->fence_ctx);
872 #endif
873
874 rve_cancel_timer();
875
876 platform_driver_unregister(&rve_driver);
877
878 misc_deregister(&rve_dev);
879
880 kfree(rve_drvdata);
881 }
882
883 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 0))
884 #ifdef CONFIG_ROCKCHIP_THUNDER_BOOT
885 module_init(rve_init);
886 #else
887 late_initcall(rve_init);
888 #endif
889 #else
890 fs_initcall(rve_init);
891 #endif
892 module_exit(rve_exit);
893
894 /* Module information */
895 MODULE_AUTHOR("putin.li@rock-chips.com");
896 MODULE_DESCRIPTION("Driver for rve device");
897 MODULE_LICENSE("GPL");
898