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