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