1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright(c) 2019-2022, Intel Corporation. All rights reserved.
4  *
5  * Intel Management Engine Interface (Intel MEI) Linux driver
6  */
7 
8 #include <linux/module.h>
9 #include <linux/mei_aux.h>
10 #include <linux/device.h>
11 #include <linux/irqreturn.h>
12 #include <linux/jiffies.h>
13 #include <linux/ktime.h>
14 #include <linux/delay.h>
15 #include <linux/pm_runtime.h>
16 #include <linux/kthread.h>
17 
18 #include "mei_dev.h"
19 #include "hw-me.h"
20 #include "hw-me-regs.h"
21 
22 #include "mei-trace.h"
23 
24 #define MEI_GSC_RPM_TIMEOUT 500
25 
mei_gsc_read_hfs(const struct mei_device * dev,int where,u32 * val)26 static int mei_gsc_read_hfs(const struct mei_device *dev, int where, u32 *val)
27 {
28 	struct mei_me_hw *hw = to_me_hw(dev);
29 
30 	*val = ioread32(hw->mem_addr + where + 0xC00);
31 
32 	return 0;
33 }
34 
mei_gsc_set_ext_op_mem(const struct mei_me_hw * hw,struct resource * mem)35 static void mei_gsc_set_ext_op_mem(const struct mei_me_hw *hw, struct resource *mem)
36 {
37 	u32 low = lower_32_bits(mem->start);
38 	u32 hi  = upper_32_bits(mem->start);
39 	u32 limit = (resource_size(mem) / SZ_4K) | GSC_EXT_OP_MEM_VALID;
40 
41 	iowrite32(low, hw->mem_addr + H_GSC_EXT_OP_MEM_BASE_ADDR_LO_REG);
42 	iowrite32(hi, hw->mem_addr + H_GSC_EXT_OP_MEM_BASE_ADDR_HI_REG);
43 	iowrite32(limit, hw->mem_addr + H_GSC_EXT_OP_MEM_LIMIT_REG);
44 }
45 
mei_gsc_probe(struct auxiliary_device * aux_dev,const struct auxiliary_device_id * aux_dev_id)46 static int mei_gsc_probe(struct auxiliary_device *aux_dev,
47 			 const struct auxiliary_device_id *aux_dev_id)
48 {
49 	struct mei_aux_device *adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
50 	struct mei_device *dev;
51 	struct mei_me_hw *hw;
52 	struct device *device;
53 	const struct mei_cfg *cfg;
54 	int ret;
55 
56 	cfg = mei_me_get_cfg(aux_dev_id->driver_data);
57 	if (!cfg)
58 		return -ENODEV;
59 
60 	device = &aux_dev->dev;
61 
62 	dev = mei_me_dev_init(device, cfg, adev->slow_firmware);
63 	if (!dev) {
64 		ret = -ENOMEM;
65 		goto err;
66 	}
67 
68 	hw = to_me_hw(dev);
69 	hw->mem_addr = devm_ioremap_resource(device, &adev->bar);
70 	if (IS_ERR(hw->mem_addr)) {
71 		ret = PTR_ERR(hw->mem_addr);
72 		goto err;
73 	}
74 
75 	hw->irq = adev->irq;
76 	hw->read_fws = mei_gsc_read_hfs;
77 
78 	dev_set_drvdata(device, dev);
79 
80 	if (adev->ext_op_mem.start) {
81 		mei_gsc_set_ext_op_mem(hw, &adev->ext_op_mem);
82 		dev->pxp_mode = MEI_DEV_PXP_INIT;
83 	}
84 
85 	/* use polling */
86 	if (mei_me_hw_use_polling(hw)) {
87 		mei_disable_interrupts(dev);
88 		mei_clear_interrupts(dev);
89 		init_waitqueue_head(&hw->wait_active);
90 		hw->is_active = true; /* start in active mode for initialization */
91 		hw->polling_thread = kthread_run(mei_me_polling_thread, dev,
92 						 "kmegscirqd/%s", dev_name(device));
93 		if (IS_ERR(hw->polling_thread)) {
94 			ret = PTR_ERR(hw->polling_thread);
95 			dev_err(device, "unable to create kernel thread: %d\n", ret);
96 			goto err;
97 		}
98 	} else {
99 		ret = devm_request_threaded_irq(device, hw->irq,
100 						mei_me_irq_quick_handler,
101 						mei_me_irq_thread_handler,
102 						IRQF_ONESHOT, KBUILD_MODNAME, dev);
103 		if (ret) {
104 			dev_err(device, "irq register failed %d\n", ret);
105 			goto err;
106 		}
107 	}
108 
109 	pm_runtime_get_noresume(device);
110 	pm_runtime_set_active(device);
111 	pm_runtime_enable(device);
112 
113 	/* Continue to char device setup in spite of firmware handshake failure.
114 	 * In order to provide access to the firmware status registers to the user
115 	 * space via sysfs.
116 	 */
117 	if (mei_start(dev))
118 		dev_warn(device, "init hw failure.\n");
119 
120 	pm_runtime_set_autosuspend_delay(device, MEI_GSC_RPM_TIMEOUT);
121 	pm_runtime_use_autosuspend(device);
122 
123 	ret = mei_register(dev, device);
124 	if (ret)
125 		goto register_err;
126 
127 	pm_runtime_put_noidle(device);
128 	return 0;
129 
130 register_err:
131 	mei_stop(dev);
132 	if (!mei_me_hw_use_polling(hw))
133 		devm_free_irq(device, hw->irq, dev);
134 
135 err:
136 	dev_err(device, "probe failed: %d\n", ret);
137 	dev_set_drvdata(device, NULL);
138 	return ret;
139 }
140 
mei_gsc_remove(struct auxiliary_device * aux_dev)141 static void mei_gsc_remove(struct auxiliary_device *aux_dev)
142 {
143 	struct mei_device *dev;
144 	struct mei_me_hw *hw;
145 
146 	dev = dev_get_drvdata(&aux_dev->dev);
147 	if (!dev)
148 		return;
149 
150 	hw = to_me_hw(dev);
151 
152 	mei_stop(dev);
153 
154 	hw = to_me_hw(dev);
155 	if (mei_me_hw_use_polling(hw))
156 		kthread_stop(hw->polling_thread);
157 
158 	mei_deregister(dev);
159 
160 	pm_runtime_disable(&aux_dev->dev);
161 
162 	mei_disable_interrupts(dev);
163 	if (!mei_me_hw_use_polling(hw))
164 		devm_free_irq(&aux_dev->dev, hw->irq, dev);
165 }
166 
mei_gsc_pm_suspend(struct device * device)167 static int __maybe_unused mei_gsc_pm_suspend(struct device *device)
168 {
169 	struct mei_device *dev = dev_get_drvdata(device);
170 
171 	if (!dev)
172 		return -ENODEV;
173 
174 	mei_stop(dev);
175 
176 	mei_disable_interrupts(dev);
177 
178 	return 0;
179 }
180 
mei_gsc_pm_resume(struct device * device)181 static int __maybe_unused mei_gsc_pm_resume(struct device *device)
182 {
183 	struct mei_device *dev = dev_get_drvdata(device);
184 	struct auxiliary_device *aux_dev;
185 	struct mei_aux_device *adev;
186 	int err;
187 	struct mei_me_hw *hw;
188 
189 	if (!dev)
190 		return -ENODEV;
191 
192 	hw = to_me_hw(dev);
193 	aux_dev = to_auxiliary_dev(device);
194 	adev = auxiliary_dev_to_mei_aux_dev(aux_dev);
195 	if (adev->ext_op_mem.start) {
196 		mei_gsc_set_ext_op_mem(hw, &adev->ext_op_mem);
197 		dev->pxp_mode = MEI_DEV_PXP_INIT;
198 	}
199 
200 	err = mei_restart(dev);
201 	if (err)
202 		return err;
203 
204 	/* Start timer if stopped in suspend */
205 	schedule_delayed_work(&dev->timer_work, HZ);
206 
207 	return 0;
208 }
209 
mei_gsc_pm_runtime_idle(struct device * device)210 static int __maybe_unused mei_gsc_pm_runtime_idle(struct device *device)
211 {
212 	struct mei_device *dev = dev_get_drvdata(device);
213 
214 	if (!dev)
215 		return -ENODEV;
216 	if (mei_write_is_idle(dev))
217 		pm_runtime_autosuspend(device);
218 
219 	return -EBUSY;
220 }
221 
mei_gsc_pm_runtime_suspend(struct device * device)222 static int  __maybe_unused mei_gsc_pm_runtime_suspend(struct device *device)
223 {
224 	struct mei_device *dev = dev_get_drvdata(device);
225 	struct mei_me_hw *hw;
226 	int ret;
227 
228 	if (!dev)
229 		return -ENODEV;
230 
231 	mutex_lock(&dev->device_lock);
232 
233 	if (mei_write_is_idle(dev)) {
234 		hw = to_me_hw(dev);
235 		hw->pg_state = MEI_PG_ON;
236 
237 		if (mei_me_hw_use_polling(hw))
238 			hw->is_active = false;
239 		ret = 0;
240 	} else {
241 		ret = -EAGAIN;
242 	}
243 
244 	mutex_unlock(&dev->device_lock);
245 
246 	return ret;
247 }
248 
mei_gsc_pm_runtime_resume(struct device * device)249 static int __maybe_unused mei_gsc_pm_runtime_resume(struct device *device)
250 {
251 	struct mei_device *dev = dev_get_drvdata(device);
252 	struct mei_me_hw *hw;
253 	irqreturn_t irq_ret;
254 
255 	if (!dev)
256 		return -ENODEV;
257 
258 	mutex_lock(&dev->device_lock);
259 
260 	hw = to_me_hw(dev);
261 	hw->pg_state = MEI_PG_OFF;
262 
263 	if (mei_me_hw_use_polling(hw)) {
264 		hw->is_active = true;
265 		wake_up(&hw->wait_active);
266 	}
267 
268 	mutex_unlock(&dev->device_lock);
269 
270 	irq_ret = mei_me_irq_thread_handler(1, dev);
271 	if (irq_ret != IRQ_HANDLED)
272 		dev_err(dev->dev, "thread handler fail %d\n", irq_ret);
273 
274 	return 0;
275 }
276 
277 static const struct dev_pm_ops mei_gsc_pm_ops = {
278 	SET_SYSTEM_SLEEP_PM_OPS(mei_gsc_pm_suspend,
279 				mei_gsc_pm_resume)
280 	SET_RUNTIME_PM_OPS(mei_gsc_pm_runtime_suspend,
281 			   mei_gsc_pm_runtime_resume,
282 			   mei_gsc_pm_runtime_idle)
283 };
284 
285 static const struct auxiliary_device_id mei_gsc_id_table[] = {
286 	{
287 		.name = "i915.mei-gsc",
288 		.driver_data = MEI_ME_GSC_CFG,
289 
290 	},
291 	{
292 		.name = "i915.mei-gscfi",
293 		.driver_data = MEI_ME_GSCFI_CFG,
294 	},
295 	{
296 		/* sentinel */
297 	}
298 };
299 MODULE_DEVICE_TABLE(auxiliary, mei_gsc_id_table);
300 
301 static struct auxiliary_driver mei_gsc_driver = {
302 	.probe	= mei_gsc_probe,
303 	.remove = mei_gsc_remove,
304 	.driver = {
305 		/* auxiliary_driver_register() sets .name to be the modname */
306 		.pm = &mei_gsc_pm_ops,
307 	},
308 	.id_table = mei_gsc_id_table
309 };
310 module_auxiliary_driver(mei_gsc_driver);
311 
312 MODULE_AUTHOR("Intel Corporation");
313 MODULE_ALIAS("auxiliary:i915.mei-gsc");
314 MODULE_ALIAS("auxiliary:i915.mei-gscfi");
315 MODULE_DESCRIPTION("Intel(R) Graphics System Controller");
316 MODULE_LICENSE("GPL");
317