static void __exit scc_enet_cleanup(void)
{
struct rtnet_device *rtdev = rtdev_root;
struct scc_enet_private *cep = (struct scc_enet_private *)rtdev->priv;
volatile cpm8xx_t *cp = cpmp;
volatile scc_enet_t *ep;
if (rtdev) {
rt_disable_irq(rtdev->irq);
rt_free_global_irq(rtdev->irq);
ep = (scc_enet_t *)(&cp->cp_dparam[PROFF_ENET]);
m8xx_cpm_dpfree(ep->sen_genscc.scc_rbase);
m8xx_cpm_dpfree(ep->sen_genscc.scc_tbase);
rt_stack_disconnect(rtdev);
rt_unregister_rtnetdev(rtdev);
rt_rtdev_disconnect(rtdev);
printk("%s: unloaded\n", rtdev->name);
rtskb_pool_release(&cep->skb_pool);
rtdev_free(rtdev);
rtdev_root = NULL;
}
}
void cleanup_module(void)
{
rt_free_timer();
rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);
rt_free_global_irq(TIMER_8254_IRQ);
rt_umount_rtai();
}
void rt_free_timer(void)
{
unsigned long flags;
TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_FREE, 0, 0);
flags = hard_lock_all();
rt_free_global_irq(TIMER_8254_IRQ);
irq_desc[TIMER_8254_IRQ].action->handler = linux_timer_interrupt;
hard_unlock_all(flags);
}
void rt_request_timer(void (*handler)(void), unsigned int tick, int unused)
{
RTIME t;
extern union rtai_tsc rtai_tsc;
unsigned long flags;
TRACE_RTAI_TIMER(TRACE_RTAI_EV_TIMER_REQUEST, handler, tick);
flags = hard_lock_all();
/*
* sync w/jiffie, wait for a OS timer 0 match and clear the match bit
*/
rtai_tsc.tsc = 0;
/* wait for a timer match 0 and clear the match bit */
do {
} while ( (signed long)(OSMR0 - OSCR) >= 0 );
OSSR = OSSR_M0;
/* set up rt_times structure */
rt_times.linux_tick = LATCH;
rt_times.periodic_tick = tick > 0 && tick < (RTIME)rt_times.linux_tick ? tick : rt_times.linux_tick;
rt_times.tick_time = t = rdtsc();
rt_times.intr_time = t + (RTIME)rt_times.periodic_tick;
rt_times.linux_time = t + (RTIME)rt_times.linux_tick;
/* Trick the scheduler - set this our way. */
// tuned.setup_time_TIMER_CPUNIT = (int)(~(~0 >> 1)) + 1; /* smallest negative + 1 - for extra safety:-) */
/* update Match-register */
rt_set_timer_match_reg(rt_times.periodic_tick);
irq_desc[TIMER_8254_IRQ].action->handler = soft_timer_interrupt;
rt_free_global_irq(TIMER_8254_IRQ);
rt_request_global_irq(TIMER_8254_IRQ, handler);
/*
* pend linux timer irq to handle current jiffie
*/
rt_pend_linux_irq(TIMER_8254_IRQ);
hard_unlock_all(flags);
return;
}
void cleanup_module(void)
{
rt_shutdown_irq(parirq);
rt_free_global_irq(parirq);
outb(0, PAR_CONTROL);
/* Important: First close the socket! */
while (rt_socket_close(sock) == -EAGAIN) {
printk("rt_server: Socket busy - waiting...\n");
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(1*HZ); /* wait a second */
}
rt_printk("rt_task_delete() = %d\n",rt_task_delete(&rt_task));
rt_sem_delete(&tx_sem);
rtf_destroy(PRINT_FIFO);
}
void cleanup_module(void)
{
rt_shutdown_irq(parirq);
rt_free_global_irq(parirq);
outb(0, PAR_CONTROL);
/* stop timer */
stop_rt_timer();
/* rt_task_delete */
rt_task_delete(&rt_task);
/* close th rt-socket */
rt_socket_close(sock);
rt_sem_delete(&tx_sem);
/* destroy the fifo */
rtf_destroy(PRINT);
}
static long long user_srq(unsigned long whatever)
{
extern int calibrate_8254(void);
unsigned long args[MAXARGS];
int ret;
ret = copy_from_user(args, (unsigned long *)whatever, MAXARGS*sizeof(unsigned long));
switch (args[0]) {
case CAL_8254: {
return calibrate_8254();
break;
}
case KTHREADS:
case KLATENCY: {
rt_set_oneshot_mode();
period = start_rt_timer(nano2count(args[1]));
if (args[0] == KLATENCY) {
rt_task_init_cpuid(&rtask, spv, args[2], STACKSIZE, 0, 0, 0, hard_cpu_id());
} else {
// rt_kthread_init_cpuid(&rtask, spv, args[2], STACKSIZE, 0, 0, 0, hard_cpu_id());
}
expected = rt_get_time() + 100*period;
rt_task_make_periodic(&rtask, expected, period);
break;
}
case END_KLATENCY: {
stop_rt_timer();
rt_task_delete(&rtask);
break;
}
case FREQ_CAL: {
times.intrs = -1;
reset_count = args[1]*HZ;
count = 0;
rt_assign_irq_to_cpu(TIMER_8254_IRQ, 1 << hard_cpu_id());
rt_request_timer(just_ret, COUNT, 1);
rt_request_global_irq(TIMER_8254_IRQ, calibrate);
break;
}
case END_FREQ_CAL: {
rt_free_timer();
rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);
rt_free_global_irq(TIMER_8254_IRQ);
break;
}
case BUS_CHECK: {
loops = maxj = 0;
bus_period = imuldiv(args[1], CPU_FREQ, 1000000000);
bus_threshold = imuldiv(args[2], CPU_FREQ, 1000000000);
use_parport = args[3];
rt_assign_irq_to_cpu(TIMER_8254_IRQ, 1 << hard_cpu_id());
rt_request_timer((void *)rt_timer_tick_ext, imuldiv(args[1], FREQ_8254, 1000000000), 0);
rt_set_global_irq_ext(TIMER_8254_IRQ, 1, 0);
break;
}
case END_BUS_CHECK: {
rt_free_timer();
rt_reset_irq_to_sym_mode(TIMER_8254_IRQ);
break;
}
case GET_PARAMS: {
rtf_put(0, ¶ms, sizeof(params));
break;
}
}
return 0;
}
static int comedi_rt_release_irq(struct comedi_irq_struct *it)
{
rt_shutdown_irq(it->irq);
rt_free_global_irq(it->irq);
return 0;
}
void cleanup_rtai_proxy( void )
{
rt_free_global_irq(TIMER_IRQ);
rt_reset_irq_to_sym_mode(TIMER_IRQ);
printk("MAX INTERRUPT LATENCY: %d\n", tmrcnt);
}
