1 // SPDX-License-Identifier: GPL-2.0-only OR MIT 2 /* 3 * Apple RTKit IPC library 4 * Copyright (C) The Asahi Linux Contributors 5 */ 6 7 #include "rtkit-internal.h" 8 9 enum { 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_IDLE = 0x201, /* sleeping, retain state */ 13 APPLE_RTKIT_PWR_STATE_QUIESCED = 0x10, /* running but no communication */ 14 APPLE_RTKIT_PWR_STATE_ON = 0x20, /* normal operating state */ 15 }; 16 17 enum { 18 APPLE_RTKIT_EP_MGMT = 0, 19 APPLE_RTKIT_EP_CRASHLOG = 1, 20 APPLE_RTKIT_EP_SYSLOG = 2, 21 APPLE_RTKIT_EP_DEBUG = 3, 22 APPLE_RTKIT_EP_IOREPORT = 4, 23 APPLE_RTKIT_EP_OSLOG = 8, 24 }; 25 26 #define APPLE_RTKIT_MGMT_TYPE GENMASK_ULL(59, 52) 27 28 enum { 29 APPLE_RTKIT_MGMT_HELLO = 1, 30 APPLE_RTKIT_MGMT_HELLO_REPLY = 2, 31 APPLE_RTKIT_MGMT_STARTEP = 5, 32 APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE = 6, 33 APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK = 7, 34 APPLE_RTKIT_MGMT_EPMAP = 8, 35 APPLE_RTKIT_MGMT_EPMAP_REPLY = 8, 36 APPLE_RTKIT_MGMT_SET_AP_PWR_STATE = 0xb, 37 APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK = 0xb, 38 }; 39 40 #define APPLE_RTKIT_MGMT_HELLO_MINVER GENMASK_ULL(15, 0) 41 #define APPLE_RTKIT_MGMT_HELLO_MAXVER GENMASK_ULL(31, 16) 42 43 #define APPLE_RTKIT_MGMT_EPMAP_LAST BIT_ULL(51) 44 #define APPLE_RTKIT_MGMT_EPMAP_BASE GENMASK_ULL(34, 32) 45 #define APPLE_RTKIT_MGMT_EPMAP_BITMAP GENMASK_ULL(31, 0) 46 47 #define APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE BIT_ULL(0) 48 49 #define APPLE_RTKIT_MGMT_STARTEP_EP GENMASK_ULL(39, 32) 50 #define APPLE_RTKIT_MGMT_STARTEP_FLAG BIT_ULL(1) 51 52 #define APPLE_RTKIT_MGMT_PWR_STATE GENMASK_ULL(15, 0) 53 54 #define APPLE_RTKIT_CRASHLOG_CRASH 1 55 56 #define APPLE_RTKIT_BUFFER_REQUEST 1 57 #define APPLE_RTKIT_BUFFER_REQUEST_SIZE GENMASK_ULL(51, 44) 58 #define APPLE_RTKIT_BUFFER_REQUEST_IOVA GENMASK_ULL(43, 0) 59 60 #define APPLE_RTKIT_SYSLOG_TYPE GENMASK_ULL(59, 52) 61 62 #define APPLE_RTKIT_SYSLOG_LOG 5 63 64 #define APPLE_RTKIT_SYSLOG_INIT 8 65 #define APPLE_RTKIT_SYSLOG_N_ENTRIES GENMASK_ULL(7, 0) 66 #define APPLE_RTKIT_SYSLOG_MSG_SIZE GENMASK_ULL(31, 24) 67 68 #define APPLE_RTKIT_OSLOG_TYPE GENMASK_ULL(63, 56) 69 #define APPLE_RTKIT_OSLOG_INIT 1 70 #define APPLE_RTKIT_OSLOG_ACK 3 71 72 #define APPLE_RTKIT_MIN_SUPPORTED_VERSION 11 73 #define APPLE_RTKIT_MAX_SUPPORTED_VERSION 12 74 75 struct apple_rtkit_rx_work { 76 struct apple_rtkit *rtk; 77 u8 ep; 78 u64 msg; 79 struct work_struct work; 80 }; 81 82 bool apple_rtkit_is_running(struct apple_rtkit *rtk) 83 { 84 if (rtk->crashed) 85 return false; 86 if ((rtk->iop_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON) 87 return false; 88 if ((rtk->ap_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON) 89 return false; 90 return true; 91 } 92 EXPORT_SYMBOL_GPL(apple_rtkit_is_running); 93 94 bool apple_rtkit_is_crashed(struct apple_rtkit *rtk) 95 { 96 return rtk->crashed; 97 } 98 EXPORT_SYMBOL_GPL(apple_rtkit_is_crashed); 99 100 static void apple_rtkit_management_send(struct apple_rtkit *rtk, u8 type, 101 u64 msg) 102 { 103 msg &= ~APPLE_RTKIT_MGMT_TYPE; 104 msg |= FIELD_PREP(APPLE_RTKIT_MGMT_TYPE, type); 105 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_MGMT, msg, NULL, false); 106 } 107 108 static void apple_rtkit_management_rx_hello(struct apple_rtkit *rtk, u64 msg) 109 { 110 u64 reply; 111 112 int min_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MINVER, msg); 113 int max_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MAXVER, msg); 114 int want_ver = min(APPLE_RTKIT_MAX_SUPPORTED_VERSION, max_ver); 115 116 dev_dbg(rtk->dev, "RTKit: Min ver %d, max ver %d\n", min_ver, max_ver); 117 118 if (min_ver > APPLE_RTKIT_MAX_SUPPORTED_VERSION) { 119 dev_err(rtk->dev, "RTKit: Firmware min version %d is too new\n", 120 min_ver); 121 goto abort_boot; 122 } 123 124 if (max_ver < APPLE_RTKIT_MIN_SUPPORTED_VERSION) { 125 dev_err(rtk->dev, "RTKit: Firmware max version %d is too old\n", 126 max_ver); 127 goto abort_boot; 128 } 129 130 dev_info(rtk->dev, "RTKit: Initializing (protocol version %d)\n", 131 want_ver); 132 rtk->version = want_ver; 133 134 reply = FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MINVER, want_ver); 135 reply |= FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MAXVER, want_ver); 136 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_HELLO_REPLY, reply); 137 138 return; 139 140 abort_boot: 141 rtk->boot_result = -EINVAL; 142 complete_all(&rtk->epmap_completion); 143 } 144 145 static void apple_rtkit_management_rx_epmap(struct apple_rtkit *rtk, u64 msg) 146 { 147 int i, ep; 148 u64 reply; 149 unsigned long bitmap = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BITMAP, msg); 150 u32 base = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BASE, msg); 151 152 dev_dbg(rtk->dev, 153 "RTKit: received endpoint bitmap 0x%lx with base 0x%x\n", 154 bitmap, base); 155 156 for_each_set_bit(i, &bitmap, 32) { 157 ep = 32 * base + i; 158 dev_dbg(rtk->dev, "RTKit: Discovered endpoint 0x%02x\n", ep); 159 set_bit(ep, rtk->endpoints); 160 } 161 162 reply = FIELD_PREP(APPLE_RTKIT_MGMT_EPMAP_BASE, base); 163 if (msg & APPLE_RTKIT_MGMT_EPMAP_LAST) 164 reply |= APPLE_RTKIT_MGMT_EPMAP_LAST; 165 else 166 reply |= APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE; 167 168 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_EPMAP_REPLY, reply); 169 170 if (!(msg & APPLE_RTKIT_MGMT_EPMAP_LAST)) 171 return; 172 173 for_each_set_bit(ep, rtk->endpoints, APPLE_RTKIT_APP_ENDPOINT_START) { 174 switch (ep) { 175 /* the management endpoint is started by default */ 176 case APPLE_RTKIT_EP_MGMT: 177 break; 178 179 /* without starting these RTKit refuses to boot */ 180 case APPLE_RTKIT_EP_SYSLOG: 181 case APPLE_RTKIT_EP_CRASHLOG: 182 case APPLE_RTKIT_EP_DEBUG: 183 case APPLE_RTKIT_EP_IOREPORT: 184 case APPLE_RTKIT_EP_OSLOG: 185 dev_dbg(rtk->dev, 186 "RTKit: Starting system endpoint 0x%02x\n", ep); 187 apple_rtkit_start_ep(rtk, ep); 188 break; 189 190 default: 191 dev_warn(rtk->dev, 192 "RTKit: Unknown system endpoint: 0x%02x\n", 193 ep); 194 } 195 } 196 197 rtk->boot_result = 0; 198 complete_all(&rtk->epmap_completion); 199 } 200 201 static void apple_rtkit_management_rx_iop_pwr_ack(struct apple_rtkit *rtk, 202 u64 msg) 203 { 204 unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg); 205 206 dev_dbg(rtk->dev, "RTKit: IOP power state transition: 0x%x -> 0x%x\n", 207 rtk->iop_power_state, new_state); 208 rtk->iop_power_state = new_state; 209 210 complete_all(&rtk->iop_pwr_ack_completion); 211 } 212 213 static void apple_rtkit_management_rx_ap_pwr_ack(struct apple_rtkit *rtk, 214 u64 msg) 215 { 216 unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg); 217 218 dev_dbg(rtk->dev, "RTKit: AP power state transition: 0x%x -> 0x%x\n", 219 rtk->ap_power_state, new_state); 220 rtk->ap_power_state = new_state; 221 222 complete_all(&rtk->ap_pwr_ack_completion); 223 } 224 225 static void apple_rtkit_management_rx(struct apple_rtkit *rtk, u64 msg) 226 { 227 u8 type = FIELD_GET(APPLE_RTKIT_MGMT_TYPE, msg); 228 229 switch (type) { 230 case APPLE_RTKIT_MGMT_HELLO: 231 apple_rtkit_management_rx_hello(rtk, msg); 232 break; 233 case APPLE_RTKIT_MGMT_EPMAP: 234 apple_rtkit_management_rx_epmap(rtk, msg); 235 break; 236 case APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK: 237 apple_rtkit_management_rx_iop_pwr_ack(rtk, msg); 238 break; 239 case APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK: 240 apple_rtkit_management_rx_ap_pwr_ack(rtk, msg); 241 break; 242 default: 243 dev_warn( 244 rtk->dev, 245 "RTKit: unknown management message: 0x%llx (type: 0x%02x)\n", 246 msg, type); 247 } 248 } 249 250 static int apple_rtkit_common_rx_get_buffer(struct apple_rtkit *rtk, 251 struct apple_rtkit_shmem *buffer, 252 u8 ep, u64 msg) 253 { 254 size_t n_4kpages = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_SIZE, msg); 255 u64 reply; 256 int err; 257 258 buffer->buffer = NULL; 259 buffer->iomem = NULL; 260 buffer->is_mapped = false; 261 buffer->iova = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_IOVA, msg); 262 buffer->size = n_4kpages << 12; 263 264 dev_dbg(rtk->dev, "RTKit: buffer request for 0x%zx bytes at %pad\n", 265 buffer->size, &buffer->iova); 266 267 if (buffer->iova && 268 (!rtk->ops->shmem_setup || !rtk->ops->shmem_destroy)) { 269 err = -EINVAL; 270 goto error; 271 } 272 273 if (rtk->ops->shmem_setup) { 274 err = rtk->ops->shmem_setup(rtk->cookie, buffer); 275 if (err) 276 goto error; 277 } else { 278 buffer->buffer = dma_alloc_coherent(rtk->dev, buffer->size, 279 &buffer->iova, GFP_KERNEL); 280 if (!buffer->buffer) { 281 err = -ENOMEM; 282 goto error; 283 } 284 } 285 286 if (!buffer->is_mapped) { 287 reply = FIELD_PREP(APPLE_RTKIT_SYSLOG_TYPE, 288 APPLE_RTKIT_BUFFER_REQUEST); 289 reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_SIZE, n_4kpages); 290 reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_IOVA, 291 buffer->iova); 292 apple_rtkit_send_message(rtk, ep, reply, NULL, false); 293 } 294 295 return 0; 296 297 error: 298 buffer->buffer = NULL; 299 buffer->iomem = NULL; 300 buffer->iova = 0; 301 buffer->size = 0; 302 buffer->is_mapped = false; 303 return err; 304 } 305 306 static void apple_rtkit_free_buffer(struct apple_rtkit *rtk, 307 struct apple_rtkit_shmem *bfr) 308 { 309 if (bfr->size == 0) 310 return; 311 312 if (rtk->ops->shmem_destroy) 313 rtk->ops->shmem_destroy(rtk->cookie, bfr); 314 else if (bfr->buffer) 315 dma_free_coherent(rtk->dev, bfr->size, bfr->buffer, bfr->iova); 316 317 bfr->buffer = NULL; 318 bfr->iomem = NULL; 319 bfr->iova = 0; 320 bfr->size = 0; 321 bfr->is_mapped = false; 322 } 323 324 static void apple_rtkit_memcpy(struct apple_rtkit *rtk, void *dst, 325 struct apple_rtkit_shmem *bfr, size_t offset, 326 size_t len) 327 { 328 if (bfr->iomem) 329 memcpy_fromio(dst, bfr->iomem + offset, len); 330 else 331 memcpy(dst, bfr->buffer + offset, len); 332 } 333 334 static void apple_rtkit_crashlog_rx(struct apple_rtkit *rtk, u64 msg) 335 { 336 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg); 337 u8 *bfr; 338 339 if (type != APPLE_RTKIT_CRASHLOG_CRASH) { 340 dev_warn(rtk->dev, "RTKit: Unknown crashlog message: %llx\n", 341 msg); 342 return; 343 } 344 345 if (!rtk->crashlog_buffer.size) { 346 apple_rtkit_common_rx_get_buffer(rtk, &rtk->crashlog_buffer, 347 APPLE_RTKIT_EP_CRASHLOG, msg); 348 return; 349 } 350 351 dev_err(rtk->dev, "RTKit: co-processor has crashed\n"); 352 353 /* 354 * create a shadow copy here to make sure the co-processor isn't able 355 * to change the log while we're dumping it. this also ensures 356 * the buffer is in normal memory and not iomem for e.g. the SMC 357 */ 358 bfr = kzalloc(rtk->crashlog_buffer.size, GFP_KERNEL); 359 if (bfr) { 360 apple_rtkit_memcpy(rtk, bfr, &rtk->crashlog_buffer, 0, 361 rtk->crashlog_buffer.size); 362 apple_rtkit_crashlog_dump(rtk, bfr, rtk->crashlog_buffer.size); 363 kfree(bfr); 364 } else { 365 dev_err(rtk->dev, 366 "RTKit: Couldn't allocate crashlog shadow buffer\n"); 367 } 368 369 rtk->crashed = true; 370 if (rtk->ops->crashed) 371 rtk->ops->crashed(rtk->cookie); 372 } 373 374 static void apple_rtkit_ioreport_rx(struct apple_rtkit *rtk, u64 msg) 375 { 376 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg); 377 378 switch (type) { 379 case APPLE_RTKIT_BUFFER_REQUEST: 380 apple_rtkit_common_rx_get_buffer(rtk, &rtk->ioreport_buffer, 381 APPLE_RTKIT_EP_IOREPORT, msg); 382 break; 383 /* unknown, must be ACKed or the co-processor will hang */ 384 case 0x8: 385 case 0xc: 386 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_IOREPORT, msg, 387 NULL, false); 388 break; 389 default: 390 dev_warn(rtk->dev, "RTKit: Unknown ioreport message: %llx\n", 391 msg); 392 } 393 } 394 395 static void apple_rtkit_syslog_rx_init(struct apple_rtkit *rtk, u64 msg) 396 { 397 rtk->syslog_n_entries = FIELD_GET(APPLE_RTKIT_SYSLOG_N_ENTRIES, msg); 398 rtk->syslog_msg_size = FIELD_GET(APPLE_RTKIT_SYSLOG_MSG_SIZE, msg); 399 400 rtk->syslog_msg_buffer = kzalloc(rtk->syslog_msg_size, GFP_KERNEL); 401 402 dev_dbg(rtk->dev, 403 "RTKit: syslog initialized: entries: %zd, msg_size: %zd\n", 404 rtk->syslog_n_entries, rtk->syslog_msg_size); 405 } 406 407 static bool should_crop_syslog_char(char c) 408 { 409 return c == '\n' || c == '\r' || c == ' ' || c == '\0'; 410 } 411 412 static void apple_rtkit_syslog_rx_log(struct apple_rtkit *rtk, u64 msg) 413 { 414 u8 idx = msg & 0xff; 415 char log_context[24]; 416 size_t entry_size = 0x20 + rtk->syslog_msg_size; 417 int msglen; 418 419 if (!rtk->syslog_msg_buffer) { 420 dev_warn( 421 rtk->dev, 422 "RTKit: received syslog message but no syslog_msg_buffer\n"); 423 goto done; 424 } 425 if (!rtk->syslog_buffer.size) { 426 dev_warn( 427 rtk->dev, 428 "RTKit: received syslog message but syslog_buffer.size is zero\n"); 429 goto done; 430 } 431 if (!rtk->syslog_buffer.buffer && !rtk->syslog_buffer.iomem) { 432 dev_warn( 433 rtk->dev, 434 "RTKit: received syslog message but no syslog_buffer.buffer or syslog_buffer.iomem\n"); 435 goto done; 436 } 437 if (idx > rtk->syslog_n_entries) { 438 dev_warn(rtk->dev, "RTKit: syslog index %d out of range\n", 439 idx); 440 goto done; 441 } 442 443 apple_rtkit_memcpy(rtk, log_context, &rtk->syslog_buffer, 444 idx * entry_size + 8, sizeof(log_context)); 445 apple_rtkit_memcpy(rtk, rtk->syslog_msg_buffer, &rtk->syslog_buffer, 446 idx * entry_size + 8 + sizeof(log_context), 447 rtk->syslog_msg_size); 448 449 log_context[sizeof(log_context) - 1] = 0; 450 451 msglen = rtk->syslog_msg_size - 1; 452 while (msglen > 0 && 453 should_crop_syslog_char(rtk->syslog_msg_buffer[msglen - 1])) 454 msglen--; 455 456 rtk->syslog_msg_buffer[msglen] = 0; 457 dev_info(rtk->dev, "RTKit: syslog message: %s: %s\n", log_context, 458 rtk->syslog_msg_buffer); 459 460 done: 461 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_SYSLOG, msg, NULL, false); 462 } 463 464 static void apple_rtkit_syslog_rx(struct apple_rtkit *rtk, u64 msg) 465 { 466 u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg); 467 468 switch (type) { 469 case APPLE_RTKIT_BUFFER_REQUEST: 470 apple_rtkit_common_rx_get_buffer(rtk, &rtk->syslog_buffer, 471 APPLE_RTKIT_EP_SYSLOG, msg); 472 break; 473 case APPLE_RTKIT_SYSLOG_INIT: 474 apple_rtkit_syslog_rx_init(rtk, msg); 475 break; 476 case APPLE_RTKIT_SYSLOG_LOG: 477 apple_rtkit_syslog_rx_log(rtk, msg); 478 break; 479 default: 480 dev_warn(rtk->dev, "RTKit: Unknown syslog message: %llx\n", 481 msg); 482 } 483 } 484 485 static void apple_rtkit_oslog_rx_init(struct apple_rtkit *rtk, u64 msg) 486 { 487 u64 ack; 488 489 dev_dbg(rtk->dev, "RTKit: oslog init: msg: 0x%llx\n", msg); 490 ack = FIELD_PREP(APPLE_RTKIT_OSLOG_TYPE, APPLE_RTKIT_OSLOG_ACK); 491 apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_OSLOG, ack, NULL, false); 492 } 493 494 static void apple_rtkit_oslog_rx(struct apple_rtkit *rtk, u64 msg) 495 { 496 u8 type = FIELD_GET(APPLE_RTKIT_OSLOG_TYPE, msg); 497 498 switch (type) { 499 case APPLE_RTKIT_OSLOG_INIT: 500 apple_rtkit_oslog_rx_init(rtk, msg); 501 break; 502 default: 503 dev_warn(rtk->dev, "RTKit: Unknown oslog message: %llx\n", msg); 504 } 505 } 506 507 static void apple_rtkit_rx_work(struct work_struct *work) 508 { 509 struct apple_rtkit_rx_work *rtk_work = 510 container_of(work, struct apple_rtkit_rx_work, work); 511 struct apple_rtkit *rtk = rtk_work->rtk; 512 513 switch (rtk_work->ep) { 514 case APPLE_RTKIT_EP_MGMT: 515 apple_rtkit_management_rx(rtk, rtk_work->msg); 516 break; 517 case APPLE_RTKIT_EP_CRASHLOG: 518 apple_rtkit_crashlog_rx(rtk, rtk_work->msg); 519 break; 520 case APPLE_RTKIT_EP_SYSLOG: 521 apple_rtkit_syslog_rx(rtk, rtk_work->msg); 522 break; 523 case APPLE_RTKIT_EP_IOREPORT: 524 apple_rtkit_ioreport_rx(rtk, rtk_work->msg); 525 break; 526 case APPLE_RTKIT_EP_OSLOG: 527 apple_rtkit_oslog_rx(rtk, rtk_work->msg); 528 break; 529 case APPLE_RTKIT_APP_ENDPOINT_START ... 0xff: 530 if (rtk->ops->recv_message) 531 rtk->ops->recv_message(rtk->cookie, rtk_work->ep, 532 rtk_work->msg); 533 else 534 dev_warn( 535 rtk->dev, 536 "Received unexpected message to EP%02d: %llx\n", 537 rtk_work->ep, rtk_work->msg); 538 break; 539 default: 540 dev_warn(rtk->dev, 541 "RTKit: message to unknown endpoint %02x: %llx\n", 542 rtk_work->ep, rtk_work->msg); 543 } 544 545 kfree(rtk_work); 546 } 547 548 static void apple_rtkit_rx(struct apple_mbox *mbox, struct apple_mbox_msg msg, 549 void *cookie) 550 { 551 struct apple_rtkit *rtk = cookie; 552 struct apple_rtkit_rx_work *work; 553 u8 ep = msg.msg1; 554 555 /* 556 * The message was read from a MMIO FIFO and we have to make 557 * sure all reads from buffers sent with that message happen 558 * afterwards. 559 */ 560 dma_rmb(); 561 562 if (!test_bit(ep, rtk->endpoints)) 563 dev_warn(rtk->dev, 564 "RTKit: Message to undiscovered endpoint 0x%02x\n", 565 ep); 566 567 if (ep >= APPLE_RTKIT_APP_ENDPOINT_START && 568 rtk->ops->recv_message_early && 569 rtk->ops->recv_message_early(rtk->cookie, ep, msg.msg0)) 570 return; 571 572 work = kzalloc(sizeof(*work), GFP_ATOMIC); 573 if (!work) 574 return; 575 576 work->rtk = rtk; 577 work->ep = ep; 578 work->msg = msg.msg0; 579 INIT_WORK(&work->work, apple_rtkit_rx_work); 580 queue_work(rtk->wq, &work->work); 581 } 582 583 int apple_rtkit_send_message(struct apple_rtkit *rtk, u8 ep, u64 message, 584 struct completion *completion, bool atomic) 585 { 586 struct apple_mbox_msg msg = { 587 .msg0 = message, 588 .msg1 = ep, 589 }; 590 591 if (rtk->crashed) 592 return -EINVAL; 593 if (ep >= APPLE_RTKIT_APP_ENDPOINT_START && 594 !apple_rtkit_is_running(rtk)) 595 return -EINVAL; 596 597 /* 598 * The message will be sent with a MMIO write. We need the barrier 599 * here to ensure any previous writes to buffers are visible to the 600 * device before that MMIO write happens. 601 */ 602 dma_wmb(); 603 604 return apple_mbox_send(rtk->mbox, msg, atomic); 605 } 606 EXPORT_SYMBOL_GPL(apple_rtkit_send_message); 607 608 int apple_rtkit_poll(struct apple_rtkit *rtk) 609 { 610 return apple_mbox_poll(rtk->mbox); 611 } 612 EXPORT_SYMBOL_GPL(apple_rtkit_poll); 613 614 int apple_rtkit_start_ep(struct apple_rtkit *rtk, u8 endpoint) 615 { 616 u64 msg; 617 618 if (!test_bit(endpoint, rtk->endpoints)) 619 return -EINVAL; 620 if (endpoint >= APPLE_RTKIT_APP_ENDPOINT_START && 621 !apple_rtkit_is_running(rtk)) 622 return -EINVAL; 623 624 msg = FIELD_PREP(APPLE_RTKIT_MGMT_STARTEP_EP, endpoint); 625 msg |= APPLE_RTKIT_MGMT_STARTEP_FLAG; 626 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_STARTEP, msg); 627 628 return 0; 629 } 630 EXPORT_SYMBOL_GPL(apple_rtkit_start_ep); 631 632 struct apple_rtkit *apple_rtkit_init(struct device *dev, void *cookie, 633 const char *mbox_name, int mbox_idx, 634 const struct apple_rtkit_ops *ops) 635 { 636 struct apple_rtkit *rtk; 637 int ret; 638 639 if (!ops) 640 return ERR_PTR(-EINVAL); 641 642 rtk = kzalloc(sizeof(*rtk), GFP_KERNEL); 643 if (!rtk) 644 return ERR_PTR(-ENOMEM); 645 646 rtk->dev = dev; 647 rtk->cookie = cookie; 648 rtk->ops = ops; 649 650 init_completion(&rtk->epmap_completion); 651 init_completion(&rtk->iop_pwr_ack_completion); 652 init_completion(&rtk->ap_pwr_ack_completion); 653 654 bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS); 655 set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints); 656 657 if (mbox_name) 658 rtk->mbox = apple_mbox_get_byname(dev, mbox_name); 659 else 660 rtk->mbox = apple_mbox_get(dev, mbox_idx); 661 662 if (IS_ERR(rtk->mbox)) { 663 ret = PTR_ERR(rtk->mbox); 664 goto free_rtk; 665 } 666 667 rtk->mbox->rx = apple_rtkit_rx; 668 rtk->mbox->cookie = rtk; 669 670 rtk->wq = alloc_ordered_workqueue("rtkit-%s", WQ_MEM_RECLAIM, 671 dev_name(rtk->dev)); 672 if (!rtk->wq) { 673 ret = -ENOMEM; 674 goto free_rtk; 675 } 676 677 ret = apple_mbox_start(rtk->mbox); 678 if (ret) 679 goto destroy_wq; 680 681 return rtk; 682 683 destroy_wq: 684 destroy_workqueue(rtk->wq); 685 free_rtk: 686 kfree(rtk); 687 return ERR_PTR(ret); 688 } 689 EXPORT_SYMBOL_GPL(apple_rtkit_init); 690 691 static int apple_rtkit_wait_for_completion(struct completion *c) 692 { 693 long t; 694 695 t = wait_for_completion_interruptible_timeout(c, 696 msecs_to_jiffies(1000)); 697 if (t < 0) 698 return t; 699 else if (t == 0) 700 return -ETIME; 701 else 702 return 0; 703 } 704 705 int apple_rtkit_reinit(struct apple_rtkit *rtk) 706 { 707 /* make sure we don't handle any messages while reinitializing */ 708 apple_mbox_stop(rtk->mbox); 709 flush_workqueue(rtk->wq); 710 711 apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer); 712 apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer); 713 apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer); 714 715 kfree(rtk->syslog_msg_buffer); 716 717 rtk->syslog_msg_buffer = NULL; 718 rtk->syslog_n_entries = 0; 719 rtk->syslog_msg_size = 0; 720 721 bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS); 722 set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints); 723 724 reinit_completion(&rtk->epmap_completion); 725 reinit_completion(&rtk->iop_pwr_ack_completion); 726 reinit_completion(&rtk->ap_pwr_ack_completion); 727 728 rtk->crashed = false; 729 rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_OFF; 730 rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_OFF; 731 732 return apple_mbox_start(rtk->mbox); 733 } 734 EXPORT_SYMBOL_GPL(apple_rtkit_reinit); 735 736 static int apple_rtkit_set_ap_power_state(struct apple_rtkit *rtk, 737 unsigned int state) 738 { 739 u64 msg; 740 int ret; 741 742 reinit_completion(&rtk->ap_pwr_ack_completion); 743 744 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state); 745 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_AP_PWR_STATE, 746 msg); 747 748 ret = apple_rtkit_wait_for_completion(&rtk->ap_pwr_ack_completion); 749 if (ret) 750 return ret; 751 752 if (rtk->ap_power_state != state) 753 return -EINVAL; 754 return 0; 755 } 756 757 static int apple_rtkit_set_iop_power_state(struct apple_rtkit *rtk, 758 unsigned int state) 759 { 760 u64 msg; 761 int ret; 762 763 reinit_completion(&rtk->iop_pwr_ack_completion); 764 765 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state); 766 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE, 767 msg); 768 769 ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion); 770 if (ret) 771 return ret; 772 773 if (rtk->iop_power_state != state) 774 return -EINVAL; 775 return 0; 776 } 777 778 int apple_rtkit_boot(struct apple_rtkit *rtk) 779 { 780 int ret; 781 782 if (apple_rtkit_is_running(rtk)) 783 return 0; 784 if (rtk->crashed) 785 return -EINVAL; 786 787 dev_dbg(rtk->dev, "RTKit: waiting for boot to finish\n"); 788 ret = apple_rtkit_wait_for_completion(&rtk->epmap_completion); 789 if (ret) 790 return ret; 791 if (rtk->boot_result) 792 return rtk->boot_result; 793 794 dev_dbg(rtk->dev, "RTKit: waiting for IOP power state ACK\n"); 795 ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion); 796 if (ret) 797 return ret; 798 799 return apple_rtkit_set_ap_power_state(rtk, APPLE_RTKIT_PWR_STATE_ON); 800 } 801 EXPORT_SYMBOL_GPL(apple_rtkit_boot); 802 803 int apple_rtkit_shutdown(struct apple_rtkit *rtk) 804 { 805 int ret; 806 807 /* if OFF is used here the co-processor will not wake up again */ 808 ret = apple_rtkit_set_ap_power_state(rtk, 809 APPLE_RTKIT_PWR_STATE_QUIESCED); 810 if (ret) 811 return ret; 812 813 ret = apple_rtkit_set_iop_power_state(rtk, APPLE_RTKIT_PWR_STATE_SLEEP); 814 if (ret) 815 return ret; 816 817 return apple_rtkit_reinit(rtk); 818 } 819 EXPORT_SYMBOL_GPL(apple_rtkit_shutdown); 820 821 int apple_rtkit_idle(struct apple_rtkit *rtk) 822 { 823 int ret; 824 825 /* if OFF is used here the co-processor will not wake up again */ 826 ret = apple_rtkit_set_ap_power_state(rtk, 827 APPLE_RTKIT_PWR_STATE_IDLE); 828 if (ret) 829 return ret; 830 831 ret = apple_rtkit_set_iop_power_state(rtk, APPLE_RTKIT_PWR_STATE_IDLE); 832 if (ret) 833 return ret; 834 835 rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_IDLE; 836 rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_IDLE; 837 return 0; 838 } 839 EXPORT_SYMBOL_GPL(apple_rtkit_idle); 840 841 int apple_rtkit_quiesce(struct apple_rtkit *rtk) 842 { 843 int ret; 844 845 ret = apple_rtkit_set_ap_power_state(rtk, 846 APPLE_RTKIT_PWR_STATE_QUIESCED); 847 if (ret) 848 return ret; 849 850 ret = apple_rtkit_set_iop_power_state(rtk, 851 APPLE_RTKIT_PWR_STATE_QUIESCED); 852 if (ret) 853 return ret; 854 855 ret = apple_rtkit_reinit(rtk); 856 if (ret) 857 return ret; 858 859 rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED; 860 rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED; 861 return 0; 862 } 863 EXPORT_SYMBOL_GPL(apple_rtkit_quiesce); 864 865 int apple_rtkit_wake(struct apple_rtkit *rtk) 866 { 867 u64 msg; 868 869 if (apple_rtkit_is_running(rtk)) 870 return -EINVAL; 871 872 reinit_completion(&rtk->iop_pwr_ack_completion); 873 874 /* 875 * Use open-coded apple_rtkit_set_iop_power_state since apple_rtkit_boot 876 * will wait for the completion anyway. 877 */ 878 msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, APPLE_RTKIT_PWR_STATE_ON); 879 apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE, 880 msg); 881 882 return apple_rtkit_boot(rtk); 883 } 884 EXPORT_SYMBOL_GPL(apple_rtkit_wake); 885 886 void apple_rtkit_free(struct apple_rtkit *rtk) 887 { 888 apple_mbox_stop(rtk->mbox); 889 destroy_workqueue(rtk->wq); 890 891 apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer); 892 apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer); 893 apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer); 894 895 kfree(rtk->syslog_msg_buffer); 896 kfree(rtk); 897 } 898 EXPORT_SYMBOL_GPL(apple_rtkit_free); 899 900 static void apple_rtkit_free_wrapper(void *data) 901 { 902 apple_rtkit_free(data); 903 } 904 905 struct apple_rtkit *devm_apple_rtkit_init(struct device *dev, void *cookie, 906 const char *mbox_name, int mbox_idx, 907 const struct apple_rtkit_ops *ops) 908 { 909 struct apple_rtkit *rtk; 910 int ret; 911 912 rtk = apple_rtkit_init(dev, cookie, mbox_name, mbox_idx, ops); 913 if (IS_ERR(rtk)) 914 return rtk; 915 916 ret = devm_add_action_or_reset(dev, apple_rtkit_free_wrapper, rtk); 917 if (ret) 918 return ERR_PTR(ret); 919 920 return rtk; 921 } 922 EXPORT_SYMBOL_GPL(devm_apple_rtkit_init); 923 924 MODULE_LICENSE("Dual MIT/GPL"); 925 MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>"); 926 MODULE_DESCRIPTION("Apple RTKit driver"); 927