示例#1
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	int ret;
	unsigned long flags;

	spin_lock_irqsave(&vibe_lock, flags);
	switch (vibe_state) {
	case TASK_KICK_START:
		ret = long_vibe_time;
		break;
	case TASK_START:
	case TASK_STOP:
		ret = long_vibe_time;
		if (hrtimer_active(&vibe_timer)) {
			ktime_t r = hrtimer_get_remaining(&vibe_timer);
			ret += r.tv.sec * 1000 + r.tv.nsec / 1000000;
		}
		break;
	case TASK_FORCE_STOP:
	case TASK_NONE:
	default:
		ret = 0;
		break;
	}
	spin_unlock_irqrestore(&vibe_lock, flags);
	return ret;
}
示例#2
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	if (hrtimer_active(&vibe_timer)) {
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		return ktime_to_ms(r);
	} else
		return 0;
}
示例#3
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	if (hrtimer_active(&vibe_timer)) {
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} else
		return 0;
}
示例#4
0
static int herring_vibrator_get_time(struct timed_output_dev *dev)
{
	if (hrtimer_active(&vibdata.timer)) {
		ktime_t r = hrtimer_get_remaining(&vibdata.timer);
		return ktime_to_ms(r);
	}

	return 0;
}
/*
 * Timeout value can be read from sysfs entry
 * created by timed_output_dev.
 * cat /sys/class/timed_output/vibrator/enable
 */
static int vibrator_get_time(struct timed_output_dev *dev)
{
	struct vibrator *vib = container_of(dev, struct vibrator, timed_dev);
	if (hrtimer_active(&vib->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&vib->vib_timer);
		return (int)ktime_to_us(r);
	} else
		return 0;
}
static int drv2667_get_time(struct timed_output_dev *dev)
{
	struct drv2667_data *data = container_of(dev, struct drv2667_data, dev);

	if (hrtimer_active(&data->timer))
		return	data->runtime_left +
			ktime_to_ms(hrtimer_get_remaining(&data->timer));
	return 0;
}
示例#7
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	if (hrtimer_active(&vibe_timer)) {
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		struct timeval t = ktime_to_timeval(r);
		return t.tv_sec * 1000 + t.tv_usec / 1000;
	}
	return 0;
}
示例#8
0
static int get_time_for_vibetonz(struct timed_output_dev *dev)
{
	int remaining;
	if (hrtimer_active(&timer)) {
		ktime_t r = hrtimer_get_remaining(&timer);
		remaining = r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} else
		remaining = 0;
	return remaining;
}
示例#9
0
static void msm_otg_del_timer(struct msm_otg *dev)
{
	int bit = dev->active_tmout;

	pr_debug("deleting %s timer. remaining %lld msec \n", timer_string(bit),
			div_s64(ktime_to_us(hrtimer_get_remaining(&dev->timer)),
					1000));
	hrtimer_cancel(&dev->timer);
	clear_bit(bit, &dev->tmouts);
}
示例#10
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	struct timed_vibrator_data *data = container_of(dev, struct timed_vibrator_data, dev);

	if (hrtimer_active(&data->timer)) {
		ktime_t r = hrtimer_get_remaining(&data->timer);
		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} else
		return 0;
}
示例#11
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
    struct timed_vibrator_data *vib = container_of(dev, struct timed_vibrator_data, dev);

    if (hrtimer_active(&vib->timer)) {
        ktime_t r = hrtimer_get_remaining(&vib->timer);
        return ktime_to_ms(r);
    } else
        return 0;
}
示例#12
0
	int     mx6_get_time(structtimed_output_dev *sdev)  
	{  
	     if(hrtimer_active(&vibdata.timer))  
	     {  
		       ktime_tr = hrtimer_get_remaining(&vibdata.timer);                 //读取剩余时间按并返回  
		       returnktime_to_ms(r);  
	     }  
	      
	     return 0;  
	}  
static int vibrator_get_time(struct timed_output_dev *dev)
{
	//struct Haptics	*pvibdata = container_of(dev, struct Haptics, to_dev);

	if (hrtimer_active(&vibdata.timer)) {
		ktime_t r = hrtimer_get_remaining(&vibdata.timer);
		return ktime_to_ms(r);
	}

	return 0;
}
static int vibrator_get_time(struct timed_output_dev *dev)
{
	struct timespec time_tmp;
	if (hrtimer_active(&vibe_timer)) {
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		time_tmp = ktime_to_timespec(r);
		//return r.tv.sec * 1000 + r.tv.nsec/1000000;
		return time_tmp.tv_sec* 1000 + time_tmp.tv_nsec/1000000;
	} else
		return 0;
}
static int k3_vibrator_get_time(struct timed_output_dev *dev)
{
	struct k3_vibrator_data *pdata =
			container_of(dev, struct k3_vibrator_data, dev);
	if (hrtimer_active(&pdata->timer)) {
		ktime_t r = hrtimer_get_remaining(&pdata->timer);
		struct timeval t = ktime_to_timeval(r);
		return t.tv_sec * 1000 + t.tv_usec / 1000;
	} else
		return 0;
}
示例#16
0
static int vibrator_get_time(struct timed_output_dev *dev)
{
	printk("[tspdrv] %s\n", __func__);

	if (hrtimer_active(&vibe_timer)) {
		ktime_t r = hrtimer_get_remaining(&vibe_timer);
		return ktime_to_ms(r);
	}

	return 0;
}
static int pmic8058_vib_get_time(struct timed_output_dev *dev)
{
	struct pmic8058_vib *vib = container_of(dev, struct pmic8058_vib,
					 timed_dev);

	if (hrtimer_active(&vib->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&vib->vib_timer);
		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} else
		return 0;
}
示例#18
0
static int haptic_get_time(struct timed_output_dev *tdev)
{
	struct haptic_data *chip =
		container_of(tdev, struct haptic_data, tdev);

	if (hrtimer_active(&chip->timer)) {
		ktime_t r = hrtimer_get_remaining(&chip->timer);
		struct timeval t = ktime_to_timeval(r);
		return t.tv_sec * 1000 + t.tv_usec / 1000;
	}
	return 0;	
}
示例#19
0
/* get time api to know the remaining time */
static int qpnp_hap_get_time(struct timed_output_dev *dev)
{
	struct qpnp_hap *hap = container_of(dev, struct qpnp_hap,
							 timed_dev);

	if (hrtimer_active(&hap->hap_timer)) {
		ktime_t r = hrtimer_get_remaining(&hap->hap_timer);
		return (int)ktime_to_us(r);
	} else {
		return 0;
	}
}
示例#20
0
static int lge_isa1200_vibrator_get_time(struct timed_output_dev *dev)
{
	struct lge_isa1200_context *context = container_of(dev, struct lge_isa1200_context, dev);

	dev_info(dev->dev, "%s()\n", __func__);

	if (hrtimer_active(&context->timer)) {
		ktime_t r = hrtimer_get_remaining(&context->timer);
		return ktime_to_ms(r);
	} else
		return 0;
}
static int vibrator_get_time(struct timed_output_dev *dev)
{
	struct drv2605_data *data;

	data = container_of(dev, struct drv2605_data, dev);

	if (hrtimer_active(&(data->timer))) {
		ktime_t r = hrtimer_get_remaining(&data->timer);
		return ktime_to_ms(r);
	}

	return 0;
}
示例#22
0
int qsd_timed_vibrator_get_time(struct timed_output_dev *sdev)
{
  ktime_t remain;
  int value = 0;
  MSG("%s", __func__);
	if(hrtimer_active(&qsd_timed_vibrator_timer))
	{
		remain = hrtimer_get_remaining(&qsd_timed_vibrator_timer);
		value = remain.tv.sec * 1000 + remain.tv.nsec / 1000000;
	}
  MSG("timeout = %d",value);
  return value;
}
示例#23
0
static ssize_t aat1271_flash_enable_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct timed_gpio_data *gpio_data = dev_get_drvdata(dev);
	int remaining;

	if (hrtimer_active(&gpio_data->timer)) {
		ktime_t r = hrtimer_get_remaining(&gpio_data->timer);
		remaining = r.tv.sec * 1000 + r.tv.nsec / 1000000;
	} else
		remaining = 0;

	return sprintf(buf, "%d\n", remaining);
}
示例#24
0
static int lc898300_vib_get_time(struct timed_output_dev *dev)
{
	struct lc898300_data *data = container_of(dev, struct lc898300_data,
							 timed_dev);
	int remain;
	if (hrtimer_active(&data->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&data->vib_timer);
		remain = (int)ktime_to_ms(r);
		return remain > 0 ? remain : 0;
	} else {
		return 0;
	}
}
static int ldo_vibrator_vib_get_time(struct timed_output_dev *dev)
{
	struct ldo_vibrator_data *data = container_of(dev,
						      struct ldo_vibrator_data,
						      timed_dev);
	int ret = 0;

	if (hrtimer_active(&data->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&data->vib_timer);
		ret = (int)ktime_to_us(r);
	}
	return ret;
}
static int haptic_get_time(struct timed_output_dev *tout_dev)
{
	struct max77833_haptic_data *hap_data
		= container_of(tout_dev, struct max77833_haptic_data, tout_dev);

	struct hrtimer *timer = &hap_data->timer;
	if (hrtimer_active(timer)) {
		ktime_t remain = hrtimer_get_remaining(timer);
		struct timeval t = ktime_to_timeval(remain);
		return t.tv_sec * 1000 + t.tv_usec / 1000;
	}
	return 0;
}
示例#27
0
static int pm8xxx_vib_get_time(struct timed_output_dev *dev)
{
    struct pm8xxx_vib *vib = container_of(dev, struct pm8xxx_vib, timed_dev);

    VIB_DEBUG_LOG(KERN_INFO, "called.\n");
    if (hrtimer_active(&vib->vib_timer)) {
        ktime_t r = hrtimer_get_remaining(&vib->vib_timer);
        VIB_DEBUG_LOG(KERN_INFO, "remaining=%d.\n", (int)ktime_to_us(r));
        return (int)ktime_to_ms(r);
    } else {
        VIB_DEBUG_LOG(KERN_INFO, "hrtimer not active.\n");
        return 0;
    }
}
static int pm8xxx_vib_get_time(struct timed_output_dev *dev)
{
	struct pm8xxx_vib *vib = container_of(dev, struct pm8xxx_vib,
							 timed_dev);

	if (hrtimer_active(&vib->vib_timer)) {
		ktime_t r = hrtimer_get_remaining(&vib->vib_timer);
		VIBRATOR_PRINTK(1, "%s: time=%d \n", __func__, (int)ktime_to_us(r));
		return (int)ktime_to_us(r);
	} else {
		VIBRATOR_PRINTK(1, "%s: no timer device atcived--\n", __func__);
		return 0;
}
}
示例#29
0
/*
 * Get the time remaining on a POSIX.1b interval timer.  This function
 * is ALWAYS called with spin_lock_irq on the timer, thus it must not
 * mess with irq.
 *
 * We have a couple of messes to clean up here.  First there is the case
 * of a timer that has a requeue pending.  These timers should appear to
 * be in the timer list with an expiry as if we were to requeue them
 * now.
 *
 * The second issue is the SIGEV_NONE timer which may be active but is
 * not really ever put in the timer list (to save system resources).
 * This timer may be expired, and if so, we will do it here.  Otherwise
 * it is the same as a requeue pending timer WRT to what we should
 * report.
 */
static void
common_timer_get(struct k_itimer *timr, struct itimerspec *cur_setting)
{
	ktime_t remaining;
	struct hrtimer *timer = &timr->it.real.timer;

	memset(cur_setting, 0, sizeof(struct itimerspec));
	remaining = hrtimer_get_remaining(timer);

	/* Time left ? or timer pending */
	if (remaining.tv64 > 0 || hrtimer_active(timer))
		goto calci;
	/* interval timer ? */
	if (timr->it.real.interval.tv64 == 0)
		return;
	/*
	 * When a requeue is pending or this is a SIGEV_NONE timer
	 * move the expiry time forward by intervals, so expiry is >
	 * now.
	 */
	if (timr->it_requeue_pending & REQUEUE_PENDING ||
	    (timr->it_sigev_notify & ~SIGEV_THREAD_ID) == SIGEV_NONE) {
		timr->it_overrun +=
			hrtimer_forward(timer, timr->it.real.interval);
		remaining = hrtimer_get_remaining(timer);
	}
 calci:
	/* interval timer ? */
	if (timr->it.real.interval.tv64 != 0)
		cur_setting->it_interval =
			ktime_to_timespec(timr->it.real.interval);
	/* Return 0 only, when the timer is expired and not pending */
	if (remaining.tv64 <= 0)
		cur_setting->it_value.tv_nsec = 1;
	else
		cur_setting->it_value = ktime_to_timespec(remaining);
}
示例#30
0
static int isa1200_chip_get_time(struct timed_output_dev *dev)
{
	struct isa1200_chip *haptic = container_of(dev, struct isa1200_chip,
					dev);

	if (hrtimer_active(&haptic->timer)) {
		ktime_t r = hrtimer_get_remaining(&haptic->timer);
#ifdef CONFIG_MACH_MEHMET
		return ktime_to_ms(r);
#else
		return r.tv.sec * 1000 + r.tv.nsec / 1000000;
#endif //CONFIG_MACH_T10S
	} else
		return 0;
}