192961fd71739d22ad4ff9a65df5a101bc460fbd
[pandora-kernel.git] / drivers / char / mmtimer.c
1 /*
2  * Timer device implementation for SGI SN platforms.
3  *
4  * This file is subject to the terms and conditions of the GNU General Public
5  * License.  See the file "COPYING" in the main directory of this archive
6  * for more details.
7  *
8  * Copyright (c) 2001-2006 Silicon Graphics, Inc.  All rights reserved.
9  *
10  * This driver exports an API that should be supportable by any HPET or IA-PC
11  * multimedia timer.  The code below is currently specific to the SGI Altix
12  * SHub RTC, however.
13  *
14  * 11/01/01 - jbarnes - initial revision
15  * 9/10/04 - Christoph Lameter - remove interrupt support for kernel inclusion
16  * 10/1/04 - Christoph Lameter - provide posix clock CLOCK_SGI_CYCLE
17  * 10/13/04 - Christoph Lameter, Dimitri Sivanich - provide timer interrupt
18  *              support via the posix timer interface
19  */
20
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/ioctl.h>
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/errno.h>
27 #include <linux/mm.h>
28 #include <linux/fs.h>
29 #include <linux/mmtimer.h>
30 #include <linux/miscdevice.h>
31 #include <linux/posix-timers.h>
32 #include <linux/interrupt.h>
33 #include <linux/time.h>
34 #include <linux/math64.h>
35
36 #include <asm/uaccess.h>
37 #include <asm/sn/addrs.h>
38 #include <asm/sn/intr.h>
39 #include <asm/sn/shub_mmr.h>
40 #include <asm/sn/nodepda.h>
41 #include <asm/sn/shubio.h>
42
43 MODULE_AUTHOR("Jesse Barnes <jbarnes@sgi.com>");
44 MODULE_DESCRIPTION("SGI Altix RTC Timer");
45 MODULE_LICENSE("GPL");
46
47 /* name of the device, usually in /dev */
48 #define MMTIMER_NAME "mmtimer"
49 #define MMTIMER_DESC "SGI Altix RTC Timer"
50 #define MMTIMER_VERSION "2.1"
51
52 #define RTC_BITS 55 /* 55 bits for this implementation */
53
54 extern unsigned long sn_rtc_cycles_per_second;
55
56 #define RTC_COUNTER_ADDR        ((long *)LOCAL_MMR_ADDR(SH_RTC))
57
58 #define rtc_time()              (*RTC_COUNTER_ADDR)
59
60 static int mmtimer_ioctl(struct inode *inode, struct file *file,
61                          unsigned int cmd, unsigned long arg);
62 static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma);
63
64 /*
65  * Period in femtoseconds (10^-15 s)
66  */
67 static unsigned long mmtimer_femtoperiod = 0;
68
69 static const struct file_operations mmtimer_fops = {
70         .owner =        THIS_MODULE,
71         .mmap =         mmtimer_mmap,
72         .ioctl =        mmtimer_ioctl,
73 };
74
75 /*
76  * We only have comparison registers RTC1-4 currently available per
77  * node.  RTC0 is used by SAL.
78  */
79 /* Check for an RTC interrupt pending */
80 static int mmtimer_int_pending(int comparator)
81 {
82         if (HUB_L((unsigned long *)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED)) &
83                         SH_EVENT_OCCURRED_RTC1_INT_MASK << comparator)
84                 return 1;
85         else
86                 return 0;
87 }
88
89 /* Clear the RTC interrupt pending bit */
90 static void mmtimer_clr_int_pending(int comparator)
91 {
92         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_EVENT_OCCURRED_ALIAS),
93                 SH_EVENT_OCCURRED_RTC1_INT_MASK << comparator);
94 }
95
96 /* Setup timer on comparator RTC1 */
97 static void mmtimer_setup_int_0(int cpu, u64 expires)
98 {
99         u64 val;
100
101         /* Disable interrupt */
102         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE), 0UL);
103
104         /* Initialize comparator value */
105         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPB), -1L);
106
107         /* Clear pending bit */
108         mmtimer_clr_int_pending(0);
109
110         val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC1_INT_CONFIG_IDX_SHFT) |
111                 ((u64)cpu_physical_id(cpu) <<
112                         SH_RTC1_INT_CONFIG_PID_SHFT);
113
114         /* Set configuration */
115         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_CONFIG), val);
116
117         /* Enable RTC interrupts */
118         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE), 1UL);
119
120         /* Initialize comparator value */
121         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPB), expires);
122
123
124 }
125
126 /* Setup timer on comparator RTC2 */
127 static void mmtimer_setup_int_1(int cpu, u64 expires)
128 {
129         u64 val;
130
131         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE), 0UL);
132
133         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPC), -1L);
134
135         mmtimer_clr_int_pending(1);
136
137         val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC2_INT_CONFIG_IDX_SHFT) |
138                 ((u64)cpu_physical_id(cpu) <<
139                         SH_RTC2_INT_CONFIG_PID_SHFT);
140
141         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_CONFIG), val);
142
143         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE), 1UL);
144
145         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPC), expires);
146 }
147
148 /* Setup timer on comparator RTC3 */
149 static void mmtimer_setup_int_2(int cpu, u64 expires)
150 {
151         u64 val;
152
153         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE), 0UL);
154
155         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPD), -1L);
156
157         mmtimer_clr_int_pending(2);
158
159         val = ((u64)SGI_MMTIMER_VECTOR << SH_RTC3_INT_CONFIG_IDX_SHFT) |
160                 ((u64)cpu_physical_id(cpu) <<
161                         SH_RTC3_INT_CONFIG_PID_SHFT);
162
163         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_CONFIG), val);
164
165         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE), 1UL);
166
167         HUB_S((u64 *)LOCAL_MMR_ADDR(SH_INT_CMPD), expires);
168 }
169
170 /*
171  * This function must be called with interrupts disabled and preemption off
172  * in order to insure that the setup succeeds in a deterministic time frame.
173  * It will check if the interrupt setup succeeded.
174  */
175 static int mmtimer_setup(int cpu, int comparator, unsigned long expires)
176 {
177
178         switch (comparator) {
179         case 0:
180                 mmtimer_setup_int_0(cpu, expires);
181                 break;
182         case 1:
183                 mmtimer_setup_int_1(cpu, expires);
184                 break;
185         case 2:
186                 mmtimer_setup_int_2(cpu, expires);
187                 break;
188         }
189         /* We might've missed our expiration time */
190         if (rtc_time() <= expires)
191                 return 1;
192
193         /*
194          * If an interrupt is already pending then its okay
195          * if not then we failed
196          */
197         return mmtimer_int_pending(comparator);
198 }
199
200 static int mmtimer_disable_int(long nasid, int comparator)
201 {
202         switch (comparator) {
203         case 0:
204                 nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC1_INT_ENABLE),
205                         0UL) : REMOTE_HUB_S(nasid, SH_RTC1_INT_ENABLE, 0UL);
206                 break;
207         case 1:
208                 nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC2_INT_ENABLE),
209                         0UL) : REMOTE_HUB_S(nasid, SH_RTC2_INT_ENABLE, 0UL);
210                 break;
211         case 2:
212                 nasid == -1 ? HUB_S((u64 *)LOCAL_MMR_ADDR(SH_RTC3_INT_ENABLE),
213                         0UL) : REMOTE_HUB_S(nasid, SH_RTC3_INT_ENABLE, 0UL);
214                 break;
215         default:
216                 return -EFAULT;
217         }
218         return 0;
219 }
220
221 #define COMPARATOR      1               /* The comparator to use */
222
223 #define TIMER_OFF       0xbadcabLL      /* Timer is not setup */
224 #define TIMER_SET       0               /* Comparator is set for this timer */
225
226 /* There is one of these for each timer */
227 struct mmtimer {
228         struct rb_node list;
229         struct k_itimer *timer;
230         int cpu;
231 };
232
233 struct mmtimer_node {
234         spinlock_t lock ____cacheline_aligned;
235         struct rb_root timer_head;
236         struct rb_node *next;
237         struct tasklet_struct tasklet;
238 };
239 static struct mmtimer_node *timers;
240
241
242 /*
243  * Add a new mmtimer struct to the node's mmtimer list.
244  * This function assumes the struct mmtimer_node is locked.
245  */
246 static void mmtimer_add_list(struct mmtimer *n)
247 {
248         int nodeid = n->timer->it.mmtimer.node;
249         unsigned long expires = n->timer->it.mmtimer.expires;
250         struct rb_node **link = &timers[nodeid].timer_head.rb_node;
251         struct rb_node *parent = NULL;
252         struct mmtimer *x;
253
254         /*
255          * Find the right place in the rbtree:
256          */
257         while (*link) {
258                 parent = *link;
259                 x = rb_entry(parent, struct mmtimer, list);
260
261                 if (expires < x->timer->it.mmtimer.expires)
262                         link = &(*link)->rb_left;
263                 else
264                         link = &(*link)->rb_right;
265         }
266
267         /*
268          * Insert the timer to the rbtree and check whether it
269          * replaces the first pending timer
270          */
271         rb_link_node(&n->list, parent, link);
272         rb_insert_color(&n->list, &timers[nodeid].timer_head);
273
274         if (!timers[nodeid].next || expires < rb_entry(timers[nodeid].next,
275                         struct mmtimer, list)->timer->it.mmtimer.expires)
276                 timers[nodeid].next = &n->list;
277 }
278
279 /*
280  * Set the comparator for the next timer.
281  * This function assumes the struct mmtimer_node is locked.
282  */
283 static void mmtimer_set_next_timer(int nodeid)
284 {
285         struct mmtimer_node *n = &timers[nodeid];
286         struct mmtimer *x;
287         struct k_itimer *t;
288         int o;
289
290 restart:
291         if (n->next == NULL)
292                 return;
293
294         x = rb_entry(n->next, struct mmtimer, list);
295         t = x->timer;
296         if (!t->it.mmtimer.incr) {
297                 /* Not an interval timer */
298                 if (!mmtimer_setup(x->cpu, COMPARATOR,
299                                         t->it.mmtimer.expires)) {
300                         /* Late setup, fire now */
301                         tasklet_schedule(&n->tasklet);
302                 }
303                 return;
304         }
305
306         /* Interval timer */
307         o = 0;
308         while (!mmtimer_setup(x->cpu, COMPARATOR, t->it.mmtimer.expires)) {
309                 unsigned long e, e1;
310                 struct rb_node *next;
311                 t->it.mmtimer.expires += t->it.mmtimer.incr << o;
312                 t->it_overrun += 1 << o;
313                 o++;
314                 if (o > 20) {
315                         printk(KERN_ALERT "mmtimer: cannot reschedule timer\n");
316                         t->it.mmtimer.clock = TIMER_OFF;
317                         n->next = rb_next(&x->list);
318                         rb_erase(&x->list, &n->timer_head);
319                         kfree(x);
320                         goto restart;
321                 }
322
323                 e = t->it.mmtimer.expires;
324                 next = rb_next(&x->list);
325
326                 if (next == NULL)
327                         continue;
328
329                 e1 = rb_entry(next, struct mmtimer, list)->
330                         timer->it.mmtimer.expires;
331                 if (e > e1) {
332                         n->next = next;
333                         rb_erase(&x->list, &n->timer_head);
334                         mmtimer_add_list(x);
335                         goto restart;
336                 }
337         }
338 }
339
340 /**
341  * mmtimer_ioctl - ioctl interface for /dev/mmtimer
342  * @inode: inode of the device
343  * @file: file structure for the device
344  * @cmd: command to execute
345  * @arg: optional argument to command
346  *
347  * Executes the command specified by @cmd.  Returns 0 for success, < 0 for
348  * failure.
349  *
350  * Valid commands:
351  *
352  * %MMTIMER_GETOFFSET - Should return the offset (relative to the start
353  * of the page where the registers are mapped) for the counter in question.
354  *
355  * %MMTIMER_GETRES - Returns the resolution of the clock in femto (10^-15)
356  * seconds
357  *
358  * %MMTIMER_GETFREQ - Copies the frequency of the clock in Hz to the address
359  * specified by @arg
360  *
361  * %MMTIMER_GETBITS - Returns the number of bits in the clock's counter
362  *
363  * %MMTIMER_MMAPAVAIL - Returns 1 if the registers can be mmap'd into userspace
364  *
365  * %MMTIMER_GETCOUNTER - Gets the current value in the counter and places it
366  * in the address specified by @arg.
367  */
368 static int mmtimer_ioctl(struct inode *inode, struct file *file,
369                          unsigned int cmd, unsigned long arg)
370 {
371         int ret = 0;
372
373         switch (cmd) {
374         case MMTIMER_GETOFFSET: /* offset of the counter */
375                 /*
376                  * SN RTC registers are on their own 64k page
377                  */
378                 if(PAGE_SIZE <= (1 << 16))
379                         ret = (((long)RTC_COUNTER_ADDR) & (PAGE_SIZE-1)) / 8;
380                 else
381                         ret = -ENOSYS;
382                 break;
383
384         case MMTIMER_GETRES: /* resolution of the clock in 10^-15 s */
385                 if(copy_to_user((unsigned long __user *)arg,
386                                 &mmtimer_femtoperiod, sizeof(unsigned long)))
387                         return -EFAULT;
388                 break;
389
390         case MMTIMER_GETFREQ: /* frequency in Hz */
391                 if(copy_to_user((unsigned long __user *)arg,
392                                 &sn_rtc_cycles_per_second,
393                                 sizeof(unsigned long)))
394                         return -EFAULT;
395                 ret = 0;
396                 break;
397
398         case MMTIMER_GETBITS: /* number of bits in the clock */
399                 ret = RTC_BITS;
400                 break;
401
402         case MMTIMER_MMAPAVAIL: /* can we mmap the clock into userspace? */
403                 ret = (PAGE_SIZE <= (1 << 16)) ? 1 : 0;
404                 break;
405
406         case MMTIMER_GETCOUNTER:
407                 if(copy_to_user((unsigned long __user *)arg,
408                                 RTC_COUNTER_ADDR, sizeof(unsigned long)))
409                         return -EFAULT;
410                 break;
411         default:
412                 ret = -ENOSYS;
413                 break;
414         }
415
416         return ret;
417 }
418
419 /**
420  * mmtimer_mmap - maps the clock's registers into userspace
421  * @file: file structure for the device
422  * @vma: VMA to map the registers into
423  *
424  * Calls remap_pfn_range() to map the clock's registers into
425  * the calling process' address space.
426  */
427 static int mmtimer_mmap(struct file *file, struct vm_area_struct *vma)
428 {
429         unsigned long mmtimer_addr;
430
431         if (vma->vm_end - vma->vm_start != PAGE_SIZE)
432                 return -EINVAL;
433
434         if (vma->vm_flags & VM_WRITE)
435                 return -EPERM;
436
437         if (PAGE_SIZE > (1 << 16))
438                 return -ENOSYS;
439
440         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
441
442         mmtimer_addr = __pa(RTC_COUNTER_ADDR);
443         mmtimer_addr &= ~(PAGE_SIZE - 1);
444         mmtimer_addr &= 0xfffffffffffffffUL;
445
446         if (remap_pfn_range(vma, vma->vm_start, mmtimer_addr >> PAGE_SHIFT,
447                                         PAGE_SIZE, vma->vm_page_prot)) {
448                 printk(KERN_ERR "remap_pfn_range failed in mmtimer.c\n");
449                 return -EAGAIN;
450         }
451
452         return 0;
453 }
454
455 static struct miscdevice mmtimer_miscdev = {
456         SGI_MMTIMER,
457         MMTIMER_NAME,
458         &mmtimer_fops
459 };
460
461 static struct timespec sgi_clock_offset;
462 static int sgi_clock_period;
463
464 /*
465  * Posix Timer Interface
466  */
467
468 static struct timespec sgi_clock_offset;
469 static int sgi_clock_period;
470
471 static int sgi_clock_get(clockid_t clockid, struct timespec *tp)
472 {
473         u64 nsec;
474
475         nsec = rtc_time() * sgi_clock_period
476                         + sgi_clock_offset.tv_nsec;
477         *tp = ns_to_timespec(nsec);
478         tp->tv_sec += sgi_clock_offset.tv_sec;
479         return 0;
480 };
481
482 static int sgi_clock_set(clockid_t clockid, struct timespec *tp)
483 {
484
485         u64 nsec;
486         u32 rem;
487
488         nsec = rtc_time() * sgi_clock_period;
489
490         sgi_clock_offset.tv_sec = tp->tv_sec - div_u64_rem(nsec, NSEC_PER_SEC, &rem);
491
492         if (rem <= tp->tv_nsec)
493                 sgi_clock_offset.tv_nsec = tp->tv_sec - rem;
494         else {
495                 sgi_clock_offset.tv_nsec = tp->tv_sec + NSEC_PER_SEC - rem;
496                 sgi_clock_offset.tv_sec--;
497         }
498         return 0;
499 }
500
501 /**
502  * mmtimer_interrupt - timer interrupt handler
503  * @irq: irq received
504  * @dev_id: device the irq came from
505  *
506  * Called when one of the comarators matches the counter, This
507  * routine will send signals to processes that have requested
508  * them.
509  *
510  * This interrupt is run in an interrupt context
511  * by the SHUB. It is therefore safe to locally access SHub
512  * registers.
513  */
514 static irqreturn_t
515 mmtimer_interrupt(int irq, void *dev_id)
516 {
517         unsigned long expires = 0;
518         int result = IRQ_NONE;
519         unsigned indx = cpu_to_node(smp_processor_id());
520         struct mmtimer *base;
521
522         spin_lock(&timers[indx].lock);
523         base = rb_entry(timers[indx].next, struct mmtimer, list);
524         if (base == NULL) {
525                 spin_unlock(&timers[indx].lock);
526                 return result;
527         }
528
529         if (base->cpu == smp_processor_id()) {
530                 if (base->timer)
531                         expires = base->timer->it.mmtimer.expires;
532                 /* expires test won't work with shared irqs */
533                 if ((mmtimer_int_pending(COMPARATOR) > 0) ||
534                         (expires && (expires <= rtc_time()))) {
535                         mmtimer_clr_int_pending(COMPARATOR);
536                         tasklet_schedule(&timers[indx].tasklet);
537                         result = IRQ_HANDLED;
538                 }
539         }
540         spin_unlock(&timers[indx].lock);
541         return result;
542 }
543
544 static void mmtimer_tasklet(unsigned long data)
545 {
546         int nodeid = data;
547         struct mmtimer_node *mn = &timers[nodeid];
548         struct mmtimer *x = rb_entry(mn->next, struct mmtimer, list);
549         struct k_itimer *t;
550         unsigned long flags;
551
552         /* Send signal and deal with periodic signals */
553         spin_lock_irqsave(&mn->lock, flags);
554         if (!mn->next)
555                 goto out;
556
557         x = rb_entry(mn->next, struct mmtimer, list);
558         t = x->timer;
559
560         if (t->it.mmtimer.clock == TIMER_OFF)
561                 goto out;
562
563         t->it_overrun = 0;
564
565         mn->next = rb_next(&x->list);
566         rb_erase(&x->list, &mn->timer_head);
567
568         if (posix_timer_event(t, 0) != 0)
569                 t->it_overrun++;
570
571         if(t->it.mmtimer.incr) {
572                 t->it.mmtimer.expires += t->it.mmtimer.incr;
573                 mmtimer_add_list(x);
574         } else {
575                 /* Ensure we don't false trigger in mmtimer_interrupt */
576                 t->it.mmtimer.clock = TIMER_OFF;
577                 t->it.mmtimer.expires = 0;
578                 kfree(x);
579         }
580         /* Set comparator for next timer, if there is one */
581         mmtimer_set_next_timer(nodeid);
582
583         t->it_overrun_last = t->it_overrun;
584 out:
585         spin_unlock_irqrestore(&mn->lock, flags);
586 }
587
588 static int sgi_timer_create(struct k_itimer *timer)
589 {
590         /* Insure that a newly created timer is off */
591         timer->it.mmtimer.clock = TIMER_OFF;
592         return 0;
593 }
594
595 /* This does not really delete a timer. It just insures
596  * that the timer is not active
597  *
598  * Assumption: it_lock is already held with irq's disabled
599  */
600 static int sgi_timer_del(struct k_itimer *timr)
601 {
602         cnodeid_t nodeid = timr->it.mmtimer.node;
603         unsigned long irqflags;
604
605         spin_lock_irqsave(&timers[nodeid].lock, irqflags);
606         if (timr->it.mmtimer.clock != TIMER_OFF) {
607                 unsigned long expires = timr->it.mmtimer.expires;
608                 struct rb_node *n = timers[nodeid].timer_head.rb_node;
609                 struct mmtimer *uninitialized_var(t);
610                 int r = 0;
611
612                 timr->it.mmtimer.clock = TIMER_OFF;
613                 timr->it.mmtimer.expires = 0;
614
615                 while (n) {
616                         t = rb_entry(n, struct mmtimer, list);
617                         if (t->timer == timr)
618                                 break;
619
620                         if (expires < t->timer->it.mmtimer.expires)
621                                 n = n->rb_left;
622                         else
623                                 n = n->rb_right;
624                 }
625
626                 if (!n) {
627                         spin_unlock_irqrestore(&timers[nodeid].lock, irqflags);
628                         return 0;
629                 }
630
631                 if (timers[nodeid].next == n) {
632                         timers[nodeid].next = rb_next(n);
633                         r = 1;
634                 }
635
636                 rb_erase(n, &timers[nodeid].timer_head);
637                 kfree(t);
638
639                 if (r) {
640                         mmtimer_disable_int(cnodeid_to_nasid(nodeid),
641                                 COMPARATOR);
642                         mmtimer_set_next_timer(nodeid);
643                 }
644         }
645         spin_unlock_irqrestore(&timers[nodeid].lock, irqflags);
646         return 0;
647 }
648
649 /* Assumption: it_lock is already held with irq's disabled */
650 static void sgi_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
651 {
652
653         if (timr->it.mmtimer.clock == TIMER_OFF) {
654                 cur_setting->it_interval.tv_nsec = 0;
655                 cur_setting->it_interval.tv_sec = 0;
656                 cur_setting->it_value.tv_nsec = 0;
657                 cur_setting->it_value.tv_sec =0;
658                 return;
659         }
660
661         cur_setting->it_interval = ns_to_timespec(timr->it.mmtimer.incr * sgi_clock_period);
662         cur_setting->it_value = ns_to_timespec((timr->it.mmtimer.expires - rtc_time()) * sgi_clock_period);
663 }
664
665
666 static int sgi_timer_set(struct k_itimer *timr, int flags,
667         struct itimerspec * new_setting,
668         struct itimerspec * old_setting)
669 {
670         unsigned long when, period, irqflags;
671         int err = 0;
672         cnodeid_t nodeid;
673         struct mmtimer *base;
674         struct rb_node *n;
675
676         if (old_setting)
677                 sgi_timer_get(timr, old_setting);
678
679         sgi_timer_del(timr);
680         when = timespec_to_ns(&new_setting->it_value);
681         period = timespec_to_ns(&new_setting->it_interval);
682
683         if (when == 0)
684                 /* Clear timer */
685                 return 0;
686
687         base = kmalloc(sizeof(struct mmtimer), GFP_KERNEL);
688         if (base == NULL)
689                 return -ENOMEM;
690
691         if (flags & TIMER_ABSTIME) {
692                 struct timespec n;
693                 unsigned long now;
694
695                 getnstimeofday(&n);
696                 now = timespec_to_ns(&n);
697                 if (when > now)
698                         when -= now;
699                 else
700                         /* Fire the timer immediately */
701                         when = 0;
702         }
703
704         /*
705          * Convert to sgi clock period. Need to keep rtc_time() as near as possible
706          * to getnstimeofday() in order to be as faithful as possible to the time
707          * specified.
708          */
709         when = (when + sgi_clock_period - 1) / sgi_clock_period + rtc_time();
710         period = (period + sgi_clock_period - 1)  / sgi_clock_period;
711
712         /*
713          * We are allocating a local SHub comparator. If we would be moved to another
714          * cpu then another SHub may be local to us. Prohibit that by switching off
715          * preemption.
716          */
717         preempt_disable();
718
719         nodeid =  cpu_to_node(smp_processor_id());
720
721         /* Lock the node timer structure */
722         spin_lock_irqsave(&timers[nodeid].lock, irqflags);
723
724         base->timer = timr;
725         base->cpu = smp_processor_id();
726
727         timr->it.mmtimer.clock = TIMER_SET;
728         timr->it.mmtimer.node = nodeid;
729         timr->it.mmtimer.incr = period;
730         timr->it.mmtimer.expires = when;
731
732         n = timers[nodeid].next;
733
734         /* Add the new struct mmtimer to node's timer list */
735         mmtimer_add_list(base);
736
737         if (timers[nodeid].next == n) {
738                 /* No need to reprogram comparator for now */
739                 spin_unlock_irqrestore(&timers[nodeid].lock, irqflags);
740                 preempt_enable();
741                 return err;
742         }
743
744         /* We need to reprogram the comparator */
745         if (n)
746                 mmtimer_disable_int(cnodeid_to_nasid(nodeid), COMPARATOR);
747
748         mmtimer_set_next_timer(nodeid);
749
750         /* Unlock the node timer structure */
751         spin_unlock_irqrestore(&timers[nodeid].lock, irqflags);
752
753         preempt_enable();
754
755         return err;
756 }
757
758 static struct k_clock sgi_clock = {
759         .res = 0,
760         .clock_set = sgi_clock_set,
761         .clock_get = sgi_clock_get,
762         .timer_create = sgi_timer_create,
763         .nsleep = do_posix_clock_nonanosleep,
764         .timer_set = sgi_timer_set,
765         .timer_del = sgi_timer_del,
766         .timer_get = sgi_timer_get
767 };
768
769 /**
770  * mmtimer_init - device initialization routine
771  *
772  * Does initial setup for the mmtimer device.
773  */
774 static int __init mmtimer_init(void)
775 {
776         cnodeid_t node, maxn = -1;
777
778         if (!ia64_platform_is("sn2"))
779                 return 0;
780
781         /*
782          * Sanity check the cycles/sec variable
783          */
784         if (sn_rtc_cycles_per_second < 100000) {
785                 printk(KERN_ERR "%s: unable to determine clock frequency\n",
786                        MMTIMER_NAME);
787                 goto out1;
788         }
789
790         mmtimer_femtoperiod = ((unsigned long)1E15 + sn_rtc_cycles_per_second /
791                                2) / sn_rtc_cycles_per_second;
792
793         if (request_irq(SGI_MMTIMER_VECTOR, mmtimer_interrupt, IRQF_PERCPU, MMTIMER_NAME, NULL)) {
794                 printk(KERN_WARNING "%s: unable to allocate interrupt.",
795                         MMTIMER_NAME);
796                 goto out1;
797         }
798
799         if (misc_register(&mmtimer_miscdev)) {
800                 printk(KERN_ERR "%s: failed to register device\n",
801                        MMTIMER_NAME);
802                 goto out2;
803         }
804
805         /* Get max numbered node, calculate slots needed */
806         for_each_online_node(node) {
807                 maxn = node;
808         }
809         maxn++;
810
811         /* Allocate list of node ptrs to mmtimer_t's */
812         timers = kzalloc(sizeof(struct mmtimer_node)*maxn, GFP_KERNEL);
813         if (timers == NULL) {
814                 printk(KERN_ERR "%s: failed to allocate memory for device\n",
815                                 MMTIMER_NAME);
816                 goto out3;
817         }
818
819         /* Initialize struct mmtimer's for each online node */
820         for_each_online_node(node) {
821                 spin_lock_init(&timers[node].lock);
822                 tasklet_init(&timers[node].tasklet, mmtimer_tasklet,
823                         (unsigned long) node);
824         }
825
826         sgi_clock_period = sgi_clock.res = NSEC_PER_SEC / sn_rtc_cycles_per_second;
827         register_posix_clock(CLOCK_SGI_CYCLE, &sgi_clock);
828
829         printk(KERN_INFO "%s: v%s, %ld MHz\n", MMTIMER_DESC, MMTIMER_VERSION,
830                sn_rtc_cycles_per_second/(unsigned long)1E6);
831
832         return 0;
833
834 out3:
835         kfree(timers);
836         misc_deregister(&mmtimer_miscdev);
837 out2:
838         free_irq(SGI_MMTIMER_VECTOR, NULL);
839 out1:
840         return -1;
841 }
842
843 module_init(mmtimer_init);