sys/dev/drm/include/linux/completion.h

   1 /*
   2  * Copyright (c) 2014 François Tigeot
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice unmodified, this list of conditions, and the following
  10  *    disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26 #ifndef _LINUX_COMPLETION_H_
  27 #define _LINUX_COMPLETION_H_
  28
  29 #include <linux/wait.h>
  30
  31 struct completion {
  32         unsigned int done;
  33         wait_queue_head_t wait;
  34 };
  35
  36 static inline void
  37 init_completion(struct completion *c)
  38 {
  39         c->done = 0;
  40         init_waitqueue_head(&c->wait);
  41 }
  42
  43 static inline void
  44 reinit_completion(struct completion *c)
  45 {
  46         c->done = 0;
  47 }
  48
  49 #define INIT_COMPLETION(c)      (c.done = 0)
  50
  51 /*
  52  * Completion interlock and wakeup.  Be careful not to execute the wakeup
  53  * from inside the spinlock as this can deadlock if the IPIQ fifo is full.
  54  * (also note that wakeup() is asynchronous anyway, so no point doing that).
  55  */
  56 static inline void
  57 complete(struct completion *c)
  58 {
  59         lockmgr(&c->wait.lock, LK_EXCLUSIVE);
  60         c->done++;
  61         lockmgr(&c->wait.lock, LK_RELEASE);
  62         wakeup_one(&c->wait);
  63 }
  64
  65 static inline void
  66 complete_all(struct completion *c)
  67 {
  68         lockmgr(&c->wait.lock, LK_EXCLUSIVE);
  69         c->done++;
  70         lockmgr(&c->wait.lock, LK_RELEASE);
  71         wakeup(&c->wait);
  72 }
  73
  74 static inline long
  75 wait_for_completion_interruptible_timeout(struct completion *c,
  76                 unsigned long timeout)
  77 {
  78         int start_jiffies, elapsed_jiffies, remaining_jiffies;
  79         bool timeout_expired = false, awakened = false;
  80         long ret = 1;
  81
  82         start_jiffies = ticks;
  83
  84         lockmgr(&c->wait.lock, LK_EXCLUSIVE);
  85         while (c->done == 0 && !timeout_expired) {
  86                 ret = lksleep(&c->wait, &c->wait.lock, PCATCH, "wfcit", timeout);
  87                 switch(ret) {
  88                 case EWOULDBLOCK:
  89                         timeout_expired = true;
  90                         ret = 0;
  91                         break;
  92                 case ERESTART:
  93                         ret = -ERESTARTSYS;
  94                         break;
  95                 case 0:
  96                         awakened = true;
  97                         break;
  98                 }
  99         }
 100         lockmgr(&c->wait.lock, LK_RELEASE);
 101
 102         if (awakened) {
 103                 elapsed_jiffies = ticks - start_jiffies;
 104                 remaining_jiffies = timeout - elapsed_jiffies;
 105                 if (remaining_jiffies > 0)
 106                         ret = remaining_jiffies;
 107         }
 108
 109         return ret;
 110 }
 111
 112 #endif  /* _LINUX_COMPLETION_H_ */