/* The caller shall take enable_sem write semaphore to avoid any timer race.
* The cpu_timer and cpu_slack_timer must be deactivated when calling this
* function.
*/
static void cpufreq_interactive_timer_start(
struct cpufreq_interactive_tunables *tunables, int cpu,
int time_override)
{
struct cpufreq_interactive_cpuinfo *pcpu = &per_cpu(cpuinfo, cpu);
unsigned long flags;
unsigned long expires;
if (time_override)
expires = jiffies + time_override;
else
expires = jiffies + usecs_to_jiffies(tunables->timer_rate);
pcpu->cpu_timer.expires = expires;
add_timer_on(&pcpu->cpu_timer, cpu);
if (tunables->timer_slack_val >= 0 &&
pcpu->target_freq > pcpu->policy->min) {
expires += usecs_to_jiffies(tunables->timer_slack_val);
pcpu->cpu_slack_timer.expires = expires;
add_timer_on(&pcpu->cpu_slack_timer, cpu);
}
spin_lock_irqsave(&pcpu->load_lock, flags);
pcpu->time_in_idle =
get_cpu_idle_time(cpu, &pcpu->time_in_idle_timestamp,
tunables->io_is_busy);
pcpu->cputime_speedadj = 0;
pcpu->cputime_speedadj_timestamp = pcpu->time_in_idle_timestamp;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
}
/* The caller shall take enable_sem write semaphore to avoid any timer race.
* The cpu_timer and cpu_slack_timer must be deactivated when calling this
* function.
*/
static void cpufreq_interactive_timer_start(int cpu)
{
struct cpufreq_interactive_cpuinfo *pcpu = &per_cpu(cpuinfo, cpu);
u64 expires = round_to_nw_start(pcpu->last_evaluated_jiffy);
unsigned long flags;
u64 now = ktime_to_us(ktime_get());
pcpu->cpu_timer.expires = expires;
add_timer_on(&pcpu->cpu_timer, cpu);
if (timer_slack_val >= 0 &&
(pcpu->target_freq > pcpu->policy->min ||
(pcpu->target_freq == pcpu->policy->min &&
now < boostpulse_endtime))) {
expires += usecs_to_jiffies(timer_slack_val);
pcpu->cpu_slack_timer.expires = expires;
add_timer_on(&pcpu->cpu_slack_timer, cpu);
}
spin_lock_irqsave(&pcpu->load_lock, flags);
pcpu->time_in_idle =
get_cpu_idle_time(cpu, &pcpu->time_in_idle_timestamp, io_is_busy);
pcpu->cputime_speedadj = 0;
pcpu->cputime_speedadj_timestamp = pcpu->time_in_idle_timestamp;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
}
static void cpufreq_interactive_timer_resched(unsigned long cpu)
{
struct cpufreq_interactive_cpuinfo *pcpu = &per_cpu(cpuinfo, cpu);
u64 expires;
unsigned long flags;
spin_lock_irqsave(&pcpu->load_lock, flags);
pcpu->time_in_idle =
get_cpu_idle_time(smp_processor_id(),
&pcpu->time_in_idle_timestamp, io_is_busy);
pcpu->cputime_speedadj = 0;
pcpu->cputime_speedadj_timestamp = pcpu->time_in_idle_timestamp;
expires = round_to_nw_start(pcpu->last_evaluated_jiffy);
del_timer(&pcpu->cpu_timer);
pcpu->cpu_timer.expires = expires;
add_timer_on(&pcpu->cpu_timer, cpu);
if (timer_slack_val >= 0 && pcpu->target_freq > pcpu->policy->min) {
expires += usecs_to_jiffies(timer_slack_val);
del_timer(&pcpu->cpu_slack_timer);
pcpu->cpu_slack_timer.expires = expires;
add_timer_on(&pcpu->cpu_slack_timer, cpu);
}
spin_unlock_irqrestore(&pcpu->load_lock, flags);
}
void dp_bfd_timer_echo_send_callback(unsigned long mydis)
{
dp_bfd_session_s *session;
session = dp_bfd_find_session_simple(mydis);
if(NULL == session)
{
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_echo_send_callback session not found\n");
return;
}
session->flag &= (~DP_BFD_ECHOSEND_TIMER_ON);
dp_bfd_send_msg(session, DP_BFD_SEND_ECHO_PACKET);
if(!(session->flag & DP_BFD_ECHOSEND_TIMER_ON))
{
session->echo_send_timer.expires = jiffies + session->echo_send_interval;
session->echo_send_timer.data = mydis;
session->echo_send_timer.function = dp_bfd_timer_echo_send_callback;
add_timer_on(&session->echo_send_timer, 1);
session->flag |= DP_BFD_ECHOSEND_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_echo_send_callback add echo_send_timer\n");
}
else
{
mod_timer(&session->echo_send_timer, jiffies + session->echo_send_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_echo_send_callback mod echo_send_timer\n");
}
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
}
static void timelimit_expire(unsigned long timeout_seconds)
{
char msg[128];
int msglen = 127;
if (timeout_seconds) {
if (timeout_seconds >= 60)
snprintf(msg, msglen,
"Uptime: kernel validity duration has %d %s remaining\n",
(int) timeout_seconds / 60, "minute(s)");
else
snprintf(msg, msglen,
"Uptime: kernel validity duration has %d %s remaining\n",
(int) timeout_seconds, "seconds");
printk(KERN_CRIT "%s", msg);
timelimit_timer.expires = jiffies + timeout_seconds * HZ;
timelimit_timer.data = 0;
add_timer_on(&timelimit_timer, cpumask_first(cpu_online_mask));
} else {
printk(KERN_CRIT "Uptime: Kernel validity timeout has expired\n");
#ifdef CONFIG_UPTIME_LIMIT_KERNEL_REBOOT
uptime_expiration_action = uptime_reboot;
wake_up_process(uptime_worker_task);
}
#endif
}
static void gpu_dvfs_timer_control(bool enable)
{
unsigned long flags;
struct kbase_device *kbdev = pkbdev;
struct exynos_context *platform = (struct exynos_context *) kbdev->platform_context;
DVFS_ASSERT(platform);
if (!platform->dvfs_status) {
GPU_LOG(DVFS_ERROR, DUMMY, 0u, 0u, "%s: DVFS is disabled\n", __func__);
return;
}
if (kbdev->pm.metrics.timer_active && !enable) {
#if !defined(SLSI_SUBSTITUTE)
hrtimer_cancel(&kbdev->pm.metrics.timer);
#else
del_timer(&kbdev->pm.metrics.tlist);
#endif /* SLSI_SUBSTITUTE */
} else if (!kbdev->pm.metrics.timer_active && enable) {
#if !defined(SLSI_SUBSTITUTE)
hrtimer_start(&kbdev->pm.metrics.timer, HR_TIMER_DELAY_MSEC(platform->polling_speed), HRTIMER_MODE_REL);
#else
kbdev->pm.metrics.tlist.expires = jiffies + msecs_to_jiffies(platform->polling_speed);
add_timer_on(&kbdev->pm.metrics.tlist, 0);
#endif /* SLSI_SUBSTITUTE */
spin_lock_irqsave(&platform->gpu_dvfs_spinlock, flags);
platform->down_requirement = platform->table[platform->step].stay_count;
spin_unlock_irqrestore(&platform->gpu_dvfs_spinlock, flags);
}
spin_lock_irqsave(&kbdev->pm.metrics.lock, flags);
kbdev->pm.metrics.timer_active = enable;
spin_unlock_irqrestore(&kbdev->pm.metrics.lock, flags);
}
static void pet_watchdog_timer_fn(unsigned long data)
{
/* pr_err("%s kicking...\n", __func__); */
writel(watchdog_reset * TPS, S3C2410_WTCNT);
pet_watchdog_timer.expires += watchdog_pet * HZ;
add_timer_on(&pet_watchdog_timer, 0);
}
static void watchdog_start(void)
{
unsigned int val;
unsigned long flags;
spin_lock_irqsave(&wdt_lock, flags);
/* set to PCLK / 256 / 128 */
val = S3C2410_WTCON_DIV128;
val |= S3C2410_WTCON_PRESCALE(255);
writel(val, S3C2410_WTCON);
/* program initial count */
writel(watchdog_reset * TPS, S3C2410_WTCNT);
writel(watchdog_reset * TPS, S3C2410_WTDAT);
/* start timer */
val |= S3C2410_WTCON_RSTEN | S3C2410_WTCON_ENABLE;
writel(val, S3C2410_WTCON);
spin_unlock_irqrestore(&wdt_lock, flags);
/* make sure we're ready to pet the dog */
#if defined(PET_BY_WORKQUEUE)
queue_delayed_work_on(0, watchdog_wq, &watchdog_work,
watchdog_pet * HZ);
#elif defined(PET_BY_DIRECT_TIMER)
pet_watchdog_timer.expires = jiffies + watchdog_pet * HZ;
add_timer_on(&pet_watchdog_timer, 0);
#else
hrtimer_start(&watchdog_timer,
ktime_set(watchdog_pet, 0), HRTIMER_MODE_REL);
#endif
}
/* 应删除循环握手定时器, 添加发送定时器和接收定时器 */
u32 dp_bfd_down_to_up(dp_bfd_packet_s *packet, dp_bfd_session_s *session)
{
session->packet.your_discriminator = packet->my_discriminator;
session->remote_dmti = packet->min_tx_interval;
session->remote_rmri = packet->min_rx_interval;
session->remote_dm = packet->detect_mult;
if(DP_BFD_SET == packet->a)
{
dp_bfd_auth_seq_deal(session);
/*如果验证方式为MD5或SHA1重新计算digest*/
session->flag |= DP_BFD_FILL_AUTH;
}
/*立即响应握手报文*/
dp_bfd_send_msg(session, DP_BFD_SEND_CONTROL_PACKET);
/*修改BFD报文发送定时器*/
session->send_interval = (HZ)*DP_BFD_GET_MAX(session->packet.min_tx_interval, packet->min_rx_interval)/1000/1000;
if(session->bfd_cyc_switch)
{
session->bfd_cyc_switch = 0;
}
if(!(session->flag & DP_BFD_SEND_TIMER_ON))
{
session->send_timer.expires = jiffies + session->send_interval;
session->send_timer.data = (unsigned long)(session->packet.my_discriminator);
session->send_timer.function = dp_bfd_timer_send_callback;
add_timer_on(&session->send_timer, 1);
session->flag |= DP_BFD_SEND_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_down_to_up send_timer\n");
}
else
{
mod_timer(&session->send_timer, jiffies + session->send_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_down_to_up mod send_timer\n");
}
/*添加BFD报文接收定时器*/
dp_bfd_timer_receive_add(session, packet);
if(session->packet.min_echo_rx_interval != 0)
{
dp_bfd_echo_enable(session);
}
/*向用户态发送消息*/
session->state = UP;
session->fail = 0;
dp_bfd_send_event(session, EVENT_BFD_DOWN_TO_UP, BFD_EVENT_CRUCIAL);
return NF_DROP;
}
/* The caller shall take enable_sem write semaphore to avoid any timer race.
* The cpu_timer and cpu_slack_timer must be deactivated when calling this
* function.
*/
static void cpufreq_interactive_timer_start(int cpu)
{
struct cpufreq_interactive_cpuinfo *pcpu = &per_cpu(cpuinfo, cpu);
unsigned long expires = jiffies + usecs_to_jiffies(pcpu->timer_rate);
unsigned long flags;
pcpu->cpu_timer.expires = expires;
add_timer_on(&pcpu->cpu_timer, cpu);
if (pcpu->timer_slack_val >= 0 && pcpu->target_freq > pcpu->policy->min) {
expires += usecs_to_jiffies(pcpu->timer_slack_val);
pcpu->cpu_slack_timer.expires = expires;
add_timer_on(&pcpu->cpu_slack_timer, cpu);
}
spin_lock_irqsave(&pcpu->load_lock, flags);
pcpu->cputime_speedadj = 0;
pcpu->cputime_speedadj_timestamp = pcpu->time_in_idle_timestamp;
spin_unlock_irqrestore(&pcpu->load_lock, flags);
}
/*
* Schedule the timer to fire immediately. This is a helper function for
* atomic notification from scheduler so that CPU load can be re-evaluated
* immediately. Since we are just re-evaluating previous window's load, we
* should not push back slack timer.
*/
static void cpufreq_interactive_timer_resched_now(unsigned long cpu)
{
unsigned long flags;
struct cpufreq_interactive_cpuinfo *pcpu = &per_cpu(cpuinfo, cpu);
spin_lock_irqsave(&pcpu->load_lock, flags);
del_timer(&pcpu->cpu_timer);
pcpu->cpu_timer.expires = jiffies;
add_timer_on(&pcpu->cpu_timer, cpu);
spin_unlock_irqrestore(&pcpu->load_lock, flags);
}
void dp_bfd_timer_send_callback(unsigned long mydis)
{
dp_bfd_session_s *session;
session = dp_bfd_find_session_simple(mydis);
if(NULL == session)
{
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_send_callback session not found\n");
return;
}
session->flag &= (~DP_BFD_SEND_TIMER_ON);
if(session->bfd_cyc_switch)
{
session->bfd_cyc_handshake_time++;
if(session->bfd_cyc_handshake_time >= BFD_CYC_HANDSHAKE_TIMEOUT)
{
session->bfd_cyc_switch = 0;
session->fail = 1;
dp_bfd_send_event(session, EVENT_BFD_CYC_HANDSHAKE_TIMEOUT, BFD_EVENT_CRUCIAL);
}
}
if(!(session->flag & DP_BFD_SEND_TIMER_ON))
{
session->send_timer.expires = jiffies + session->send_interval;
session->send_timer.data = mydis;
session->send_timer.function = dp_bfd_timer_send_callback;
add_timer_on(&session->send_timer, 1);
session->flag |= DP_BFD_SEND_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_send_callback add send_timer\n");
}
else
{
mod_timer(&session->send_timer, jiffies + session->send_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_send_callback mod send_timer\n");
}
dp_bfd_send_msg(session, DP_BFD_SEND_CONTROL_PACKET);
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
}
static int gpu_dvfs_on_off(struct kbase_device *kbdev, bool enable)
{
unsigned long flags;
struct exynos_context *platform = (struct exynos_context *)kbdev->platform_context;
if (!platform)
return -ENODEV;
if (enable && !platform->dvfs_status) {
platform->dvfs_status = true;
gpu_control_state_set(kbdev, GPU_CONTROL_CHANGE_CLK_VOL, platform->cur_clock);
gpu_dvfs_handler_init(kbdev);
if (!kbdev->pm.metrics.timer_active) {
spin_lock_irqsave(&kbdev->pm.metrics.lock, flags);
kbdev->pm.metrics.timer_active = true;
spin_unlock_irqrestore(&kbdev->pm.metrics.lock, flags);
#if !defined(SLSI_SUBSTITUTE)
hrtimer_start(&kbdev->pm.metrics.timer, HR_TIMER_DELAY_MSEC(platform->polling_speed), HRTIMER_MODE_REL);
#else
kbdev->pm.metrics.tlist.expires = jiffies + msecs_to_jiffies(platform->polling_speed);
add_timer_on(&kbdev->pm.metrics.tlist, 0);
#endif
}
} else if (!enable && platform->dvfs_status) {
platform->dvfs_status = false;
gpu_dvfs_handler_deinit(kbdev);
gpu_control_state_set(kbdev, GPU_CONTROL_CHANGE_CLK_VOL, MALI_DVFS_BL_CONFIG_FREQ);
if (kbdev->pm.metrics.timer_active) {
spin_lock_irqsave(&kbdev->pm.metrics.lock, flags);
kbdev->pm.metrics.timer_active = false;
spin_unlock_irqrestore(&kbdev->pm.metrics.lock, flags);
#if !defined(SLSI_SUBSTITUTE)
hrtimer_cancel(&kbdev->pm.metrics.timer);
#else
del_timer(&kbdev->pm.metrics.tlist);
#endif
}
} else {
GPU_LOG(DVFS_WARNING, "impossible state to change dvfs status (current: %d, request: %d)\n",
platform->dvfs_status, enable);
return -1;
}
return 0;
}
inline void dp_bfd_timer_handshake_add(dp_bfd_session_s *session)
{
if(!(session->flag & DP_BFD_HANDSHAKE_TIMER_ON))
{
session->handshake_timer.expires= jiffies + (HZ)*HAND_SHAKE_TIME/1000;
session->handshake_timer.data = (unsigned long)(session->packet.my_discriminator);
session->handshake_timer.function = dp_bfd_timer_handshake_callback;
add_timer_on(&session->handshake_timer, 1);
session->flag |= DP_BFD_HANDSHAKE_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_handshake_add add handshake_timer\n");
}
else
{
mod_timer(&session->handshake_timer, jiffies + (HZ)*HAND_SHAKE_TIME/1000);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_handshake_add mod handshake_timer\n");
}
}
static int timeout_enable(int cpu)
{
int err = 0;
int warning_limit;
/*
* Create an uptime worker thread. This thread is required since the
* safe version of kernel restart cannot be called from a
* non-interruptible context. Which means we cannot call it directly
* from a timer callback. So we arrange for the timer expiration to
* wakeup a thread, which performs the action.
*/
uptime_worker_task = kthread_create(uptime_worker,
(void *)(unsigned long)cpu,
"uptime_worker/%d", cpu);
if (IS_ERR(uptime_worker_task)) {
printk(KERN_ERR "Uptime: task for cpu %i failed\n", cpu);
err = PTR_ERR(uptime_worker_task);
goto out;
}
/* bind to cpu0 to avoid migration and hot plug nastiness */
kthread_bind(uptime_worker_task, cpu);
wake_up_process(uptime_worker_task);
/* Create the timer that will wake the uptime thread at expiration */
init_timer(&timelimit_timer);
timelimit_timer.function = timelimit_expire;
/*
* Fire two timers. One warning timeout and the final timer
* which will carry out the expiration action. The warning timer will
* expire at the minimum of half the original time or ten minutes.
*/
warning_limit = MIN(UPTIME_LIMIT_IN_SECONDS/2, TEN_MINUTES_IN_SECONDS);
timelimit_timer.expires = jiffies + warning_limit * HZ;
timelimit_timer.data = UPTIME_LIMIT_IN_SECONDS - warning_limit;
add_timer_on(&timelimit_timer, cpumask_first(cpu_online_mask));
out:
return err;
}
inline void dp_bfd_timer_cyc_handshake_add(dp_bfd_session_s *session)
{
session->send_interval = 1*HZ;
if(!(session->flag & DP_BFD_SEND_TIMER_ON))
{
session->send_timer.expires = jiffies + session->send_interval;
session->send_timer.function = dp_bfd_timer_send_callback;
session->send_timer.data = session->packet.my_discriminator;
add_timer_on(&session->send_timer, 1);
session->flag |= DP_BFD_SEND_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_cyc_handshake_add send_timer *********send interval : %d\n", session->send_interval);
}
else
{
mod_timer(&session->send_timer, jiffies + session->send_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_cyc_handshake mod send_timer *********send interval : %d\n", session->send_interval);
}
}
inline void dp_bfd_timer_send_add(dp_bfd_session_s *session, dp_bfd_packet_s *packet)
{
session->send_interval = (HZ)*DP_BFD_GET_MAX(session->packet.min_tx_interval, packet->min_rx_interval)/1000/1000;
if(!(session->flag & DP_BFD_SEND_TIMER_ON))
{
session->send_timer.expires = jiffies + session->send_interval;
session->send_timer.data = (unsigned long)(session->packet.my_discriminator);
session->send_timer.function = dp_bfd_timer_send_callback;
add_timer_on(&session->send_timer, 1);
session->flag |= DP_BFD_SEND_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_send_add send_timer **********send interval : %d\n", session->send_interval);
}
else
{
mod_timer(&session->send_timer, jiffies + session->send_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_send_add mod send_timer **********send interval : %d\n", session->send_interval);
}
}
/* Error injection interface */
static ssize_t mce_write(struct file *filp, const char __user *ubuf,
size_t usize, loff_t *off)
{
struct delayed_mce *dm;
struct mce m;
if (!capable(CAP_SYS_ADMIN))
return -EPERM;
/*
* There are some cases where real MSR reads could slip
* through.
*/
if (!boot_cpu_has(X86_FEATURE_MCE) || !boot_cpu_has(X86_FEATURE_MCA))
return -EIO;
if ((unsigned long)usize > sizeof(struct mce))
usize = sizeof(struct mce);
if (copy_from_user(&m, ubuf, usize))
return -EFAULT;
if (m.extcpu >= num_possible_cpus() || !cpu_online(m.extcpu))
return -EINVAL;
dm = kmalloc(sizeof(struct delayed_mce), GFP_KERNEL);
if (!dm)
return -ENOMEM;
/*
* Need to give user space some time to set everything up,
* so do it a jiffie or two later everywhere.
* Should we use a hrtimer here for better synchronization?
*/
memcpy(&dm->m, &m, sizeof(struct mce));
setup_timer(&dm->timer, raise_mce, (unsigned long)dm);
dm->timer.expires = jiffies + 2;
add_timer_on(&dm->timer, m.extcpu);
return usize;
}
inline void dp_bfd_timer_echo_receive_add(dp_bfd_session_s *session)
{
session->echo_receive_interval = (HZ)*session->packet.min_echo_rx_interval/1000/1000;
if(!(session->flag & DP_BFD_ECHORECV_TIMER_ON))
{
session->echo_receive_timer.expires = jiffies + session->echo_receive_interval;
session->echo_receive_timer.data = (unsigned long)(session->packet.my_discriminator);
session->echo_receive_timer.function = dp_bfd_timer_echo_receive_callback;
add_timer_on(&session->echo_receive_timer, 1);
session->flag |= DP_BFD_ECHORECV_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_echo_receive_add echo_receive_timer\n");
}
else
{
mod_timer(&session->echo_receive_timer, jiffies + session->echo_receive_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_echo_receive_add mod echo_receive_timer\n");
}
}
inline void dp_bfd_timer_receive_add(dp_bfd_session_s *session, dp_bfd_packet_s *packet)
{
session->receive_interval = (HZ)*(packet->detect_mult)*(DP_BFD_GET_MAX(packet->min_tx_interval, session->packet.min_rx_interval)/1000)/1000;
if(!(session->flag & DP_BFD_RECEIVE_TIMER_ON))
{
session->receive_timer.expires = jiffies + session->receive_interval;
session->receive_timer.data = (unsigned long)(session->packet.my_discriminator);
session->receive_timer.function = dp_bfd_timer_receive_callback;
add_timer_on(&session->receive_timer, 1);
session->flag |= DP_BFD_RECEIVE_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_receive_add receive_timer @@@@@@@@@@@@session->receive_interval=%d\n", session->receive_interval);
}
else
{
mod_timer(&session->receive_timer, jiffies + session->receive_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_timer_receive_add mod receive_timer @@@@@@@@@@@@session->receive_interval=%d\n", session->receive_interval);
}
}
u32 dp_bfd_up_to_up(dp_bfd_packet_s *packet, dp_bfd_session_s *session)
{
if(!(session->flag & DP_BFD_RECEIVE_TIMER_ON))
{
session->receive_timer.data = session->packet.my_discriminator;
session->receive_timer.function = dp_bfd_timer_receive_callback;
session->receive_timer.expires = jiffies + session->receive_interval;
add_timer_on(&session->receive_timer, 1);
session->flag |= DP_BFD_RECEIVE_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_up_to_up add receive_timer *********receive_interval=%d\n", session->receive_interval);
}
else
{
mod_timer(&session->receive_timer, jiffies + session->receive_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_up_to_up mod receive_timer *********receive_interval=%d\n", session->receive_interval);
}
if(DP_BFD_SET == packet->p)
{
session->send_interval = (HZ)*DP_BFD_GET_MAX(session->packet.min_tx_interval, packet->min_rx_interval)/1000/1000;
session->receive_interval = (HZ)*(packet->detect_mult)*(DP_BFD_GET_MAX(packet->min_tx_interval, session->packet.min_rx_interval)/1000)/1000;
session->packet.f = DP_BFD_SET;
if(DP_BFD_SET == session->packet.a)
{
/*如果验证方式为MD5或SHA1重新计算digest*/
session->flag |= DP_BFD_FILL_AUTH;
}
dp_bfd_send_msg(session, DP_BFD_SEND_CONTROL_PACKET);
if(session->packet.f == DP_BFD_SET)
{
session->packet.f = DP_BFD_UNSET;
if(DP_BFD_SET == session->packet.a)
{
/*如果验证方式为MD5或SHA1重新计算digest*/
session->flag |= DP_BFD_FILL_AUTH;
}
}
return NF_DROP;
}
if(DP_BFD_SET == packet->f)
{
if(session->packet.min_tx_interval > session->dmti_old)
{
session->send_interval = (HZ)*DP_BFD_GET_MAX(session->packet.min_tx_interval, packet->min_rx_interval)/1000/1000;
}
if(session->packet.min_rx_interval < session->rmri_old)
{
session->receive_interval = (HZ)*(packet->detect_mult)*(DP_BFD_GET_MAX(packet->min_tx_interval, session->packet.min_rx_interval)/1000)/1000;
}
/* Using new interval to adjust timers */
return NF_DROP;
}
return NF_DROP;
}
int gpu_control_state_set(struct kbase_device *kbdev, gpu_control_state state, int param)
{
int ret = 0, voltage;
#ifdef CONFIG_MALI_MIDGARD_DVFS
unsigned long flags;
#endif /* CONFIG_MALI_MIDGARD_DVFS */
struct exynos_context *platform = (struct exynos_context *) kbdev->platform_context;
if (!platform)
return -ENODEV;
mutex_lock(&platform->gpu_clock_lock);
switch (state) {
case GPU_CONTROL_CLOCK_ON:
ret = gpu_clock_on(platform);
#ifdef GPU_EARLY_CLK_GATING
break;
case GPU_CONTROL_CLOCK_ON_POST:
#endif /* GPU_EARLY_CLK_GATING*/
#ifdef CONFIG_MALI_MIDGARD_DVFS
if (!kbdev->pm.metrics.timer_active) {
spin_lock_irqsave(&kbdev->pm.metrics.lock, flags);
kbdev->pm.metrics.timer_active = true;
spin_unlock_irqrestore(&kbdev->pm.metrics.lock, flags);
#if !defined(SLSI_SUBSTITUTE)
hrtimer_start(&kbdev->pm.metrics.timer, HR_TIMER_DELAY_MSEC(platform->polling_speed), HRTIMER_MODE_REL);
#else
kbdev->pm.metrics.tlist.expires = jiffies + msecs_to_jiffies(platform->polling_speed);
add_timer_on(&kbdev->pm.metrics.tlist, 0);
#endif
}
gpu_dvfs_handler_control(kbdev, GPU_HANDLER_UPDATE_TIME_IN_STATE, 0);
#endif /* CONFIG_MALI_MIDGARD_DVFS */
break;
#ifdef GPU_EARLY_CLK_GATING
case GPU_CONTROL_CLOCK_OFF_POST:
#else
case GPU_CONTROL_CLOCK_OFF:
#endif /* GPU_EARLY_CLK_GATING*/
#ifdef CONFIG_MALI_MIDGARD_DVFS
if (platform->dvfs_status && kbdev->pm.metrics.timer_active) {
spin_lock_irqsave(&kbdev->pm.metrics.lock, flags);
kbdev->pm.metrics.timer_active = false;
spin_unlock_irqrestore(&kbdev->pm.metrics.lock, flags);
#if !defined(SLSI_SUBSTITUTE)
hrtimer_cancel(&kbdev->pm.metrics.timer);
#else
del_timer(&kbdev->pm.metrics.tlist);
#endif
}
gpu_pm_qos_command(platform, GPU_CONTROL_PM_QOS_RESET);
gpu_dvfs_handler_control(kbdev, GPU_HANDLER_UPDATE_TIME_IN_STATE, platform->cur_clock);
#endif /* CONFIG_MALI_MIDGARD_DVFS */
#ifdef GPU_EARLY_CLK_GATING
break;
case GPU_CONTROL_CLOCK_OFF:
#endif /* GPU_EARLY_CLK_GATING*/
ret = gpu_clock_off(platform);
break;
case GPU_CONTROL_CHANGE_CLK_VOL:
ret = gpu_set_clk_vol(kbdev, param, gpu_dvfs_handler_control(kbdev, GPU_HANDLER_DVFS_GET_VOLTAGE, param));
#ifdef CONFIG_MALI_MIDGARD_DVFS
if (ret == 0) {
ret = gpu_dvfs_handler_control(kbdev, GPU_HANDLER_DVFS_GET_LEVEL, platform->cur_clock);
if (ret >= 0) {
spin_lock_irqsave(&platform->gpu_dvfs_spinlock, flags);
platform->step = ret;
spin_unlock_irqrestore(&platform->gpu_dvfs_spinlock, flags);
} else {
GPU_LOG(DVFS_ERROR, "Invalid dvfs level returned [%d]\n", GPU_CONTROL_CHANGE_CLK_VOL);
}
}
if (gpu_pm_qos_command(platform, GPU_CONTROL_PM_QOS_SET) < -1)
GPU_LOG(DVFS_ERROR, "failed to set the PM_QOS\n");
#endif /* CONFIG_MALI_MIDGARD_DVFS */
break;
case GPU_CONTROL_PREPARE_ON:
#ifdef CONFIG_MALI_MIDGARD_DVFS
spin_lock_irqsave(&platform->gpu_dvfs_spinlock, flags);
if (platform->dvfs_status && platform->wakeup_lock)
platform->cur_clock = MALI_DVFS_START_FREQ;
if (platform->min_lock > 0)
platform->cur_clock = MAX(platform->min_lock, platform->cur_clock);
if (platform->max_lock > 0)
platform->cur_clock = MIN(platform->max_lock, platform->cur_clock);
platform->down_requirement = platform->table[platform->step].stay_count;
spin_unlock_irqrestore(&platform->gpu_dvfs_spinlock, flags);
#endif /* CONFIG_MALI_MIDGARD_DVFS */
break;
case GPU_CONTROL_IS_POWER_ON:
ret = gpu_is_power_on();
break;
case GPU_CONTROL_SET_MARGIN:
voltage = MAX(platform->table[platform->step].voltage + platform->voltage_margin, COLD_MINIMUM_VOL);
gpu_set_voltage(platform, voltage);
GPU_LOG(DVFS_DEBUG, "we set the voltage: %d\n", voltage);
break;
default:
mutex_unlock(&platform->gpu_clock_lock);
return -1;
}
mutex_unlock(&platform->gpu_clock_lock);
return ret;
}
unsigned int
dp_bfd_deal(struct sk_buff *pskb)
{
struct udphdr _hdr, *hdr;
dp_bfd_packet_s _packet, *packet;
dp_bfd_auth_s _auth_packet, *auth_packet;
dp_bfd_echo_packet_s _echo_packet, *echo_packet;
dp_bfd_session_s *session;
u32 (*dp_bfd_state_trans_callback)(dp_bfd_packet_s *, dp_bfd_session_s *) = NULL;
u32 ret;
u8 old_state;
u32 dataoff = (u32)(((pskb)->nh.raw - (pskb)->data) + (pskb)->nh.iph->ihl*4);
if (IPPROTO_UDP != (pskb)->nh.iph->protocol)
{
return NF_ACCEPT;
}
hdr = skb_header_pointer(pskb, (s32)dataoff, sizeof(_hdr), &_hdr);
if ((NULL == hdr)||((DP_BFD_PORT != hdr->dest)&&(DP_BFD_ECHO_PORT != hdr->dest)))
{
return NF_ACCEPT;
}
/* deal with echo packet */
if(DP_BFD_PORT != hdr->dest)
{
return NF_ACCEPT;
/* rebound the packet */
if(DP_BFD_ECHO_PORT == hdr->dest)
{
dp_bfd_echo_packet_rebound(pskb);
return NF_DROP;
}
/* add echo receive timer */
if(DP_BFD_ECHO_PORT == hdr->source)
{
/*取回声报文*/
echo_packet = skb_header_pointer(pskb, (s32)(dataoff + sizeof(_hdr)), sizeof(_echo_packet), &_echo_packet);
if ( (NULL == echo_packet)||(0 == g_session_total) )
{
return NF_DROP;
}
session = dp_bfd_find_session_simple(echo_packet->my_discriminator);
if(NULL == session)
{
return NF_DROP;
}
session->echo_receive_interval = (HZ)*session->packet.min_echo_rx_interval/1000/1000;
if(!(session->flag & DP_BFD_ECHORECV_TIMER_ON))
{
session->echo_receive_timer.expires = jiffies + session->echo_receive_interval;
session->echo_receive_timer.data = (unsigned long)(session->packet.my_discriminator);
session->echo_receive_timer.function = dp_bfd_timer_echo_receive_callback;
add_timer_on(&session->echo_receive_timer, 1);
session->flag |= DP_BFD_ECHORECV_TIMER_ON;
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_deal echo_receive_timer\n");
}
else
{
mod_timer(&session->echo_receive_timer, jiffies + session->echo_receive_interval);
if(dp_bfd_debug & DEBUG_BFD_TIMER)
printk("dp_bfd_deal mod echo_receive_timer\n");
}
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
return NF_ACCEPT;
}
if(hdr->source < 49152)
{
return NF_ACCEPT;
}
/*BFD报文处理*/
if(0 == g_session_total)
{
return NF_DROP;
}
packet = skb_header_pointer(pskb, (s32)(dataoff + sizeof(_hdr)), sizeof(_packet), &_packet);
if ( (NULL == packet)||(NF_DROP == dp_bfd_rcv_packet_deal(packet)) )
{
return NF_DROP;
}
/* session != NULL 则该接口必然已使能 */
session = dp_bfd_find_session(packet, (pskb)->nh.iph->saddr, (pskb)->nh.iph->daddr);
if(NULL == session)
{
return NF_DROP;
}
if (ADMIN_DOWN == session->packet.sta)
{
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
if(session->packet.a != packet->a)
{
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
if(DP_BFD_SET == session->packet.a)
{
/*取认证数据报文*/
auth_packet = skb_header_pointer(pskb, (s32)(dataoff + sizeof(_hdr) + sizeof(_packet)), packet->length - sizeof(dp_bfd_packet_s), &_auth_packet);
if ( (NULL == auth_packet)||(ERROR_FAIL == dp_bfd_auth_deal(packet, auth_packet, session)) )
{
if(dp_bfd_debug & DEBUG_BFD_AUTH)
printk("********************auth failed*********************\n");
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
}
if ( (DP_BFD_UNSET == session->packet.p)&&(DP_BFD_SET == packet->f) )
{
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
if ( (DP_BFD_SET == session->packet.p)&&(DP_BFD_SET == packet->f) )
{
session->packet.p = DP_BFD_UNSET;
if (DP_BFD_SET == session->packet.a)
{
session->flag |= DP_BFD_FILL_AUTH;
}
}
old_state = session->packet.sta;
dp_bfd_state_trans_callback = g_bfd_state_trans[session->packet.sta][packet->sta].func;
session->packet.sta = g_bfd_state_trans[session->packet.sta][packet->sta].state;
if ( (INIT <= session->packet.sta)&&(NO_DIAGNOSTIC != session->packet.diag) )
{
session->packet.diag = NO_DIAGNOSTIC;
if (session->packet.a)
{
session->flag |= DP_BFD_FILL_AUTH;
}
}
if((old_state != session->packet.sta)&&(session->packet.a))
{
session->flag |= DP_BFD_FILL_AUTH;
}
if(NULL != dp_bfd_state_trans_callback)
{
ret = dp_bfd_state_trans_callback(packet, session);
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return ret;
}
write_unlock_bh(&g_session_cask[session->packet.my_discriminator%256].session_lock);
return NF_DROP;
}
