void __init
ia64_native_register_ipi(void)
{
#ifdef CONFIG_SMP
register_percpu_irq(IA64_IPI_VECTOR, &ipi_irqaction);
register_percpu_irq(IA64_IPI_RESCHEDULE, &resched_irqaction);
register_percpu_irq(IA64_IPI_LOCAL_TLB_FLUSH, &tlb_irqaction);
#endif
}
void __init
init_IRQ (void)
{
ia64_register_ipi();
register_percpu_irq(IA64_SPURIOUS_INT_VECTOR, NULL);
#ifdef CONFIG_SMP
#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_DIG)
if (vector_domain_type != VECTOR_DOMAIN_NONE)
register_percpu_irq(IA64_IRQ_MOVE_VECTOR, &irq_move_irqaction);
#endif
#endif
#ifdef CONFIG_PERFMON
pfm_init_percpu();
#endif
platform_irq_init();
}
void __init
time_init (void)
{
register_percpu_irq(IA64_TIMER_VECTOR, &timer_irqaction);
efi_gettimeofday((struct timeval *) &xtime);
ia64_init_itm();
}
void __init
time_init (void)
{
register_percpu_irq(IA64_TIMER_VECTOR, &timer_irqaction);
efi_gettimeofday(&xtime);
ia64_init_itm();
/*
* Initialize wall_to_monotonic such that adding it to xtime will yield zero, the
* tv_nsec field must be normalized (i.e., 0 <= nsec < NSEC_PER_SEC).
*/
set_normalized_timespec(&wall_to_monotonic, -xtime.tv_sec, -xtime.tv_nsec);
}
void __init
time_init (void)
{
register_percpu_irq(IA64_TIMER_VECTOR, &timer_irqaction);
ia64_init_itm();
}
/*!
* @fn int CPUMON_Install_Cpuhooks(VOID)
* @brief Assign the PMU interrupt to the driver
*
* @return zero if successful, non-zero error value if something failed
*
* Install the driver ebs handler onto the PMU interrupt. If perfmon is
* compiled in then we ask perfmon for the interrupt, otherwise we ask the
* kernel...
*
* <I>Special Notes:</I>
*
* @Note This routine is for Itanium(R)-based systems only!
*
* For IA32, the LBRs are not frozen when a PMU interrupt is taken.
* Since the LBRs capture information on every branch, for the LBR
* registers to be useful, we need to freeze them as quickly as
* possible after the interrupt. This means hooking the IDT directly
* to call a driver specific interrupt handler. That happens in the
* vtxsys.S file via samp_get_set_idt_entry. The real routine being
* called first upon PMU interrupt is t_ebs (in vtxsys.S) and that
* routine calls PMI_Interrupt_Handler()...
*
*/
extern void
CPUMON_Install_Cpuhooks (
void
)
{
int status = -1;
SEP_PRINT_DEBUG("CPUMON_Install_Cpuhooks: entered... pmv 0x%p \n", SYS_Read_PMV());
#if defined(PERFMON_V1) || defined(PERFMON_V2_ALT)
/*
* if Perfmon1 or Perfmon2_alt is set, we can use the perfmon.c
* interface to steal perfmon.c's interrupt handler for our use
* perfmon.c has already done register_percpu_irq()
*/
ebs_irq = SEP_PERFMON_IRQ;
desc.handler = &PMI_Interrupt_Handler;
status = CPUMON_INSTALL_INTERRUPT(&desc);
if (status) {
SEP_PRINT_ERROR("CPUMON_Install_Cpuhooks: CPUMON_INSTALL_INTERRUPT returned %d\n",status);
}
#elif !defined(PERFMON_V2)
if (pebs_irqaction) {
return status;
}
#ifdef SA_PERCPU_IRQ_SUPPORTED
ebs_irq = SEP_PERFMON_IRQ;
pebs_irqaction = (struct irqaction *) 1;
status = request_irq(SEP_PERFMON_IRQ,
PMI_Interrupt_Handler,
SA_INTERRUPT | SA_PERCPU_IRQ,
"SEP Sampling",
NULL);
#else
{
pebs_irqaction = kmalloc(sizeof (struct irqaction), GFP_ATOMIC);
if (pebs_irqaction) {
memset(pebs_irqaction, 0, sizeof (struct irqaction));
ebs_irq = SEP_PERFMON_IRQ;
pebs_irqaction->handler = (void *)PMI_Interrupt_Handler;
pebs_irqaction->flags = SA_INTERRUPT;
pebs_irqaction->name = SEP_DRIVER_NAME;
pebs_irqaction->dev_id = NULL;
register_percpu_irq(ebs_irq, pebs_irqaction);
status = 0;
}
else {
SEP_PRINT_WARNING("couldn't kmalloc pebs_irqaction (%d bytes)\n",
(int)sizeof(struct irqaction));
}
}
#endif
#endif
SEP_PRINT("IRQ vector 0x%x will be used for handling PMU interrupts\n", SEP_PERFMON_IRQ);
SEP_PRINT_DEBUG("CPUMON_Install_Cpuhooks: exit...... rc=0x%x pmv=0x%p \n",
status, SYS_Read_PMV());
return;
}
