xref: /linux/drivers/gpu/drm/xe/xe_module.c (revision b6943f4adc957840242dcaa5919c38fd5c70ccf9)
1 // SPDX-License-Identifier: MIT
2 /*
3  * Copyright © 2021 Intel Corporation
4  */
5 
6 #include "xe_module.h"
7 
8 #include <linux/init.h>
9 #include <linux/module.h>
10 
11 #include <drm/drm_module.h>
12 
13 #include "xe_drv.h"
14 #include "xe_configfs.h"
15 #include "xe_hw_fence.h"
16 #include "xe_pci.h"
17 #include "xe_pm.h"
18 #include "xe_observation.h"
19 #include "xe_sched_job.h"
20 
21 struct xe_modparam xe_modparam = {
22 	.probe_display = true,
23 	.guc_log_level = 3,
24 	.force_probe = CONFIG_DRM_XE_FORCE_PROBE,
25 	.wedged_mode = 1,
26 	.svm_notifier_size = 512,
27 	/* the rest are 0 by default */
28 };
29 
30 module_param_named(svm_notifier_size, xe_modparam.svm_notifier_size, uint, 0600);
31 MODULE_PARM_DESC(svm_notifier_size, "Set the svm notifier size(in MiB), must be power of 2");
32 
33 module_param_named(always_migrate_to_vram, xe_modparam.always_migrate_to_vram, bool, 0444);
34 MODULE_PARM_DESC(always_migrate_to_vram, "Always migrate to VRAM on GPU fault");
35 
36 module_param_named_unsafe(force_execlist, xe_modparam.force_execlist, bool, 0444);
37 MODULE_PARM_DESC(force_execlist, "Force Execlist submission");
38 
39 module_param_named(probe_display, xe_modparam.probe_display, bool, 0444);
40 MODULE_PARM_DESC(probe_display, "Probe display HW, otherwise it's left untouched (default: true)");
41 
42 module_param_named(vram_bar_size, xe_modparam.force_vram_bar_size, int, 0600);
43 MODULE_PARM_DESC(vram_bar_size, "Set the vram bar size (in MiB) - <0=disable-resize, 0=max-needed-size[default], >0=force-size");
44 
45 module_param_named(guc_log_level, xe_modparam.guc_log_level, int, 0600);
46 MODULE_PARM_DESC(guc_log_level, "GuC firmware logging level (0=disable, 1..5=enable with verbosity min..max)");
47 
48 module_param_named_unsafe(guc_firmware_path, xe_modparam.guc_firmware_path, charp, 0400);
49 MODULE_PARM_DESC(guc_firmware_path,
50 		 "GuC firmware path to use instead of the default one");
51 
52 module_param_named_unsafe(huc_firmware_path, xe_modparam.huc_firmware_path, charp, 0400);
53 MODULE_PARM_DESC(huc_firmware_path,
54 		 "HuC firmware path to use instead of the default one - empty string disables");
55 
56 module_param_named_unsafe(gsc_firmware_path, xe_modparam.gsc_firmware_path, charp, 0400);
57 MODULE_PARM_DESC(gsc_firmware_path,
58 		 "GSC firmware path to use instead of the default one - empty string disables");
59 
60 module_param_named_unsafe(force_probe, xe_modparam.force_probe, charp, 0400);
61 MODULE_PARM_DESC(force_probe,
62 		 "Force probe options for specified devices. See CONFIG_DRM_XE_FORCE_PROBE for details.");
63 
64 #ifdef CONFIG_PCI_IOV
65 module_param_named(max_vfs, xe_modparam.max_vfs, uint, 0400);
66 MODULE_PARM_DESC(max_vfs,
67 		 "Limit number of Virtual Functions (VFs) that could be managed. "
68 		 "(0 = no VFs [default]; N = allow up to N VFs)");
69 #endif
70 
71 module_param_named_unsafe(wedged_mode, xe_modparam.wedged_mode, int, 0600);
72 MODULE_PARM_DESC(wedged_mode,
73 		 "Module's default policy for the wedged mode - 0=never, 1=upon-critical-errors[default], 2=upon-any-hang");
74 
75 static int xe_check_nomodeset(void)
76 {
77 	if (drm_firmware_drivers_only())
78 		return -ENODEV;
79 
80 	return 0;
81 }
82 
83 struct init_funcs {
84 	int (*init)(void);
85 	void (*exit)(void);
86 };
87 
88 static const struct init_funcs init_funcs[] = {
89 	{
90 		.init = xe_check_nomodeset,
91 	},
92 	{
93 		.init = xe_configfs_init,
94 		.exit = xe_configfs_exit,
95 	},
96 	{
97 		.init = xe_hw_fence_module_init,
98 		.exit = xe_hw_fence_module_exit,
99 	},
100 	{
101 		.init = xe_sched_job_module_init,
102 		.exit = xe_sched_job_module_exit,
103 	},
104 	{
105 		.init = xe_register_pci_driver,
106 		.exit = xe_unregister_pci_driver,
107 	},
108 	{
109 		.init = xe_observation_sysctl_register,
110 		.exit = xe_observation_sysctl_unregister,
111 	},
112 	{
113 		.init = xe_pm_module_init,
114 	},
115 };
116 
117 static int __init xe_call_init_func(unsigned int i)
118 {
119 	if (WARN_ON(i >= ARRAY_SIZE(init_funcs)))
120 		return 0;
121 	if (!init_funcs[i].init)
122 		return 0;
123 
124 	return init_funcs[i].init();
125 }
126 
127 static void xe_call_exit_func(unsigned int i)
128 {
129 	if (WARN_ON(i >= ARRAY_SIZE(init_funcs)))
130 		return;
131 	if (!init_funcs[i].exit)
132 		return;
133 
134 	init_funcs[i].exit();
135 }
136 
137 static int __init xe_init(void)
138 {
139 	int err, i;
140 
141 	for (i = 0; i < ARRAY_SIZE(init_funcs); i++) {
142 		err = xe_call_init_func(i);
143 		if (err) {
144 			while (i--)
145 				xe_call_exit_func(i);
146 			return err;
147 		}
148 	}
149 
150 	return 0;
151 }
152 
153 static void __exit xe_exit(void)
154 {
155 	int i;
156 
157 	for (i = ARRAY_SIZE(init_funcs) - 1; i >= 0; i--)
158 		xe_call_exit_func(i);
159 }
160 
161 module_init(xe_init);
162 module_exit(xe_exit);
163 
164 MODULE_AUTHOR("Intel Corporation");
165 
166 MODULE_DESCRIPTION(DRIVER_DESC);
167 MODULE_LICENSE("GPL and additional rights");
168