arch/powerpc/platforms/powernv/opal-async.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * PowerNV OPAL asynchronous completion interfaces
   4  *
   5  * Copyright 2013-2017 IBM Corp.
   6  */
   7
   8 #undef DEBUG
   9
  10 #include <linux/kernel.h>
  11 #include <linux/init.h>
  12 #include <linux/slab.h>
  13 #include <linux/sched.h>
  14 #include <linux/semaphore.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/wait.h>
  17 #include <linux/gfp.h>
  18 #include <linux/of.h>
  19 #include <asm/machdep.h>
  20 #include <asm/opal.h>
  21
  22 enum opal_async_token_state {
  23         ASYNC_TOKEN_UNALLOCATED = 0,
  24         ASYNC_TOKEN_ALLOCATED,
  25         ASYNC_TOKEN_DISPATCHED,
  26         ASYNC_TOKEN_ABANDONED,
  27         ASYNC_TOKEN_COMPLETED
  28 };
  29
  30 struct opal_async_token {
  31         enum opal_async_token_state state;
  32         struct opal_msg response;
  33 };
  34
  35 static DECLARE_WAIT_QUEUE_HEAD(opal_async_wait);
  36 static DEFINE_SPINLOCK(opal_async_comp_lock);
  37 static struct semaphore opal_async_sem;
  38 static unsigned int opal_max_async_tokens;
  39 static struct opal_async_token *opal_async_tokens;
  40
  41 static int __opal_async_get_token(void)
  42 {
  43         unsigned long flags;
  44         int i, token = -EBUSY;
  45
  46         spin_lock_irqsave(&opal_async_comp_lock, flags);
  47
  48         for (i = 0; i < opal_max_async_tokens; i++) {
  49                 if (opal_async_tokens[i].state == ASYNC_TOKEN_UNALLOCATED) {
  50                         opal_async_tokens[i].state = ASYNC_TOKEN_ALLOCATED;
  51                         token = i;
  52                         break;
  53                 }
  54         }
  55
  56         spin_unlock_irqrestore(&opal_async_comp_lock, flags);
  57         return token;
  58 }
  59
  60 /*
  61  * Note: If the returned token is used in an opal call and opal returns
  62  * OPAL_ASYNC_COMPLETION you MUST call one of opal_async_wait_response() or
  63  * opal_async_wait_response_interruptible() at least once before calling another
  64  * opal_async_* function
  65  */
  66 int opal_async_get_token_interruptible(void)
  67 {
  68         int token;
  69
  70         /* Wait until a token is available */
  71         if (down_interruptible(&opal_async_sem))
  72                 return -ERESTARTSYS;
  73
  74         token = __opal_async_get_token();
  75         if (token < 0)
  76                 up(&opal_async_sem);
  77
  78         return token;
  79 }
  80 EXPORT_SYMBOL_GPL(opal_async_get_token_interruptible);
  81
  82 static int __opal_async_release_token(int token)
  83 {
  84         unsigned long flags;
  85         int rc;
  86
  87         if (token < 0 || token >= opal_max_async_tokens) {
  88                 pr_err("%s: Passed token is out of range, token %d\n",
  89                                 __func__, token);
  90                 return -EINVAL;
  91         }
  92
  93         spin_lock_irqsave(&opal_async_comp_lock, flags);
  94         switch (opal_async_tokens[token].state) {
  95         case ASYNC_TOKEN_COMPLETED:
  96         case ASYNC_TOKEN_ALLOCATED:
  97                 opal_async_tokens[token].state = ASYNC_TOKEN_UNALLOCATED;
  98                 rc = 0;
  99                 break;
 100         /*
 101          * DISPATCHED and ABANDONED tokens must wait for OPAL to respond.
 102          * Mark a DISPATCHED token as ABANDONED so that the response handling
 103          * code knows no one cares and that it can free it then.
 104          */
 105         case ASYNC_TOKEN_DISPATCHED:
 106                 opal_async_tokens[token].state = ASYNC_TOKEN_ABANDONED;
 107                 fallthrough;
 108         default:
 109                 rc = 1;
 110         }
 111         spin_unlock_irqrestore(&opal_async_comp_lock, flags);
 112
 113         return rc;
 114 }
 115
 116 int opal_async_release_token(int token)
 117 {
 118         int ret;
 119
 120         ret = __opal_async_release_token(token);
 121         if (!ret)
 122                 up(&opal_async_sem);
 123
 124         return ret;
 125 }
 126 EXPORT_SYMBOL_GPL(opal_async_release_token);
 127
 128 int opal_async_wait_response(uint64_t token, struct opal_msg *msg)
 129 {
 130         if (token >= opal_max_async_tokens) {
 131                 pr_err("%s: Invalid token passed\n", __func__);
 132                 return -EINVAL;
 133         }
 134
 135         if (!msg) {
 136                 pr_err("%s: Invalid message pointer passed\n", __func__);
 137                 return -EINVAL;
 138         }
 139
 140         /*
 141          * There is no need to mark the token as dispatched, wait_event()
 142          * will block until the token completes.
 143          *
 144          * Wakeup the poller before we wait for events to speed things
 145          * up on platforms or simulators where the interrupts aren't
 146          * functional.
 147          */
 148         opal_wake_poller();
 149         wait_event(opal_async_wait, opal_async_tokens[token].state
 150                         == ASYNC_TOKEN_COMPLETED);
 151         memcpy(msg, &opal_async_tokens[token].response, sizeof(*msg));
 152
 153         return 0;
 154 }
 155 EXPORT_SYMBOL_GPL(opal_async_wait_response);
 156
 157 int opal_async_wait_response_interruptible(uint64_t token, struct opal_msg *msg)
 158 {
 159         unsigned long flags;
 160         int ret;
 161
 162         if (token >= opal_max_async_tokens) {
 163                 pr_err("%s: Invalid token passed\n", __func__);
 164                 return -EINVAL;
 165         }
 166
 167         if (!msg) {
 168                 pr_err("%s: Invalid message pointer passed\n", __func__);
 169                 return -EINVAL;
 170         }
 171
 172         /*
 173          * The first time this gets called we mark the token as DISPATCHED
 174          * so that if wait_event_interruptible() returns not zero and the
 175          * caller frees the token, we know not to actually free the token
 176          * until the response comes.
 177          *
 178          * Only change if the token is ALLOCATED - it may have been
 179          * completed even before the caller gets around to calling this
 180          * the first time.
 181          *
 182          * There is also a dirty great comment at the token allocation
 183          * function that if the opal call returns OPAL_ASYNC_COMPLETION to
 184          * the caller then the caller *must* call this or the not
 185          * interruptible version before doing anything else with the
 186          * token.
 187          */
 188         if (opal_async_tokens[token].state == ASYNC_TOKEN_ALLOCATED) {
 189                 spin_lock_irqsave(&opal_async_comp_lock, flags);
 190                 if (opal_async_tokens[token].state == ASYNC_TOKEN_ALLOCATED)
 191                         opal_async_tokens[token].state = ASYNC_TOKEN_DISPATCHED;
 192                 spin_unlock_irqrestore(&opal_async_comp_lock, flags);
 193         }
 194
 195         /*
 196          * Wakeup the poller before we wait for events to speed things
 197          * up on platforms or simulators where the interrupts aren't
 198          * functional.
 199          */
 200         opal_wake_poller();
 201         ret = wait_event_interruptible(opal_async_wait,
 202                         opal_async_tokens[token].state ==
 203                         ASYNC_TOKEN_COMPLETED);
 204         if (!ret)
 205                 memcpy(msg, &opal_async_tokens[token].response, sizeof(*msg));
 206
 207         return ret;
 208 }
 209 EXPORT_SYMBOL_GPL(opal_async_wait_response_interruptible);
 210
 211 /* Called from interrupt context */
 212 static int opal_async_comp_event(struct notifier_block *nb,
 213                 unsigned long msg_type, void *msg)
 214 {
 215         struct opal_msg *comp_msg = msg;
 216         enum opal_async_token_state state;
 217         unsigned long flags;
 218         uint64_t token;
 219
 220         if (msg_type != OPAL_MSG_ASYNC_COMP)
 221                 return 0;
 222
 223         token = be64_to_cpu(comp_msg->params[0]);
 224         spin_lock_irqsave(&opal_async_comp_lock, flags);
 225         state = opal_async_tokens[token].state;
 226         opal_async_tokens[token].state = ASYNC_TOKEN_COMPLETED;
 227         spin_unlock_irqrestore(&opal_async_comp_lock, flags);
 228
 229         if (state == ASYNC_TOKEN_ABANDONED) {
 230                 /* Free the token, no one else will */
 231                 opal_async_release_token(token);
 232                 return 0;
 233         }
 234         memcpy(&opal_async_tokens[token].response, comp_msg, sizeof(*comp_msg));
 235         wake_up(&opal_async_wait);
 236
 237         return 0;
 238 }
 239
 240 static struct notifier_block opal_async_comp_nb = {
 241                 .notifier_call  = opal_async_comp_event,
 242                 .next           = NULL,
 243                 .priority       = 0,
 244 };
 245
 246 int __init opal_async_comp_init(void)
 247 {
 248         struct device_node *opal_node;
 249         const __be32 *async;
 250         int err;
 251
 252         opal_node = of_find_node_by_path("/ibm,opal");
 253         if (!opal_node) {
 254                 pr_err("%s: Opal node not found\n", __func__);
 255                 err = -ENOENT;
 256                 goto out;
 257         }
 258
 259         async = of_get_property(opal_node, "opal-msg-async-num", NULL);
 260         if (!async) {
 261                 pr_err("%s: %pOF has no opal-msg-async-num\n",
 262                                 __func__, opal_node);
 263                 err = -ENOENT;
 264                 goto out_opal_node;
 265         }
 266
 267         opal_max_async_tokens = be32_to_cpup(async);
 268         opal_async_tokens = kcalloc(opal_max_async_tokens,
 269                         sizeof(*opal_async_tokens), GFP_KERNEL);
 270         if (!opal_async_tokens) {
 271                 err = -ENOMEM;
 272                 goto out_opal_node;
 273         }
 274
 275         err = opal_message_notifier_register(OPAL_MSG_ASYNC_COMP,
 276                         &opal_async_comp_nb);
 277         if (err) {
 278                 pr_err("%s: Can't register OPAL event notifier (%d)\n",
 279                                 __func__, err);
 280                 kfree(opal_async_tokens);
 281                 goto out_opal_node;
 282         }
 283
 284         sema_init(&opal_async_sem, opal_max_async_tokens);
 285
 286 out_opal_node:
 287         of_node_put(opal_node);
 288 out:
 289         return err;
 290 }