Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only OR MIT
0002 /*
0003  * Apple RTKit IPC library
0004  * Copyright (C) The Asahi Linux Contributors
0005  */
0006 
0007 #include "rtkit-internal.h"
0008 
0009 enum {
0010     APPLE_RTKIT_PWR_STATE_OFF = 0x00, /* power off, cannot be restarted */
0011     APPLE_RTKIT_PWR_STATE_SLEEP = 0x01, /* sleeping, can be restarted */
0012     APPLE_RTKIT_PWR_STATE_QUIESCED = 0x10, /* running but no communication */
0013     APPLE_RTKIT_PWR_STATE_ON = 0x20, /* normal operating state */
0014 };
0015 
0016 enum {
0017     APPLE_RTKIT_EP_MGMT = 0,
0018     APPLE_RTKIT_EP_CRASHLOG = 1,
0019     APPLE_RTKIT_EP_SYSLOG = 2,
0020     APPLE_RTKIT_EP_DEBUG = 3,
0021     APPLE_RTKIT_EP_IOREPORT = 4,
0022     APPLE_RTKIT_EP_OSLOG = 8,
0023 };
0024 
0025 #define APPLE_RTKIT_MGMT_TYPE GENMASK_ULL(59, 52)
0026 
0027 enum {
0028     APPLE_RTKIT_MGMT_HELLO = 1,
0029     APPLE_RTKIT_MGMT_HELLO_REPLY = 2,
0030     APPLE_RTKIT_MGMT_STARTEP = 5,
0031     APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE = 6,
0032     APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK = 7,
0033     APPLE_RTKIT_MGMT_EPMAP = 8,
0034     APPLE_RTKIT_MGMT_EPMAP_REPLY = 8,
0035     APPLE_RTKIT_MGMT_SET_AP_PWR_STATE = 0xb,
0036     APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK = 0xb,
0037 };
0038 
0039 #define APPLE_RTKIT_MGMT_HELLO_MINVER GENMASK_ULL(15, 0)
0040 #define APPLE_RTKIT_MGMT_HELLO_MAXVER GENMASK_ULL(31, 16)
0041 
0042 #define APPLE_RTKIT_MGMT_EPMAP_LAST   BIT_ULL(51)
0043 #define APPLE_RTKIT_MGMT_EPMAP_BASE   GENMASK_ULL(34, 32)
0044 #define APPLE_RTKIT_MGMT_EPMAP_BITMAP GENMASK_ULL(31, 0)
0045 
0046 #define APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE BIT_ULL(0)
0047 
0048 #define APPLE_RTKIT_MGMT_STARTEP_EP   GENMASK_ULL(39, 32)
0049 #define APPLE_RTKIT_MGMT_STARTEP_FLAG BIT_ULL(1)
0050 
0051 #define APPLE_RTKIT_MGMT_PWR_STATE GENMASK_ULL(15, 0)
0052 
0053 #define APPLE_RTKIT_CRASHLOG_CRASH 1
0054 
0055 #define APPLE_RTKIT_BUFFER_REQUEST  1
0056 #define APPLE_RTKIT_BUFFER_REQUEST_SIZE GENMASK_ULL(51, 44)
0057 #define APPLE_RTKIT_BUFFER_REQUEST_IOVA GENMASK_ULL(41, 0)
0058 
0059 #define APPLE_RTKIT_SYSLOG_TYPE GENMASK_ULL(59, 52)
0060 
0061 #define APPLE_RTKIT_SYSLOG_LOG 5
0062 
0063 #define APPLE_RTKIT_SYSLOG_INIT      8
0064 #define APPLE_RTKIT_SYSLOG_N_ENTRIES GENMASK_ULL(7, 0)
0065 #define APPLE_RTKIT_SYSLOG_MSG_SIZE  GENMASK_ULL(31, 24)
0066 
0067 #define APPLE_RTKIT_OSLOG_TYPE GENMASK_ULL(63, 56)
0068 #define APPLE_RTKIT_OSLOG_INIT  1
0069 #define APPLE_RTKIT_OSLOG_ACK   3
0070 
0071 #define APPLE_RTKIT_MIN_SUPPORTED_VERSION 11
0072 #define APPLE_RTKIT_MAX_SUPPORTED_VERSION 12
0073 
0074 struct apple_rtkit_msg {
0075     struct completion *completion;
0076     struct apple_mbox_msg mbox_msg;
0077 };
0078 
0079 struct apple_rtkit_rx_work {
0080     struct apple_rtkit *rtk;
0081     u8 ep;
0082     u64 msg;
0083     struct work_struct work;
0084 };
0085 
0086 bool apple_rtkit_is_running(struct apple_rtkit *rtk)
0087 {
0088     if (rtk->crashed)
0089         return false;
0090     if ((rtk->iop_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON)
0091         return false;
0092     if ((rtk->ap_power_state & 0xff) != APPLE_RTKIT_PWR_STATE_ON)
0093         return false;
0094     return true;
0095 }
0096 EXPORT_SYMBOL_GPL(apple_rtkit_is_running);
0097 
0098 bool apple_rtkit_is_crashed(struct apple_rtkit *rtk)
0099 {
0100     return rtk->crashed;
0101 }
0102 EXPORT_SYMBOL_GPL(apple_rtkit_is_crashed);
0103 
0104 static void apple_rtkit_management_send(struct apple_rtkit *rtk, u8 type,
0105                     u64 msg)
0106 {
0107     msg &= ~APPLE_RTKIT_MGMT_TYPE;
0108     msg |= FIELD_PREP(APPLE_RTKIT_MGMT_TYPE, type);
0109     apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_MGMT, msg, NULL, false);
0110 }
0111 
0112 static void apple_rtkit_management_rx_hello(struct apple_rtkit *rtk, u64 msg)
0113 {
0114     u64 reply;
0115 
0116     int min_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MINVER, msg);
0117     int max_ver = FIELD_GET(APPLE_RTKIT_MGMT_HELLO_MAXVER, msg);
0118     int want_ver = min(APPLE_RTKIT_MAX_SUPPORTED_VERSION, max_ver);
0119 
0120     dev_dbg(rtk->dev, "RTKit: Min ver %d, max ver %d\n", min_ver, max_ver);
0121 
0122     if (min_ver > APPLE_RTKIT_MAX_SUPPORTED_VERSION) {
0123         dev_err(rtk->dev, "RTKit: Firmware min version %d is too new\n",
0124             min_ver);
0125         goto abort_boot;
0126     }
0127 
0128     if (max_ver < APPLE_RTKIT_MIN_SUPPORTED_VERSION) {
0129         dev_err(rtk->dev, "RTKit: Firmware max version %d is too old\n",
0130             max_ver);
0131         goto abort_boot;
0132     }
0133 
0134     dev_info(rtk->dev, "RTKit: Initializing (protocol version %d)\n",
0135          want_ver);
0136     rtk->version = want_ver;
0137 
0138     reply = FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MINVER, want_ver);
0139     reply |= FIELD_PREP(APPLE_RTKIT_MGMT_HELLO_MAXVER, want_ver);
0140     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_HELLO_REPLY, reply);
0141 
0142     return;
0143 
0144 abort_boot:
0145     rtk->boot_result = -EINVAL;
0146     complete_all(&rtk->epmap_completion);
0147 }
0148 
0149 static void apple_rtkit_management_rx_epmap(struct apple_rtkit *rtk, u64 msg)
0150 {
0151     int i, ep;
0152     u64 reply;
0153     unsigned long bitmap = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BITMAP, msg);
0154     u32 base = FIELD_GET(APPLE_RTKIT_MGMT_EPMAP_BASE, msg);
0155 
0156     dev_dbg(rtk->dev,
0157         "RTKit: received endpoint bitmap 0x%lx with base 0x%x\n",
0158         bitmap, base);
0159 
0160     for_each_set_bit(i, &bitmap, 32) {
0161         ep = 32 * base + i;
0162         dev_dbg(rtk->dev, "RTKit: Discovered endpoint 0x%02x\n", ep);
0163         set_bit(ep, rtk->endpoints);
0164     }
0165 
0166     reply = FIELD_PREP(APPLE_RTKIT_MGMT_EPMAP_BASE, base);
0167     if (msg & APPLE_RTKIT_MGMT_EPMAP_LAST)
0168         reply |= APPLE_RTKIT_MGMT_EPMAP_LAST;
0169     else
0170         reply |= APPLE_RTKIT_MGMT_EPMAP_REPLY_MORE;
0171 
0172     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_EPMAP_REPLY, reply);
0173 
0174     if (!(msg & APPLE_RTKIT_MGMT_EPMAP_LAST))
0175         return;
0176 
0177     for_each_set_bit(ep, rtk->endpoints, APPLE_RTKIT_APP_ENDPOINT_START) {
0178         switch (ep) {
0179         /* the management endpoint is started by default */
0180         case APPLE_RTKIT_EP_MGMT:
0181             break;
0182 
0183         /* without starting these RTKit refuses to boot */
0184         case APPLE_RTKIT_EP_SYSLOG:
0185         case APPLE_RTKIT_EP_CRASHLOG:
0186         case APPLE_RTKIT_EP_DEBUG:
0187         case APPLE_RTKIT_EP_IOREPORT:
0188         case APPLE_RTKIT_EP_OSLOG:
0189             dev_dbg(rtk->dev,
0190                 "RTKit: Starting system endpoint 0x%02x\n", ep);
0191             apple_rtkit_start_ep(rtk, ep);
0192             break;
0193 
0194         default:
0195             dev_warn(rtk->dev,
0196                  "RTKit: Unknown system endpoint: 0x%02x\n",
0197                  ep);
0198         }
0199     }
0200 
0201     rtk->boot_result = 0;
0202     complete_all(&rtk->epmap_completion);
0203 }
0204 
0205 static void apple_rtkit_management_rx_iop_pwr_ack(struct apple_rtkit *rtk,
0206                           u64 msg)
0207 {
0208     unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg);
0209 
0210     dev_dbg(rtk->dev, "RTKit: IOP power state transition: 0x%x -> 0x%x\n",
0211         rtk->iop_power_state, new_state);
0212     rtk->iop_power_state = new_state;
0213 
0214     complete_all(&rtk->iop_pwr_ack_completion);
0215 }
0216 
0217 static void apple_rtkit_management_rx_ap_pwr_ack(struct apple_rtkit *rtk,
0218                          u64 msg)
0219 {
0220     unsigned int new_state = FIELD_GET(APPLE_RTKIT_MGMT_PWR_STATE, msg);
0221 
0222     dev_dbg(rtk->dev, "RTKit: AP power state transition: 0x%x -> 0x%x\n",
0223         rtk->ap_power_state, new_state);
0224     rtk->ap_power_state = new_state;
0225 
0226     complete_all(&rtk->ap_pwr_ack_completion);
0227 }
0228 
0229 static void apple_rtkit_management_rx(struct apple_rtkit *rtk, u64 msg)
0230 {
0231     u8 type = FIELD_GET(APPLE_RTKIT_MGMT_TYPE, msg);
0232 
0233     switch (type) {
0234     case APPLE_RTKIT_MGMT_HELLO:
0235         apple_rtkit_management_rx_hello(rtk, msg);
0236         break;
0237     case APPLE_RTKIT_MGMT_EPMAP:
0238         apple_rtkit_management_rx_epmap(rtk, msg);
0239         break;
0240     case APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE_ACK:
0241         apple_rtkit_management_rx_iop_pwr_ack(rtk, msg);
0242         break;
0243     case APPLE_RTKIT_MGMT_SET_AP_PWR_STATE_ACK:
0244         apple_rtkit_management_rx_ap_pwr_ack(rtk, msg);
0245         break;
0246     default:
0247         dev_warn(
0248             rtk->dev,
0249             "RTKit: unknown management message: 0x%llx (type: 0x%02x)\n",
0250             msg, type);
0251     }
0252 }
0253 
0254 static int apple_rtkit_common_rx_get_buffer(struct apple_rtkit *rtk,
0255                         struct apple_rtkit_shmem *buffer,
0256                         u8 ep, u64 msg)
0257 {
0258     size_t n_4kpages = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_SIZE, msg);
0259     u64 reply;
0260     int err;
0261 
0262     buffer->buffer = NULL;
0263     buffer->iomem = NULL;
0264     buffer->is_mapped = false;
0265     buffer->iova = FIELD_GET(APPLE_RTKIT_BUFFER_REQUEST_IOVA, msg);
0266     buffer->size = n_4kpages << 12;
0267 
0268     dev_dbg(rtk->dev, "RTKit: buffer request for 0x%zx bytes at %pad\n",
0269         buffer->size, &buffer->iova);
0270 
0271     if (buffer->iova &&
0272         (!rtk->ops->shmem_setup || !rtk->ops->shmem_destroy)) {
0273         err = -EINVAL;
0274         goto error;
0275     }
0276 
0277     if (rtk->ops->shmem_setup) {
0278         err = rtk->ops->shmem_setup(rtk->cookie, buffer);
0279         if (err)
0280             goto error;
0281     } else {
0282         buffer->buffer = dma_alloc_coherent(rtk->dev, buffer->size,
0283                             &buffer->iova, GFP_KERNEL);
0284         if (!buffer->buffer) {
0285             err = -ENOMEM;
0286             goto error;
0287         }
0288     }
0289 
0290     if (!buffer->is_mapped) {
0291         reply = FIELD_PREP(APPLE_RTKIT_SYSLOG_TYPE,
0292                    APPLE_RTKIT_BUFFER_REQUEST);
0293         reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_SIZE, n_4kpages);
0294         reply |= FIELD_PREP(APPLE_RTKIT_BUFFER_REQUEST_IOVA,
0295                     buffer->iova);
0296         apple_rtkit_send_message(rtk, ep, reply, NULL, false);
0297     }
0298 
0299     return 0;
0300 
0301 error:
0302     buffer->buffer = NULL;
0303     buffer->iomem = NULL;
0304     buffer->iova = 0;
0305     buffer->size = 0;
0306     buffer->is_mapped = false;
0307     return err;
0308 }
0309 
0310 static void apple_rtkit_free_buffer(struct apple_rtkit *rtk,
0311                     struct apple_rtkit_shmem *bfr)
0312 {
0313     if (bfr->size == 0)
0314         return;
0315 
0316     if (rtk->ops->shmem_destroy)
0317         rtk->ops->shmem_destroy(rtk->cookie, bfr);
0318     else if (bfr->buffer)
0319         dma_free_coherent(rtk->dev, bfr->size, bfr->buffer, bfr->iova);
0320 
0321     bfr->buffer = NULL;
0322     bfr->iomem = NULL;
0323     bfr->iova = 0;
0324     bfr->size = 0;
0325     bfr->is_mapped = false;
0326 }
0327 
0328 static void apple_rtkit_memcpy(struct apple_rtkit *rtk, void *dst,
0329                    struct apple_rtkit_shmem *bfr, size_t offset,
0330                    size_t len)
0331 {
0332     if (bfr->iomem)
0333         memcpy_fromio(dst, bfr->iomem + offset, len);
0334     else
0335         memcpy(dst, bfr->buffer + offset, len);
0336 }
0337 
0338 static void apple_rtkit_crashlog_rx(struct apple_rtkit *rtk, u64 msg)
0339 {
0340     u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
0341     u8 *bfr;
0342 
0343     if (type != APPLE_RTKIT_CRASHLOG_CRASH) {
0344         dev_warn(rtk->dev, "RTKit: Unknown crashlog message: %llx\n",
0345              msg);
0346         return;
0347     }
0348 
0349     if (!rtk->crashlog_buffer.size) {
0350         apple_rtkit_common_rx_get_buffer(rtk, &rtk->crashlog_buffer,
0351                          APPLE_RTKIT_EP_CRASHLOG, msg);
0352         return;
0353     }
0354 
0355     dev_err(rtk->dev, "RTKit: co-processor has crashed\n");
0356 
0357     /*
0358      * create a shadow copy here to make sure the co-processor isn't able
0359      * to change the log while we're dumping it. this also ensures
0360      * the buffer is in normal memory and not iomem for e.g. the SMC
0361      */
0362     bfr = kzalloc(rtk->crashlog_buffer.size, GFP_KERNEL);
0363     if (bfr) {
0364         apple_rtkit_memcpy(rtk, bfr, &rtk->crashlog_buffer, 0,
0365                    rtk->crashlog_buffer.size);
0366         apple_rtkit_crashlog_dump(rtk, bfr, rtk->crashlog_buffer.size);
0367         kfree(bfr);
0368     } else {
0369         dev_err(rtk->dev,
0370             "RTKit: Couldn't allocate crashlog shadow buffer\n");
0371     }
0372 
0373     rtk->crashed = true;
0374     if (rtk->ops->crashed)
0375         rtk->ops->crashed(rtk->cookie);
0376 }
0377 
0378 static void apple_rtkit_ioreport_rx(struct apple_rtkit *rtk, u64 msg)
0379 {
0380     u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
0381 
0382     switch (type) {
0383     case APPLE_RTKIT_BUFFER_REQUEST:
0384         apple_rtkit_common_rx_get_buffer(rtk, &rtk->ioreport_buffer,
0385                          APPLE_RTKIT_EP_IOREPORT, msg);
0386         break;
0387     /* unknown, must be ACKed or the co-processor will hang */
0388     case 0x8:
0389     case 0xc:
0390         apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_IOREPORT, msg,
0391                      NULL, false);
0392         break;
0393     default:
0394         dev_warn(rtk->dev, "RTKit: Unknown ioreport message: %llx\n",
0395              msg);
0396     }
0397 }
0398 
0399 static void apple_rtkit_syslog_rx_init(struct apple_rtkit *rtk, u64 msg)
0400 {
0401     rtk->syslog_n_entries = FIELD_GET(APPLE_RTKIT_SYSLOG_N_ENTRIES, msg);
0402     rtk->syslog_msg_size = FIELD_GET(APPLE_RTKIT_SYSLOG_MSG_SIZE, msg);
0403 
0404     rtk->syslog_msg_buffer = kzalloc(rtk->syslog_msg_size, GFP_KERNEL);
0405 
0406     dev_dbg(rtk->dev,
0407         "RTKit: syslog initialized: entries: %zd, msg_size: %zd\n",
0408         rtk->syslog_n_entries, rtk->syslog_msg_size);
0409 }
0410 
0411 static void apple_rtkit_syslog_rx_log(struct apple_rtkit *rtk, u64 msg)
0412 {
0413     u8 idx = msg & 0xff;
0414     char log_context[24];
0415     size_t entry_size = 0x20 + rtk->syslog_msg_size;
0416 
0417     if (!rtk->syslog_msg_buffer) {
0418         dev_warn(
0419             rtk->dev,
0420             "RTKit: received syslog message but no syslog_msg_buffer\n");
0421         goto done;
0422     }
0423     if (!rtk->syslog_buffer.size) {
0424         dev_warn(
0425             rtk->dev,
0426             "RTKit: received syslog message but syslog_buffer.size is zero\n");
0427         goto done;
0428     }
0429     if (!rtk->syslog_buffer.buffer && !rtk->syslog_buffer.iomem) {
0430         dev_warn(
0431             rtk->dev,
0432             "RTKit: received syslog message but no syslog_buffer.buffer or syslog_buffer.iomem\n");
0433         goto done;
0434     }
0435     if (idx > rtk->syslog_n_entries) {
0436         dev_warn(rtk->dev, "RTKit: syslog index %d out of range\n",
0437              idx);
0438         goto done;
0439     }
0440 
0441     apple_rtkit_memcpy(rtk, log_context, &rtk->syslog_buffer,
0442                idx * entry_size + 8, sizeof(log_context));
0443     apple_rtkit_memcpy(rtk, rtk->syslog_msg_buffer, &rtk->syslog_buffer,
0444                idx * entry_size + 8 + sizeof(log_context),
0445                rtk->syslog_msg_size);
0446 
0447     log_context[sizeof(log_context) - 1] = 0;
0448     rtk->syslog_msg_buffer[rtk->syslog_msg_size - 1] = 0;
0449     dev_info(rtk->dev, "RTKit: syslog message: %s: %s\n", log_context,
0450          rtk->syslog_msg_buffer);
0451 
0452 done:
0453     apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_SYSLOG, msg, NULL, false);
0454 }
0455 
0456 static void apple_rtkit_syslog_rx(struct apple_rtkit *rtk, u64 msg)
0457 {
0458     u8 type = FIELD_GET(APPLE_RTKIT_SYSLOG_TYPE, msg);
0459 
0460     switch (type) {
0461     case APPLE_RTKIT_BUFFER_REQUEST:
0462         apple_rtkit_common_rx_get_buffer(rtk, &rtk->syslog_buffer,
0463                          APPLE_RTKIT_EP_SYSLOG, msg);
0464         break;
0465     case APPLE_RTKIT_SYSLOG_INIT:
0466         apple_rtkit_syslog_rx_init(rtk, msg);
0467         break;
0468     case APPLE_RTKIT_SYSLOG_LOG:
0469         apple_rtkit_syslog_rx_log(rtk, msg);
0470         break;
0471     default:
0472         dev_warn(rtk->dev, "RTKit: Unknown syslog message: %llx\n",
0473              msg);
0474     }
0475 }
0476 
0477 static void apple_rtkit_oslog_rx_init(struct apple_rtkit *rtk, u64 msg)
0478 {
0479     u64 ack;
0480 
0481     dev_dbg(rtk->dev, "RTKit: oslog init: msg: 0x%llx\n", msg);
0482     ack = FIELD_PREP(APPLE_RTKIT_OSLOG_TYPE, APPLE_RTKIT_OSLOG_ACK);
0483     apple_rtkit_send_message(rtk, APPLE_RTKIT_EP_OSLOG, ack, NULL, false);
0484 }
0485 
0486 static void apple_rtkit_oslog_rx(struct apple_rtkit *rtk, u64 msg)
0487 {
0488     u8 type = FIELD_GET(APPLE_RTKIT_OSLOG_TYPE, msg);
0489 
0490     switch (type) {
0491     case APPLE_RTKIT_OSLOG_INIT:
0492         apple_rtkit_oslog_rx_init(rtk, msg);
0493         break;
0494     default:
0495         dev_warn(rtk->dev, "RTKit: Unknown oslog message: %llx\n", msg);
0496     }
0497 }
0498 
0499 static void apple_rtkit_rx_work(struct work_struct *work)
0500 {
0501     struct apple_rtkit_rx_work *rtk_work =
0502         container_of(work, struct apple_rtkit_rx_work, work);
0503     struct apple_rtkit *rtk = rtk_work->rtk;
0504 
0505     switch (rtk_work->ep) {
0506     case APPLE_RTKIT_EP_MGMT:
0507         apple_rtkit_management_rx(rtk, rtk_work->msg);
0508         break;
0509     case APPLE_RTKIT_EP_CRASHLOG:
0510         apple_rtkit_crashlog_rx(rtk, rtk_work->msg);
0511         break;
0512     case APPLE_RTKIT_EP_SYSLOG:
0513         apple_rtkit_syslog_rx(rtk, rtk_work->msg);
0514         break;
0515     case APPLE_RTKIT_EP_IOREPORT:
0516         apple_rtkit_ioreport_rx(rtk, rtk_work->msg);
0517         break;
0518     case APPLE_RTKIT_EP_OSLOG:
0519         apple_rtkit_oslog_rx(rtk, rtk_work->msg);
0520         break;
0521     case APPLE_RTKIT_APP_ENDPOINT_START ... 0xff:
0522         if (rtk->ops->recv_message)
0523             rtk->ops->recv_message(rtk->cookie, rtk_work->ep,
0524                            rtk_work->msg);
0525         else
0526             dev_warn(
0527                 rtk->dev,
0528                 "Received unexpected message to EP%02d: %llx\n",
0529                 rtk_work->ep, rtk_work->msg);
0530         break;
0531     default:
0532         dev_warn(rtk->dev,
0533              "RTKit: message to unknown endpoint %02x: %llx\n",
0534              rtk_work->ep, rtk_work->msg);
0535     }
0536 
0537     kfree(rtk_work);
0538 }
0539 
0540 static void apple_rtkit_rx(struct mbox_client *cl, void *mssg)
0541 {
0542     struct apple_rtkit *rtk = container_of(cl, struct apple_rtkit, mbox_cl);
0543     struct apple_mbox_msg *msg = mssg;
0544     struct apple_rtkit_rx_work *work;
0545     u8 ep = msg->msg1;
0546 
0547     /*
0548      * The message was read from a MMIO FIFO and we have to make
0549      * sure all reads from buffers sent with that message happen
0550      * afterwards.
0551      */
0552     dma_rmb();
0553 
0554     if (!test_bit(ep, rtk->endpoints))
0555         dev_warn(rtk->dev,
0556              "RTKit: Message to undiscovered endpoint 0x%02x\n",
0557              ep);
0558 
0559     if (ep >= APPLE_RTKIT_APP_ENDPOINT_START &&
0560         rtk->ops->recv_message_early &&
0561         rtk->ops->recv_message_early(rtk->cookie, ep, msg->msg0))
0562         return;
0563 
0564     work = kzalloc(sizeof(*work), GFP_ATOMIC);
0565     if (!work)
0566         return;
0567 
0568     work->rtk = rtk;
0569     work->ep = ep;
0570     work->msg = msg->msg0;
0571     INIT_WORK(&work->work, apple_rtkit_rx_work);
0572     queue_work(rtk->wq, &work->work);
0573 }
0574 
0575 static void apple_rtkit_tx_done(struct mbox_client *cl, void *mssg, int r)
0576 {
0577     struct apple_rtkit_msg *msg =
0578         container_of(mssg, struct apple_rtkit_msg, mbox_msg);
0579 
0580     if (r == -ETIME)
0581         return;
0582 
0583     if (msg->completion)
0584         complete(msg->completion);
0585     kfree(msg);
0586 }
0587 
0588 int apple_rtkit_send_message(struct apple_rtkit *rtk, u8 ep, u64 message,
0589                  struct completion *completion, bool atomic)
0590 {
0591     struct apple_rtkit_msg *msg;
0592     int ret;
0593     gfp_t flags;
0594 
0595     if (rtk->crashed)
0596         return -EINVAL;
0597     if (ep >= APPLE_RTKIT_APP_ENDPOINT_START &&
0598         !apple_rtkit_is_running(rtk))
0599         return -EINVAL;
0600 
0601     if (atomic)
0602         flags = GFP_ATOMIC;
0603     else
0604         flags = GFP_KERNEL;
0605 
0606     msg = kzalloc(sizeof(*msg), flags);
0607     if (!msg)
0608         return -ENOMEM;
0609 
0610     msg->mbox_msg.msg0 = message;
0611     msg->mbox_msg.msg1 = ep;
0612     msg->completion = completion;
0613 
0614     /*
0615      * The message will be sent with a MMIO write. We need the barrier
0616      * here to ensure any previous writes to buffers are visible to the
0617      * device before that MMIO write happens.
0618      */
0619     dma_wmb();
0620 
0621     ret = mbox_send_message(rtk->mbox_chan, &msg->mbox_msg);
0622     if (ret < 0) {
0623         kfree(msg);
0624         return ret;
0625     }
0626 
0627     return 0;
0628 }
0629 EXPORT_SYMBOL_GPL(apple_rtkit_send_message);
0630 
0631 int apple_rtkit_send_message_wait(struct apple_rtkit *rtk, u8 ep, u64 message,
0632                   unsigned long timeout, bool atomic)
0633 {
0634     DECLARE_COMPLETION_ONSTACK(completion);
0635     int ret;
0636     long t;
0637 
0638     ret = apple_rtkit_send_message(rtk, ep, message, &completion, atomic);
0639     if (ret < 0)
0640         return ret;
0641 
0642     if (atomic) {
0643         ret = mbox_flush(rtk->mbox_chan, timeout);
0644         if (ret < 0)
0645             return ret;
0646 
0647         if (try_wait_for_completion(&completion))
0648             return 0;
0649 
0650         return -ETIME;
0651     } else {
0652         t = wait_for_completion_interruptible_timeout(
0653             &completion, msecs_to_jiffies(timeout));
0654         if (t < 0)
0655             return t;
0656         else if (t == 0)
0657             return -ETIME;
0658         return 0;
0659     }
0660 }
0661 EXPORT_SYMBOL_GPL(apple_rtkit_send_message_wait);
0662 
0663 int apple_rtkit_start_ep(struct apple_rtkit *rtk, u8 endpoint)
0664 {
0665     u64 msg;
0666 
0667     if (!test_bit(endpoint, rtk->endpoints))
0668         return -EINVAL;
0669     if (endpoint >= APPLE_RTKIT_APP_ENDPOINT_START &&
0670         !apple_rtkit_is_running(rtk))
0671         return -EINVAL;
0672 
0673     msg = FIELD_PREP(APPLE_RTKIT_MGMT_STARTEP_EP, endpoint);
0674     msg |= APPLE_RTKIT_MGMT_STARTEP_FLAG;
0675     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_STARTEP, msg);
0676 
0677     return 0;
0678 }
0679 EXPORT_SYMBOL_GPL(apple_rtkit_start_ep);
0680 
0681 static int apple_rtkit_request_mbox_chan(struct apple_rtkit *rtk)
0682 {
0683     if (rtk->mbox_name)
0684         rtk->mbox_chan = mbox_request_channel_byname(&rtk->mbox_cl,
0685                                  rtk->mbox_name);
0686     else
0687         rtk->mbox_chan =
0688             mbox_request_channel(&rtk->mbox_cl, rtk->mbox_idx);
0689 
0690     if (IS_ERR(rtk->mbox_chan))
0691         return PTR_ERR(rtk->mbox_chan);
0692     return 0;
0693 }
0694 
0695 static struct apple_rtkit *apple_rtkit_init(struct device *dev, void *cookie,
0696                         const char *mbox_name, int mbox_idx,
0697                         const struct apple_rtkit_ops *ops)
0698 {
0699     struct apple_rtkit *rtk;
0700     int ret;
0701 
0702     if (!ops)
0703         return ERR_PTR(-EINVAL);
0704 
0705     rtk = kzalloc(sizeof(*rtk), GFP_KERNEL);
0706     if (!rtk)
0707         return ERR_PTR(-ENOMEM);
0708 
0709     rtk->dev = dev;
0710     rtk->cookie = cookie;
0711     rtk->ops = ops;
0712 
0713     init_completion(&rtk->epmap_completion);
0714     init_completion(&rtk->iop_pwr_ack_completion);
0715     init_completion(&rtk->ap_pwr_ack_completion);
0716 
0717     bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS);
0718     set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints);
0719 
0720     rtk->mbox_name = mbox_name;
0721     rtk->mbox_idx = mbox_idx;
0722     rtk->mbox_cl.dev = dev;
0723     rtk->mbox_cl.tx_block = false;
0724     rtk->mbox_cl.knows_txdone = false;
0725     rtk->mbox_cl.rx_callback = &apple_rtkit_rx;
0726     rtk->mbox_cl.tx_done = &apple_rtkit_tx_done;
0727 
0728     rtk->wq = alloc_ordered_workqueue("rtkit-%s", WQ_MEM_RECLAIM,
0729                       dev_name(rtk->dev));
0730     if (!rtk->wq) {
0731         ret = -ENOMEM;
0732         goto free_rtk;
0733     }
0734 
0735     ret = apple_rtkit_request_mbox_chan(rtk);
0736     if (ret)
0737         goto destroy_wq;
0738 
0739     return rtk;
0740 
0741 destroy_wq:
0742     destroy_workqueue(rtk->wq);
0743 free_rtk:
0744     kfree(rtk);
0745     return ERR_PTR(ret);
0746 }
0747 
0748 static int apple_rtkit_wait_for_completion(struct completion *c)
0749 {
0750     long t;
0751 
0752     t = wait_for_completion_interruptible_timeout(c,
0753                               msecs_to_jiffies(1000));
0754     if (t < 0)
0755         return t;
0756     else if (t == 0)
0757         return -ETIME;
0758     else
0759         return 0;
0760 }
0761 
0762 int apple_rtkit_reinit(struct apple_rtkit *rtk)
0763 {
0764     /* make sure we don't handle any messages while reinitializing */
0765     mbox_free_channel(rtk->mbox_chan);
0766     flush_workqueue(rtk->wq);
0767 
0768     apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer);
0769     apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer);
0770     apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer);
0771 
0772     kfree(rtk->syslog_msg_buffer);
0773 
0774     rtk->syslog_msg_buffer = NULL;
0775     rtk->syslog_n_entries = 0;
0776     rtk->syslog_msg_size = 0;
0777 
0778     bitmap_zero(rtk->endpoints, APPLE_RTKIT_MAX_ENDPOINTS);
0779     set_bit(APPLE_RTKIT_EP_MGMT, rtk->endpoints);
0780 
0781     reinit_completion(&rtk->epmap_completion);
0782     reinit_completion(&rtk->iop_pwr_ack_completion);
0783     reinit_completion(&rtk->ap_pwr_ack_completion);
0784 
0785     rtk->crashed = false;
0786     rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_OFF;
0787     rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_OFF;
0788 
0789     return apple_rtkit_request_mbox_chan(rtk);
0790 }
0791 EXPORT_SYMBOL_GPL(apple_rtkit_reinit);
0792 
0793 static int apple_rtkit_set_ap_power_state(struct apple_rtkit *rtk,
0794                       unsigned int state)
0795 {
0796     u64 msg;
0797     int ret;
0798 
0799     reinit_completion(&rtk->ap_pwr_ack_completion);
0800 
0801     msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state);
0802     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_AP_PWR_STATE,
0803                     msg);
0804 
0805     ret = apple_rtkit_wait_for_completion(&rtk->ap_pwr_ack_completion);
0806     if (ret)
0807         return ret;
0808 
0809     if (rtk->ap_power_state != state)
0810         return -EINVAL;
0811     return 0;
0812 }
0813 
0814 static int apple_rtkit_set_iop_power_state(struct apple_rtkit *rtk,
0815                        unsigned int state)
0816 {
0817     u64 msg;
0818     int ret;
0819 
0820     reinit_completion(&rtk->iop_pwr_ack_completion);
0821 
0822     msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, state);
0823     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE,
0824                     msg);
0825 
0826     ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion);
0827     if (ret)
0828         return ret;
0829 
0830     if (rtk->iop_power_state != state)
0831         return -EINVAL;
0832     return 0;
0833 }
0834 
0835 int apple_rtkit_boot(struct apple_rtkit *rtk)
0836 {
0837     int ret;
0838 
0839     if (apple_rtkit_is_running(rtk))
0840         return 0;
0841     if (rtk->crashed)
0842         return -EINVAL;
0843 
0844     dev_dbg(rtk->dev, "RTKit: waiting for boot to finish\n");
0845     ret = apple_rtkit_wait_for_completion(&rtk->epmap_completion);
0846     if (ret)
0847         return ret;
0848     if (rtk->boot_result)
0849         return rtk->boot_result;
0850 
0851     dev_dbg(rtk->dev, "RTKit: waiting for IOP power state ACK\n");
0852     ret = apple_rtkit_wait_for_completion(&rtk->iop_pwr_ack_completion);
0853     if (ret)
0854         return ret;
0855 
0856     return apple_rtkit_set_ap_power_state(rtk, APPLE_RTKIT_PWR_STATE_ON);
0857 }
0858 EXPORT_SYMBOL_GPL(apple_rtkit_boot);
0859 
0860 int apple_rtkit_shutdown(struct apple_rtkit *rtk)
0861 {
0862     int ret;
0863 
0864     /* if OFF is used here the co-processor will not wake up again */
0865     ret = apple_rtkit_set_ap_power_state(rtk,
0866                          APPLE_RTKIT_PWR_STATE_QUIESCED);
0867     if (ret)
0868         return ret;
0869 
0870     ret = apple_rtkit_set_iop_power_state(rtk, APPLE_RTKIT_PWR_STATE_SLEEP);
0871     if (ret)
0872         return ret;
0873 
0874     return apple_rtkit_reinit(rtk);
0875 }
0876 EXPORT_SYMBOL_GPL(apple_rtkit_shutdown);
0877 
0878 int apple_rtkit_quiesce(struct apple_rtkit *rtk)
0879 {
0880     int ret;
0881 
0882     ret = apple_rtkit_set_ap_power_state(rtk,
0883                          APPLE_RTKIT_PWR_STATE_QUIESCED);
0884     if (ret)
0885         return ret;
0886 
0887     ret = apple_rtkit_set_iop_power_state(rtk,
0888                           APPLE_RTKIT_PWR_STATE_QUIESCED);
0889     if (ret)
0890         return ret;
0891 
0892     ret = apple_rtkit_reinit(rtk);
0893     if (ret)
0894         return ret;
0895 
0896     rtk->iop_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED;
0897     rtk->ap_power_state = APPLE_RTKIT_PWR_STATE_QUIESCED;
0898     return 0;
0899 }
0900 EXPORT_SYMBOL_GPL(apple_rtkit_quiesce);
0901 
0902 int apple_rtkit_wake(struct apple_rtkit *rtk)
0903 {
0904     u64 msg;
0905 
0906     if (apple_rtkit_is_running(rtk))
0907         return -EINVAL;
0908 
0909     reinit_completion(&rtk->iop_pwr_ack_completion);
0910 
0911     /*
0912      * Use open-coded apple_rtkit_set_iop_power_state since apple_rtkit_boot
0913      * will wait for the completion anyway.
0914      */
0915     msg = FIELD_PREP(APPLE_RTKIT_MGMT_PWR_STATE, APPLE_RTKIT_PWR_STATE_ON);
0916     apple_rtkit_management_send(rtk, APPLE_RTKIT_MGMT_SET_IOP_PWR_STATE,
0917                     msg);
0918 
0919     return apple_rtkit_boot(rtk);
0920 }
0921 EXPORT_SYMBOL_GPL(apple_rtkit_wake);
0922 
0923 static void apple_rtkit_free(struct apple_rtkit *rtk)
0924 {
0925     mbox_free_channel(rtk->mbox_chan);
0926     destroy_workqueue(rtk->wq);
0927 
0928     apple_rtkit_free_buffer(rtk, &rtk->ioreport_buffer);
0929     apple_rtkit_free_buffer(rtk, &rtk->crashlog_buffer);
0930     apple_rtkit_free_buffer(rtk, &rtk->syslog_buffer);
0931 
0932     kfree(rtk->syslog_msg_buffer);
0933     kfree(rtk);
0934 }
0935 
0936 struct apple_rtkit *devm_apple_rtkit_init(struct device *dev, void *cookie,
0937                       const char *mbox_name, int mbox_idx,
0938                       const struct apple_rtkit_ops *ops)
0939 {
0940     struct apple_rtkit *rtk;
0941     int ret;
0942 
0943     rtk = apple_rtkit_init(dev, cookie, mbox_name, mbox_idx, ops);
0944     if (IS_ERR(rtk))
0945         return rtk;
0946 
0947     ret = devm_add_action_or_reset(dev, (void (*)(void *))apple_rtkit_free,
0948                        rtk);
0949     if (ret)
0950         return ERR_PTR(ret);
0951 
0952     return rtk;
0953 }
0954 EXPORT_SYMBOL_GPL(devm_apple_rtkit_init);
0955 
0956 MODULE_LICENSE("Dual MIT/GPL");
0957 MODULE_AUTHOR("Sven Peter <sven@svenpeter.dev>");
0958 MODULE_DESCRIPTION("Apple RTKit driver");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!