int arbiter_acquire(struct channel_arbiter_t *a, int timeout)
{
int w = semaphore_wait(&a->sema, timeout);
if(w == OBJ_WAIT_TIMEDOUT)
return w;
mutex_lock(&a->mutex);
int chan = find_first_set_bit(a->free_bm);
if(chan >= a->count)
panicf("arbiter_acquire cannot find a free channel !");
a->free_bm &= ~(1 << chan);
mutex_unlock(&a->mutex);
return chan;
}
bool find_next_run(gc_bit_run_iterator* itr,
long* start,
long* len) {
long run_start = find_first_set_bit(itr->table,
itr->current_index,
itr->end_index);
if((run_start < 0) || ((run_start + 1) == itr->end_index))
return false;
long run_end = find_first_set_bit(itr->table,
run_start + 1,
itr->end_index);
if(run_end < 0) return false;
itr->current_index = min(run_end + 1, itr->end_index);
*start = run_start;
*len = (run_end - run_start + 1);
return true;
}
int imx233_lradc_acquire_channel(int timeout)
{
int w = semaphore_wait(&free_bm_sema, timeout);
if(w == OBJ_WAIT_TIMEDOUT)
return w;
mutex_lock(&free_bm_mutex);
int chan = find_first_set_bit(free_bm);
if(chan >= HW_LRADC_NUM_CHANNELS)
panicf("imx233_lradc_acquire_channel cannot find a free channel !");
free_bm &= ~(1 << chan);
mutex_unlock(&free_bm_mutex);
return chan;
}
asmlinkage void do_softirq(void)
{
unsigned int i, cpu;
unsigned long pending;
/* SCHEDULE_SOFTIRQ may move to anothor processor */
while(1) {
cpu = smp_processor_id();
if ( (pending = softirq_pending(cpu)) == 0 )
break;
i = find_first_set_bit(pending);
clear_bit(i, &softirq_pending(cpu));
(*softirq_handlers[i])();
};
}
asmlinkage void do_softirq(void)
{
unsigned int i, cpu;
unsigned long pending;
for ( ; ; )
{
/*
* Initialise @cpu on every iteration: SCHEDULE_SOFTIRQ may move
* us to another processor.
*/
cpu = smp_processor_id();
if ( rcu_pending(cpu) )
rcu_check_callbacks(cpu);
if ( (pending = softirq_pending(cpu)) == 0 )
break;
i = find_first_set_bit(pending);
clear_bit(i, &softirq_pending(cpu));
(*softirq_handlers[i])();
}
}
const char* test_bit_table() {
gc_bit_table table;
initialize_bit_table(&table, 1023);
if(table.bit_count != 1023) return "initialize failed";
set_bit(&table, 67);
if(table.bits[1] != 0x8) return "set bit 1 failed";
set_bit(&table, 68);
if(table.bits[1] != 0x18) return "set bit 2 failed";
clear_bit(&table, 67);
if(table.bits[1] != 0x10) return "clear bit 1 failed";
set_bit(&table, 64);
set_bit(&table, 63);
if(table.bits[0] != 9223372036854775808UL
|| table.bits[1] != 0x11) {
return "set bit 3 failed";
}
if(!is_bit_set(&table, 63)) return "get bit 1 failed";
if(!is_bit_set(&table, 64)) return "get bit 2 failed";
if(!is_bit_set(&table, 68)) return "get bit 3 failed";
if(find_first_set_bit(&table, 0, 1023) != 63)
return "find first set bit 1 failed";
if(find_first_set_bit(&table, 64, 1023) != 64)
return "find first set bit 2 failed";
if(find_first_set_bit(&table, 65, 1023) != 68)
return "find first set bit 3 failed";
set_bit(&table, 73);
// at this point, 63, 64, 68, and 73 are set
long start_table[] = {63, 68};
long len_table[] = {2, 6};
gc_bit_run_iterator itr;
begin_run_iteration(&table, &itr, 0, 100);
long start = 0;
long len = 0;
long idx = 0;
while(find_next_run(&itr, &start, &len)) {
if((start != start_table[idx]) || (len != len_table[idx]))
return "run iteration 1 failed";
++idx;
}
for(int i = 256; i < 768; ++i)
set_bit(&table, i);
clear_run(&table, 320, 128);
clear_run(&table, 450, 200);
for(int i = 256; i < 768; ++i) {
if(i >= 256 && i < 320 && !is_bit_set(&table, i))
return "clear run 1 failed";
if(i >= 320 && i < 448 && is_bit_set(&table, i))
return "clear run 1 failed";
if(i >= 448 && i < 450 && !is_bit_set(&table, i))
return "clear run 1 failed";
if(i >= 450 && i < 650 && is_bit_set(&table, i))
return "clear run 2 failed";
if(i >= 650 && !is_bit_set(&table, i))
return "clear run 2 failed";
}
finalize_bit_table(&table);
return "passed";
}
