9 files changed, 40 insertions, 34 deletions

diff --git a/drivers/input/touchscreen/ads7846.c b/drivers/input/touchscreen/ads7846.c
index cd251efda410..0a26e0663542 100644
--- a/drivers/input/touchscreen/ads7846.c
+++ b/drivers/input/touchscreen/ads7846.c
@@ -546,7 +546,7 @@ static void ads7846_rx(void *ads)
                         ts->spi->dev.bus_id, ts->tc.ignore, Rt);
 #endif
                 hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
-                              HRTIMER_REL);
+                              HRTIMER_MODE_REL);
                 return;
         }
 
@@ -578,7 +578,8 @@ static void ads7846_rx(void *ads)
 #endif
         }
 
-        hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD), HRTIMER_REL);
+        hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_PERIOD),
+                        HRTIMER_MODE_REL);
 }
 
 static int ads7846_debounce(void *ads, int data_idx, int *val)
@@ -667,7 +668,7 @@ static void ads7846_rx_val(void *ads)
                                 status);
 }
 
-static int ads7846_timer(struct hrtimer *handle)
+static enum hrtimer_restart ads7846_timer(struct hrtimer *handle)
 {
         struct ads7846  *ts = container_of(handle, struct ads7846, timer);
         int             status = 0;
@@ -724,7 +725,7 @@ static irqreturn_t ads7846_irq(int irq, void *handle)
                         disable_irq(ts->spi->irq);
                         ts->pending = 1;
                         hrtimer_start(&ts->timer, ktime_set(0, TS_POLL_DELAY),
-                                        HRTIMER_REL);
+                                        HRTIMER_MODE_REL);
                 }
         }
         spin_unlock_irqrestore(&ts->lock, flags);
@@ -862,7 +863,7 @@ static int __devinit ads7846_probe(struct spi_device *spi)
         ts->spi = spi;
         ts->input = input_dev;
 
-        hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_REL);
+        hrtimer_init(&ts->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
         ts->timer.function = ads7846_timer;
 
         spin_lock_init(&ts->lock);
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index 660d91dea78c..44c7d280b1a5 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -25,17 +25,18 @@
  * Mode arguments of xxx_hrtimer functions:
  */
 enum hrtimer_mode {
-        HRTIMER_ABS,    /* Time value is absolute */
-        HRTIMER_REL,    /* Time value is relative to now */
+        HRTIMER_MODE_ABS,       /* Time value is absolute */
+        HRTIMER_MODE_REL,       /* Time value is relative to now */
 };
 
+/*
+ * Return values for the callback function
+ */
 enum hrtimer_restart {
-        HRTIMER_NORESTART,
-        HRTIMER_RESTART,
+        HRTIMER_NORESTART,      /* Timer is not restarted */
+        HRTIMER_RESTART,        /* Timer must be restarted */
 };
 
-#define HRTIMER_INACTIVE        ((void *)1UL)
-
 struct hrtimer_base;
 
 /**
@@ -52,7 +53,7 @@ struct hrtimer_base;
 struct hrtimer {
         struct rb_node          node;
         ktime_t                 expires;
-        int                     (*function)(struct hrtimer *);
+        enum hrtimer_restart    (*function)(struct hrtimer *);
         struct hrtimer_base     *base;
 };
 
@@ -114,7 +115,10 @@ extern int hrtimer_start(struct hrtimer *timer, ktime_t tim,
 extern int hrtimer_cancel(struct hrtimer *timer);
 extern int hrtimer_try_to_cancel(struct hrtimer *timer);
 
-#define hrtimer_restart(timer) hrtimer_start((timer), (timer)->expires, HRTIMER_ABS)
+static inline int hrtimer_restart(struct hrtimer *timer)
+{
+        return hrtimer_start(timer, timer->expires, HRTIMER_MODE_ABS);
+}
 
 /* Query timers: */
 extern ktime_t hrtimer_get_remaining(const struct hrtimer *timer);
diff --git a/include/linux/timer.h b/include/linux/timer.h
index bd0af324fd48..44d41e9d7818 100644
--- a/include/linux/timer.h
+++ b/include/linux/timer.h
@@ -106,7 +106,7 @@ static inline void add_timer(struct timer_list *timer)
 extern void init_timers(void);
 extern void run_local_timers(void);
 struct hrtimer;
-extern int it_real_fn(struct hrtimer *);
+extern enum hrtimer_restart it_real_fn(struct hrtimer *);
 
 unsigned long __round_jiffies(unsigned long j, int cpu);
 unsigned long __round_jiffies_relative(unsigned long j, int cpu);
diff --git a/kernel/fork.c b/kernel/fork.c
index 0b6293d94d96..d154cc786489 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -858,7 +858,7 @@ static inline int copy_signal(unsigned long clone_flags, struct task_struct * ts
         init_sigpending(&sig->shared_pending);
         INIT_LIST_HEAD(&sig->posix_timers);
 
-        hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_REL);
+        hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
         sig->it_real_incr.tv64 = 0;
         sig->real_timer.function = it_real_fn;
         sig->tsk = tsk;
diff --git a/kernel/futex.c b/kernel/futex.c
index 5a737de857d3..e749e7df14b1 100644
--- a/kernel/futex.c
+++ b/kernel/futex.c
@@ -1134,7 +1134,7 @@ static int futex_lock_pi(u32 __user *uaddr, int detect, unsigned long sec,
 
         if (sec != MAX_SCHEDULE_TIMEOUT) {
                 to = &timeout;
-                hrtimer_init(&to->timer, CLOCK_REALTIME, HRTIMER_ABS);
+                hrtimer_init(&to->timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
                 hrtimer_init_sleeper(to, current);
                 to->timer.expires = ktime_set(sec, nsec);
         }
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index bd57ef403049..83fc50416b1d 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -444,7 +444,7 @@ hrtimer_start(struct hrtimer *timer, ktime_t tim, const enum hrtimer_mode mode)
         /* Switch the timer base, if necessary: */
         new_base = switch_hrtimer_base(timer, base);
 
-        if (mode == HRTIMER_REL) {
+        if (mode == HRTIMER_MODE_REL) {
                 tim = ktime_add(tim, new_base->get_time());
                 /*
                  * CONFIG_TIME_LOW_RES is a temporary way for architectures
@@ -583,7 +583,7 @@ void hrtimer_init(struct hrtimer *timer, clockid_t clock_id,
 
         bases = __raw_get_cpu_var(hrtimer_bases);
 
-        if (clock_id == CLOCK_REALTIME && mode != HRTIMER_ABS)
+        if (clock_id == CLOCK_REALTIME && mode != HRTIMER_MODE_ABS)
                 clock_id = CLOCK_MONOTONIC;
 
         timer->base = &bases[clock_id];
@@ -627,7 +627,7 @@ static inline void run_hrtimer_queue(struct hrtimer_base *base)
 
         while ((node = base->first)) {
                 struct hrtimer *timer;
-                int (*fn)(struct hrtimer *);
+                enum hrtimer_restart (*fn)(struct hrtimer *);
                 int restart;
 
                 timer = rb_entry(node, struct hrtimer, node);
@@ -669,7 +669,7 @@ void hrtimer_run_queues(void)
 /*
  * Sleep related functions:
  */
-static int hrtimer_wakeup(struct hrtimer *timer)
+static enum hrtimer_restart hrtimer_wakeup(struct hrtimer *timer)
 {
         struct hrtimer_sleeper *t =
                 container_of(timer, struct hrtimer_sleeper, timer);
@@ -699,7 +699,7 @@ static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mod
                 schedule();
 
                 hrtimer_cancel(&t->timer);
-                mode = HRTIMER_ABS;
+                mode = HRTIMER_MODE_ABS;
 
         } while (t->task && !signal_pending(current));
 
@@ -715,10 +715,10 @@ long __sched hrtimer_nanosleep_restart(struct restart_block *restart)
 
         restart->fn = do_no_restart_syscall;
 
-        hrtimer_init(&t.timer, restart->arg0, HRTIMER_ABS);
+        hrtimer_init(&t.timer, restart->arg0, HRTIMER_MODE_ABS);
         t.timer.expires.tv64 = ((u64)restart->arg3 << 32) | (u64) restart->arg2;
 
-        if (do_nanosleep(&t, HRTIMER_ABS))
+        if (do_nanosleep(&t, HRTIMER_MODE_ABS))
                 return 0;
 
         rmtp = (struct timespec __user *) restart->arg1;
@@ -751,7 +751,7 @@ long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
                 return 0;
 
         /* Absolute timers do not update the rmtp value and restart: */
-        if (mode == HRTIMER_ABS)
+        if (mode == HRTIMER_MODE_ABS)
                 return -ERESTARTNOHAND;
 
         if (rmtp) {
@@ -784,7 +784,7 @@ sys_nanosleep(struct timespec __user *rqtp, struct timespec __user *rmtp)
         if (!timespec_valid(&tu))
                 return -EINVAL;
 
-        return hrtimer_nanosleep(&tu, rmtp, HRTIMER_REL, CLOCK_MONOTONIC);
+        return hrtimer_nanosleep(&tu, rmtp, HRTIMER_MODE_REL, CLOCK_MONOTONIC);
 }
 
 /*
diff --git a/kernel/itimer.c b/kernel/itimer.c
index 204ed7939e75..9cefe1d1eb13 100644
--- a/kernel/itimer.c
+++ b/kernel/itimer.c
@@ -128,7 +128,7 @@ asmlinkage long sys_getitimer(int which, struct itimerval __user *value)
 /*
  * The timer is automagically restarted, when interval != 0
  */
-int it_real_fn(struct hrtimer *timer)
+enum hrtimer_restart it_real_fn(struct hrtimer *timer)
 {
         struct signal_struct *sig =
             container_of(timer, struct signal_struct, real_timer);
@@ -235,7 +235,7 @@ again:
                         timeval_to_ktime(value->it_interval);
                 expires = timeval_to_ktime(value->it_value);
                 if (expires.tv64 != 0)
-                        hrtimer_start(timer, expires, HRTIMER_REL);
+                        hrtimer_start(timer, expires, HRTIMER_MODE_REL);
                 spin_unlock_irq(&tsk->sighand->siglock);
                 break;
         case ITIMER_VIRTUAL:
diff --git a/kernel/posix-timers.c b/kernel/posix-timers.c
index a1bf61617839..210f462c650e 100644
--- a/kernel/posix-timers.c
+++ b/kernel/posix-timers.c
@@ -145,7 +145,7 @@ static int common_timer_set(struct k_itimer *, int,
                             struct itimerspec *, struct itimerspec *);
 static int common_timer_del(struct k_itimer *timer);
 
-static int posix_timer_fn(struct hrtimer *data);
+static enum hrtimer_restart posix_timer_fn(struct hrtimer *data);
 
 static struct k_itimer *lock_timer(timer_t timer_id, unsigned long *flags);
 
@@ -334,12 +334,12 @@ EXPORT_SYMBOL_GPL(posix_timer_event);
 
  * This code is for CLOCK_REALTIME* and CLOCK_MONOTONIC* timers.
  */
-static int posix_timer_fn(struct hrtimer *timer)
+static enum hrtimer_restart posix_timer_fn(struct hrtimer *timer)
 {
         struct k_itimer *timr;
         unsigned long flags;
         int si_private = 0;
-        int ret = HRTIMER_NORESTART;
+        enum hrtimer_restart ret = HRTIMER_NORESTART;
 
         timr = container_of(timer, struct k_itimer, it.real.timer);
         spin_lock_irqsave(&timr->it_lock, flags);
@@ -722,7 +722,7 @@ common_timer_set(struct k_itimer *timr, int flags,
         if (!new_setting->it_value.tv_sec && !new_setting->it_value.tv_nsec)
                 return 0;
 
-        mode = flags & TIMER_ABSTIME ? HRTIMER_ABS : HRTIMER_REL;
+        mode = flags & TIMER_ABSTIME ? HRTIMER_MODE_ABS : HRTIMER_MODE_REL;
         hrtimer_init(&timr->it.real.timer, timr->it_clock, mode);
         timr->it.real.timer.function = posix_timer_fn;
 
@@ -734,7 +734,7 @@ common_timer_set(struct k_itimer *timr, int flags,
         /* SIGEV_NONE timers are not queued ! See common_timer_get */
         if (((timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE)) {
                 /* Setup correct expiry time for relative timers */
-                if (mode == HRTIMER_REL)
+                if (mode == HRTIMER_MODE_REL)
                         timer->expires = ktime_add(timer->expires,
                                                    timer->base->get_time());
                 return 0;
@@ -950,7 +950,8 @@ static int common_nsleep(const clockid_t which_clock, int flags,
                          struct timespec *tsave, struct timespec __user *rmtp)
 {
         return hrtimer_nanosleep(tsave, rmtp, flags & TIMER_ABSTIME ?
-                                 HRTIMER_ABS : HRTIMER_REL, which_clock);
+                                 HRTIMER_MODE_ABS : HRTIMER_MODE_REL,
+                                 which_clock);
 }
 
 asmlinkage long
diff --git a/kernel/rtmutex.c b/kernel/rtmutex.c
index 4ab17da46fd8..180978cb2f75 100644
--- a/kernel/rtmutex.c
+++ b/kernel/rtmutex.c
@@ -625,7 +625,7 @@ rt_mutex_slowlock(struct rt_mutex *lock, int state,
         /* Setup the timer, when timeout != NULL */
         if (unlikely(timeout))
                 hrtimer_start(&timeout->timer, timeout->timer.expires,
-                              HRTIMER_ABS);
+                              HRTIMER_MODE_ABS);
 
         for (;;) {
                 /* Try to acquire the lock: */