← Back to branch summary

~ubuntu-branches/ubuntu/lucid/xenomai/lucid

« back to all changes in this revision

Viewing changes to ksrc/nucleus/intr.c

  • Committer: Bazaar Package Importer
  • Author(s): Andres Rodriguez
  • Date: 2009-06-24 22:17:01 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090624221701-mwnah8aj90zmp6uj
Tags: 2.4.8-2ubuntu1
https://launchpad.net/bugs/391918
* Merge from debian unstable (LP: #391918), remaining changes:
  - Add lpia to supported architectures.
  - debian/rules: Create file for debhelper to pick up, use debhelper to
    install it.
  - debian/libxenomai1.dirs: Do not create directory.
  - debian/libxenomai1.preinst: Remove symlink on upgrade, remove old udev.
    rule unless modified in which case move to new name.
  - debian/libxenomai1.postinst: Do not create symlink.
  - debian/libxenomai1.postrm: No symlink to remove.
  - Bump build-depend on debhelper to install udev rules into
    /lib/udev/rules.d, add Breaks on udev to get correct version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ksrc/nucleus/intr.c
84
84
 
85
85
static void xnintr_irq_handler(unsigned irq, void *cookie);
86
86
 
 
87
void xnintr_host_tick(struct xnsched *sched) /* Interrupts off. */
 
88
{
 
89
        __clrbits(sched->status, XNHTICK);
 
90
        xnarch_relay_tick();
 
91
}
 
92
 
87
93
/* Low-level clock irq handler. */
88
94
 
89
95
void xnintr_clock_handler(void)
97
103
 
98
104
        xnarch_announce_tick();
99
105
 
100
 
        trace_mark(xn_nucleus_irq_enter, "irq %u", XNARCH_TIMER_IRQ);
101
 
        trace_mark(xn_nucleus_tbase_tick, "base %s", nktbase.name);
 
106
        trace_mark(xn_nucleus, irq_enter, "irq %u", XNARCH_TIMER_IRQ);
 
107
        trace_mark(xn_nucleus, tbase_tick, "base %s", nktbase.name);
102
108
 
103
109
        ++sched->inesting;
104
110
 
112
118
 
113
119
        if (--sched->inesting == 0 && xnsched_resched_p())
114
120
                xnpod_schedule();
115
 
 
116
 
        /* Since the host tick is low priority, we can wait for returning
117
 
           from the rescheduling procedure before actually calling the
118
 
           propagation service, if it is pending. */
119
 
 
120
 
        if (testbits(sched->status, XNHTICK)) {
121
 
                __clrbits(sched->status, XNHTICK);
122
 
                xnarch_relay_tick();
123
 
        }
124
 
 
125
 
        trace_mark(xn_nucleus_irq_exit, "irq %u", XNARCH_TIMER_IRQ);
 
121
        /*
 
122
         * If the clock interrupt preempted a real-time thread, any
 
123
         * transition to the root thread has already triggered a host
 
124
         * tick propagation from xnpod_schedule(), so at this point,
 
125
         * we only need to propagate the host tick in case the
 
126
         * interrupt preempted the root thread.
 
127
         */
 
128
        if (testbits(sched->status, XNHTICK) &&
 
129
            xnthread_test_state(sched->runthread, XNROOT))
 
130
                xnintr_host_tick(sched);
 
131
 
 
132
        trace_mark(xn_nucleus, irq_exit, "irq %u", XNARCH_TIMER_IRQ);
126
133
        xnstat_exectime_switch(sched, prev);
127
134
}
128
135
 
166
173
 
167
174
        prev  = xnstat_exectime_get_current(sched);
168
175
        start = xnstat_exectime_now();
169
 
        trace_mark(xn_nucleus_irq_enter, "irq %u", irq);
 
176
        trace_mark(xn_nucleus, irq_enter, "irq %u", irq);
170
177
 
171
178
        ++sched->inesting;
172
179
 
210
217
        if (--sched->inesting == 0 && xnsched_resched_p())
211
218
                xnpod_schedule();
212
219
 
213
 
        trace_mark(xn_nucleus_irq_exit, "irq %u", irq);
 
220
        trace_mark(xn_nucleus, irq_exit, "irq %u", irq);
214
221
        xnstat_exectime_switch(sched, prev);
215
222
}
216
223
 
231
238
 
232
239
        prev  = xnstat_exectime_get_current(sched);
233
240
        start = xnstat_exectime_now();
234
 
        trace_mark(xn_nucleus_irq_enter, "irq %u", irq);
 
241
        trace_mark(xn_nucleus, irq_enter, "irq %u", irq);
235
242
 
236
243
        ++sched->inesting;
237
244
 
290
297
        if (--sched->inesting == 0 && xnsched_resched_p())
291
298
                xnpod_schedule();
292
299
 
293
 
        trace_mark(xn_nucleus_irq_exit, "irq %u", irq);
 
300
        trace_mark(xn_nucleus, irq_exit, "irq %u", irq);
294
301
        xnstat_exectime_switch(sched, prev);
295
302
}
296
303
 
332
339
                }
333
340
                shirq->unhandled = 0;
334
341
 
335
 
                err = xnarch_hook_irq(intr->irq, handler, intr->iack, intr);
 
342
                err = xnarch_hook_irq(intr->irq, handler,
 
343
                                      (rthal_irq_ackfn_t)intr->iack, intr);
336
344
                if (err)
337
345
                        return err;
338
346
        }
409
417
 
410
418
static inline int xnintr_irq_attach(xnintr_t *intr)
411
419
{
412
 
        return xnarch_hook_irq(intr->irq, &xnintr_irq_handler, intr->iack, intr);
 
420
        return xnarch_hook_irq(intr->irq, &xnintr_irq_handler,
 
421
                               (rthal_irq_ackfn_t)intr->iack, intr);
413
422
}
414
423
 
415
424
static inline int xnintr_irq_detach(xnintr_t *intr)
441
450
 
442
451
        prev  = xnstat_exectime_get_current(sched);
443
452
        start = xnstat_exectime_now();
444
 
        trace_mark(xn_nucleus_irq_enter, "irq %u", irq);
 
453
        trace_mark(xn_nucleus, irq_enter, "irq %u", irq);
445
454
 
446
455
        ++sched->inesting;
447
456
 
488
497
        if (--sched->inesting == 0 && xnsched_resched_p())
489
498
                xnpod_schedule();
490
499
 
491
 
        trace_mark(xn_nucleus_irq_exit, "irq %u", irq);
 
500
        trace_mark(xn_nucleus, irq_exit, "irq %u", irq);
492
501
        xnstat_exectime_switch(sched, prev);
493
502
}
494
503
 
690
699
        int err;
691
700
        spl_t s;
692
701
 
693
 
        trace_mark(xn_nucleus_irq_attach, "irq %u name %s",
 
702
        trace_mark(xn_nucleus, irq_attach, "irq %u name %s",
694
703
                   intr->irq, intr->name);
695
704
 
696
705
        intr->cookie = cookie;
697
706
        memset(&intr->stat, 0, sizeof(intr->stat));
698
707
 
699
 
        xnlock_get_irqsave(&intrlock, s);
700
 
 
701
708
#ifdef CONFIG_SMP
702
709
        xnarch_set_irq_affinity(intr->irq, nkaffinity);
703
710
#endif /* CONFIG_SMP */
 
711
 
 
712
        xnlock_get_irqsave(&intrlock, s);
 
713
 
704
714
        err = xnintr_irq_attach(intr);
705
715
 
706
716
        if (!err)
747
757
        int err;
748
758
        spl_t s;
749
759
 
750
 
        trace_mark(xn_nucleus_irq_detach, "irq %u", intr->irq);
 
760
        trace_mark(xn_nucleus, irq_detach, "irq %u", intr->irq);
751
761
 
752
762
        xnlock_get_irqsave(&intrlock, s);
753
763
 
788
798
 
789
799
int xnintr_enable(xnintr_t *intr)
790
800
{
791
 
        trace_mark(xn_nucleus_irq_enable, "irq %u", intr->irq);
 
801
        trace_mark(xn_nucleus, irq_enable, "irq %u", intr->irq);
792
802
 
793
803
        return xnarch_enable_irq(intr->irq);
794
804
}
819
829
 
820
830
int xnintr_disable(xnintr_t *intr)
821
831
{
822
 
        trace_mark(xn_nucleus_irq_disable, "irq %u", intr->irq);
 
832
        trace_mark(xn_nucleus, irq_disable, "irq %u", intr->irq);
823
833
 
824
834
        return xnarch_disable_irq(intr->irq);
825
835
}
845
855
 
846
856
xnarch_cpumask_t xnintr_affinity(xnintr_t *intr, xnarch_cpumask_t cpumask)
847
857
{
848
 
        trace_mark(xn_nucleus_irq_affinity, "irq %u %lu",
 
858
        trace_mark(xn_nucleus, irq_affinity, "irq %u %lu",
849
859
                   intr->irq, *(unsigned long *)&cpumask);
850
860
 
851
861
        return xnarch_set_irq_affinity(intr->irq, cpumask);