1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2018-2019, Intel Corporation
4  */
5 
6 #include <linux/arm-smccc.h>
7 #include <linux/bitfield.h>
8 #include <linux/completion.h>
9 #include <linux/kobject.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/of.h>
13 #include <linux/of_platform.h>
14 #include <linux/platform_device.h>
15 #include <linux/firmware/intel/stratix10-svc-client.h>
16 #include <linux/string.h>
17 #include <linux/sysfs.h>
18 
19 #define RSU_STATE_MASK			GENMASK_ULL(31, 0)
20 #define RSU_VERSION_MASK		GENMASK_ULL(63, 32)
21 #define RSU_ERROR_LOCATION_MASK		GENMASK_ULL(31, 0)
22 #define RSU_ERROR_DETAIL_MASK		GENMASK_ULL(63, 32)
23 #define RSU_DCMF0_MASK			GENMASK_ULL(31, 0)
24 #define RSU_DCMF1_MASK			GENMASK_ULL(63, 32)
25 #define RSU_DCMF2_MASK			GENMASK_ULL(31, 0)
26 #define RSU_DCMF3_MASK			GENMASK_ULL(63, 32)
27 #define RSU_DCMF0_STATUS_MASK		GENMASK_ULL(15, 0)
28 #define RSU_DCMF1_STATUS_MASK		GENMASK_ULL(31, 16)
29 #define RSU_DCMF2_STATUS_MASK		GENMASK_ULL(47, 32)
30 #define RSU_DCMF3_STATUS_MASK		GENMASK_ULL(63, 48)
31 
32 #define RSU_TIMEOUT	(msecs_to_jiffies(SVC_RSU_REQUEST_TIMEOUT_MS))
33 
34 #define INVALID_RETRY_COUNTER		0xFF
35 #define INVALID_DCMF_VERSION		0xFF
36 #define INVALID_DCMF_STATUS		0xFFFFFFFF
37 
38 typedef void (*rsu_callback)(struct stratix10_svc_client *client,
39 			     struct stratix10_svc_cb_data *data);
40 /**
41  * struct stratix10_rsu_priv - rsu data structure
42  * @chan: pointer to the allocated service channel
43  * @client: active service client
44  * @completion: state for callback completion
45  * @lock: a mutex to protect callback completion state
46  * @status.current_image: address of image currently running in flash
47  * @status.fail_image: address of failed image in flash
48  * @status.version: the interface version number of RSU firmware
49  * @status.state: the state of RSU system
50  * @status.error_details: error code
51  * @status.error_location: the error offset inside the image that failed
52  * @dcmf_version.dcmf0: Quartus dcmf0 version
53  * @dcmf_version.dcmf1: Quartus dcmf1 version
54  * @dcmf_version.dcmf2: Quartus dcmf2 version
55  * @dcmf_version.dcmf3: Quartus dcmf3 version
56  * @dcmf_status.dcmf0: dcmf0 status
57  * @dcmf_status.dcmf1: dcmf1 status
58  * @dcmf_status.dcmf2: dcmf2 status
59  * @dcmf_status.dcmf3: dcmf3 status
60  * @retry_counter: the current image's retry counter
61  * @max_retry: the preset max retry value
62  */
63 struct stratix10_rsu_priv {
64 	struct stratix10_svc_chan *chan;
65 	struct stratix10_svc_client client;
66 	struct completion completion;
67 	struct mutex lock;
68 	struct {
69 		unsigned long current_image;
70 		unsigned long fail_image;
71 		unsigned int version;
72 		unsigned int state;
73 		unsigned int error_details;
74 		unsigned int error_location;
75 	} status;
76 
77 	struct {
78 		unsigned int dcmf0;
79 		unsigned int dcmf1;
80 		unsigned int dcmf2;
81 		unsigned int dcmf3;
82 	} dcmf_version;
83 
84 	struct {
85 		unsigned int dcmf0;
86 		unsigned int dcmf1;
87 		unsigned int dcmf2;
88 		unsigned int dcmf3;
89 	} dcmf_status;
90 
91 	unsigned int retry_counter;
92 	unsigned int max_retry;
93 };
94 
95 /**
96  * rsu_status_callback() - Status callback from Intel Service Layer
97  * @client: pointer to service client
98  * @data: pointer to callback data structure
99  *
100  * Callback from Intel service layer for RSU status request. Status is
101  * only updated after a system reboot, so a get updated status call is
102  * made during driver probe.
103  */
104 static void rsu_status_callback(struct stratix10_svc_client *client,
105 				struct stratix10_svc_cb_data *data)
106 {
107 	struct stratix10_rsu_priv *priv = client->priv;
108 	struct arm_smccc_res *res = (struct arm_smccc_res *)data->kaddr1;
109 
110 	if (data->status == BIT(SVC_STATUS_OK)) {
111 		priv->status.version = FIELD_GET(RSU_VERSION_MASK,
112 						 res->a2);
113 		priv->status.state = FIELD_GET(RSU_STATE_MASK, res->a2);
114 		priv->status.fail_image = res->a1;
115 		priv->status.current_image = res->a0;
116 		priv->status.error_location =
117 			FIELD_GET(RSU_ERROR_LOCATION_MASK, res->a3);
118 		priv->status.error_details =
119 			FIELD_GET(RSU_ERROR_DETAIL_MASK, res->a3);
120 	} else {
121 		dev_err(client->dev, "COMMAND_RSU_STATUS returned 0x%lX\n",
122 			res->a0);
123 		priv->status.version = 0;
124 		priv->status.state = 0;
125 		priv->status.fail_image = 0;
126 		priv->status.current_image = 0;
127 		priv->status.error_location = 0;
128 		priv->status.error_details = 0;
129 	}
130 
131 	complete(&priv->completion);
132 }
133 
134 /**
135  * rsu_command_callback() - Update callback from Intel Service Layer
136  * @client: pointer to client
137  * @data: pointer to callback data structure
138  *
139  * Callback from Intel service layer for RSU commands.
140  */
141 static void rsu_command_callback(struct stratix10_svc_client *client,
142 				 struct stratix10_svc_cb_data *data)
143 {
144 	struct stratix10_rsu_priv *priv = client->priv;
145 
146 	if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
147 		dev_warn(client->dev, "Secure FW doesn't support notify\n");
148 	else if (data->status == BIT(SVC_STATUS_ERROR))
149 		dev_err(client->dev, "Failure, returned status is %lu\n",
150 			BIT(data->status));
151 
152 	complete(&priv->completion);
153 }
154 
155 /**
156  * rsu_retry_callback() - Callback from Intel service layer for getting
157  * the current image's retry counter from the firmware
158  * @client: pointer to client
159  * @data: pointer to callback data structure
160  *
161  * Callback from Intel service layer for retry counter, which is used by
162  * user to know how many times the images is still allowed to reload
163  * itself before giving up and starting RSU fail-over flow.
164  */
165 static void rsu_retry_callback(struct stratix10_svc_client *client,
166 			       struct stratix10_svc_cb_data *data)
167 {
168 	struct stratix10_rsu_priv *priv = client->priv;
169 	unsigned int *counter = (unsigned int *)data->kaddr1;
170 
171 	if (data->status == BIT(SVC_STATUS_OK))
172 		priv->retry_counter = *counter;
173 	else if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
174 		dev_warn(client->dev, "Secure FW doesn't support retry\n");
175 	else
176 		dev_err(client->dev, "Failed to get retry counter %lu\n",
177 			BIT(data->status));
178 
179 	complete(&priv->completion);
180 }
181 
182 /**
183  * rsu_max_retry_callback() - Callback from Intel service layer for getting
184  * the max retry value from the firmware
185  * @client: pointer to client
186  * @data: pointer to callback data structure
187  *
188  * Callback from Intel service layer for max retry.
189  */
190 static void rsu_max_retry_callback(struct stratix10_svc_client *client,
191 				   struct stratix10_svc_cb_data *data)
192 {
193 	struct stratix10_rsu_priv *priv = client->priv;
194 	unsigned int *max_retry = (unsigned int *)data->kaddr1;
195 
196 	if (data->status == BIT(SVC_STATUS_OK))
197 		priv->max_retry = *max_retry;
198 	else if (data->status == BIT(SVC_STATUS_NO_SUPPORT))
199 		dev_warn(client->dev, "Secure FW doesn't support max retry\n");
200 	else
201 		dev_err(client->dev, "Failed to get max retry %lu\n",
202 			BIT(data->status));
203 
204 	complete(&priv->completion);
205 }
206 
207 /**
208  * rsu_dcmf_version_callback() - Callback from Intel service layer for getting
209  * the DCMF version
210  * @client: pointer to client
211  * @data: pointer to callback data structure
212  *
213  * Callback from Intel service layer for DCMF version number
214  */
215 static void rsu_dcmf_version_callback(struct stratix10_svc_client *client,
216 				      struct stratix10_svc_cb_data *data)
217 {
218 	struct stratix10_rsu_priv *priv = client->priv;
219 	unsigned long long *value1 = (unsigned long long *)data->kaddr1;
220 	unsigned long long *value2 = (unsigned long long *)data->kaddr2;
221 
222 	if (data->status == BIT(SVC_STATUS_OK)) {
223 		priv->dcmf_version.dcmf0 = FIELD_GET(RSU_DCMF0_MASK, *value1);
224 		priv->dcmf_version.dcmf1 = FIELD_GET(RSU_DCMF1_MASK, *value1);
225 		priv->dcmf_version.dcmf2 = FIELD_GET(RSU_DCMF2_MASK, *value2);
226 		priv->dcmf_version.dcmf3 = FIELD_GET(RSU_DCMF3_MASK, *value2);
227 	} else
228 		dev_err(client->dev, "failed to get DCMF version\n");
229 
230 	complete(&priv->completion);
231 }
232 
233 /**
234  * rsu_dcmf_status_callback() - Callback from Intel service layer for getting
235  * the DCMF status
236  * @client: pointer to client
237  * @data: pointer to callback data structure
238  *
239  * Callback from Intel service layer for DCMF status
240  */
241 static void rsu_dcmf_status_callback(struct stratix10_svc_client *client,
242 				     struct stratix10_svc_cb_data *data)
243 {
244 	struct stratix10_rsu_priv *priv = client->priv;
245 	unsigned long long *value = (unsigned long long *)data->kaddr1;
246 
247 	if (data->status == BIT(SVC_STATUS_OK)) {
248 		priv->dcmf_status.dcmf0 = FIELD_GET(RSU_DCMF0_STATUS_MASK,
249 						    *value);
250 		priv->dcmf_status.dcmf1 = FIELD_GET(RSU_DCMF1_STATUS_MASK,
251 						    *value);
252 		priv->dcmf_status.dcmf2 = FIELD_GET(RSU_DCMF2_STATUS_MASK,
253 						    *value);
254 		priv->dcmf_status.dcmf3 = FIELD_GET(RSU_DCMF3_STATUS_MASK,
255 						    *value);
256 	} else
257 		dev_err(client->dev, "failed to get DCMF status\n");
258 
259 	complete(&priv->completion);
260 }
261 
262 /**
263  * rsu_send_msg() - send a message to Intel service layer
264  * @priv: pointer to rsu private data
265  * @command: RSU status or update command
266  * @arg: the request argument, the bitstream address or notify status
267  * @callback: function pointer for the callback (status or update)
268  *
269  * Start an Intel service layer transaction to perform the SMC call that
270  * is necessary to get RSU boot log or set the address of bitstream to
271  * boot after reboot.
272  *
273  * Returns 0 on success or -ETIMEDOUT on error.
274  */
275 static int rsu_send_msg(struct stratix10_rsu_priv *priv,
276 			enum stratix10_svc_command_code command,
277 			unsigned long arg,
278 			rsu_callback callback)
279 {
280 	struct stratix10_svc_client_msg msg;
281 	int ret;
282 
283 	mutex_lock(&priv->lock);
284 	reinit_completion(&priv->completion);
285 	priv->client.receive_cb = callback;
286 
287 	msg.command = command;
288 	if (arg)
289 		msg.arg[0] = arg;
290 
291 	ret = stratix10_svc_send(priv->chan, &msg);
292 	if (ret < 0)
293 		goto status_done;
294 
295 	ret = wait_for_completion_interruptible_timeout(&priv->completion,
296 							RSU_TIMEOUT);
297 	if (!ret) {
298 		dev_err(priv->client.dev,
299 			"timeout waiting for SMC call\n");
300 		ret = -ETIMEDOUT;
301 		goto status_done;
302 	} else if (ret < 0) {
303 		dev_err(priv->client.dev,
304 			"error %d waiting for SMC call\n", ret);
305 		goto status_done;
306 	} else {
307 		ret = 0;
308 	}
309 
310 status_done:
311 	stratix10_svc_done(priv->chan);
312 	mutex_unlock(&priv->lock);
313 	return ret;
314 }
315 
316 /*
317  * This driver exposes some optional features of the Intel Stratix 10 SoC FPGA.
318  * The sysfs interfaces exposed here are FPGA Remote System Update (RSU)
319  * related. They allow user space software to query the configuration system
320  * status and to request optional reboot behavior specific to Intel FPGAs.
321  */
322 
323 static ssize_t current_image_show(struct device *dev,
324 				  struct device_attribute *attr, char *buf)
325 {
326 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
327 
328 	if (!priv)
329 		return -ENODEV;
330 
331 	return sprintf(buf, "0x%08lx\n", priv->status.current_image);
332 }
333 
334 static ssize_t fail_image_show(struct device *dev,
335 			       struct device_attribute *attr, char *buf)
336 {
337 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
338 
339 	if (!priv)
340 		return -ENODEV;
341 
342 	return sprintf(buf, "0x%08lx\n", priv->status.fail_image);
343 }
344 
345 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
346 			    char *buf)
347 {
348 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
349 
350 	if (!priv)
351 		return -ENODEV;
352 
353 	return sprintf(buf, "0x%08x\n", priv->status.version);
354 }
355 
356 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
357 			  char *buf)
358 {
359 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
360 
361 	if (!priv)
362 		return -ENODEV;
363 
364 	return sprintf(buf, "0x%08x\n", priv->status.state);
365 }
366 
367 static ssize_t error_location_show(struct device *dev,
368 				   struct device_attribute *attr, char *buf)
369 {
370 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
371 
372 	if (!priv)
373 		return -ENODEV;
374 
375 	return sprintf(buf, "0x%08x\n", priv->status.error_location);
376 }
377 
378 static ssize_t error_details_show(struct device *dev,
379 				  struct device_attribute *attr, char *buf)
380 {
381 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
382 
383 	if (!priv)
384 		return -ENODEV;
385 
386 	return sprintf(buf, "0x%08x\n", priv->status.error_details);
387 }
388 
389 static ssize_t retry_counter_show(struct device *dev,
390 				  struct device_attribute *attr, char *buf)
391 {
392 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
393 
394 	if (!priv)
395 		return -ENODEV;
396 
397 	return sprintf(buf, "0x%08x\n", priv->retry_counter);
398 }
399 
400 static ssize_t max_retry_show(struct device *dev,
401 			      struct device_attribute *attr, char *buf)
402 {
403 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
404 
405 	if (!priv)
406 		return -ENODEV;
407 
408 	return scnprintf(buf, sizeof(priv->max_retry),
409 			 "0x%08x\n", priv->max_retry);
410 }
411 
412 static ssize_t dcmf0_show(struct device *dev,
413 			  struct device_attribute *attr, char *buf)
414 {
415 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
416 
417 	if (!priv)
418 		return -ENODEV;
419 
420 	return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf0);
421 }
422 
423 static ssize_t dcmf1_show(struct device *dev,
424 			  struct device_attribute *attr, char *buf)
425 {
426 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
427 
428 	if (!priv)
429 		return -ENODEV;
430 
431 	return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf1);
432 }
433 
434 static ssize_t dcmf2_show(struct device *dev,
435 			  struct device_attribute *attr, char *buf)
436 {
437 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
438 
439 	if (!priv)
440 		return -ENODEV;
441 
442 	return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf2);
443 }
444 
445 static ssize_t dcmf3_show(struct device *dev,
446 			  struct device_attribute *attr, char *buf)
447 {
448 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
449 
450 	if (!priv)
451 		return -ENODEV;
452 
453 	return sprintf(buf, "0x%08x\n", priv->dcmf_version.dcmf3);
454 }
455 
456 static ssize_t dcmf0_status_show(struct device *dev,
457 				 struct device_attribute *attr, char *buf)
458 {
459 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
460 
461 	if (!priv)
462 		return -ENODEV;
463 
464 	if (priv->dcmf_status.dcmf0 == INVALID_DCMF_STATUS)
465 		return -EIO;
466 
467 	return sprintf(buf, "0x%08x\n", priv->dcmf_status.dcmf0);
468 }
469 
470 static ssize_t dcmf1_status_show(struct device *dev,
471 				 struct device_attribute *attr, char *buf)
472 {
473 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
474 
475 	if (!priv)
476 		return -ENODEV;
477 
478 	if (priv->dcmf_status.dcmf1 == INVALID_DCMF_STATUS)
479 		return -EIO;
480 
481 	return sprintf(buf, "0x%08x\n", priv->dcmf_status.dcmf1);
482 }
483 
484 static ssize_t dcmf2_status_show(struct device *dev,
485 				struct device_attribute *attr, char *buf)
486 {
487 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
488 
489 	if (!priv)
490 		return -ENODEV;
491 
492 	if (priv->dcmf_status.dcmf2 == INVALID_DCMF_STATUS)
493 		return -EIO;
494 
495 	return sprintf(buf, "0x%08x\n", priv->dcmf_status.dcmf2);
496 }
497 
498 static ssize_t dcmf3_status_show(struct device *dev,
499 				 struct device_attribute *attr, char *buf)
500 {
501 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
502 
503 	if (!priv)
504 		return -ENODEV;
505 
506 	if (priv->dcmf_status.dcmf3 == INVALID_DCMF_STATUS)
507 		return -EIO;
508 
509 	return sprintf(buf, "0x%08x\n", priv->dcmf_status.dcmf3);
510 }
511 static ssize_t reboot_image_store(struct device *dev,
512 				  struct device_attribute *attr,
513 				  const char *buf, size_t count)
514 {
515 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
516 	unsigned long address;
517 	int ret;
518 
519 	if (!priv)
520 		return -ENODEV;
521 
522 	ret = kstrtoul(buf, 0, &address);
523 	if (ret)
524 		return ret;
525 
526 	ret = rsu_send_msg(priv, COMMAND_RSU_UPDATE,
527 			   address, rsu_command_callback);
528 	if (ret) {
529 		dev_err(dev, "Error, RSU update returned %i\n", ret);
530 		return ret;
531 	}
532 
533 	return count;
534 }
535 
536 static ssize_t notify_store(struct device *dev,
537 			    struct device_attribute *attr,
538 			    const char *buf, size_t count)
539 {
540 	struct stratix10_rsu_priv *priv = dev_get_drvdata(dev);
541 	unsigned long status;
542 	int ret;
543 
544 	if (!priv)
545 		return -ENODEV;
546 
547 	ret = kstrtoul(buf, 0, &status);
548 	if (ret)
549 		return ret;
550 
551 	ret = rsu_send_msg(priv, COMMAND_RSU_NOTIFY,
552 			   status, rsu_command_callback);
553 	if (ret) {
554 		dev_err(dev, "Error, RSU notify returned %i\n", ret);
555 		return ret;
556 	}
557 
558 	/* to get the updated state */
559 	ret = rsu_send_msg(priv, COMMAND_RSU_STATUS,
560 			   0, rsu_status_callback);
561 	if (ret) {
562 		dev_err(dev, "Error, getting RSU status %i\n", ret);
563 		return ret;
564 	}
565 
566 	ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
567 	if (ret) {
568 		dev_err(dev, "Error, getting RSU retry %i\n", ret);
569 		return ret;
570 	}
571 
572 	return count;
573 }
574 
575 static DEVICE_ATTR_RO(current_image);
576 static DEVICE_ATTR_RO(fail_image);
577 static DEVICE_ATTR_RO(state);
578 static DEVICE_ATTR_RO(version);
579 static DEVICE_ATTR_RO(error_location);
580 static DEVICE_ATTR_RO(error_details);
581 static DEVICE_ATTR_RO(retry_counter);
582 static DEVICE_ATTR_RO(max_retry);
583 static DEVICE_ATTR_RO(dcmf0);
584 static DEVICE_ATTR_RO(dcmf1);
585 static DEVICE_ATTR_RO(dcmf2);
586 static DEVICE_ATTR_RO(dcmf3);
587 static DEVICE_ATTR_RO(dcmf0_status);
588 static DEVICE_ATTR_RO(dcmf1_status);
589 static DEVICE_ATTR_RO(dcmf2_status);
590 static DEVICE_ATTR_RO(dcmf3_status);
591 static DEVICE_ATTR_WO(reboot_image);
592 static DEVICE_ATTR_WO(notify);
593 
594 static struct attribute *rsu_attrs[] = {
595 	&dev_attr_current_image.attr,
596 	&dev_attr_fail_image.attr,
597 	&dev_attr_state.attr,
598 	&dev_attr_version.attr,
599 	&dev_attr_error_location.attr,
600 	&dev_attr_error_details.attr,
601 	&dev_attr_retry_counter.attr,
602 	&dev_attr_max_retry.attr,
603 	&dev_attr_dcmf0.attr,
604 	&dev_attr_dcmf1.attr,
605 	&dev_attr_dcmf2.attr,
606 	&dev_attr_dcmf3.attr,
607 	&dev_attr_dcmf0_status.attr,
608 	&dev_attr_dcmf1_status.attr,
609 	&dev_attr_dcmf2_status.attr,
610 	&dev_attr_dcmf3_status.attr,
611 	&dev_attr_reboot_image.attr,
612 	&dev_attr_notify.attr,
613 	NULL
614 };
615 
616 ATTRIBUTE_GROUPS(rsu);
617 
618 static int stratix10_rsu_probe(struct platform_device *pdev)
619 {
620 	struct device *dev = &pdev->dev;
621 	struct stratix10_rsu_priv *priv;
622 	int ret;
623 
624 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
625 	if (!priv)
626 		return -ENOMEM;
627 
628 	priv->client.dev = dev;
629 	priv->client.receive_cb = NULL;
630 	priv->client.priv = priv;
631 	priv->status.current_image = 0;
632 	priv->status.fail_image = 0;
633 	priv->status.error_location = 0;
634 	priv->status.error_details = 0;
635 	priv->status.version = 0;
636 	priv->status.state = 0;
637 	priv->retry_counter = INVALID_RETRY_COUNTER;
638 	priv->dcmf_version.dcmf0 = INVALID_DCMF_VERSION;
639 	priv->dcmf_version.dcmf1 = INVALID_DCMF_VERSION;
640 	priv->dcmf_version.dcmf2 = INVALID_DCMF_VERSION;
641 	priv->dcmf_version.dcmf3 = INVALID_DCMF_VERSION;
642 	priv->max_retry = INVALID_RETRY_COUNTER;
643 	priv->dcmf_status.dcmf0 = INVALID_DCMF_STATUS;
644 	priv->dcmf_status.dcmf1 = INVALID_DCMF_STATUS;
645 	priv->dcmf_status.dcmf2 = INVALID_DCMF_STATUS;
646 	priv->dcmf_status.dcmf3 = INVALID_DCMF_STATUS;
647 
648 	mutex_init(&priv->lock);
649 	priv->chan = stratix10_svc_request_channel_byname(&priv->client,
650 							  SVC_CLIENT_RSU);
651 	if (IS_ERR(priv->chan)) {
652 		dev_err(dev, "couldn't get service channel %s\n",
653 			SVC_CLIENT_RSU);
654 		return PTR_ERR(priv->chan);
655 	}
656 
657 	init_completion(&priv->completion);
658 	platform_set_drvdata(pdev, priv);
659 
660 	/* get the initial state from firmware */
661 	ret = rsu_send_msg(priv, COMMAND_RSU_STATUS,
662 			   0, rsu_status_callback);
663 	if (ret) {
664 		dev_err(dev, "Error, getting RSU status %i\n", ret);
665 		stratix10_svc_free_channel(priv->chan);
666 	}
667 
668 	/* get DCMF version from firmware */
669 	ret = rsu_send_msg(priv, COMMAND_RSU_DCMF_VERSION,
670 			   0, rsu_dcmf_version_callback);
671 	if (ret) {
672 		dev_err(dev, "Error, getting DCMF version %i\n", ret);
673 		stratix10_svc_free_channel(priv->chan);
674 	}
675 
676 	ret = rsu_send_msg(priv, COMMAND_RSU_DCMF_STATUS,
677 			   0, rsu_dcmf_status_callback);
678 	if (ret) {
679 		dev_err(dev, "Error, getting DCMF status %i\n", ret);
680 		stratix10_svc_free_channel(priv->chan);
681 	}
682 
683 	ret = rsu_send_msg(priv, COMMAND_RSU_RETRY, 0, rsu_retry_callback);
684 	if (ret) {
685 		dev_err(dev, "Error, getting RSU retry %i\n", ret);
686 		stratix10_svc_free_channel(priv->chan);
687 	}
688 
689 	ret = rsu_send_msg(priv, COMMAND_RSU_MAX_RETRY, 0,
690 			   rsu_max_retry_callback);
691 	if (ret) {
692 		dev_err(dev, "Error, getting RSU max retry %i\n", ret);
693 		stratix10_svc_free_channel(priv->chan);
694 	}
695 
696 	return ret;
697 }
698 
699 static int stratix10_rsu_remove(struct platform_device *pdev)
700 {
701 	struct stratix10_rsu_priv *priv = platform_get_drvdata(pdev);
702 
703 	stratix10_svc_free_channel(priv->chan);
704 	return 0;
705 }
706 
707 static struct platform_driver stratix10_rsu_driver = {
708 	.probe = stratix10_rsu_probe,
709 	.remove = stratix10_rsu_remove,
710 	.driver = {
711 		.name = "stratix10-rsu",
712 		.dev_groups = rsu_groups,
713 	},
714 };
715 
716 module_platform_driver(stratix10_rsu_driver);
717 
718 MODULE_LICENSE("GPL v2");
719 MODULE_DESCRIPTION("Intel Remote System Update Driver");
720 MODULE_AUTHOR("Richard Gong <richard.gong@intel.com>");
721