static int key_gpio_timer_function(struct timer_t * timer, void * data)
{
struct input_t * input = (struct input_t *)(data);
struct key_gpio_private_data_t * dat = (struct key_gpio_private_data_t *)input->priv;
struct key_gpio_data_t * rdat = (struct key_gpio_data_t *)dat->rdat;
enum event_type_t type;
int i, val;
for(i = 0; i < rdat->nbutton; i++)
{
val = gpio_get_value(rdat->buttons[i].gpio);
if(val != dat->state[i])
{
if(rdat->buttons[i].active_low)
type = val ? EVENT_TYPE_KEY_UP : EVENT_TYPE_KEY_DOWN;
else
type = val ? EVENT_TYPE_KEY_DOWN : EVENT_TYPE_KEY_UP;
if(type == EVENT_TYPE_KEY_DOWN)
push_event_key_down(input, rdat->buttons[i].key);
else if(type == EVENT_TYPE_KEY_UP)
push_event_key_up(input, rdat->buttons[i].key);
}
dat->state[i] = val;
}
timer_forward_now(timer, ms_to_ktime(100));
return 1;
}
static int motor_gpio_timer_function(struct timer_t * timer, void * data)
{
struct motor_t * m = (struct motor_t *)(data);
struct motor_gpio_pdata_t * pdat = (struct motor_gpio_pdata_t *)m->priv;
if(pdat->speed < 0)
{
pdat->flag = !pdat->flag;
if(pdat->flag)
{
gpio_set_value(pdat->a, 0);
gpio_set_value(pdat->b, 1);
timer_forward_now(&pdat->timer, ns_to_ktime(pdat->duty));
}
else
{
gpio_set_value(pdat->a, 0);
gpio_set_value(pdat->b, 0);
timer_forward_now(&pdat->timer, ns_to_ktime(pdat->period - pdat->duty));
}
return 1;
}
else if(pdat->speed > 0)
{
pdat->flag = !pdat->flag;
if(pdat->flag)
{
gpio_set_value(pdat->b, 0);
gpio_set_value(pdat->a, 1);
timer_forward_now(&pdat->timer, ns_to_ktime(pdat->duty));
}
else
{
gpio_set_value(pdat->b, 0);
gpio_set_value(pdat->a, 0);
timer_forward_now(&pdat->timer, ns_to_ktime(pdat->period - pdat->duty));
}
return 1;
}
pdat->flag = 0;
gpio_set_value(pdat->a, 0);
gpio_set_value(pdat->b, 0);
return 0;
}
static int buzzer_pwm_timer_function(struct timer_t * timer, void * data)
{
struct buzzer_t * buzzer = (struct buzzer_t *)(data);
struct buzzer_pwm_pdata_t * pdat = (struct buzzer_pwm_pdata_t *)buzzer->priv;
struct beep_param_t * param = queue_pop(pdat->beep);
if(!param)
{
buzzer_pwm_set(buzzer, 0);
return 0;
}
buzzer_pwm_set(buzzer, param->frequency);
timer_forward_now(&pdat->timer, ms_to_ktime(param->millisecond));
free(param);
return 1;
}
static int clocksource_keeper_timer_function(struct timer_t * timer, void * data)
{
struct clocksource_t * cs = (struct clocksource_t *)(data);
u64_t now, delta, offset;
irq_flags_t flags;
write_seqlock_irqsave(&cs->keeper.lock, flags);
now = clocksource_cycle(cs);
delta = clocksource_delta(cs, cs->keeper.last, now);
offset = clocksource_delta2ns(cs, delta);
cs->keeper.nsec += offset;
cs->keeper.last = now;
write_sequnlock_irqrestore(&cs->keeper.lock, flags);
timer_forward_now(timer, ns_to_ktime(cs->keeper.interval));
return 1;
}
static int ledtrig_general_timer_function(struct timer_t * timer, void * data)
{
struct ledtrig_t * trigger = (struct ledtrig_t *)(data);
struct ledtrig_general_pdata_t * pdat = (struct ledtrig_general_pdata_t *)trigger->priv;
if(pdat->last_activity != pdat->activity)
{
pdat->last_activity = pdat->activity;
led_set_brightness(pdat->led, CONFIG_MAX_BRIGHTNESS);
timer_forward_now(timer, ms_to_ktime(20));
return 1;
}
else
{
led_set_brightness(pdat->led, 0);
return 0;
}
}
static int heartbeat_timer_function(struct timer_t * timer, void * data)
{
struct ledtrig_t * trigger = (struct ledtrig_t *)(data);
struct ledtrig_heartbeat_data_t * dat = (struct ledtrig_heartbeat_data_t *)trigger->priv;
struct led_t * led = (struct led_t *)(trigger->led);
int brightness = 0;
u32_t delay = 0;
/*
* Acts like an actual heart beat -- thump-thump-pause ...
*/
switch(dat->phase)
{
case 0:
dat->period = 1260;
delay = 70;
dat->phase++;
brightness = CONFIG_MAX_BRIGHTNESS;
break;
case 1:
delay = dat->period / 4 - 70;
dat->phase++;
brightness = 0;
break;
case 2:
delay = 70;
dat->phase++;
brightness = CONFIG_MAX_BRIGHTNESS;
break;
default:
delay = dat->period - dat->period / 4 - 70;
dat->phase = 0;
brightness = 0;
break;
}
led_set_brightness(led, brightness);
timer_forward_now(timer, ms_to_ktime(delay));
return 1;
}
