static void calcstep(struct channel *c)
/* Used by calcsteps
* SET
*/
{
if (!(c->status&MIXRQ_PLAYING))
return;
if (c->orgdiv)
c->step=imuldiv(imuldiv((c->step>=0)?c->orgfrq:-c->orgfrq, c->orgrate, c->orgdiv)<<8, relpitch, samprate);
else
c->step=0;
c->status&=~MIXRQ_INTERPOLATE;
if (!quality)
{
if (interpolation>1)
c->status|=MIXRQ_INTERPOLATE;
if (interpolation==1)
if (abs(c->step)<=(3<<15))
c->status|=MIXRQ_INTERPOLATE;
} else {
if (interpolation>1)
c->status|=MIXRQ_INTERPOLATEMAX|MIXRQ_INTERPOLATE;
if (interpolation==1)
{
c->status|=MIXRQ_INTERPOLATE;
c->status&=~MIXRQ_INTERPOLATEMAX;
}
}
}
static int rt_timer_tick_ext(int irq, unsigned long data)
{
RTIME t;
int jit;
if (loops++ < INILOOPS) {
t0 = rdtsc();
} else {
t = rdtsc();
if (use_parport) {
outb(bit = 1 - bit, PARPORT);
}
if ((jit = abs((int)(t - t0) - bus_period)) > maxj) {
maxj = jit;
if (maxj > bus_threshold) {
int msg;
msg = imuldiv(maxj, 1000000000, CPU_FREQ);
rtf_put(0, &msg, sizeof(msg));
}
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
hard_sti();
rt_pend_linux_irq(TIMER_8254_IRQ);
return 0;
}
hard_sti();
return 1;
}
static bool_t ParseDecimal(char* s, uint32_t size)
{
uint32_t integer = 0;
while(*s >= '0' && *s <= '9' && size-- > 0)
integer = integer * 10 + *s++ - '0';
if(*s == '.')
{
uint32_t fraction = 0;
uint32_t d = 1;
++s;
--size;
while(*s >= '0' && *s <= '9' && size-- > 0)
{
fraction = fraction * 10 + *s++ - '0';
d *= 10;
}
integer = (integer << 16) + imuldiv(fraction, 65536, d);
}
g_CurrentToken.TokenLength -= size;
g_CurrentToken.Value.nInteger = integer;
return true;
}
static int rt_timer_tick_ext(int irq, unsigned long data)
{
int ret = 1;
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
ret = 0;
}
rt_sched_lock();
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
rt_sched_unlock();
return ret;
}
static void rt_timer_tick(void)
{
cpu_used[NR_RT_CPUS]++;
if (passed++ < 5) {
t0 = rdtsc();
} else {
t = rdtsc();
if ((jit = t - t0 - imuldiv(rt_times.periodic_tick, CPU_FREQ, FREQ_8254)) < 0) {
jit = -jit;
}
if (jit > maxj) {
maxj = jit;
}
t0 = t;
}
rt_times.tick_time = rt_times.intr_time;
rt_times.intr_time = rt_times.tick_time + rt_times.periodic_tick;
rt_set_timer_delay(0);
if (rt_times.tick_time >= rt_times.linux_time) {
rt_times.linux_time += rt_times.linux_tick;
rt_pend_linux_irq(TIMER_8254_IRQ);
}
if (Mode) {
rt_sem_signal(&sem);
} else {
rt_task_resume(&thread);
}
}
int init_module(void)
{
rtf_create_using_bh(CMDF, 4, 0);
rt_mount_rtai();
rt_request_timer(rt_timer_tick, imuldiv(TICK, FREQ_8254, 1000000000), 0);
return 0;
}
static void calcspeed(void)
{
/* Used by SET
* OpenPlayer
*/
if (channelnum)
newtickwidth=imuldiv(256*256*256, samprate, orgspeed*relspeed);
}
int init_module(void)
{
rt_assign_irq_to_cpu(0, 0);
rtf_create(CMDF, 10000);
if (Mode) {
rt_typed_sem_init(&sem, 0, SEM_TYPE);
}
rt_task_init_cpuid(&thread, intr_handler, 0, STACK_SIZE, 0, 0, 0, 0);
rt_task_resume(&thread);
#ifdef IRQEXT
rt_request_timer((void *)rt_timer_tick_ext, imuldiv(TICK, FREQ_8254, 1000000000), 0);
rt_set_global_irq_ext(0, 1, 0);
#else
rt_request_timer((void *)rt_timer_tick, imuldiv(TICK, FREQ_8254, 1000000000), 0);
#endif
SETUP_8254_TSC_EMULATION;
return 0;
}
int init_module(void)
{
tasknode = ddn2nl(TaskNode);
rt_mbx_init(&mbx, 1);
rt_register(nam2num("HDLMBX"), &mbx, IS_MBX, 0);
rt_task_init(&sup_task, sup_fun, 0, 2000, 1, 0, 0);
rt_task_resume(&sup_task);
rt_request_timer(timer_tick, imuldiv(PERIOD, FREQ_8254, 1000000000), 0);
return 0;
}
static void intr_handler(int t) {
while(1) {
cpu_used[hard_cpu_id()]++;
t = imuldiv(maxj, 1000000, CPU_FREQ);
rtf_put(CMDF, &t, sizeof(int));
if (Mode) {
if (rt_sem_wait(&sem) >= SEM_TIMOUT) {
return;
}
} else {
rt_task_suspend(&thread);
}
}
}
static void calibrate(void)
{
static int count = 0, gcount = -1;
static unsigned long tbase, time, temp;
time = apic_read(APIC_TMCCT);
if (gcount < 0) {
tbase = time;
}
gcount++;
if (++count == RESET_COUNT) {
time = tbase - time;
count = imuldiv(time, CLOCK_TICK_RATE, gcount*LATCH);
printk("\n->>> MEASURED APIC_FREQ: %d (hz) [%d (s)], IN USE %d (hz) <<<-\n", count, gcount/100 + 1, FREQ_APIC);
count = 0;
}
rt_pend_linux_irq(TIMER_8254_IRQ);
temp = (apic_read(APIC_ICR) & (~0xCDFFF)) |
(APIC_DM_FIXED | APIC_DEST_ALLINC | LOCAL_TIMER_VECTOR);
apic_write(APIC_ICR, temp);
}
void fun(int thread) {
int skip, average;
average = 0;
for (skip = 0; skip < SKIP; skip++) {
expected += period;
rt_task_wait_period();
average += (int)count2nano(rt_get_time() - expected);
}
if (abs(imuldiv(tuned.setup_time_TIMER_CPUNIT, 1000000000, tuned.cpu_freq) - SETUP_TIME_APIC) < 3) {
rt_printk("\n\n*** '#define LATENCY_APIC %d' (IN USE %d)", LATENCY_APIC + average/SKIP, LATENCY_APIC);
} else {
rt_printk("\n\n*** '#define LATENCY_8254 %d' (IN USE %d)", LATENCY_8254 + average/SKIP, LATENCY_8254);
}
rt_printk(", you can do 'make stop' now ***\n");
while(1) {
rt_task_wait_period();
}
}
int init_module(void)
{
rt_request_timer(rt_timer_tick, imuldiv(TICK, FREQ_8254, 1000000000), 0);
return 0;
}
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;
}
