change wifi driver to cypress

hc

2024-01-05 071106ecf68c401173c58808b1cf5f68cc50d390

 kernel/drivers/rknpu/rknpu_drv.c
..
..
@@ -31,19 +31,11 @@
31
31
 #include <linux/clk-provider.h>
32
32
 #include <linux/pm_domain.h>
33
33
 #include <linux/pm_runtime.h>
34
-#include <linux/devfreq_cooling.h>
35
34
 #include <linux/regmap.h>
36
-#include <linux/dma-iommu.h>
37
35
 #include <linux/of_address.h>
38
36
 
39
37
 #ifndef FPGA_PLATFORM
40
38
 #include <soc/rockchip/rockchip_iommu.h>
41
-#include <soc/rockchip/rockchip_opp_select.h>
42
-#include <soc/rockchip/rockchip_system_monitor.h>
43
-#include <soc/rockchip/rockchip_ipa.h>
44
-#ifdef CONFIG_PM_DEVFREQ
45
-#include <../drivers/devfreq/governor.h>
46
-#endif
47
39
 #endif
48
40
 
49
41
 #include "rknpu_ioctl.h"
..
..
@@ -51,6 +43,7 @@
51
43
 #include "rknpu_fence.h"
52
44
 #include "rknpu_drv.h"
53
45
 #include "rknpu_gem.h"
46
+#include "rknpu_devfreq.h"
54
47
 
55
48
 #ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
56
49
 #include <drm/drm_device.h>
..
..
@@ -118,7 +111,9 @@
118
111
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
119
112
 	.num_resets = ARRAY_SIZE(rknpu_resets),
120
113
 	.nbuf_phyaddr = 0,
121
-	.nbuf_size = 0
114
+	.nbuf_size = 0,
115
+	.max_submit_number = (1 << 12) - 1,
116
+	.core_mask = 0x1,
122
117
 };
123
118
 
124
119
 static const struct rknpu_config rk3588_rknpu_config = {
..
..
@@ -136,7 +131,29 @@
136
131
 	.num_irqs = ARRAY_SIZE(rk3588_npu_irqs),
137
132
 	.num_resets = ARRAY_SIZE(rk3588_npu_resets),
138
133
 	.nbuf_phyaddr = 0,
139
-	.nbuf_size = 0
134
+	.nbuf_size = 0,
135
+	.max_submit_number = (1 << 12) - 1,
136
+	.core_mask = 0x7,
137
+};
138
+
139
+static const struct rknpu_config rk3583_rknpu_config = {
140
+	.bw_priority_addr = 0x0,
141
+	.bw_priority_length = 0x0,
142
+	.dma_mask = DMA_BIT_MASK(40),
143
+	.pc_data_amount_scale = 2,
144
+	.pc_task_number_bits = 12,
145
+	.pc_task_number_mask = 0xfff,
146
+	.pc_task_status_offset = 0x3c,
147
+	.pc_dma_ctrl = 0,
148
+	.bw_enable = 0,
149
+	.irqs = rk3588_npu_irqs,
150
+	.resets = rk3588_npu_resets,
151
+	.num_irqs = 2,
152
+	.num_resets = 2,
153
+	.nbuf_phyaddr = 0,
154
+	.nbuf_size = 0,
155
+	.max_submit_number = (1 << 12) - 1,
156
+	.core_mask = 0x3,
140
157
 };
141
158
 
142
159
 static const struct rknpu_config rv1106_rknpu_config = {
..
..
@@ -154,7 +171,9 @@
154
171
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
155
172
 	.num_resets = ARRAY_SIZE(rknpu_resets),
156
173
 	.nbuf_phyaddr = 0,
157
-	.nbuf_size = 0
174
+	.nbuf_size = 0,
175
+	.max_submit_number = (1 << 16) - 1,
176
+	.core_mask = 0x1,
158
177
 };
159
178
 
160
179
 static const struct rknpu_config rk3562_rknpu_config = {
..
..
@@ -172,7 +191,9 @@
172
191
 	.num_irqs = ARRAY_SIZE(rknpu_irqs),
173
192
 	.num_resets = ARRAY_SIZE(rknpu_resets),
174
193
 	.nbuf_phyaddr = 0xfe400000,
175
-	.nbuf_size = 256 * 1024
194
+	.nbuf_size = 256 * 1024,
195
+	.max_submit_number = (1 << 16) - 1,
196
+	.core_mask = 0x1,
176
197
 };
177
198
 
178
199
 /* driver probe and init */
..
..
@@ -225,7 +246,6 @@
225
246
 {
226
247
 	int ret = 0;
227
248
 
228
-	cancel_delayed_work(&rknpu_dev->power_off_work);
229
249
 	mutex_lock(&rknpu_dev->power_lock);
230
250
 	if (atomic_inc_return(&rknpu_dev->power_refcount) == 1)
231
251
 		ret = rknpu_power_on(rknpu_dev);
..
..
@@ -248,6 +268,9 @@
248
268
 
249
269
 static int rknpu_power_put_delay(struct rknpu_device *rknpu_dev)
250
270
 {
271
+	if (rknpu_dev->power_put_delay == 0)
272
+		return rknpu_power_put(rknpu_dev);
273
+
251
274
 	mutex_lock(&rknpu_dev->power_lock);
252
275
 	if (atomic_read(&rknpu_dev->power_refcount) == 1)
253
276
 		queue_delayed_work(
..
..
@@ -256,6 +279,7 @@
256
279
 	else
257
280
 		atomic_dec_if_positive(&rknpu_dev->power_refcount);
258
281
 	mutex_unlock(&rknpu_dev->power_lock);
282
+
259
283
 	return 0;
260
284
 }
261
285
 
..
..
@@ -489,11 +513,13 @@
489
513
 #endif
490
514
 
491
515
 #ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
516
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
492
517
 static const struct vm_operations_struct rknpu_gem_vm_ops = {
493
518
 	.fault = rknpu_gem_fault,
494
519
 	.open = drm_gem_vm_open,
495
520
 	.close = drm_gem_vm_close,
496
521
 };
522
+#endif
497
523
 
498
524
 static int rknpu_action_ioctl(struct drm_device *dev, void *data,
499
525
 			      struct drm_file *file_priv)
..
..
@@ -535,6 +561,9 @@
535
561
 			  DRM_RENDER_ALLOW),
536
562
 };
537
563
 
564
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
565
+DEFINE_DRM_GEM_FOPS(rknpu_drm_driver_fops);
566
+#else
538
567
 static const struct file_operations rknpu_drm_driver_fops = {
539
568
 	.owner = THIS_MODULE,
540
569
 	.open = drm_open,
..
..
@@ -548,6 +577,7 @@
548
577
 	.release = drm_release,
549
578
 	.llseek = noop_llseek,
550
579
 };
580
+#endif
551
581
 
552
582
 static struct drm_driver rknpu_drm_driver = {
553
583
 #if KERNEL_VERSION(5, 4, 0) <= LINUX_VERSION_CODE
..
..
@@ -555,28 +585,34 @@
555
585
 #else
556
586
 	.driver_features = DRIVER_GEM | DRIVER_PRIME | DRIVER_RENDER,
557
587
 #endif
588
+#if KERNEL_VERSION(6, 1, 0) > LINUX_VERSION_CODE
558
589
 	.gem_free_object_unlocked = rknpu_gem_free_object,
559
590
 	.gem_vm_ops = &rknpu_gem_vm_ops,
591
+	.dumb_destroy = drm_gem_dumb_destroy,
592
+	.gem_prime_export = drm_gem_prime_export,
593
+	.gem_prime_get_sg_table = rknpu_gem_prime_get_sg_table,
594
+	.gem_prime_vmap = rknpu_gem_prime_vmap,
595
+	.gem_prime_vunmap = rknpu_gem_prime_vunmap,
596
+#endif
560
597
 	.dumb_create = rknpu_gem_dumb_create,
561
598
 #if KERNEL_VERSION(4, 19, 0) > LINUX_VERSION_CODE
562
599
 	.dumb_map_offset = rknpu_gem_dumb_map_offset,
563
600
 #else
564
601
 	.dumb_map_offset = drm_gem_dumb_map_offset,
565
602
 #endif
566
-	.dumb_destroy = drm_gem_dumb_destroy,
567
603
 	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
568
604
 	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
569
-	.gem_prime_export = drm_gem_prime_export,
570
605
 #if KERNEL_VERSION(4, 13, 0) <= LINUX_VERSION_CODE
571
606
 	.gem_prime_import = rknpu_gem_prime_import,
572
607
 #else
573
608
 	.gem_prime_import = drm_gem_prime_import,
574
609
 #endif
575
-	.gem_prime_get_sg_table = rknpu_gem_prime_get_sg_table,
576
610
 	.gem_prime_import_sg_table = rknpu_gem_prime_import_sg_table,
577
-	.gem_prime_vmap = rknpu_gem_prime_vmap,
578
-	.gem_prime_vunmap = rknpu_gem_prime_vunmap,
611
+#if KERNEL_VERSION(6, 1, 0) <= LINUX_VERSION_CODE
612
+	.gem_prime_mmap = drm_gem_prime_mmap,
613
+#else
579
614
 	.gem_prime_mmap = rknpu_gem_prime_mmap,
615
+#endif
580
616
 	.ioctls = rknpu_ioctls,
581
617
 	.num_ioctls = ARRAY_SIZE(rknpu_ioctls),
582
618
 	.fops = &rknpu_drm_driver_fops,
..
..
@@ -596,7 +632,7 @@
596
632
 		container_of(timer, struct rknpu_device, timer);
597
633
 	struct rknpu_subcore_data *subcore_data = NULL;
598
634
 	struct rknpu_job *job = NULL;
599
-	ktime_t now = ktime_get();
635
+	ktime_t now;
600
636
 	unsigned long flags;
601
637
 	int i;
602
638
 
..
..
@@ -607,14 +643,16 @@
607
643
 
608
644
 		job = subcore_data->job;
609
645
 		if (job) {
646
+			now = ktime_get();
610
647
 			subcore_data->timer.busy_time +=
611
-				ktime_us_delta(now, job->hw_recoder_time);
612
-			job->hw_recoder_time = ktime_get();
648
+				ktime_sub(now, job->hw_recoder_time);
649
+			job->hw_recoder_time = now;
613
650
 		}
614
651
 
615
-		subcore_data->timer.busy_time_record =
652
+		subcore_data->timer.total_busy_time =
616
653
 			subcore_data->timer.busy_time;
617
654
 		subcore_data->timer.busy_time = 0;
655
+
618
656
 		spin_unlock_irqrestore(&rknpu_dev->irq_lock, flags);
619
657
 	}
620
658
 
..
..
@@ -661,6 +699,42 @@
661
699
 }
662
700
 
663
701
 #ifdef CONFIG_ROCKCHIP_RKNPU_DRM_GEM
702
+static int drm_fake_dev_register(struct rknpu_device *rknpu_dev)
703
+{
704
+	const struct platform_device_info rknpu_dev_info = {
705
+		.name = "rknpu_dev",
706
+		.id = PLATFORM_DEVID_AUTO,
707
+		.dma_mask = rknpu_dev->config->dma_mask,
708
+	};
709
+	struct platform_device *pdev = NULL;
710
+	int ret = -EINVAL;
711
+
712
+	pdev = platform_device_register_full(&rknpu_dev_info);
713
+	if (pdev) {
714
+		ret = of_dma_configure(&pdev->dev, NULL, true);
715
+		if (ret) {
716
+			platform_device_unregister(pdev);
717
+			pdev = NULL;
718
+		}
719
+	}
720
+
721
+	rknpu_dev->fake_dev = pdev ? &pdev->dev : NULL;
722
+
723
+	return ret;
724
+}
725
+
726
+static void drm_fake_dev_unregister(struct rknpu_device *rknpu_dev)
727
+{
728
+	struct platform_device *pdev = NULL;
729
+
730
+	if (!rknpu_dev->fake_dev)
731
+		return;
732
+
733
+	pdev = to_platform_device(rknpu_dev->fake_dev);
734
+
735
+	platform_device_unregister(pdev);
736
+}
737
+
664
738
 static int rknpu_drm_probe(struct rknpu_device *rknpu_dev)
665
739
 {
666
740
 	struct device *dev = rknpu_dev->dev;
..
..
@@ -679,6 +753,8 @@
679
753
 	drm_dev->dev_private = rknpu_dev;
680
754
 	rknpu_dev->drm_dev = drm_dev;
681
755
 
756
+	drm_fake_dev_register(rknpu_dev);
757
+
682
758
 	return 0;
683
759
 
684
760
 err_free_drm:
..
..
@@ -694,6 +770,8 @@
694
770
 static void rknpu_drm_remove(struct rknpu_device *rknpu_dev)
695
771
 {
696
772
 	struct drm_device *drm_dev = rknpu_dev->drm_dev;
773
+
774
+	drm_fake_dev_unregister(rknpu_dev);
697
775
 
698
776
 	drm_dev_unregister(drm_dev);
699
777
 
..
..
@@ -742,9 +820,7 @@
742
820
 	}
743
821
 
744
822
 #ifndef FPGA_PLATFORM
745
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
746
-	rockchip_monitor_volt_adjust_lock(rknpu_dev->mdev_info);
747
-#endif
823
+	rknpu_devfreq_lock(rknpu_dev);
748
824
 #endif
749
825
 
750
826
 	if (rknpu_dev->multiple_domains) {
..
..
@@ -803,9 +879,7 @@
803
879
 
804
880
 out:
805
881
 #ifndef FPGA_PLATFORM
806
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
807
-	rockchip_monitor_volt_adjust_unlock(rknpu_dev->mdev_info);
808
-#endif
882
+	rknpu_devfreq_unlock(rknpu_dev);
809
883
 #endif
810
884
 
811
885
 	return ret;
..
..
@@ -819,9 +893,7 @@
819
893
 	int ret;
820
894
 	bool val;
821
895
 
822
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
823
-	rockchip_monitor_volt_adjust_lock(rknpu_dev->mdev_info);
824
-#endif
896
+	rknpu_devfreq_lock(rknpu_dev);
825
897
 #endif
826
898
 
827
899
 	pm_runtime_put_sync(dev);
..
..
@@ -843,10 +915,7 @@
843
915
 		if (ret) {
844
916
 			LOG_DEV_ERROR(dev, "iommu still enabled\n");
845
917
 			pm_runtime_get_sync(dev);
846
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
847
-			rockchip_monitor_volt_adjust_unlock(
848
-				rknpu_dev->mdev_info);
849
-#endif
918
+			rknpu_devfreq_unlock(rknpu_dev);
850
919
 			return ret;
851
920
 		}
852
921
 #else
..
..
@@ -862,9 +931,7 @@
862
931
 	}
863
932
 
864
933
 #ifndef FPGA_PLATFORM
865
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
866
-	rockchip_monitor_volt_adjust_unlock(rknpu_dev->mdev_info);
867
-#endif
934
+	rknpu_devfreq_unlock(rknpu_dev);
868
935
 #endif
869
936
 
870
937
 	clk_bulk_disable_unprepare(rknpu_dev->num_clks, rknpu_dev->clks);
..
..
@@ -879,686 +946,6 @@
879
946
 
880
947
 	return 0;
881
948
 }
882
-
883
-#ifndef FPGA_PLATFORM
884
-static struct monitor_dev_profile npu_mdevp = {
885
-	.type = MONITOR_TYPE_DEV,
886
-	.low_temp_adjust = rockchip_monitor_dev_low_temp_adjust,
887
-	.high_temp_adjust = rockchip_monitor_dev_high_temp_adjust,
888
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
889
-	.update_volt = rockchip_monitor_check_rate_volt,
890
-#endif
891
-};
892
-
893
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
894
-static int npu_opp_helper(struct dev_pm_set_opp_data *data)
895
-{
896
-	struct device *dev = data->dev;
897
-	struct dev_pm_opp_supply *old_supply_vdd = &data->old_opp.supplies[0];
898
-	struct dev_pm_opp_supply *old_supply_mem = &data->old_opp.supplies[1];
899
-	struct dev_pm_opp_supply *new_supply_vdd = &data->new_opp.supplies[0];
900
-	struct dev_pm_opp_supply *new_supply_mem = &data->new_opp.supplies[1];
901
-	struct regulator *vdd_reg = data->regulators[0];
902
-	struct regulator *mem_reg = data->regulators[1];
903
-	struct clk *clk = data->clk;
904
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
905
-	struct rockchip_opp_info *opp_info = &rknpu_dev->opp_info;
906
-	unsigned long old_freq = data->old_opp.rate;
907
-	unsigned long new_freq = data->new_opp.rate;
908
-	bool is_set_rm = true;
909
-	bool is_set_clk = true;
910
-	u32 target_rm = UINT_MAX;
911
-	int ret = 0;
912
-
913
-	if (!pm_runtime_active(dev)) {
914
-		is_set_rm = false;
915
-		if (opp_info->scmi_clk)
916
-			is_set_clk = false;
917
-	}
918
-
919
-	ret = clk_bulk_prepare_enable(opp_info->num_clks, opp_info->clks);
920
-	if (ret < 0) {
921
-		LOG_DEV_ERROR(dev, "failed to enable opp clks\n");
922
-		return ret;
923
-	}
924
-	rockchip_get_read_margin(dev, opp_info, new_supply_vdd->u_volt,
925
-				 &target_rm);
926
-
927
-	/* Change frequency */
928
-	LOG_DEV_DEBUG(dev, "switching OPP: %lu Hz --> %lu Hz\n", old_freq,
929
-		      new_freq);
930
-	/* Scaling up? Scale voltage before frequency */
931
-	if (new_freq >= old_freq) {
932
-		rockchip_set_intermediate_rate(dev, opp_info, clk, old_freq,
933
-					       new_freq, true, is_set_clk);
934
-		ret = regulator_set_voltage(mem_reg, new_supply_mem->u_volt,
935
-					    INT_MAX);
936
-		if (ret) {
937
-			LOG_DEV_ERROR(dev,
938
-				      "failed to set volt %lu uV for mem reg\n",
939
-				      new_supply_mem->u_volt);
940
-			goto restore_voltage;
941
-		}
942
-		ret = regulator_set_voltage(vdd_reg, new_supply_vdd->u_volt,
943
-					    INT_MAX);
944
-		if (ret) {
945
-			LOG_DEV_ERROR(dev,
946
-				      "failed to set volt %lu uV for vdd reg\n",
947
-				      new_supply_vdd->u_volt);
948
-			goto restore_voltage;
949
-		}
950
-		rockchip_set_read_margin(dev, opp_info, target_rm, is_set_rm);
951
-		if (is_set_clk && clk_set_rate(clk, new_freq)) {
952
-			ret = -EINVAL;
953
-			LOG_DEV_ERROR(dev, "failed to set clk rate: %d\n", ret);
954
-			goto restore_rm;
955
-		}
956
-		/* Scaling down? Scale voltage after frequency */
957
-	} else {
958
-		rockchip_set_intermediate_rate(dev, opp_info, clk, old_freq,
959
-					       new_freq, false, is_set_clk);
960
-		rockchip_set_read_margin(dev, opp_info, target_rm, is_set_rm);
961
-		if (is_set_clk && clk_set_rate(clk, new_freq)) {
962
-			ret = -EINVAL;
963
-			LOG_DEV_ERROR(dev, "failed to set clk rate: %d\n", ret);
964
-			goto restore_rm;
965
-		}
966
-		ret = regulator_set_voltage(vdd_reg, new_supply_vdd->u_volt,
967
-					    INT_MAX);
968
-		if (ret) {
969
-			LOG_DEV_ERROR(dev,
970
-				      "failed to set volt %lu uV for vdd reg\n",
971
-				      new_supply_vdd->u_volt);
972
-			goto restore_freq;
973
-		}
974
-		ret = regulator_set_voltage(mem_reg, new_supply_mem->u_volt,
975
-					    INT_MAX);
976
-		if (ret) {
977
-			LOG_DEV_ERROR(dev,
978
-				      "failed to set volt %lu uV for mem reg\n",
979
-				      new_supply_mem->u_volt);
980
-			goto restore_freq;
981
-		}
982
-	}
983
-
984
-	clk_bulk_disable_unprepare(opp_info->num_clks, opp_info->clks);
985
-
986
-	return 0;
987
-
988
-restore_freq:
989
-	if (is_set_clk && clk_set_rate(clk, old_freq))
990
-		LOG_DEV_ERROR(dev, "failed to restore old-freq %lu Hz\n",
991
-			      old_freq);
992
-restore_rm:
993
-	rockchip_get_read_margin(dev, opp_info, old_supply_vdd->u_volt,
994
-				 &target_rm);
995
-	rockchip_set_read_margin(dev, opp_info, opp_info->current_rm,
996
-				 is_set_rm);
997
-restore_voltage:
998
-	regulator_set_voltage(mem_reg, old_supply_mem->u_volt, INT_MAX);
999
-	regulator_set_voltage(vdd_reg, old_supply_vdd->u_volt, INT_MAX);
1000
-	clk_bulk_disable_unprepare(opp_info->num_clks, opp_info->clks);
1001
-
1002
-	return ret;
1003
-}
1004
-
1005
-static int npu_devfreq_target(struct device *dev, unsigned long *freq,
1006
-			      u32 flags)
1007
-{
1008
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
1009
-	struct dev_pm_opp *opp;
1010
-	unsigned long opp_volt;
1011
-	int ret = 0;
1012
-
1013
-	if (!npu_mdevp.is_checked)
1014
-		return -EINVAL;
1015
-
1016
-	opp = devfreq_recommended_opp(dev, freq, flags);
1017
-	if (IS_ERR(opp))
1018
-		return PTR_ERR(opp);
1019
-	opp_volt = dev_pm_opp_get_voltage(opp);
1020
-	dev_pm_opp_put(opp);
1021
-
1022
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
1023
-	rockchip_monitor_volt_adjust_lock(rknpu_dev->mdev_info);
1024
-#endif
1025
-	ret = dev_pm_opp_set_rate(dev, *freq);
1026
-	if (!ret) {
1027
-		rknpu_dev->current_freq = *freq;
1028
-		if (rknpu_dev->devfreq)
1029
-			rknpu_dev->devfreq->last_status.current_frequency =
1030
-				*freq;
1031
-		rknpu_dev->current_volt = opp_volt;
1032
-		LOG_DEV_INFO(dev, "set rknpu freq: %lu, volt: %lu\n",
1033
-			     rknpu_dev->current_freq, rknpu_dev->current_volt);
1034
-	}
1035
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
1036
-	rockchip_monitor_volt_adjust_unlock(rknpu_dev->mdev_info);
1037
-#endif
1038
-
1039
-	return ret;
1040
-}
1041
-
1042
-#else
1043
-
1044
-static int npu_devfreq_target(struct device *dev, unsigned long *target_freq,
1045
-			      u32 flags)
1046
-{
1047
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
1048
-	struct dev_pm_opp *opp = NULL;
1049
-	unsigned long freq = *target_freq;
1050
-	unsigned long old_freq = rknpu_dev->current_freq;
1051
-	unsigned long volt, old_volt = rknpu_dev->current_volt;
1052
-	int ret = -EINVAL;
1053
-
1054
-#if KERNEL_VERSION(4, 11, 0) > LINUX_VERSION_CODE
1055
-	rcu_read_lock();
1056
-#endif
1057
-
1058
-	opp = devfreq_recommended_opp(dev, &freq, flags);
1059
-	if (IS_ERR(opp)) {
1060
-#if KERNEL_VERSION(4, 11, 0) > LINUX_VERSION_CODE
1061
-		rcu_read_unlock();
1062
-#endif
1063
-		LOG_DEV_ERROR(dev, "failed to get opp (%ld)\n", PTR_ERR(opp));
1064
-		return PTR_ERR(opp);
1065
-	}
1066
-	volt = dev_pm_opp_get_voltage(opp);
1067
-#if KERNEL_VERSION(4, 11, 0) > LINUX_VERSION_CODE
1068
-	rcu_read_unlock();
1069
-#endif
1070
-
1071
-	/*
1072
-	 * Only update if there is a change of frequency
1073
-	 */
1074
-	if (old_freq == freq) {
1075
-		*target_freq = freq;
1076
-		if (old_volt == volt)
1077
-			return 0;
1078
-		ret = regulator_set_voltage(rknpu_dev->vdd, volt, INT_MAX);
1079
-		if (ret) {
1080
-			LOG_DEV_ERROR(dev, "failed to set volt %lu\n", volt);
1081
-			return ret;
1082
-		}
1083
-		rknpu_dev->current_volt = volt;
1084
-		return 0;
1085
-	}
1086
-
1087
-	if (rknpu_dev->vdd && old_volt != volt && old_freq < freq) {
1088
-		ret = regulator_set_voltage(rknpu_dev->vdd, volt, INT_MAX);
1089
-		if (ret) {
1090
-			LOG_DEV_ERROR(dev, "failed to increase volt %lu\n",
1091
-				      volt);
1092
-			return ret;
1093
-		}
1094
-	}
1095
-	LOG_DEV_DEBUG(dev, "%luHz %luuV -> %luHz %luuV\n", old_freq, old_volt,
1096
-		      freq, volt);
1097
-	ret = clk_set_rate(rknpu_dev->clks[0].clk, freq);
1098
-	if (ret) {
1099
-		LOG_DEV_ERROR(dev, "failed to set clock %lu\n", freq);
1100
-		return ret;
1101
-	}
1102
-	*target_freq = freq;
1103
-	rknpu_dev->current_freq = freq;
1104
-
1105
-	if (rknpu_dev->devfreq)
1106
-		rknpu_dev->devfreq->last_status.current_frequency = freq;
1107
-
1108
-	if (rknpu_dev->vdd && old_volt != volt && old_freq > freq) {
1109
-		ret = regulator_set_voltage(rknpu_dev->vdd, volt, INT_MAX);
1110
-		if (ret) {
1111
-			LOG_DEV_ERROR(dev, "failed to decrease volt %lu\n",
1112
-				      volt);
1113
-			return ret;
1114
-		}
1115
-	}
1116
-	rknpu_dev->current_volt = volt;
1117
-
1118
-	LOG_DEV_INFO(dev, "set rknpu freq: %lu, volt: %lu\n",
1119
-		     rknpu_dev->current_freq, rknpu_dev->current_volt);
1120
-
1121
-	return ret;
1122
-}
1123
-#endif
1124
-
1125
-static int npu_devfreq_get_dev_status(struct device *dev,
1126
-				      struct devfreq_dev_status *stat)
1127
-{
1128
-	return 0;
1129
-}
1130
-
1131
-static int npu_devfreq_get_cur_freq(struct device *dev, unsigned long *freq)
1132
-{
1133
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
1134
-
1135
-	*freq = rknpu_dev->current_freq;
1136
-
1137
-	return 0;
1138
-}
1139
-
1140
-static struct devfreq_dev_profile npu_devfreq_profile = {
1141
-	.polling_ms = 50,
1142
-	.target = npu_devfreq_target,
1143
-	.get_dev_status = npu_devfreq_get_dev_status,
1144
-	.get_cur_freq = npu_devfreq_get_cur_freq,
1145
-};
1146
-
1147
-#ifdef CONFIG_PM_DEVFREQ
1148
-static int devfreq_rknpu_ondemand_func(struct devfreq *df, unsigned long *freq)
1149
-{
1150
-	struct rknpu_device *rknpu_dev = df->data;
1151
-
1152
-	if (rknpu_dev)
1153
-		*freq = rknpu_dev->ondemand_freq;
1154
-	else
1155
-		*freq = df->previous_freq;
1156
-
1157
-	return 0;
1158
-}
1159
-
1160
-static int devfreq_rknpu_ondemand_handler(struct devfreq *devfreq,
1161
-					  unsigned int event, void *data)
1162
-{
1163
-	return 0;
1164
-}
1165
-
1166
-static struct devfreq_governor devfreq_rknpu_ondemand = {
1167
-	.name = "rknpu_ondemand",
1168
-	.get_target_freq = devfreq_rknpu_ondemand_func,
1169
-	.event_handler = devfreq_rknpu_ondemand_handler,
1170
-};
1171
-#endif
1172
-
1173
-static unsigned long npu_get_static_power(struct devfreq *devfreq,
1174
-					  unsigned long voltage)
1175
-{
1176
-	struct device *dev = devfreq->dev.parent;
1177
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
1178
-
1179
-	if (!rknpu_dev->model_data)
1180
-		return 0;
1181
-
1182
-	return rockchip_ipa_get_static_power(rknpu_dev->model_data, voltage);
1183
-}
1184
-
1185
-static struct devfreq_cooling_power npu_cooling_power = {
1186
-	.get_static_power = &npu_get_static_power,
1187
-};
1188
-
1189
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
1190
-static int rk3588_npu_get_soc_info(struct device *dev, struct device_node *np,
1191
-				   int *bin, int *process)
1192
-{
1193
-	int ret = 0;
1194
-	u8 value = 0;
1195
-
1196
-	if (!bin)
1197
-		return 0;
1198
-
1199
-	if (of_property_match_string(np, "nvmem-cell-names",
1200
-				     "specification_serial_number") >= 0) {
1201
-		ret = rockchip_nvmem_cell_read_u8(
1202
-			np, "specification_serial_number", &value);
1203
-		if (ret) {
1204
-			LOG_DEV_ERROR(
1205
-				dev,
1206
-				"Failed to get specification_serial_number\n");
1207
-			return ret;
1208
-		}
1209
-		/* RK3588M */
1210
-		if (value == 0xd)
1211
-			*bin = 1;
1212
-		/* RK3588J */
1213
-		else if (value == 0xa)
1214
-			*bin = 2;
1215
-	}
1216
-	if (*bin < 0)
1217
-		*bin = 0;
1218
-	LOG_DEV_INFO(dev, "bin=%d\n", *bin);
1219
-
1220
-	return ret;
1221
-}
1222
-
1223
-static int rk3588_npu_set_soc_info(struct device *dev, struct device_node *np,
1224
-				   int bin, int process, int volt_sel)
1225
-{
1226
-	struct opp_table *opp_table;
1227
-	u32 supported_hw[2];
1228
-
1229
-	if (volt_sel < 0)
1230
-		return 0;
1231
-	if (bin < 0)
1232
-		bin = 0;
1233
-
1234
-	if (!of_property_read_bool(np, "rockchip,supported-hw"))
1235
-		return 0;
1236
-
1237
-	/* SoC Version */
1238
-	supported_hw[0] = BIT(bin);
1239
-	/* Speed Grade */
1240
-	supported_hw[1] = BIT(volt_sel);
1241
-	opp_table = dev_pm_opp_set_supported_hw(dev, supported_hw, 2);
1242
-	if (IS_ERR(opp_table)) {
1243
-		LOG_DEV_ERROR(dev, "failed to set supported opp\n");
1244
-		return PTR_ERR(opp_table);
1245
-	}
1246
-
1247
-	return 0;
1248
-}
1249
-
1250
-static int rk3588_npu_set_read_margin(struct device *dev,
1251
-				      struct rockchip_opp_info *opp_info,
1252
-				      u32 rm)
1253
-{
1254
-	u32 offset = 0, val = 0;
1255
-	int i, ret = 0;
1256
-
1257
-	if (!opp_info->grf || !opp_info->volt_rm_tbl)
1258
-		return 0;
1259
-
1260
-	if (rm == opp_info->current_rm || rm == UINT_MAX)
1261
-		return 0;
1262
-
1263
-	LOG_DEV_DEBUG(dev, "set rm to %d\n", rm);
1264
-
1265
-	for (i = 0; i < 3; i++) {
1266
-		ret = regmap_read(opp_info->grf, offset, &val);
1267
-		if (ret < 0) {
1268
-			LOG_DEV_ERROR(dev, "failed to get rm from 0x%x\n",
1269
-				      offset);
1270
-			return ret;
1271
-		}
1272
-		val &= ~0x1c;
1273
-		regmap_write(opp_info->grf, offset, val | (rm << 2));
1274
-		offset += 4;
1275
-	}
1276
-	opp_info->current_rm = rm;
1277
-
1278
-	return 0;
1279
-}
1280
-
1281
-static const struct rockchip_opp_data rk3588_npu_opp_data = {
1282
-	.get_soc_info = rk3588_npu_get_soc_info,
1283
-	.set_soc_info = rk3588_npu_set_soc_info,
1284
-	.set_read_margin = rk3588_npu_set_read_margin,
1285
-};
1286
-
1287
-static const struct of_device_id rockchip_npu_of_match[] = {
1288
-	{
1289
-		.compatible = "rockchip,rk3588",
1290
-		.data = (void *)&rk3588_npu_opp_data,
1291
-	},
1292
-	{},
1293
-};
1294
-
1295
-static int rknpu_devfreq_init(struct rknpu_device *rknpu_dev)
1296
-{
1297
-	struct device *dev = rknpu_dev->dev;
1298
-	struct devfreq_dev_profile *dp = &npu_devfreq_profile;
1299
-	struct dev_pm_opp *opp;
1300
-	struct opp_table *reg_table = NULL;
1301
-	struct opp_table *opp_table = NULL;
1302
-	const char *const reg_names[] = { "rknpu", "mem" };
1303
-	int ret = -EINVAL;
1304
-
1305
-	if (of_find_property(dev->of_node, "rknpu-supply", NULL) &&
1306
-	    of_find_property(dev->of_node, "mem-supply", NULL)) {
1307
-		reg_table = dev_pm_opp_set_regulators(dev, reg_names, 2);
1308
-		if (IS_ERR(reg_table))
1309
-			return PTR_ERR(reg_table);
1310
-		opp_table =
1311
-			dev_pm_opp_register_set_opp_helper(dev, npu_opp_helper);
1312
-		if (IS_ERR(opp_table)) {
1313
-			dev_pm_opp_put_regulators(reg_table);
1314
-			return PTR_ERR(opp_table);
1315
-		}
1316
-	} else {
1317
-		reg_table = dev_pm_opp_set_regulators(dev, reg_names, 1);
1318
-		if (IS_ERR(reg_table))
1319
-			return PTR_ERR(reg_table);
1320
-	}
1321
-
1322
-	rockchip_get_opp_data(rockchip_npu_of_match, &rknpu_dev->opp_info);
1323
-	ret = rockchip_init_opp_table(dev, &rknpu_dev->opp_info, "npu_leakage",
1324
-				      "rknpu");
1325
-	if (ret) {
1326
-		LOG_DEV_ERROR(dev, "failed to init_opp_table\n");
1327
-		return ret;
1328
-	}
1329
-
1330
-	rknpu_dev->current_freq = clk_get_rate(rknpu_dev->clks[0].clk);
1331
-
1332
-	opp = devfreq_recommended_opp(dev, &rknpu_dev->current_freq, 0);
1333
-	if (IS_ERR(opp)) {
1334
-		ret = PTR_ERR(opp);
1335
-		goto err_remove_table;
1336
-	}
1337
-	dev_pm_opp_put(opp);
1338
-	dp->initial_freq = rknpu_dev->current_freq;
1339
-
1340
-#ifdef CONFIG_PM_DEVFREQ
1341
-	ret = devfreq_add_governor(&devfreq_rknpu_ondemand);
1342
-	if (ret) {
1343
-		LOG_DEV_ERROR(dev, "failed to add rknpu_ondemand governor\n");
1344
-		goto err_remove_table;
1345
-	}
1346
-#endif
1347
-
1348
-	rknpu_dev->devfreq = devm_devfreq_add_device(dev, dp, "rknpu_ondemand",
1349
-						     (void *)rknpu_dev);
1350
-	if (IS_ERR(rknpu_dev->devfreq)) {
1351
-		LOG_DEV_ERROR(dev, "failed to add devfreq\n");
1352
-		ret = PTR_ERR(rknpu_dev->devfreq);
1353
-		goto err_remove_governor;
1354
-	}
1355
-	devm_devfreq_register_opp_notifier(dev, rknpu_dev->devfreq);
1356
-
1357
-	rknpu_dev->devfreq->last_status.current_frequency = dp->initial_freq;
1358
-	rknpu_dev->devfreq->last_status.total_time = 1;
1359
-	rknpu_dev->devfreq->last_status.busy_time = 1;
1360
-
1361
-	npu_mdevp.data = rknpu_dev->devfreq;
1362
-	npu_mdevp.opp_info = &rknpu_dev->opp_info;
1363
-	rknpu_dev->mdev_info =
1364
-		rockchip_system_monitor_register(dev, &npu_mdevp);
1365
-	if (IS_ERR(rknpu_dev->mdev_info)) {
1366
-		LOG_DEV_DEBUG(dev, "without system monitor\n");
1367
-		rknpu_dev->mdev_info = NULL;
1368
-		npu_mdevp.is_checked = true;
1369
-	}
1370
-	rknpu_dev->current_freq = clk_get_rate(rknpu_dev->clks[0].clk);
1371
-	rknpu_dev->current_volt = regulator_get_voltage(rknpu_dev->vdd);
1372
-
1373
-	of_property_read_u32(dev->of_node, "dynamic-power-coefficient",
1374
-			     (u32 *)&npu_cooling_power.dyn_power_coeff);
1375
-	rknpu_dev->model_data =
1376
-		rockchip_ipa_power_model_init(dev, "npu_leakage");
1377
-	if (IS_ERR_OR_NULL(rknpu_dev->model_data)) {
1378
-		rknpu_dev->model_data = NULL;
1379
-		LOG_DEV_ERROR(dev, "failed to initialize power model\n");
1380
-	} else if (rknpu_dev->model_data->dynamic_coefficient) {
1381
-		npu_cooling_power.dyn_power_coeff =
1382
-			rknpu_dev->model_data->dynamic_coefficient;
1383
-	}
1384
-	if (!npu_cooling_power.dyn_power_coeff) {
1385
-		LOG_DEV_ERROR(dev, "failed to get dynamic-coefficient\n");
1386
-		goto out;
1387
-	}
1388
-
1389
-	rknpu_dev->devfreq_cooling = of_devfreq_cooling_register_power(
1390
-		dev->of_node, rknpu_dev->devfreq, &npu_cooling_power);
1391
-	if (IS_ERR_OR_NULL(rknpu_dev->devfreq_cooling))
1392
-		LOG_DEV_ERROR(dev, "failed to register cooling device\n");
1393
-
1394
-out:
1395
-	return 0;
1396
-
1397
-err_remove_governor:
1398
-#ifdef CONFIG_PM_DEVFREQ
1399
-	devfreq_remove_governor(&devfreq_rknpu_ondemand);
1400
-#endif
1401
-err_remove_table:
1402
-	dev_pm_opp_of_remove_table(dev);
1403
-
1404
-	rknpu_dev->devfreq = NULL;
1405
-
1406
-	return ret;
1407
-}
1408
-
1409
-#else
1410
-
1411
-static int npu_devfreq_adjust_current_freq_volt(struct device *dev,
1412
-						struct rknpu_device *rknpu_dev)
1413
-{
1414
-	unsigned long volt, old_freq, freq;
1415
-	struct dev_pm_opp *opp = NULL;
1416
-	int ret = -EINVAL;
1417
-
1418
-	old_freq = clk_get_rate(rknpu_dev->clks[0].clk);
1419
-	freq = old_freq;
1420
-
1421
-#if KERNEL_VERSION(4, 11, 0) > LINUX_VERSION_CODE
1422
-	rcu_read_lock();
1423
-#endif
1424
-
1425
-	opp = devfreq_recommended_opp(dev, &freq, 0);
1426
-	volt = dev_pm_opp_get_voltage(opp);
1427
-
1428
-#if KERNEL_VERSION(4, 11, 0) > LINUX_VERSION_CODE
1429
-	rcu_read_unlock();
1430
-#endif
1431
-
1432
-	if (freq >= old_freq && rknpu_dev->vdd) {
1433
-		ret = regulator_set_voltage(rknpu_dev->vdd, volt, INT_MAX);
1434
-		if (ret) {
1435
-			LOG_DEV_ERROR(dev, "failed to set volt %lu\n", volt);
1436
-			return ret;
1437
-		}
1438
-	}
1439
-	LOG_DEV_DEBUG(dev, "adjust current freq=%luHz, volt=%luuV\n", freq,
1440
-		      volt);
1441
-	ret = clk_set_rate(rknpu_dev->clks[0].clk, freq);
1442
-	if (ret) {
1443
-		LOG_DEV_ERROR(dev, "failed to set clock %lu\n", freq);
1444
-		return ret;
1445
-	}
1446
-	if (freq < old_freq && rknpu_dev->vdd) {
1447
-		ret = regulator_set_voltage(rknpu_dev->vdd, volt, INT_MAX);
1448
-		if (ret) {
1449
-			LOG_DEV_ERROR(dev, "failed to set volt %lu\n", volt);
1450
-			return ret;
1451
-		}
1452
-	}
1453
-	rknpu_dev->current_freq = freq;
1454
-	rknpu_dev->current_volt = volt;
1455
-
1456
-	return 0;
1457
-}
1458
-
1459
-static int rknpu_devfreq_init(struct rknpu_device *rknpu_dev)
1460
-{
1461
-	struct device *dev = rknpu_dev->dev;
1462
-	struct devfreq_dev_profile *dp = &npu_devfreq_profile;
1463
-	int ret = -EINVAL;
1464
-
1465
-	ret = rockchip_init_opp_table(dev, NULL, "npu_leakage", "rknpu");
1466
-	if (ret) {
1467
-		LOG_DEV_ERROR(dev, "failed to init_opp_table\n");
1468
-		return ret;
1469
-	}
1470
-
1471
-	ret = npu_devfreq_adjust_current_freq_volt(dev, rknpu_dev);
1472
-	if (ret) {
1473
-		LOG_DEV_ERROR(dev, "failed to adjust current freq volt\n");
1474
-		goto err_remove_table;
1475
-	}
1476
-	dp->initial_freq = rknpu_dev->current_freq;
1477
-
1478
-#ifdef CONFIG_PM_DEVFREQ
1479
-	ret = devfreq_add_governor(&devfreq_rknpu_ondemand);
1480
-	if (ret) {
1481
-		LOG_DEV_ERROR(dev, "failed to add rknpu_ondemand governor\n");
1482
-		goto err_remove_table;
1483
-	}
1484
-#endif
1485
-
1486
-	rknpu_dev->devfreq = devm_devfreq_add_device(dev, dp, "rknpu_ondemand",
1487
-						     (void *)rknpu_dev);
1488
-	if (IS_ERR(rknpu_dev->devfreq)) {
1489
-		LOG_DEV_ERROR(dev, "failed to add devfreq\n");
1490
-		ret = PTR_ERR(rknpu_dev->devfreq);
1491
-		goto err_remove_governor;
1492
-	}
1493
-	devm_devfreq_register_opp_notifier(dev, rknpu_dev->devfreq);
1494
-
1495
-	rknpu_dev->devfreq->last_status.current_frequency = dp->initial_freq;
1496
-	rknpu_dev->devfreq->last_status.total_time = 1;
1497
-	rknpu_dev->devfreq->last_status.busy_time = 1;
1498
-
1499
-	npu_mdevp.data = rknpu_dev->devfreq;
1500
-	rknpu_dev->mdev_info =
1501
-		rockchip_system_monitor_register(dev, &npu_mdevp);
1502
-	if (IS_ERR(rknpu_dev->mdev_info)) {
1503
-		LOG_DEV_DEBUG(dev, "without system monitor\n");
1504
-		rknpu_dev->mdev_info = NULL;
1505
-	}
1506
-	rknpu_dev->current_freq = clk_get_rate(rknpu_dev->clks[0].clk);
1507
-	rknpu_dev->current_volt = regulator_get_voltage(rknpu_dev->vdd);
1508
-
1509
-	of_property_read_u32(dev->of_node, "dynamic-power-coefficient",
1510
-			     (u32 *)&npu_cooling_power.dyn_power_coeff);
1511
-	rknpu_dev->model_data =
1512
-		rockchip_ipa_power_model_init(dev, "npu_leakage");
1513
-	if (IS_ERR_OR_NULL(rknpu_dev->model_data)) {
1514
-		rknpu_dev->model_data = NULL;
1515
-		LOG_DEV_ERROR(dev, "failed to initialize power model\n");
1516
-	} else if (rknpu_dev->model_data->dynamic_coefficient) {
1517
-		npu_cooling_power.dyn_power_coeff =
1518
-			rknpu_dev->model_data->dynamic_coefficient;
1519
-	}
1520
-
1521
-	if (!npu_cooling_power.dyn_power_coeff) {
1522
-		LOG_DEV_ERROR(dev, "failed to get dynamic-coefficient\n");
1523
-		goto out;
1524
-	}
1525
-
1526
-	rknpu_dev->devfreq_cooling = of_devfreq_cooling_register_power(
1527
-		dev->of_node, rknpu_dev->devfreq, &npu_cooling_power);
1528
-	if (IS_ERR_OR_NULL(rknpu_dev->devfreq_cooling))
1529
-		LOG_DEV_ERROR(dev, "failed to register cooling device\n");
1530
-
1531
-out:
1532
-	return 0;
1533
-
1534
-err_remove_governor:
1535
-#ifdef CONFIG_PM_DEVFREQ
1536
-	devfreq_remove_governor(&devfreq_rknpu_ondemand);
1537
-#endif
1538
-err_remove_table:
1539
-	dev_pm_opp_of_remove_table(dev);
1540
-
1541
-	rknpu_dev->devfreq = NULL;
1542
-
1543
-	return ret;
1544
-}
1545
-#endif
1546
-
1547
-static int rknpu_devfreq_remove(struct rknpu_device *rknpu_dev)
1548
-{
1549
-	if (rknpu_dev->devfreq) {
1550
-		devfreq_unregister_opp_notifier(rknpu_dev->dev,
1551
-						rknpu_dev->devfreq);
1552
-		dev_pm_opp_of_remove_table(rknpu_dev->dev);
1553
-#ifdef CONFIG_PM_DEVFREQ
1554
-		devfreq_remove_governor(&devfreq_rknpu_ondemand);
1555
-#endif
1556
-	}
1557
-
1558
-	return 0;
1559
-}
1560
-
1561
-#endif
1562
949
 
1563
950
 static int rknpu_register_irq(struct platform_device *pdev,
1564
951
 			      struct rknpu_device *rknpu_dev)
..
..
@@ -1685,6 +1072,28 @@
1685
1072
 	return 0;
1686
1073
 }
1687
1074
 
1075
+static int rknpu_get_invalid_core_mask(struct device *dev)
1076
+{
1077
+	int ret = 0;
1078
+	u8 invalid_core_mask = 0;
1079
+
1080
+	if (of_property_match_string(dev->of_node, "nvmem-cell-names",
1081
+				     "cores") >= 0) {
1082
+		ret = rockchip_nvmem_cell_read_u8(dev->of_node, "cores",
1083
+						  &invalid_core_mask);
1084
+		/* The default valid npu cores for RK3583 are core0 and core1 */
1085
+		invalid_core_mask |= RKNPU_CORE2_MASK;
1086
+		if (ret) {
1087
+			LOG_DEV_ERROR(
1088
+				dev,
1089
+				"failed to get specification_serial_number\n");
1090
+			return invalid_core_mask;
1091
+		}
1092
+	}
1093
+
1094
+	return (int)invalid_core_mask;
1095
+}
1096
+
1688
1097
 static int rknpu_probe(struct platform_device *pdev)
1689
1098
 {
1690
1099
 	struct resource *res = NULL;
..
..
@@ -1716,6 +1125,22 @@
1716
1125
 	if (!config)
1717
1126
 		return -EINVAL;
1718
1127
 
1128
+	if (match->data == (void *)&rk3588_rknpu_config) {
1129
+		int invalid_core_mask = rknpu_get_invalid_core_mask(dev);
1130
+		/* The default valid npu cores for RK3583 are core0 and core1 */
1131
+		if (invalid_core_mask & RKNPU_CORE2_MASK) {
1132
+			if ((invalid_core_mask & RKNPU_CORE0_MASK) ||
1133
+			    (invalid_core_mask & RKNPU_CORE1_MASK)) {
1134
+				LOG_DEV_ERROR(
1135
+					dev,
1136
+					"rknpu core invalid, invalid core mask: %#x\n",
1137
+					invalid_core_mask);
1138
+				return -ENODEV;
1139
+			}
1140
+			config = &rk3583_rknpu_config;
1141
+		}
1142
+	}
1143
+
1719
1144
 	rknpu_dev->config = config;
1720
1145
 	rknpu_dev->dev = dev;
1721
1146
 
..
..
@@ -1744,11 +1169,6 @@
1744
1169
 	}
1745
1170
 
1746
1171
 #ifndef FPGA_PLATFORM
1747
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
1748
-	if (strstr(__clk_get_name(rknpu_dev->clks[0].clk), "scmi"))
1749
-		rknpu_dev->opp_info.scmi_clk = rknpu_dev->clks[0].clk;
1750
-#endif
1751
-
1752
1172
 	rknpu_dev->vdd = devm_regulator_get_optional(dev, "rknpu");
1753
1173
 	if (IS_ERR(rknpu_dev->vdd)) {
1754
1174
 		if (PTR_ERR(rknpu_dev->vdd) != -ENODEV) {
..
..
@@ -1875,9 +1295,11 @@
1875
1295
 		virt_dev = dev_pm_domain_attach_by_name(dev, "npu1");
1876
1296
 		if (!IS_ERR(virt_dev))
1877
1297
 			rknpu_dev->genpd_dev_npu1 = virt_dev;
1878
-		virt_dev = dev_pm_domain_attach_by_name(dev, "npu2");
1879
-		if (!IS_ERR(virt_dev))
1880
-			rknpu_dev->genpd_dev_npu2 = virt_dev;
1298
+		if (config->num_irqs > 2) {
1299
+			virt_dev = dev_pm_domain_attach_by_name(dev, "npu2");
1300
+			if (!IS_ERR(virt_dev))
1301
+				rknpu_dev->genpd_dev_npu2 = virt_dev;
1302
+		}
1881
1303
 		rknpu_dev->multiple_domains = true;
1882
1304
 	}
1883
1305
 
..
..
@@ -1995,47 +1417,14 @@
1995
1417
 }
1996
1418
 
1997
1419
 #ifndef FPGA_PLATFORM
1998
-#if KERNEL_VERSION(5, 10, 0) <= LINUX_VERSION_CODE
1999
1420
 static int rknpu_runtime_suspend(struct device *dev)
2000
1421
 {
2001
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
2002
-	struct rockchip_opp_info *opp_info = &rknpu_dev->opp_info;
2003
-
2004
-	if (opp_info->scmi_clk) {
2005
-		if (clk_set_rate(opp_info->scmi_clk, POWER_DOWN_FREQ))
2006
-			LOG_DEV_ERROR(dev, "failed to restore clk rate\n");
2007
-	}
2008
-	opp_info->current_rm = UINT_MAX;
2009
-
2010
-	return 0;
1422
+	return rknpu_devfreq_runtime_suspend(dev);
2011
1423
 }
2012
1424
 
2013
1425
 static int rknpu_runtime_resume(struct device *dev)
2014
1426
 {
2015
-	struct rknpu_device *rknpu_dev = dev_get_drvdata(dev);
2016
-	struct rockchip_opp_info *opp_info = &rknpu_dev->opp_info;
2017
-	int ret = 0;
2018
-
2019
-	if (!rknpu_dev->current_freq || !rknpu_dev->current_volt)
2020
-		return 0;
2021
-
2022
-	ret = clk_bulk_prepare_enable(opp_info->num_clks, opp_info->clks);
2023
-	if (ret) {
2024
-		LOG_DEV_ERROR(dev, "failed to enable opp clks\n");
2025
-		return ret;
2026
-	}
2027
-
2028
-	if (opp_info->data && opp_info->data->set_read_margin)
2029
-		opp_info->data->set_read_margin(dev, opp_info,
2030
-						opp_info->target_rm);
2031
-	if (opp_info->scmi_clk) {
2032
-		if (clk_set_rate(opp_info->scmi_clk, rknpu_dev->current_freq))
2033
-			LOG_DEV_ERROR(dev, "failed to set power down rate\n");
2034
-	}
2035
-
2036
-	clk_bulk_disable_unprepare(opp_info->num_clks, opp_info->clks);
2037
-
2038
-	return ret;
1427
+	return rknpu_devfreq_runtime_resume(dev);
2039
1428
 }
2040
1429
 
2041
1430
 static const struct dev_pm_ops rknpu_pm_ops = {
..
..
@@ -2045,7 +1434,6 @@
2045
1434
 				   NULL)
2046
1435
 };
2047
1436
 #endif
2048
-#endif
2049
1437
 
2050
1438
 static struct platform_driver rknpu_driver = {
2051
1439
 	.probe = rknpu_probe,
..
..
@@ -2054,9 +1442,7 @@
2054
1442
 		.owner = THIS_MODULE,
2055
1443
 		.name = "RKNPU",
2056
1444
 #ifndef FPGA_PLATFORM
2057
-#if KERNEL_VERSION(5, 5, 0) < LINUX_VERSION_CODE
2058
1445
 		.pm = &rknpu_pm_ops,
2059
-#endif
2060
1446
 #endif
2061
1447
 		.of_match_table = of_match_ptr(rknpu_of_match),
2062
1448
 	},
..
..
@@ -2081,3 +1467,6 @@
2081
1467
 MODULE_LICENSE("GPL v2");
2082
1468
 MODULE_VERSION(RKNPU_GET_DRV_VERSION_STRING(DRIVER_MAJOR, DRIVER_MINOR,
2083
1469
 					    DRIVER_PATCHLEVEL));
1470
+#if KERNEL_VERSION(5, 16, 0) < LINUX_VERSION_CODE
1471
+MODULE_IMPORT_NS(DMA_BUF);
1472
+#endif