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