int ret;
        static int number;
        unsigned long flags;
-       struct timespec ts;
 
        ret = -ENOMEM;
        spu = kzalloc(sizeof (*spu), GFP_KERNEL);
        mutex_unlock(&spu_full_list_mutex);
 
        spu->stats.util_state = SPU_UTIL_IDLE_LOADED;
-       ktime_get_ts(&ts);
-       spu->stats.tstamp = timespec_to_ns(&ts);
+       spu->stats.tstamp = ktime_get_ns();
 
        INIT_LIST_HEAD(&spu->aff_list);
 
 static unsigned long long spu_acct_time(struct spu *spu,
                enum spu_utilization_state state)
 {
-       struct timespec ts;
        unsigned long long time = spu->stats.times[state];
 
        /*
         * statistics are not updated.  Apply the time delta from the
         * last recorded state of the spu.
         */
-       if (spu->stats.util_state == state) {
-               ktime_get_ts(&ts);
-               time += timespec_to_ns(&ts) - spu->stats.tstamp;
-       }
+       if (spu->stats.util_state == state)
+               time += ktime_get_ns() - spu->stats.tstamp;
 
        return time / NSEC_PER_MSEC;
 }
 
 struct spu_context *alloc_spu_context(struct spu_gang *gang)
 {
        struct spu_context *ctx;
-       struct timespec ts;
 
        ctx = kzalloc(sizeof *ctx, GFP_KERNEL);
        if (!ctx)
        __spu_update_sched_info(ctx);
        spu_set_timeslice(ctx);
        ctx->stats.util_state = SPU_UTIL_IDLE_LOADED;
-       ktime_get_ts(&ts);
-       ctx->stats.tstamp = timespec_to_ns(&ts);
+       ctx->stats.tstamp = ktime_get_ns();
 
        atomic_inc(&nr_spu_contexts);
        goto out;
 
 static unsigned long long spufs_acct_time(struct spu_context *ctx,
                enum spu_utilization_state state)
 {
-       struct timespec ts;
        unsigned long long time = ctx->stats.times[state];
 
        /*
         * of the spu context.
         */
        if (ctx->spu && ctx->stats.util_state == state) {
-               ktime_get_ts(&ts);
-               time += timespec_to_ns(&ts) - ctx->stats.tstamp;
+               time += ktime_get_ns() - ctx->stats.tstamp;
        }
 
        return time / NSEC_PER_MSEC;
 
 {
        unsigned long long curtime;
        signed long long delta;
-       struct timespec ts;
        struct spu *spu;
        enum spu_utilization_state old_state;
        int node;
 
-       ktime_get_ts(&ts);
-       curtime = timespec_to_ns(&ts);
+       curtime = ktime_get_ns();
        delta = curtime - ctx->stats.tstamp;
 
        WARN_ON(!mutex_is_locked(&ctx->state_mutex));