1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (c) 2021, MediaTek Inc.
4 * Copyright (c) 2021-2022, Intel Corporation.
5 *
6 * Authors:
7 * Haijun Liu <haijun.liu@mediatek.com>
8 * Eliot Lee <eliot.lee@intel.com>
9 * Moises Veleta <moises.veleta@intel.com>
10 * Ricardo Martinez <ricardo.martinez@linux.intel.com>
11 *
12 * Contributors:
13 * Amir Hanania <amir.hanania@intel.com>
14 * Sreehari Kancharla <sreehari.kancharla@intel.com>
15 */
16
17 #include <linux/bits.h>
18 #include <linux/bitfield.h>
19 #include <linux/completion.h>
20 #include <linux/device.h>
21 #include <linux/delay.h>
22 #include <linux/err.h>
23 #include <linux/gfp.h>
24 #include <linux/iopoll.h>
25 #include <linux/jiffies.h>
26 #include <linux/kernel.h>
27 #include <linux/kthread.h>
28 #include <linux/list.h>
29 #include <linux/slab.h>
30 #include <linux/spinlock.h>
31 #include <linux/string.h>
32 #include <linux/types.h>
33 #include <linux/wait.h>
34
35 #include "t7xx_hif_cldma.h"
36 #include "t7xx_mhccif.h"
37 #include "t7xx_modem_ops.h"
38 #include "t7xx_pci.h"
39 #include "t7xx_pcie_mac.h"
40 #include "t7xx_port_proxy.h"
41 #include "t7xx_reg.h"
42 #include "t7xx_state_monitor.h"
43
44 #define FSM_DRM_DISABLE_DELAY_MS 200
45 #define FSM_EVENT_POLL_INTERVAL_MS 20
46 #define FSM_MD_EX_REC_OK_TIMEOUT_MS 10000
47 #define FSM_MD_EX_PASS_TIMEOUT_MS 45000
48 #define FSM_CMD_TIMEOUT_MS 2000
49
t7xx_fsm_notifier_register(struct t7xx_modem * md,struct t7xx_fsm_notifier * notifier)50 void t7xx_fsm_notifier_register(struct t7xx_modem *md, struct t7xx_fsm_notifier *notifier)
51 {
52 struct t7xx_fsm_ctl *ctl = md->fsm_ctl;
53 unsigned long flags;
54
55 spin_lock_irqsave(&ctl->notifier_lock, flags);
56 list_add_tail(¬ifier->entry, &ctl->notifier_list);
57 spin_unlock_irqrestore(&ctl->notifier_lock, flags);
58 }
59
t7xx_fsm_notifier_unregister(struct t7xx_modem * md,struct t7xx_fsm_notifier * notifier)60 void t7xx_fsm_notifier_unregister(struct t7xx_modem *md, struct t7xx_fsm_notifier *notifier)
61 {
62 struct t7xx_fsm_notifier *notifier_cur, *notifier_next;
63 struct t7xx_fsm_ctl *ctl = md->fsm_ctl;
64 unsigned long flags;
65
66 spin_lock_irqsave(&ctl->notifier_lock, flags);
67 list_for_each_entry_safe(notifier_cur, notifier_next, &ctl->notifier_list, entry) {
68 if (notifier_cur == notifier)
69 list_del(¬ifier->entry);
70 }
71 spin_unlock_irqrestore(&ctl->notifier_lock, flags);
72 }
73
fsm_state_notify(struct t7xx_modem * md,enum md_state state)74 static void fsm_state_notify(struct t7xx_modem *md, enum md_state state)
75 {
76 struct t7xx_fsm_ctl *ctl = md->fsm_ctl;
77 struct t7xx_fsm_notifier *notifier;
78 unsigned long flags;
79
80 spin_lock_irqsave(&ctl->notifier_lock, flags);
81 list_for_each_entry(notifier, &ctl->notifier_list, entry) {
82 spin_unlock_irqrestore(&ctl->notifier_lock, flags);
83 if (notifier->notifier_fn)
84 notifier->notifier_fn(state, notifier->data);
85
86 spin_lock_irqsave(&ctl->notifier_lock, flags);
87 }
88 spin_unlock_irqrestore(&ctl->notifier_lock, flags);
89 }
90
t7xx_fsm_broadcast_state(struct t7xx_fsm_ctl * ctl,enum md_state state)91 void t7xx_fsm_broadcast_state(struct t7xx_fsm_ctl *ctl, enum md_state state)
92 {
93 ctl->md_state = state;
94
95 /* Update to port first, otherwise sending message on HS2 may fail */
96 t7xx_port_proxy_md_status_notify(ctl->md->port_prox, state);
97 fsm_state_notify(ctl->md, state);
98 }
99
fsm_finish_command(struct t7xx_fsm_ctl * ctl,struct t7xx_fsm_command * cmd,int result)100 static void fsm_finish_command(struct t7xx_fsm_ctl *ctl, struct t7xx_fsm_command *cmd, int result)
101 {
102 if (cmd->flag & FSM_CMD_FLAG_WAIT_FOR_COMPLETION) {
103 *cmd->ret = result;
104 complete_all(cmd->done);
105 }
106
107 kfree(cmd);
108 }
109
fsm_del_kf_event(struct t7xx_fsm_event * event)110 static void fsm_del_kf_event(struct t7xx_fsm_event *event)
111 {
112 list_del(&event->entry);
113 kfree(event);
114 }
115
fsm_flush_event_cmd_qs(struct t7xx_fsm_ctl * ctl)116 static void fsm_flush_event_cmd_qs(struct t7xx_fsm_ctl *ctl)
117 {
118 struct device *dev = &ctl->md->t7xx_dev->pdev->dev;
119 struct t7xx_fsm_event *event, *evt_next;
120 struct t7xx_fsm_command *cmd, *cmd_next;
121 unsigned long flags;
122
123 spin_lock_irqsave(&ctl->command_lock, flags);
124 list_for_each_entry_safe(cmd, cmd_next, &ctl->command_queue, entry) {
125 dev_warn(dev, "Unhandled command %d\n", cmd->cmd_id);
126 list_del(&cmd->entry);
127 fsm_finish_command(ctl, cmd, -EINVAL);
128 }
129 spin_unlock_irqrestore(&ctl->command_lock, flags);
130
131 spin_lock_irqsave(&ctl->event_lock, flags);
132 list_for_each_entry_safe(event, evt_next, &ctl->event_queue, entry) {
133 dev_warn(dev, "Unhandled event %d\n", event->event_id);
134 fsm_del_kf_event(event);
135 }
136 spin_unlock_irqrestore(&ctl->event_lock, flags);
137 }
138
fsm_wait_for_event(struct t7xx_fsm_ctl * ctl,enum t7xx_fsm_event_state event_expected,enum t7xx_fsm_event_state event_ignore,int retries)139 static void fsm_wait_for_event(struct t7xx_fsm_ctl *ctl, enum t7xx_fsm_event_state event_expected,
140 enum t7xx_fsm_event_state event_ignore, int retries)
141 {
142 struct t7xx_fsm_event *event;
143 bool event_received = false;
144 unsigned long flags;
145 int cnt = 0;
146
147 while (cnt++ < retries && !event_received) {
148 bool sleep_required = true;
149
150 if (kthread_should_stop())
151 return;
152
153 spin_lock_irqsave(&ctl->event_lock, flags);
154 event = list_first_entry_or_null(&ctl->event_queue, struct t7xx_fsm_event, entry);
155 if (event) {
156 event_received = event->event_id == event_expected;
157 if (event_received || event->event_id == event_ignore) {
158 fsm_del_kf_event(event);
159 sleep_required = false;
160 }
161 }
162 spin_unlock_irqrestore(&ctl->event_lock, flags);
163
164 if (sleep_required)
165 msleep(FSM_EVENT_POLL_INTERVAL_MS);
166 }
167 }
168
fsm_routine_exception(struct t7xx_fsm_ctl * ctl,struct t7xx_fsm_command * cmd,enum t7xx_ex_reason reason)169 static void fsm_routine_exception(struct t7xx_fsm_ctl *ctl, struct t7xx_fsm_command *cmd,
170 enum t7xx_ex_reason reason)
171 {
172 struct device *dev = &ctl->md->t7xx_dev->pdev->dev;
173
174 if (ctl->curr_state != FSM_STATE_READY && ctl->curr_state != FSM_STATE_STARTING) {
175 if (cmd)
176 fsm_finish_command(ctl, cmd, -EINVAL);
177
178 return;
179 }
180
181 ctl->curr_state = FSM_STATE_EXCEPTION;
182
183 switch (reason) {
184 case EXCEPTION_HS_TIMEOUT:
185 dev_err(dev, "Boot Handshake failure\n");
186 break;
187
188 case EXCEPTION_EVENT:
189 dev_err(dev, "Exception event\n");
190 t7xx_fsm_broadcast_state(ctl, MD_STATE_EXCEPTION);
191 t7xx_pci_pm_exp_detected(ctl->md->t7xx_dev);
192 t7xx_md_exception_handshake(ctl->md);
193
194 fsm_wait_for_event(ctl, FSM_EVENT_MD_EX_REC_OK, FSM_EVENT_MD_EX,
195 FSM_MD_EX_REC_OK_TIMEOUT_MS / FSM_EVENT_POLL_INTERVAL_MS);
196 fsm_wait_for_event(ctl, FSM_EVENT_MD_EX_PASS, FSM_EVENT_INVALID,
197 FSM_MD_EX_PASS_TIMEOUT_MS / FSM_EVENT_POLL_INTERVAL_MS);
198 break;
199
200 default:
201 dev_err(dev, "Exception %d\n", reason);
202 break;
203 }
204
205 if (cmd)
206 fsm_finish_command(ctl, cmd, 0);
207 }
208
fsm_stopped_handler(struct t7xx_fsm_ctl * ctl)209 static int fsm_stopped_handler(struct t7xx_fsm_ctl *ctl)
210 {
211 ctl->curr_state = FSM_STATE_STOPPED;
212
213 t7xx_fsm_broadcast_state(ctl, MD_STATE_STOPPED);
214 return t7xx_md_reset(ctl->md->t7xx_dev);
215 }
216
fsm_routine_stopped(struct t7xx_fsm_ctl * ctl,struct t7xx_fsm_command * cmd)217 static void fsm_routine_stopped(struct t7xx_fsm_ctl *ctl, struct t7xx_fsm_command *cmd)
218 {
219 if (ctl->curr_state == FSM_STATE_STOPPED) {
220 fsm_finish_command(ctl, cmd, -EINVAL);
221 return;
222 }
223
224 fsm_finish_command(ctl, cmd, fsm_stopped_handler(ctl));
225 }
226
fsm_routine_stopping(struct t7xx_fsm_ctl * ctl,struct t7xx_fsm_command * cmd)227 static void fsm_routine_stopping(struct t7xx_fsm_ctl *ctl, struct t7xx_fsm_command *cmd)
228 {
229 struct t7xx_pci_dev *t7xx_dev;
230 struct cldma_ctrl *md_ctrl;
231 int err;
232
233 if (ctl->curr_state == FSM_STATE_STOPPED || ctl->curr_state == FSM_STATE_STOPPING) {
234 fsm_finish_command(ctl, cmd, -EINVAL);
235 return;
236 }
237
238 md_ctrl = ctl->md->md_ctrl[CLDMA_ID_MD];
239 t7xx_dev = ctl->md->t7xx_dev;
240
241 ctl->curr_state = FSM_STATE_STOPPING;
242 t7xx_fsm_broadcast_state(ctl, MD_STATE_WAITING_TO_STOP);
243 t7xx_cldma_stop(md_ctrl);
244
245 if (!ctl->md->rgu_irq_asserted) {
246 t7xx_mhccif_h2d_swint_trigger(t7xx_dev, H2D_CH_DRM_DISABLE_AP);
247 /* Wait for the DRM disable to take effect */
248 msleep(FSM_DRM_DISABLE_DELAY_MS);
249
250 err = t7xx_acpi_fldr_func(t7xx_dev);
251 if (err)
252 t7xx_mhccif_h2d_swint_trigger(t7xx_dev, H2D_CH_DEVICE_RESET);
253 }
254
255 fsm_finish_command(ctl, cmd, fsm_stopped_handler(ctl));
256 }
257
t7xx_fsm_broadcast_ready_state(struct t7xx_fsm_ctl * ctl)258 static void t7xx_fsm_broadcast_ready_state(struct t7xx_fsm_ctl *ctl)
259 {
260 if (ctl->md_state != MD_STATE_WAITING_FOR_HS2)
261 return;
262
263 ctl->md_state = MD_STATE_READY;
264
265 fsm_state_notify(ctl->md, MD_STATE_READY);
266 t7xx_port_proxy_md_status_notify(ctl->md->port_prox, MD_STATE_READY);
267 }
268
fsm_routine_ready(struct t7xx_fsm_ctl * ctl)269 static void fsm_routine_ready(struct t7xx_fsm_ctl *ctl)
270 {
271 struct t7xx_modem *md = ctl->md;
272
273 ctl->curr_state = FSM_STATE_READY;
274 t7xx_fsm_broadcast_ready_state(ctl);
275 t7xx_md_event_notify(md, FSM_READY);
276 }
277
fsm_routine_starting(struct t7xx_fsm_ctl * ctl)278 static int fsm_routine_starting(struct t7xx_fsm_ctl *ctl)
279 {
280 struct t7xx_modem *md = ctl->md;
281 struct device *dev;
282
283 ctl->curr_state = FSM_STATE_STARTING;
284
285 t7xx_fsm_broadcast_state(ctl, MD_STATE_WAITING_FOR_HS1);
286 t7xx_md_event_notify(md, FSM_START);
287
288 wait_event_interruptible_timeout(ctl->async_hk_wq, md->core_md.ready || ctl->exp_flg,
289 HZ * 60);
290 dev = &md->t7xx_dev->pdev->dev;
291
292 if (ctl->exp_flg)
293 dev_err(dev, "MD exception is captured during handshake\n");
294
295 if (!md->core_md.ready) {
296 dev_err(dev, "MD handshake timeout\n");
297 if (md->core_md.handshake_ongoing)
298 t7xx_fsm_append_event(ctl, FSM_EVENT_MD_HS2_EXIT, NULL, 0);
299
300 fsm_routine_exception(ctl, NULL, EXCEPTION_HS_TIMEOUT);
301 return -ETIMEDOUT;
302 }
303
304 t7xx_pci_pm_init_late(md->t7xx_dev);
305 fsm_routine_ready(ctl);
306 return 0;
307 }
308
fsm_routine_start(struct t7xx_fsm_ctl * ctl,struct t7xx_fsm_command * cmd)309 static void fsm_routine_start(struct t7xx_fsm_ctl *ctl, struct t7xx_fsm_command *cmd)
310 {
311 struct t7xx_modem *md = ctl->md;
312 u32 dev_status;
313 int ret;
314
315 if (!md)
316 return;
317
318 if (ctl->curr_state != FSM_STATE_INIT && ctl->curr_state != FSM_STATE_PRE_START &&
319 ctl->curr_state != FSM_STATE_STOPPED) {
320 fsm_finish_command(ctl, cmd, -EINVAL);
321 return;
322 }
323
324 ctl->curr_state = FSM_STATE_PRE_START;
325 t7xx_md_event_notify(md, FSM_PRE_START);
326
327 ret = read_poll_timeout(ioread32, dev_status,
328 (dev_status & MISC_STAGE_MASK) == LINUX_STAGE, 20000, 2000000,
329 false, IREG_BASE(md->t7xx_dev) + T7XX_PCIE_MISC_DEV_STATUS);
330 if (ret) {
331 struct device *dev = &md->t7xx_dev->pdev->dev;
332
333 fsm_finish_command(ctl, cmd, -ETIMEDOUT);
334 dev_err(dev, "Invalid device status 0x%lx\n", dev_status & MISC_STAGE_MASK);
335 return;
336 }
337
338 t7xx_cldma_hif_hw_init(md->md_ctrl[CLDMA_ID_MD]);
339 fsm_finish_command(ctl, cmd, fsm_routine_starting(ctl));
340 }
341
fsm_main_thread(void * data)342 static int fsm_main_thread(void *data)
343 {
344 struct t7xx_fsm_ctl *ctl = data;
345 struct t7xx_fsm_command *cmd;
346 unsigned long flags;
347
348 while (!kthread_should_stop()) {
349 if (wait_event_interruptible(ctl->command_wq, !list_empty(&ctl->command_queue) ||
350 kthread_should_stop()))
351 continue;
352
353 if (kthread_should_stop())
354 break;
355
356 spin_lock_irqsave(&ctl->command_lock, flags);
357 cmd = list_first_entry(&ctl->command_queue, struct t7xx_fsm_command, entry);
358 list_del(&cmd->entry);
359 spin_unlock_irqrestore(&ctl->command_lock, flags);
360
361 switch (cmd->cmd_id) {
362 case FSM_CMD_START:
363 fsm_routine_start(ctl, cmd);
364 break;
365
366 case FSM_CMD_EXCEPTION:
367 fsm_routine_exception(ctl, cmd, FIELD_GET(FSM_CMD_EX_REASON, cmd->flag));
368 break;
369
370 case FSM_CMD_PRE_STOP:
371 fsm_routine_stopping(ctl, cmd);
372 break;
373
374 case FSM_CMD_STOP:
375 fsm_routine_stopped(ctl, cmd);
376 break;
377
378 default:
379 fsm_finish_command(ctl, cmd, -EINVAL);
380 fsm_flush_event_cmd_qs(ctl);
381 break;
382 }
383 }
384
385 return 0;
386 }
387
t7xx_fsm_append_cmd(struct t7xx_fsm_ctl * ctl,enum t7xx_fsm_cmd_state cmd_id,unsigned int flag)388 int t7xx_fsm_append_cmd(struct t7xx_fsm_ctl *ctl, enum t7xx_fsm_cmd_state cmd_id, unsigned int flag)
389 {
390 DECLARE_COMPLETION_ONSTACK(done);
391 struct t7xx_fsm_command *cmd;
392 unsigned long flags;
393 int ret;
394
395 cmd = kzalloc(sizeof(*cmd), flag & FSM_CMD_FLAG_IN_INTERRUPT ? GFP_ATOMIC : GFP_KERNEL);
396 if (!cmd)
397 return -ENOMEM;
398
399 INIT_LIST_HEAD(&cmd->entry);
400 cmd->cmd_id = cmd_id;
401 cmd->flag = flag;
402 if (flag & FSM_CMD_FLAG_WAIT_FOR_COMPLETION) {
403 cmd->done = &done;
404 cmd->ret = &ret;
405 }
406
407 spin_lock_irqsave(&ctl->command_lock, flags);
408 list_add_tail(&cmd->entry, &ctl->command_queue);
409 spin_unlock_irqrestore(&ctl->command_lock, flags);
410
411 wake_up(&ctl->command_wq);
412
413 if (flag & FSM_CMD_FLAG_WAIT_FOR_COMPLETION) {
414 unsigned long wait_ret;
415
416 wait_ret = wait_for_completion_timeout(&done,
417 msecs_to_jiffies(FSM_CMD_TIMEOUT_MS));
418 if (!wait_ret)
419 return -ETIMEDOUT;
420
421 return ret;
422 }
423
424 return 0;
425 }
426
t7xx_fsm_append_event(struct t7xx_fsm_ctl * ctl,enum t7xx_fsm_event_state event_id,unsigned char * data,unsigned int length)427 int t7xx_fsm_append_event(struct t7xx_fsm_ctl *ctl, enum t7xx_fsm_event_state event_id,
428 unsigned char *data, unsigned int length)
429 {
430 struct device *dev = &ctl->md->t7xx_dev->pdev->dev;
431 struct t7xx_fsm_event *event;
432 unsigned long flags;
433
434 if (event_id <= FSM_EVENT_INVALID || event_id >= FSM_EVENT_MAX) {
435 dev_err(dev, "Invalid event %d\n", event_id);
436 return -EINVAL;
437 }
438
439 event = kmalloc(sizeof(*event) + length, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
440 if (!event)
441 return -ENOMEM;
442
443 INIT_LIST_HEAD(&event->entry);
444 event->event_id = event_id;
445 event->length = length;
446
447 if (data && length)
448 memcpy(event->data, data, length);
449
450 spin_lock_irqsave(&ctl->event_lock, flags);
451 list_add_tail(&event->entry, &ctl->event_queue);
452 spin_unlock_irqrestore(&ctl->event_lock, flags);
453
454 wake_up_all(&ctl->event_wq);
455 return 0;
456 }
457
t7xx_fsm_clr_event(struct t7xx_fsm_ctl * ctl,enum t7xx_fsm_event_state event_id)458 void t7xx_fsm_clr_event(struct t7xx_fsm_ctl *ctl, enum t7xx_fsm_event_state event_id)
459 {
460 struct t7xx_fsm_event *event, *evt_next;
461 unsigned long flags;
462
463 spin_lock_irqsave(&ctl->event_lock, flags);
464 list_for_each_entry_safe(event, evt_next, &ctl->event_queue, entry) {
465 if (event->event_id == event_id)
466 fsm_del_kf_event(event);
467 }
468 spin_unlock_irqrestore(&ctl->event_lock, flags);
469 }
470
t7xx_fsm_get_md_state(struct t7xx_fsm_ctl * ctl)471 enum md_state t7xx_fsm_get_md_state(struct t7xx_fsm_ctl *ctl)
472 {
473 if (ctl)
474 return ctl->md_state;
475
476 return MD_STATE_INVALID;
477 }
478
t7xx_fsm_get_ctl_state(struct t7xx_fsm_ctl * ctl)479 unsigned int t7xx_fsm_get_ctl_state(struct t7xx_fsm_ctl *ctl)
480 {
481 if (ctl)
482 return ctl->curr_state;
483
484 return FSM_STATE_STOPPED;
485 }
486
t7xx_fsm_recv_md_intr(struct t7xx_fsm_ctl * ctl,enum t7xx_md_irq_type type)487 int t7xx_fsm_recv_md_intr(struct t7xx_fsm_ctl *ctl, enum t7xx_md_irq_type type)
488 {
489 unsigned int cmd_flags = FSM_CMD_FLAG_IN_INTERRUPT;
490
491 if (type == MD_IRQ_PORT_ENUM) {
492 return t7xx_fsm_append_cmd(ctl, FSM_CMD_START, cmd_flags);
493 } else if (type == MD_IRQ_CCIF_EX) {
494 ctl->exp_flg = true;
495 wake_up(&ctl->async_hk_wq);
496 cmd_flags |= FIELD_PREP(FSM_CMD_EX_REASON, EXCEPTION_EVENT);
497 return t7xx_fsm_append_cmd(ctl, FSM_CMD_EXCEPTION, cmd_flags);
498 }
499
500 return -EINVAL;
501 }
502
t7xx_fsm_reset(struct t7xx_modem * md)503 void t7xx_fsm_reset(struct t7xx_modem *md)
504 {
505 struct t7xx_fsm_ctl *ctl = md->fsm_ctl;
506
507 fsm_flush_event_cmd_qs(ctl);
508 ctl->curr_state = FSM_STATE_STOPPED;
509 ctl->exp_flg = false;
510 }
511
t7xx_fsm_init(struct t7xx_modem * md)512 int t7xx_fsm_init(struct t7xx_modem *md)
513 {
514 struct device *dev = &md->t7xx_dev->pdev->dev;
515 struct t7xx_fsm_ctl *ctl;
516
517 ctl = devm_kzalloc(dev, sizeof(*ctl), GFP_KERNEL);
518 if (!ctl)
519 return -ENOMEM;
520
521 md->fsm_ctl = ctl;
522 ctl->md = md;
523 ctl->curr_state = FSM_STATE_INIT;
524 INIT_LIST_HEAD(&ctl->command_queue);
525 INIT_LIST_HEAD(&ctl->event_queue);
526 init_waitqueue_head(&ctl->async_hk_wq);
527 init_waitqueue_head(&ctl->event_wq);
528 INIT_LIST_HEAD(&ctl->notifier_list);
529 init_waitqueue_head(&ctl->command_wq);
530 spin_lock_init(&ctl->event_lock);
531 spin_lock_init(&ctl->command_lock);
532 ctl->exp_flg = false;
533 spin_lock_init(&ctl->notifier_lock);
534
535 ctl->fsm_thread = kthread_run(fsm_main_thread, ctl, "t7xx_fsm");
536 return PTR_ERR_OR_ZERO(ctl->fsm_thread);
537 }
538
t7xx_fsm_uninit(struct t7xx_modem * md)539 void t7xx_fsm_uninit(struct t7xx_modem *md)
540 {
541 struct t7xx_fsm_ctl *ctl = md->fsm_ctl;
542
543 if (!ctl)
544 return;
545
546 if (ctl->fsm_thread)
547 kthread_stop(ctl->fsm_thread);
548
549 fsm_flush_event_cmd_qs(ctl);
550 }
551