1 // SPDX-License-Identifier: GPL-2.0-only OR MIT
3 * Apple RTKit IPC library
4 * Copyright (C) The Asahi Linux Contributors
7 #include "rtkit-internal.h"
10 APPLE_RTKIT_PWR_STATE_OFF = 0x00, /* power off, cannot be restarted */
11 APPLE_RTKIT_PWR_STATE_SLEEP = 0x01, /* sleeping, can be restarted */
12 APPLE_RTKIT_PWR_STATE_QUIESCED = 0x10, /* running but no communication */
13 APPLE_RTKIT_PWR_STATE_ON = 0x20, /* normal operating state */
17 APPLE_RTKIT_EP_MGMT = 0,
18 APPLE_RTKIT_EP_CRASHLOG = 1,
19 APPLE_RTKIT_EP_SYSLOG = 2,
20 APPLE_RTKIT_EP_DEBUG = 3,
21 APPLE_RTKIT_EP_IOREPORT = 4,
22 APPLE_RTKIT_EP_OSLOG = 8,
25 #define APPLE_RTKIT_MGMT_TYPE GENMASK_ULL(59, 52)
28 APPLE_RTKIT_MGMT_HELLO = 1,
29 APPLE_RTKIT_MGMT_HELLO_REPLY = 2,
30 APPLE_RTKIT_MGMT_STARTEP = 5,
31 APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE = 6,
32 APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK = 7,
33 APPLE_RTKIT_MGMT_EPMAP = 8,
34 APPLE_RTKIT_MGMT_EPMAP_REPLY = 8,
35 APPLE_RTKIT_MGMT_SET_AP_PWR_STATE = 0xb,
36 APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK = 0xb,
39 #define APPLE_RTKIT_MGMT_HELLO_MINVER GENMASK_ULL(15, 0)
40 #define APPLE_RTKIT_MGMT_HELLO_MAXVER GENMASK_ULL(31, 16)
42 #define APPLE_RTKIT_MGMT_EPMAP_LAST BIT_ULL(51)
43 #define APPLE_RTKIT_MGMT_EPMAP_BASE GENMASK_ULL(34, 32)
44 #define APPLE_RTKIT_MGMT_EPMAP_BITMAP GENMASK_ULL(31, 0)
46 #define APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE BIT_ULL(0)
48 #define APPLE_RTKIT_MGMT_STARTEP_EP GENMASK_ULL(39, 32)
49 #define APPLE_RTKIT_MGMT_STARTEP_FLAG BIT_ULL(1)
51 #define APPLE_RTKIT_MGMT_PWR_STATE GENMASK_ULL(15, 0)
53 #define APPLE_RTKIT_CRASHLOG_CRASH 1
55 #define APPLE_RTKIT_BUFFER_REQUEST 1
56 #define APPLE_RTKIT_BUFFER_REQUEST_SIZE GENMASK_ULL(51, 44)
57 #define APPLE_RTKIT_BUFFER_REQUEST_IOVA GENMASK_ULL(41, 0)
59 #define APPLE_RTKIT_SYSLOG_TYPE GENMASK_ULL(59, 52)
61 #define APPLE_RTKIT_SYSLOG_LOG 5
63 #define APPLE_RTKIT_SYSLOG_INIT 8
64 #define APPLE_RTKIT_SYSLOG_N_ENTRIES GENMASK_ULL(7, 0)
65 #define APPLE_RTKIT_SYSLOG_MSG_SIZE GENMASK_ULL(31, 24)
67 #define APPLE_RTKIT_OSLOG_TYPE GENMASK_ULL(63, 56)
68 #define APPLE_RTKIT_OSLOG_INIT 1
69 #define APPLE_RTKIT_OSLOG_ACK 3
71 #define APPLE_RTKIT_MIN_SUPPORTED_VERSION 11
72 #define APPLE_RTKIT_MAX_SUPPORTED_VERSION 12
74 struct apple_rtkit_msg {
75 struct completion *completion;
76 struct apple_mbox_msg mbox_msg;
79 struct apple_rtkit_rx_work {
80 struct apple_rtkit *rtk;
83 struct work_struct work;
86 bool apple_rtkit_is_running(struct apple_rtkit *rtk)
90 if ((rtk->iop_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON)
92 if ((rtk->ap_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON)
96 EXPORT_SYMBOL_GPL(apple_rtkit_is_running);
98 bool apple_rtkit_is_crashed(struct apple_rtkit *rtk)
102 EXPORT_SYMBOL_GPL(apple_rtkit_is_crashed);
104 static void apple_rtkit_management_send(struct apple_rtkit *rtk, u8 type,
107 msg &= ~APPLE_RTKIT_MGMT_TYPE;
108 msg |= FIELD_PREP(APPLE_RTKIT_MGMT_TYPE, type);
109 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_MGMT, msg, NULL, false);
112 static void apple_rtkit_management_rx_hello(struct apple_rtkit *rtk, u64 msg)
116 int min_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MINVER, msg);
117 int max_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MAXVER, msg);
118 int want_ver = min(APPLE_RTKIT_MAX_SUPPORTED_VERSION, max_ver);
120 dev_dbg(rtk->dev, "RTKit: Min ver %d, max ver %d\n", min_ver, max_ver);
122 if (min_ver > APPLE_RTKIT_MAX_SUPPORTED_VERSION) {
123 dev_err(rtk->dev, "RTKit: Firmware min version %d is too new\n",
128 if (max_ver < APPLE_RTKIT_MIN_SUPPORTED_VERSION) {
129 dev_err(rtk->dev, "RTKit: Firmware max version %d is too old\n",
134 dev_info(rtk->dev, "RTKit: Initializing (protocol version %d)\n",
136 rtk->version = want_ver;
138 reply = FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MINVER, want_ver);
139 reply |= FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MAXVER, want_ver);
140 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_HELLO_REPLY, reply);
145 rtk->boot_result = -EINVAL;
146 complete_all(&rtk->epmap_completion);
149 static void apple_rtkit_management_rx_epmap(struct apple_rtkit *rtk, u64 msg)
153 unsigned long bitmap = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BITMAP, msg);
154 u32 base = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BASE, msg);
157 "RTKit: received endpoint bitmap 0x%lx with base 0x%x\n",
160 for_each_set_bit(i, &bitmap, 32) {
162 dev_dbg(rtk->dev, "RTKit: Discovered endpoint 0x%02x\n", ep);
163 set_bit(ep, rtk->endpoints);
166 reply = FIELD_PREP(APPLE_RTKIT_MGMT_EPMAP_BASE, base);
167 if (msg & APPLE_RTKIT_MGMT_EPMAP_LAST)
168 reply |= APPLE_RTKIT_MGMT_EPMAP_LAST;
170 reply |= APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE;
172 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_EPMAP_REPLY, reply);
174 if (!(msg & APPLE_RTKIT_MGMT_EPMAP_LAST))
177 for_each_set_bit(ep, rtk->endpoints, APPLE_RTKIT_APP_ENDPOINT_START) {
179 /* the management endpoint is started by default */
180 case APPLE_RTKIT_EP_MGMT:
183 /* without starting these RTKit refuses to boot */
184 case APPLE_RTKIT_EP_SYSLOG:
185 case APPLE_RTKIT_EP_CRASHLOG:
186 case APPLE_RTKIT_EP_DEBUG:
187 case APPLE_RTKIT_EP_IOREPORT:
188 case APPLE_RTKIT_EP_OSLOG:
190 "RTKit: Starting system endpoint 0x%02x\n", ep);
191 apple_rtkit_start_ep(rtk, ep);
196 "RTKit: Unknown system endpoint: 0x%02x\n",
201 rtk->boot_result = 0;
202 complete_all(&rtk->epmap_completion);
205 static void apple_rtkit_management_rx_iop_pwr_ack(struct apple_rtkit *rtk,
208 unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg);
210 dev_dbg(rtk->dev, "RTKit: IOP power state transition: 0x%x -> 0x%x\n",
211 rtk->iop_power_state, new_state);
212 rtk->iop_power_state = new_state;
214 complete_all(&rtk->iop_pwr_ack_completion);
217 static void apple_rtkit_management_rx_ap_pwr_ack(struct apple_rtkit *rtk,
220 unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg);
222 dev_dbg(rtk->dev, "RTKit: AP power state transition: 0x%x -> 0x%x\n",
223 rtk->ap_power_state, new_state);
224 rtk->ap_power_state = new_state;
226 complete_all(&rtk->ap_pwr_ack_completion);
229 static void apple_rtkit_management_rx(struct apple_rtkit *rtk, u64 msg)
231 u8 type = FIELD_GET(APPLE_RTKIT_MGMT_TYPE, msg);
234 case APPLE_RTKIT_MGMT_HELLO:
235 apple_rtkit_management_rx_hello(rtk, msg);
237 case APPLE_RTKIT_MGMT_EPMAP:
238 apple_rtkit_management_rx_epmap(rtk, msg);
240 case APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK:
241 apple_rtkit_management_rx_iop_pwr_ack(rtk, msg);
243 case APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK:
244 apple_rtkit_management_rx_ap_pwr_ack(rtk, msg);
249 "RTKit: unknown management message: 0x%llx (type: 0x%02x)\n",
254 static int apple_rtkit_common_rx_get_buffer(struct apple_rtkit *rtk,
255 struct apple_rtkit_shmem *buffer,
258 size_t n_4kpages = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_SIZE, msg);
262 buffer->buffer = NULL;
263 buffer->iomem = NULL;
264 buffer->is_mapped = false;
265 buffer->iova = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_IOVA, msg);
266 buffer->size = n_4kpages << 12;
268 dev_dbg(rtk->dev, "RTKit: buffer request for 0x%zx bytes at %pad\n",
269 buffer->size, &buffer->iova);
272 (!rtk->ops->shmem_setup || !rtk->ops->shmem_destroy)) {
277 if (rtk->ops->shmem_setup) {
278 err = rtk->ops->shmem_setup(rtk->cookie, buffer);
282 buffer->buffer = dma_alloc_coherent(rtk->dev, buffer->size,
283 &buffer->iova, GFP_KERNEL);
284 if (!buffer->buffer) {
290 if (!buffer->is_mapped) {
291 reply = FIELD_PREP(APPLE_RTKIT_SYSLOG_TYPE,
292 APPLE_RTKIT_BUFFER_REQUEST);
293 reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_SIZE, n_4kpages);
294 reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_IOVA,
296 apple_rtkit_send_message(rtk, ep, reply, NULL, false);
302 buffer->buffer = NULL;
303 buffer->iomem = NULL;
306 buffer->is_mapped = false;
310 static void apple_rtkit_free_buffer(struct apple_rtkit *rtk,
311 struct apple_rtkit_shmem *bfr)
316 if (rtk->ops->shmem_destroy)
317 rtk->ops->shmem_destroy(rtk->cookie, bfr);
318 else if (bfr->buffer)
319 dma_free_coherent(rtk->dev, bfr->size, bfr->buffer, bfr->iova);
325 bfr->is_mapped = false;
328 static void apple_rtkit_memcpy(struct apple_rtkit *rtk, void *dst,
329 struct apple_rtkit_shmem *bfr, size_t offset,
333 memcpy_fromio(dst, bfr->iomem + offset, len);
335 memcpy(dst, bfr->buffer + offset, len);
338 static void apple_rtkit_crashlog_rx(struct apple_rtkit *rtk, u64 msg)
340 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
343 if (type != APPLE_RTKIT_CRASHLOG_CRASH) {
344 dev_warn(rtk->dev, "RTKit: Unknown crashlog message: %llx\n",
349 if (!rtk->crashlog_buffer.size) {
350 apple_rtkit_common_rx_get_buffer(rtk, &rtk->crashlog_buffer,
351 APPLE_RTKIT_EP_CRASHLOG, msg);
355 dev_err(rtk->dev, "RTKit: co-processor has crashed\n");
358 * create a shadow copy here to make sure the co-processor isn't able
359 * to change the log while we're dumping it. this also ensures
360 * the buffer is in normal memory and not iomem for e.g. the SMC
362 bfr = kzalloc(rtk->crashlog_buffer.size, GFP_KERNEL);
364 apple_rtkit_memcpy(rtk, bfr, &rtk->crashlog_buffer, 0,
365 rtk->crashlog_buffer.size);
366 apple_rtkit_crashlog_dump(rtk, bfr, rtk->crashlog_buffer.size);
370 "RTKit: Couldn't allocate crashlog shadow buffer\n");
374 if (rtk->ops->crashed)
375 rtk->ops->crashed(rtk->cookie);
378 static void apple_rtkit_ioreport_rx(struct apple_rtkit *rtk, u64 msg)
380 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
383 case APPLE_RTKIT_BUFFER_REQUEST:
384 apple_rtkit_common_rx_get_buffer(rtk, &rtk->ioreport_buffer,
385 APPLE_RTKIT_EP_IOREPORT, msg);
387 /* unknown, must be ACKed or the co-processor will hang */
390 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_IOREPORT, msg,
394 dev_warn(rtk->dev, "RTKit: Unknown ioreport message: %llx\n",
399 static void apple_rtkit_syslog_rx_init(struct apple_rtkit *rtk, u64 msg)
401 rtk->syslog_n_entries = FIELD_GET(APPLE_RTKIT_SYSLOG_N_ENTRIES, msg);
402 rtk->syslog_msg_size = FIELD_GET(APPLE_RTKIT_SYSLOG_MSG_SIZE, msg);
404 rtk->syslog_msg_buffer = kzalloc(rtk->syslog_msg_size, GFP_KERNEL);
407 "RTKit: syslog initialized: entries: %zd, msg_size: %zd\n",
408 rtk->syslog_n_entries, rtk->syslog_msg_size);
411 static void apple_rtkit_syslog_rx_log(struct apple_rtkit *rtk, u64 msg)
414 char log_context[24];
415 size_t entry_size = 0x20 + rtk->syslog_msg_size;
417 if (!rtk->syslog_msg_buffer) {
420 "RTKit: received syslog message but no syslog_msg_buffer\n");
423 if (!rtk->syslog_buffer.size) {
426 "RTKit: received syslog message but syslog_buffer.size is zero\n");
429 if (!rtk->syslog_buffer.buffer && !rtk->syslog_buffer.iomem) {
432 "RTKit: received syslog message but no syslog_buffer.buffer or syslog_buffer.iomem\n");
435 if (idx > rtk->syslog_n_entries) {
436 dev_warn(rtk->dev, "RTKit: syslog index %d out of range\n",
441 apple_rtkit_memcpy(rtk, log_context, &rtk->syslog_buffer,
442 idx * entry_size + 8, sizeof(log_context));
443 apple_rtkit_memcpy(rtk, rtk->syslog_msg_buffer, &rtk->syslog_buffer,
444 idx * entry_size + 8 + sizeof(log_context),
445 rtk->syslog_msg_size);
447 log_context[sizeof(log_context) - 1] = 0;
448 rtk->syslog_msg_buffer[rtk->syslog_msg_size - 1] = 0;
449 dev_info(rtk->dev, "RTKit: syslog message: %s: %s\n", log_context,
450 rtk->syslog_msg_buffer);
453 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_SYSLOG, msg, NULL, false);
456 static void apple_rtkit_syslog_rx(struct apple_rtkit *rtk, u64 msg)
458 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
461 case APPLE_RTKIT_BUFFER_REQUEST:
462 apple_rtkit_common_rx_get_buffer(rtk, &rtk->syslog_buffer,
463 APPLE_RTKIT_EP_SYSLOG, msg);
465 case APPLE_RTKIT_SYSLOG_INIT:
466 apple_rtkit_syslog_rx_init(rtk, msg);
468 case APPLE_RTKIT_SYSLOG_LOG:
469 apple_rtkit_syslog_rx_log(rtk, msg);
472 dev_warn(rtk->dev, "RTKit: Unknown syslog message: %llx\n",
477 static void apple_rtkit_oslog_rx_init(struct apple_rtkit *rtk, u64 msg)
481 dev_dbg(rtk->dev, "RTKit: oslog init: msg: 0x%llx\n", msg);
482 ack = FIELD_PREP(APPLE_RTKIT_OSLOG_TYPE, APPLE_RTKIT_OSLOG_ACK);
483 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_OSLOG, ack, NULL, false);
486 static void apple_rtkit_oslog_rx(struct apple_rtkit *rtk, u64 msg)
488 u8 type = FIELD_GET(APPLE_RTKIT_OSLOG_TYPE, msg);
491 case APPLE_RTKIT_OSLOG_INIT:
492 apple_rtkit_oslog_rx_init(rtk, msg);
495 dev_warn(rtk->dev, "RTKit: Unknown oslog message: %llx\n", msg);
499 static void apple_rtkit_rx_work(struct work_struct *work)
501 struct apple_rtkit_rx_work *rtk_work =
502 container_of(work, struct apple_rtkit_rx_work, work);
503 struct apple_rtkit *rtk = rtk_work->rtk;
505 switch (rtk_work->ep) {
506 case APPLE_RTKIT_EP_MGMT:
507 apple_rtkit_management_rx(rtk, rtk_work->msg);
509 case APPLE_RTKIT_EP_CRASHLOG:
510 apple_rtkit_crashlog_rx(rtk, rtk_work->msg);
512 case APPLE_RTKIT_EP_SYSLOG:
513 apple_rtkit_syslog_rx(rtk, rtk_work->msg);
515 case APPLE_RTKIT_EP_IOREPORT:
516 apple_rtkit_ioreport_rx(rtk, rtk_work->msg);
518 case APPLE_RTKIT_EP_OSLOG:
519 apple_rtkit_oslog_rx(rtk, rtk_work->msg);
521 case APPLE_RTKIT_APP_ENDPOINT_START ... 0xff:
522 if (rtk->ops->recv_message)
523 rtk->ops->recv_message(rtk->cookie, rtk_work->ep,
528 "Received unexpected message to EP%02d: %llx\n",
529 rtk_work->ep, rtk_work->msg);
533 "RTKit: message to unknown endpoint %02x: %llx\n",
534 rtk_work->ep, rtk_work->msg);
540 static void apple_rtkit_rx(struct mbox_client *cl, void *mssg)
542 struct apple_rtkit *rtk = container_of(cl, struct apple_rtkit, mbox_cl);
543 struct apple_mbox_msg *msg = mssg;
544 struct apple_rtkit_rx_work *work;
548 * The message was read from a MMIO FIFO and we have to make
549 * sure all reads from buffers sent with that message happen
554 if (!test_bit(ep, rtk->endpoints))
556 "RTKit: Message to undiscovered endpoint 0x%02x\n",
559 if (ep >= APPLE_RTKIT_APP_ENDPOINT_START &&
560 rtk->ops->recv_message_early &&
561 rtk->ops->recv_message_early(rtk->cookie, ep, msg->msg0))
564 work = kzalloc(sizeof(*work), GFP_ATOMIC);
570 work->msg = msg->msg0;
571 INIT_WORK(&work->work, apple_rtkit_rx_work);
572 queue_work(rtk->wq, &work->work);
575 static void apple_rtkit_tx_done(struct mbox_client *cl, void *mssg, int r)
577 struct apple_rtkit_msg *msg =
578 container_of(mssg, struct apple_rtkit_msg, mbox_msg);
584 complete(msg->completion);
588 int apple_rtkit_send_message(struct apple_rtkit *rtk, u8 ep, u64 message,
589 struct completion *completion, bool atomic)
591 struct apple_rtkit_msg *msg;
597 if (ep >= APPLE_RTKIT_APP_ENDPOINT_START &&
598 !apple_rtkit_is_running(rtk))
606 msg = kzalloc(sizeof(*msg), flags);
610 msg->mbox_msg.msg0 = message;
611 msg->mbox_msg.msg1 = ep;
612 msg->completion = completion;
615 * The message will be sent with a MMIO write. We need the barrier
616 * here to ensure any previous writes to buffers are visible to the
617 * device before that MMIO write happens.
621 ret = mbox_send_message(rtk->mbox_chan, &msg->mbox_msg);
629 EXPORT_SYMBOL_GPL(apple_rtkit_send_message);
631 int apple_rtkit_send_message_wait(struct apple_rtkit *rtk, u8 ep, u64 message,
632 unsigned long timeout, bool atomic)
634 DECLARE_COMPLETION_ONSTACK(completion);
638 ret = apple_rtkit_send_message(rtk, ep, message, &completion, atomic);
643 ret = mbox_flush(rtk->mbox_chan, timeout);
647 if (try_wait_for_completion(&completion))
652 t = wait_for_completion_interruptible_timeout(
653 &completion, msecs_to_jiffies(timeout));
661 EXPORT_SYMBOL_GPL(apple_rtkit_send_message_wait);
663 int apple_rtkit_start_ep(struct apple_rtkit *rtk, u8 endpoint)
667 if (!test_bit(endpoint, rtk->endpoints))
669 if (endpoint >= APPLE_RTKIT_APP_ENDPOINT_START &&
670 !apple_rtkit_is_running(rtk))
673 msg = FIELD_PREP(APPLE_RTKIT_MGMT_STARTEP_EP, endpoint);
674 msg |= APPLE_RTKIT_MGMT_STARTEP_FLAG;
675 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_STARTEP, msg);
679 EXPORT_SYMBOL_GPL(apple_rtkit_start_ep);
681 static int apple_rtkit_request_mbox_chan(struct apple_rtkit *rtk)
684 rtk->mbox_chan = mbox_request_channel_byname(&rtk->mbox_cl,
688 mbox_request_channel(&rtk->mbox_cl, rtk->mbox_idx);
690 if (IS_ERR(rtk->mbox_chan))
691 return PTR_ERR(rtk->mbox_chan);
695 static struct apple_rtkit *apple_rtkit_init(struct device *dev, void *cookie,
696 const char *mbox_name, int mbox_idx,
697 const struct apple_rtkit_ops *ops)
699 struct apple_rtkit *rtk;
703 return ERR_PTR(-EINVAL);
705 rtk = kzalloc(sizeof(*rtk), GFP_KERNEL);
707 return ERR_PTR(-ENOMEM);
710 rtk->cookie = cookie;
713 init_completion(&rtk->epmap_completion);
714 init_completion(&rtk->iop_pwr_ack_completion);
715 init_completion(&rtk->ap_pwr_ack_completion);
717 bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS);
718 set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints);
720 rtk->mbox_name = mbox_name;
721 rtk->mbox_idx = mbox_idx;
722 rtk->mbox_cl.dev = dev;
723 rtk->mbox_cl.tx_block = false;
724 rtk->mbox_cl.knows_txdone = false;
725 rtk->mbox_cl.rx_callback = &apple_rtkit_rx;
726 rtk->mbox_cl.tx_done = &apple_rtkit_tx_done;
728 rtk->wq = alloc_ordered_workqueue("rtkit-%s", WQ_MEM_RECLAIM,
735 ret = apple_rtkit_request_mbox_chan(rtk);
742 destroy_workqueue(rtk->wq);
748 static int apple_rtkit_wait_for_completion(struct completion *c)
752 t = wait_for_completion_interruptible_timeout(c,
753 msecs_to_jiffies(1000));
762 int apple_rtkit_reinit(struct apple_rtkit *rtk)
764 /* make sure we don't handle any messages while reinitializing */
765 mbox_free_channel(rtk->mbox_chan);
766 flush_workqueue(rtk->wq);
768 apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer);
769 apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer);
770 apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer);
772 kfree(rtk->syslog_msg_buffer);
774 rtk->syslog_msg_buffer = NULL;
775 rtk->syslog_n_entries = 0;
776 rtk->syslog_msg_size = 0;
778 bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS);
779 set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints);
781 reinit_completion(&rtk->epmap_completion);
782 reinit_completion(&rtk->iop_pwr_ack_completion);
783 reinit_completion(&rtk->ap_pwr_ack_completion);
785 rtk->crashed = false;
786 rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_OFF;
787 rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_OFF;
789 return apple_rtkit_request_mbox_chan(rtk);
791 EXPORT_SYMBOL_GPL(apple_rtkit_reinit);
793 static int apple_rtkit_set_ap_power_state(struct apple_rtkit *rtk,
799 reinit_completion(&rtk->ap_pwr_ack_completion);
801 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state);
802 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_AP_PWR_STATE,
805 ret = apple_rtkit_wait_for_completion(&rtk->ap_pwr_ack_completion);
809 if (rtk->ap_power_state != state)
814 static int apple_rtkit_set_iop_power_state(struct apple_rtkit *rtk,
820 reinit_completion(&rtk->iop_pwr_ack_completion);
822 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state);
823 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE,
826 ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion);
830 if (rtk->iop_power_state != state)
835 int apple_rtkit_boot(struct apple_rtkit *rtk)
839 if (apple_rtkit_is_running(rtk))
844 dev_dbg(rtk->dev, "RTKit: waiting for boot to finish\n");
845 ret = apple_rtkit_wait_for_completion(&rtk->epmap_completion);
848 if (rtk->boot_result)
849 return rtk->boot_result;
851 dev_dbg(rtk->dev, "RTKit: waiting for IOP power state ACK\n");
852 ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion);
856 return apple_rtkit_set_ap_power_state(rtk, APPLE_RTKIT_PWR_STATE_ON);
858 EXPORT_SYMBOL_GPL(apple_rtkit_boot);
860 int apple_rtkit_shutdown(struct apple_rtkit *rtk)
864 /* if OFF is used here the co-processor will not wake up again */
865 ret = apple_rtkit_set_ap_power_state(rtk,
866 APPLE_RTKIT_PWR_STATE_QUIESCED);
870 ret = apple_rtkit_set_iop_power_state(rtk, APPLE_RTKIT_PWR_STATE_SLEEP);
874 return apple_rtkit_reinit(rtk);
876 EXPORT_SYMBOL_GPL(apple_rtkit_shutdown);
878 int apple_rtkit_quiesce(struct apple_rtkit *rtk)
882 ret = apple_rtkit_set_ap_power_state(rtk,
883 APPLE_RTKIT_PWR_STATE_QUIESCED);
887 ret = apple_rtkit_set_iop_power_state(rtk,
888 APPLE_RTKIT_PWR_STATE_QUIESCED);
892 ret = apple_rtkit_reinit(rtk);
896 rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED;
897 rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED;
900 EXPORT_SYMBOL_GPL(apple_rtkit_quiesce);
902 int apple_rtkit_wake(struct apple_rtkit *rtk)
906 if (apple_rtkit_is_running(rtk))
909 reinit_completion(&rtk->iop_pwr_ack_completion);
912 * Use open-coded apple_rtkit_set_iop_power_state since apple_rtkit_boot
913 * will wait for the completion anyway.
915 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, APPLE_RTKIT_PWR_STATE_ON);
916 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE,
919 return apple_rtkit_boot(rtk);
921 EXPORT_SYMBOL_GPL(apple_rtkit_wake);
923 static void apple_rtkit_free(struct apple_rtkit *rtk)
925 mbox_free_channel(rtk->mbox_chan);
926 destroy_workqueue(rtk->wq);
928 apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer);
929 apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer);
930 apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer);
932 kfree(rtk->syslog_msg_buffer);
936 struct apple_rtkit *devm_apple_rtkit_init(struct device *dev, void *cookie,
937 const char *mbox_name, int mbox_idx,
938 const struct apple_rtkit_ops *ops)
940 struct apple_rtkit *rtk;
943 rtk = apple_rtkit_init(dev, cookie, mbox_name, mbox_idx, ops);
947 ret = devm_add_action_or_reset(dev, (void (*)(void *))apple_rtkit_free,
954 EXPORT_SYMBOL_GPL(devm_apple_rtkit_init);
956 MODULE_LICENSE("Dual MIT/GPL");
957 MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>");
958 MODULE_DESCRIPTION("Apple RTKit driver");