Merge tag 'pinctrl-for-3.7-late' of git://git.kernel.org/pub/scm/linux/kernel/git...

[karo-tx-linux.git] / include / linux / workqueue.h

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 26c5b4c63861e57433cd4b4371d83a2d190b2f02..2b58905d3504f71f71bb7636f2e195c80090c577 100644 (file)
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -133,26 +133,21 @@ struct execute_work {
        __WORK_INIT_LOCKDEP_MAP(#n, &(n))                               \
        }
 
-#define __DELAYED_WORK_INITIALIZER(n, f) {                             \
+#define __DELAYED_WORK_INITIALIZER(n, f, tflags) {                     \
        .work = __WORK_INITIALIZER((n).work, (f)),                      \
-       .timer = TIMER_INITIALIZER(delayed_work_timer_fn,               \
-                               0, (unsigned long)&(n)),                \
-       }
-
-#define __DEFERRED_WORK_INITIALIZER(n, f) {                            \
-       .work = __WORK_INITIALIZER((n).work, (f)),                      \
-       .timer = TIMER_DEFERRED_INITIALIZER(delayed_work_timer_fn,      \
-                               0, (unsigned long)&(n)),                \
+       .timer = __TIMER_INITIALIZER(delayed_work_timer_fn,             \
+                                    0, (unsigned long)&(n),            \
+                                    (tflags) | TIMER_IRQSAFE),         \
        }
 
 #define DECLARE_WORK(n, f)                                             \
        struct work_struct n = __WORK_INITIALIZER(n, f)
 
 #define DECLARE_DELAYED_WORK(n, f)                                     \
-       struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
+       struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0)
 
-#define DECLARE_DEFERRED_WORK(n, f)                                    \
-       struct delayed_work n = __DEFERRED_WORK_INITIALIZER(n, f)
+#define DECLARE_DEFERRABLE_WORK(n, f)                                  \
+       struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE)
 
 /*
  * initialize a work item's function pointer
@@ -216,29 +211,34 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
                __INIT_WORK((_work), (_func), 1);                       \
        } while (0)
 
-#define INIT_DELAYED_WORK(_work, _func)                                        \
+#define __INIT_DELAYED_WORK(_work, _func, _tflags)                     \
        do {                                                            \
                INIT_WORK(&(_work)->work, (_func));                     \
-               init_timer(&(_work)->timer);                            \
-               (_work)->timer.function = delayed_work_timer_fn;        \
-               (_work)->timer.data = (unsigned long)(_work);           \
+               __setup_timer(&(_work)->timer, delayed_work_timer_fn,   \
+                             (unsigned long)(_work),                   \
+                             (_tflags) | TIMER_IRQSAFE);               \
        } while (0)
 
-#define INIT_DELAYED_WORK_ONSTACK(_work, _func)                                \
+#define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags)             \
        do {                                                            \
                INIT_WORK_ONSTACK(&(_work)->work, (_func));             \
-               init_timer_on_stack(&(_work)->timer);                   \
-               (_work)->timer.function = delayed_work_timer_fn;        \
-               (_work)->timer.data = (unsigned long)(_work);           \
+               __setup_timer_on_stack(&(_work)->timer,                 \
+                                      delayed_work_timer_fn,           \
+                                      (unsigned long)(_work),          \
+                                      (_tflags) | TIMER_IRQSAFE);      \
        } while (0)
 
-#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func)                     \
-       do {                                                            \
-               INIT_WORK(&(_work)->work, (_func));                     \
-               init_timer_deferrable(&(_work)->timer);                 \
-               (_work)->timer.function = delayed_work_timer_fn;        \
-               (_work)->timer.data = (unsigned long)(_work);           \
-       } while (0)
+#define INIT_DELAYED_WORK(_work, _func)                                        \
+       __INIT_DELAYED_WORK(_work, _func, 0)
+
+#define INIT_DELAYED_WORK_ONSTACK(_work, _func)                                \
+       __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0)
+
+#define INIT_DEFERRABLE_WORK(_work, _func)                             \
+       __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE)
+
+#define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func)                     \
+       __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE)
 
 /**
  * work_pending - Find out whether a work item is currently pending
@@ -420,6 +420,7 @@ extern bool flush_work(struct work_struct *work);
 extern bool cancel_work_sync(struct work_struct *work);
 
 extern bool flush_delayed_work(struct delayed_work *dwork);
+extern bool cancel_delayed_work(struct delayed_work *dwork);
 extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
 
 extern void workqueue_set_max_active(struct workqueue_struct *wq,
@@ -428,28 +429,12 @@ extern bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq);
 extern unsigned int work_cpu(struct work_struct *work);
 extern unsigned int work_busy(struct work_struct *work);
 
-/*
- * Kill off a pending schedule_delayed_work().  Note that the work callback
- * function may still be running on return from cancel_delayed_work(), unless
- * it returns 1 and the work doesn't re-arm itself. Run flush_workqueue() or
- * cancel_work_sync() to wait on it.
- */
-static inline bool cancel_delayed_work(struct delayed_work *work)
-{
-       bool ret;
-
-       ret = del_timer_sync(&work->timer);
-       if (ret)
-               work_clear_pending(&work->work);
-       return ret;
-}
-
 /*
  * Like above, but uses del_timer() instead of del_timer_sync(). This means,
  * if it returns 0 the timer function may be running and the queueing is in
  * progress.
  */
-static inline bool __cancel_delayed_work(struct delayed_work *work)
+static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work)
 {
        bool ret;