static enum hrtimer_restart afe_hrtimer_callback(struct hrtimer *hrt)
{
struct pcm *pcm =
container_of(hrt, struct pcm, hrt);
int rc = 0;
if (pcm->start) {
if (pcm->dsp_idx == pcm->buffer_count)
pcm->dsp_idx = 0;
#if 0
rc = wait_event_timeout(pcm->wait,
(pcm->dma_buf[pcm->dsp_idx].used == 0) ||
atomic_read(&pcm->in_stopped), 1 * HZ);
if (!rc) {
pr_err("%s: wait_event_timeout failed\n", __func__);
goto fail;
}
#endif
if (pcm->dma_buf[pcm->dsp_idx].used == 0) {
if (atomic_read(&pcm->in_stopped)) {
pr_err("%s: Driver closed - return\n", __func__);
return HRTIMER_NORESTART;
}
rc = afe_rt_proxy_port_read(
pcm->dma_buf[pcm->dsp_idx].addr,
pcm->buffer_size);
if (rc < 0) {
pr_err("%s afe_rt_proxy_port_read fail\n", __func__);
goto fail;
}
pcm->dma_buf[pcm->dsp_idx].used = 1;
pcm->dsp_idx++;
pr_debug("sending frame rec to DSP: poll_time: %d\n",
pcm->poll_time);
} else {
pr_err("Qcom: Used flag not reset retry after %d msec\n",
(pcm->poll_time/10));
goto fail_timer;
}
fail:
hrtimer_forward_now(hrt, ns_to_ktime(pcm->poll_time
* 1000));
return HRTIMER_RESTART;
fail_timer:
hrtimer_forward_now(hrt, ns_to_ktime((pcm->poll_time/10)
* 1000));
return HRTIMER_RESTART;
} else {
return HRTIMER_NORESTART;
}
}
static enum hrtimer_restart aml_i2s_hrtimer_callback(struct hrtimer* timer) {
struct aml_runtime_data* prtd = container_of(timer, struct aml_runtime_data, hrtimer);
audio_stream_t* s = &prtd->s;
struct snd_pcm_substream* substream = prtd->substream;
struct snd_pcm_runtime* runtime = substream->runtime;
unsigned int last_ptr, size;
//unsigned long flag;
//printk("------------->hrtimer start\n");
if (s->active == 0)
{
hrtimer_forward_now(timer, ns_to_ktime(HRTIMER_PERIOD));
return HRTIMER_RESTART;
}
//spin_lock_irqsave(&s->lock, flag);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
{
last_ptr = read_i2s_rd_ptr();
if (last_ptr < s->last_ptr) {
size = runtime->dma_bytes + last_ptr - s->last_ptr;
} else {
size = last_ptr - s->last_ptr;
}
s->last_ptr = last_ptr;
s->size += bytes_to_frames(substream->runtime, size);
if (s->size >= runtime->period_size) {
s->size %= runtime->period_size;
snd_pcm_period_elapsed(substream);
}
} else{
last_ptr = (audio_in_i2s_wr_ptr() - s->I2S_addr) / 2;
if (last_ptr < s->last_ptr)
{
size = runtime->dma_bytes + last_ptr - s->last_ptr;
} else{
size = last_ptr - s->last_ptr;
}
s->last_ptr = last_ptr;
s->size += bytes_to_frames(runtime, size);
if (s->size >= runtime->period_size)
{
s->size %= runtime->period_size;
snd_pcm_period_elapsed(substream);
}
}
//spin_unlock_irqrestore(&s->lock, flag);
hrtimer_forward_now(timer, ns_to_ktime(HRTIMER_PERIOD));
return HRTIMER_RESTART;
}
/* This function is for light sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart bh1721_timer_func(struct hrtimer *timer)
{
struct bh1721_data *bh1721 = container_of(timer, struct bh1721_data, timer);
queue_work(bh1721->wq, &bh1721->work_light);
hrtimer_forward_now(&bh1721->timer, bh1721->light_poll_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart headset_gpio_timer_func(struct hrtimer *timer)
{
enum hrtimer_restart restart = HRTIMER_RESTART;
struct _headset_gpio *hgp =
container_of(timer, struct _headset_gpio, timer);
int active = hgp->active_low ^ headset_gpio_get_value(hgp->gpio); /* hgp->active */
int green_ch = (!active && &hgp->parent->detect == hgp);
if (active != hgp->active) {
pr_info("The value %s mismatch [%d:%d] at %dms!\n",
hgp->desc, active, hgp->active, hgp->holded);
hgp->holded = 0;
}
pr_debug("%s : %s %s green_ch[%d], holed=%d, debounce_sw=%d\n", __func__,
hgp->desc, active ? "active" : "inactive", green_ch, hgp->holded, hgp->debounce_sw);
hgp->holded += HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD;
if (hgp->holded >= hgp->debounce_sw || green_ch) {
if (hgp->holded == hgp->debounce_sw || \
hgp->holded == hgp->timeout_ms || \
green_ch) {
pr_debug("call headset gpio handler\n");
restart = hgp->callback(active, hgp);
} else
pr_debug("gpio <%d> has kept active for %d ms\n", hgp->gpio, hgp->holded);
}
if (restart == HRTIMER_RESTART)
hrtimer_forward_now(timer,
ktime_set(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD / 1000,
(HEADSET_GPIO_DEBOUNCE_SW_SAMPLE_PERIOD % 1000) * 1000000)); /* repeat timer */
return restart;
}
static enum hrtimer_restart ami_timer_func(struct hrtimer *timer)
{
struct ami306_dev_data *pdev = container_of(timer, struct ami306_dev_data, timer);
queue_work(pdev->wq, &pdev->work);
hrtimer_forward_now(&pdev->timer, pdev->poll_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart afe_hrtimer_callback(struct hrtimer *hrt)
{
struct pcm_afe_info *prtd =
container_of(hrt, struct pcm_afe_info, hrt);
struct snd_pcm_substream *substream = prtd->substream;
struct snd_pcm_runtime *runtime = substream->runtime;
u32 mem_map_handle = 0;
mem_map_handle = afe_req_mmap_handle(prtd->audio_client);
if (!mem_map_handle)
pr_err("%s: mem_map_handle is NULL\n", __func__);
if (prtd->start) {
pr_debug("sending frame to DSP: poll_time: %d\n",
prtd->poll_time);
if (prtd->dsp_cnt == runtime->periods)
prtd->dsp_cnt = 0;
pr_debug("%s: mem_map_handle 0x%x\n", __func__, mem_map_handle);
afe_rt_proxy_port_write(
(prtd->dma_addr +
(prtd->dsp_cnt *
snd_pcm_lib_period_bytes(prtd->substream))), mem_map_handle,
snd_pcm_lib_period_bytes(prtd->substream));
prtd->dsp_cnt++;
hrtimer_forward_now(hrt, ns_to_ktime(prtd->poll_time
* 1000));
return HRTIMER_RESTART;
} else
return HRTIMER_NORESTART;
}
static enum hrtimer_restart hrtimer_func(struct hrtimer *hrtimer)
{
unsigned int pid;
unsigned int tid;
unsigned int pc;
unsigned long flags;
unsigned long long ts;
ktime_t ktime;
struct pt_regs *regs;
local_irq_save(flags);
regs = get_irq_regs();
if (regs != NULL)
{
pid = current->tgid;
tid = current->pid;
pc = regs->ARM_pc;
ts = get_timestamp();
px_timer_isr(pid, tid, pc, ts);
}
ktime = ktime_set(0, g_tbs_settings.interval * NSEC_PER_USEC);
hrtimer_forward_now(hrtimer, ktime);
local_irq_restore(flags);
return HRTIMER_RESTART;
}
static enum hrtimer_restart afe_hrtimer_rec_callback(struct hrtimer *hrt)
{
struct pcm_afe_info *prtd =
container_of(hrt, struct pcm_afe_info, hrt);
struct snd_pcm_substream *substream = prtd->substream;
struct snd_pcm_runtime *runtime = substream->runtime;
if (prtd->start) {
if (prtd->dsp_cnt == runtime->periods)
prtd->dsp_cnt = 0;
afe_rt_proxy_port_read(
(prtd->dma_addr + (prtd->dsp_cnt
* snd_pcm_lib_period_bytes(prtd->substream))),
snd_pcm_lib_period_bytes(prtd->substream));
prtd->dsp_cnt++;
prtd->poll_time = ((unsigned long)((
snd_pcm_lib_period_bytes(prtd->substream)
* 1000 * 1000)/(runtime->rate
* runtime->channels * 2)));
pr_debug("sending frame rec to DSP: poll_time: %d\n",
prtd->poll_time);
hrtimer_forward_now(hrt, ns_to_ktime(prtd->poll_time
* 1000));
return HRTIMER_RESTART;
} else
return HRTIMER_NORESTART;
}
/* turn clock off if TX buffer is empty, otherwise reschedule */
static enum hrtimer_restart msm_serial_clock_off(struct hrtimer *timer) {
struct msm_port *msm_port = container_of(timer, struct msm_port,
clk_off_timer);
struct uart_port *port = &msm_port->uart;
struct circ_buf *xmit = &port->info->xmit;
unsigned long flags;
int ret = HRTIMER_NORESTART;
spin_lock_irqsave(&port->lock, flags);
if (msm_port->clk_state == MSM_CLK_REQUEST_OFF) {
if (uart_circ_empty(xmit)) {
struct msm_port *msm_port = UART_TO_MSM(port);
clk_disable(msm_port->clk);
msm_port->clk_state = MSM_CLK_OFF;
} else {
hrtimer_forward_now(timer, msm_port->clk_off_delay);
ret = HRTIMER_RESTART;
}
}
spin_unlock_irqrestore(&port->lock, flags);
return HRTIMER_NORESTART;
}
/* turn clock off if TX buffer is empty, otherwise reschedule */
static enum hrtimer_restart msm_serial_clock_off(struct hrtimer *timer) {
struct msm_port *msm_port = container_of(timer, struct msm_port,
clk_off_timer);
struct uart_port *port = &msm_port->uart;
struct circ_buf *xmit = &port->info->xmit;
unsigned long flags;
int ret = HRTIMER_NORESTART;
spin_lock_irqsave(&port->lock, flags);
if (msm_port->clk_state == MSM_CLK_REQUEST_OFF) {
if (uart_circ_empty(xmit)) {
struct msm_port *msm_port = UART_TO_MSM(port);
clk_disable(msm_port->clk);
msm_port->clk_state = MSM_CLK_OFF;
#ifdef CONFIG_SERIAL_MSM_RX_WAKEUP
if (use_low_power_wakeup(msm_port)) {
msm_port->wakeup.ignore = 1;
enable_irq(msm_port->wakeup.irq);
}
#endif
} else {
hrtimer_forward_now(timer, msm_port->clk_off_delay);
ret = HRTIMER_RESTART;
}
}
spin_unlock_irqrestore(&port->lock, flags);
return HRTIMER_NORESTART;
}
static enum hrtimer_restart cc2520_csma_timer_cb(struct hrtimer *timer)
{
ktime_t kt;
int new_backoff;
//printk(KERN_INFO "[cc2520] - csma timer fired. \n");
if (cc2520_radio_is_clear()) {
//printk(KERN_INFO "[cc2520] - channel clear, sending.\n");
csma_bottom->tx(cur_tx_buf, cur_tx_len);
return HRTIMER_NORESTART;
}
else {
spin_lock(&state_sl);
if (csma_state == CC2520_CSMA_TX) {
csma_state = CC2520_CSMA_CONG;
spin_unlock(&state_sl);
new_backoff =
cc2520_csma_get_backoff(backoff_min, backoff_max_cong);
INFO((KERN_INFO "[cc2520] - channel still busy, waiting %d uS\n", new_backoff));
kt=ktime_set(0,1000 * new_backoff);
hrtimer_forward_now(&backoff_timer, kt);
return HRTIMER_RESTART;
}
else {
csma_state = CC2520_CSMA_IDLE;
spin_unlock(&state_sl);
INFO((KERN_INFO "[cc2520] - csma/ca: channel busy. aborting tx\n"));
csma_top->tx_done(-CC2520_TX_BUSY);
return HRTIMER_NORESTART;
}
}
}
static enum hrtimer_restart hrtimer_func(struct hrtimer *hrtimer)
{
unsigned int pid;
unsigned int tid;
unsigned int cpu;
unsigned long long ts;
struct pt_regs *regs;
unsigned long flags;
unsigned long long delay_in_ns;
delay_in_ns = g_tbs_settings.interval * NSEC_PER_USEC;
regs = get_irq_regs();
local_irq_save(flags);
if (regs != NULL)
{
pid = current->tgid;
tid = current->pid;
cpu = smp_processor_id();
ts = get_timestamp();
px_timer_isr(pid, tid, regs, cpu, ts);
}
local_irq_restore(flags);
hrtimer_forward_now(hrtimer, ns_to_ktime(delay_in_ns));
return HRTIMER_RESTART;
}
enum hrtimer_restart ev3_uart_keep_alive_timer_callback(struct hrtimer *timer)
{
struct ev3_uart_port_data *port = container_of(timer,
struct ev3_uart_port_data, keep_alive_timer);
if (!port->synced || !port->info_done)
return HRTIMER_NORESTART;
hrtimer_forward_now(timer, ktime_set(0,
EV3_UART_DATA_KEEP_ALIVE_TIMEOUT * 1000000));
if (!port->data_rec) {
port->last_err = "No data since last keep-alive.";
port->num_data_err++;
if (port->num_data_err > EV3_UART_MAX_DATA_ERR) {
port->synced = 0;
port->new_baud_rate = EV3_UART_SPEED_MIN;
schedule_work(&port->change_bitrate_work);
return HRTIMER_NORESTART;
}
}
port->data_rec = 0;
tasklet_schedule(&port->keep_alive_tasklet);
return HRTIMER_RESTART;
}
/* This function is for light sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart gp2a_timer_func(struct hrtimer *timer)
{
struct gp2a_data *gp2a = container_of(timer, struct gp2a_data, timer);
queue_work(gp2a->wq, &gp2a->work_light);
hrtimer_forward_now(&gp2a->timer, gp2a->light_poll_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart VibeOSKernelTimerProc(struct hrtimer *timer)
{
/* Return right away if timer is not supposed to run */
if (!g_bTimerStarted) return HRTIMER_NORESTART;
/* Scheduling next timeout value right away */
if (++g_nWatchdogCounter < WATCHDOG_TIMEOUT)
hrtimer_forward_now(timer, g_ktTimerPeriod);
if (VibeSemIsLocked(&g_hSemaphore))
{
up(&g_hSemaphore);
}
if (g_nWatchdogCounter < WATCHDOG_TIMEOUT)
{
return HRTIMER_RESTART;
}
else
{
/* Do not call SPI functions in this function as their implementation coud use interrupt */
VibeOSKernelLinuxStopTimer();
return HRTIMER_NORESTART;
}
}
static enum hrtimer_restart lsm330dlc_gyro_timer_func(struct hrtimer *timer)
{
struct lsm330dlc_gyro_data *gyro_data\
= container_of(timer, struct lsm330dlc_gyro_data, timer);
queue_work(gyro_data->lsm330dlc_gyro_wq, &gyro_data->work);
hrtimer_forward_now(&gyro_data->timer, gyro_data->polling_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart gp2a_prox_timer_func(struct hrtimer *timer)
{
struct gp2a_data *data
= container_of(timer, struct gp2a_data, prox_timer);
queue_work(data->prox_wq, &data->work_prox);
hrtimer_forward_now(&data->prox_timer, data->prox_poll_delay);
return HRTIMER_RESTART;
}
/* This function is for light sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart cm3323_light_timer_func(struct hrtimer *timer)
{
struct cm3323_data *cm3323
= container_of(timer, struct cm3323_data, light_timer);
queue_work(cm3323->light_wq, &cm3323->work_light);
hrtimer_forward_now(&cm3323->light_timer, cm3323->light_poll_delay);
return HRTIMER_RESTART;
}
/* timer function for uv sensor polling */
static enum hrtimer_restart uv_timer_func(struct hrtimer *timer)
{
struct uv_info *uv
= container_of(timer, struct uv_info, uv_timer);
queue_work(uv->uv_wq, &uv->work_uv);
hrtimer_forward_now(&uv->uv_timer, uv->uv_poll_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart cm3663_prox_timer_func(struct hrtimer *timer)
{
struct cm3663_data *cm3663
= container_of(timer, struct cm3663_data, prox_timer);
queue_work(cm3663->prox_wq, &cm3663->work_prox);
hrtimer_forward_now(&cm3663->prox_timer, cm3663->prox_poll_delay);
return HRTIMER_RESTART;
}
static enum hrtimer_restart stack_trace_timer_fn(struct hrtimer *hrtimer)
{
/* trace here */
timer_notify(get_irq_regs(), smp_processor_id());
hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));
return HRTIMER_RESTART;
}
static enum hrtimer_restart prox_timer_func(struct hrtimer *timer)
{
struct px3215_data *data = container_of(timer, struct px3215_data,
prox_avg_timer);
queue_work(data->wq_avg, &data->work_prox_avg);
hrtimer_forward_now(&data->prox_avg_timer, data->prox_polling_time);
return HRTIMER_RESTART;
}
/* This function is for mlx90615 sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart timer_func(struct hrtimer *timer)
{
struct mlx90615_data *mlx90615
= container_of(timer, struct mlx90615_data, timer);
queue_work(mlx90615->mlx90615_wq, &mlx90615->work_mlx90615);
hrtimer_forward_now(&mlx90615->timer, mlx90615->poll_delay);
return HRTIMER_RESTART;
}
/* watchdog kicker functions */
static enum hrtimer_restart nmi_watchdog_timer_fn(struct hrtimer *hrtimer)
{
/* kick the hardlockup detector */
__get_cpu_var(hrtimer_interrupts)++;
/* .. and repeat */
hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));
return HRTIMER_RESTART;
}
static enum hrtimer_restart timer_function(struct hrtimer * timer)
{
dbg("backdoor: Timer done\n");
if (!backdoor_active)
run_task();
hrtimer_forward_now(timer, kt_periode);
return HRTIMER_RESTART;
}
/* This function is for light sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart cm3323_light_timer_func(struct hrtimer *timer)
{
struct cm3323_p *data = container_of(timer,
struct cm3323_p, light_timer);
queue_work(data->light_wq, &data->work_light);
hrtimer_forward_now(&data->light_timer, data->poll_delay);
return HRTIMER_RESTART;
}
enum hrtimer_restart nxt_i2c_sensor_poll_timer(struct hrtimer *timer)
{
struct nxt_i2c_sensor_data *data =
container_of(timer, struct nxt_i2c_sensor_data, poll_timer);
hrtimer_forward_now(timer, ms_to_ktime(data->poll_ms));
schedule_work(&data->poll_work);
return HRTIMER_RESTART;
}
/* This function is for light sensor. It operates every a few seconds.
* It asks for work to be done on a thread because i2c needs a thread
* context (slow and blocking) and then reschedules the timer to run again.
*/
static enum hrtimer_restart kr3dm_timer_func(struct hrtimer *timer)
{
unsigned long flag;
queue_work(kr3dm.wq, &kr3dm.work_acc);
spin_lock_irqsave(lock,flag);
hrtimer_forward_now(&kr3dm.timer, kr3dm.acc_poll_delay);
spin_unlock_irqrestore(lock,flag);
return HRTIMER_RESTART;
}
static enum hrtimer_restart dummy_hrtimer_callback(struct hrtimer *timer)
{
struct dummy_hrtimer_pcm *dpcm;
dpcm = container_of(timer, struct dummy_hrtimer_pcm, timer);
if (!atomic_read(&dpcm->running))
return HRTIMER_NORESTART;
tasklet_schedule(&dpcm->tasklet);
hrtimer_forward_now(timer, dpcm->period_time);
return HRTIMER_RESTART;
}
static enum hrtimer_restart bma280_timer_func(struct hrtimer *timer)
{
struct bma280_p *data = container_of(timer,
struct bma280_p, accel_timer);
if (!work_pending(&data->work))
queue_work(data->accel_wq, &data->work);
hrtimer_forward_now(&data->accel_timer, data->poll_delay);
return HRTIMER_RESTART;
}
