Example #1
0
void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt)
{
    struct rpc_iostats *stats = clnt->cl_metrics;
    struct rpc_xprt *xprt = clnt->cl_xprt;
    unsigned int op, maxproc = clnt->cl_maxproc;

    if (!stats)
        return;

    seq_printf(seq, "\tRPC iostats version: %s  ", RPC_IOSTATS_VERS);
    seq_printf(seq, "p/v: %u/%u (%s)\n",
               clnt->cl_prog, clnt->cl_vers, clnt->cl_protname);

    if (xprt)
        xprt->ops->print_stats(xprt, seq);

    seq_printf(seq, "\tper-op statistics\n");
    for (op = 0; op < maxproc; op++) {
        struct rpc_iostats *metrics = &stats[op];
        _print_name(seq, op, clnt->cl_procinfo);
        seq_printf(seq, "%lu %lu %lu %Lu %Lu %Lu %Lu %Lu\n",
                   metrics->om_ops,
                   metrics->om_ntrans,
                   metrics->om_timeouts,
                   metrics->om_bytes_sent,
                   metrics->om_bytes_recv,
                   ktime_to_ms(metrics->om_queue),
                   ktime_to_ms(metrics->om_rtt),
                   ktime_to_ms(metrics->om_execute));
    }
}
static int do_fsync(unsigned int fd, int datasync)
{
	struct file *file;
	int ret = -EBADF;
	ktime_t fsync_t, fsync_diff;
	char pathname[256], *path;

	file = fget(fd);
	if (file) {
		path = d_path(&(file->f_path), pathname, sizeof(pathname));
		if (IS_ERR(path))
			path = "(unknown)";
		fsync_t = ktime_get();
		ret = vfs_fsync(file, datasync);
		fput(file);

		fsync_diff = ktime_sub(ktime_get(), fsync_t);
		if (ktime_to_ms(fsync_diff) >= 5000) {
			pr_info("VFS: %s pid:%d(%s)(parent:%d/%s) takes %lld ms to fsync %s.\n", __func__,
				current->pid, current->comm, current->parent->pid, current->parent->comm,
				ktime_to_ms(fsync_diff), path);
		}
	}

	return ret;
}
void aic3008_CodecInit()
{
	AUD_DBG("aic3008_CodecInit: start\n");
	pwr_up_time = ktime_to_ms(ktime_get());

	pr_device_power_on();

	// aic3008 power up
	aic3008_power_ctl->powerinit();

	// close mic
	aic3008_MicSwitch(0);

	spi_write_table_parsepage(POWER_UP_SEQ, ARRAY_SIZE(POWER_UP_SEQ));
	AUD_DBG("***** SPI CMD: Power Up Seq *****\n");

	AUD_DBG("Audio Codec Power Up takes %lld ms\n",
			ktime_to_ms(ktime_get()) - pwr_up_time);
#if AUDIO_DEBUG_BEEP
	mdelay(100);
	spi_write_table_parsepage(GENERATE_BEEP_LEFT_SPK, ARRAY_SIZE(GENERATE_BEEP_LEFT_SPK));

	AUD_DBG("***** SPI CMD: BEEP *****\n");
	mdelay(300);
	spi_write_table_parsepage(CODEC_SW_RESET, ARRAY_SIZE(CODEC_SW_RESET));
#endif

	aic3008_rx_mode = DOWNLINK_PATH_OFF;
	aic3008_tx_mode = UPLINK_PATH_OFF;
}
Example #4
0
static int do_fsync(unsigned int fd, int datasync)
{
	struct file *file;
	int ret = -EBADF;
	int fput_needed;
#ifdef CONFIG_ASYNC_FSYNC
	struct fsync_work *fwork;
#endif
	
	if (!fsync_enabled)
		return 0;
	
	file = fget_light(fd, &fput_needed);

	if (file) {
#ifdef CONFIG_ASYNC_FSYNC
		ktime_t fsync_t, fsync_diff;
		char pathname[256], *path;
		path = d_path(&(file->f_path), pathname, sizeof(pathname));
		if (IS_ERR(path))
			path = "(unknown)";
		else if (async_fsync(file, fd)) {
			if (!fsync_workqueue)
				fsync_workqueue =
					create_singlethread_workqueue("fsync");
			if (!fsync_workqueue)
				goto no_async;

			if (IS_ERR(path))
				goto no_async;

			fwork = kmalloc(sizeof(*fwork), GFP_KERNEL);
			if (fwork) {
				strncpy(fwork->pathname, path,
					sizeof(fwork->pathname) - 1);
				INIT_WORK(&fwork->work, do_afsync_work);
				queue_work(fsync_workqueue, &fwork->work);
				fput_light(file, fput_needed);
				return 0;
			}
		}
no_async:
		fsync_t = ktime_get();
#endif
		ret = vfs_fsync(file, datasync);
		fput_light(file, fput_needed);
#ifdef CONFIG_ASYNC_FSYNC
		fsync_diff = ktime_sub(ktime_get(), fsync_t);
		if (ktime_to_ms(fsync_diff) >= 5000) {
                        pr_info("VFS: %s pid:%d(%s)(parent:%d/%s)\
				takes %lld ms to fsync %s.\n", __func__,
				current->pid, current->comm,
				current->parent->pid, current->parent->comm,
				ktime_to_ms(fsync_diff), path);
		}
#endif
	}
	return ret;
}
static void aic3008_powerup(void)
{
	int64_t t1, t2;

	t1 = ktime_to_ms(ktime_get());

	aic3008_power_ctl->resume();

	t2 = ktime_to_ms(ktime_get()) - t1;
	AUD_INFO("[PWR] power on AIC3008 %lldms\n", t2);

	return;
}
Example #6
0
static int mp_decision(void)
{
	static bool first_call = true;
	int new_state = TEGRA_HP_IDLE;
	int nr_cpu_online;
	int index;
	unsigned int rq_depth;
	static cputime64_t total_time = 0;
	static cputime64_t last_time;
	cputime64_t current_time;
	cputime64_t this_time = 0;

	current_time = ktime_to_ms(ktime_get());
	if (first_call) {
		first_call = false;
	} else {
		this_time = current_time - last_time;
	}
	total_time += this_time;

	rq_depth = get_rq_info();
	nr_cpu_online = num_online_cpus();

	mutex_lock(&tegra3_mp_lock);
	if (nr_cpu_online) {
		index = (nr_cpu_online - 1) * 2;
		if ((nr_cpu_online < 4) && (rq_depth >= NwNs_Threshold[index])) {
			if (total_time >= TwTs_Threshold[index]) {
				new_state = TEGRA_HP_UP;
			}
		} else if (rq_depth <= NwNs_Threshold[index+1]) {
			if (total_time >= TwTs_Threshold[index+1] ) {
				new_state = TEGRA_HP_DOWN;
			}
		} else {
			total_time = 0;
		}
	} else {
		total_time = 0;
	}
	mutex_unlock(&tegra3_mp_lock);

	if (new_state != TEGRA_HP_IDLE) {
		total_time = 0;
	}

	last_time = ktime_to_ms(ktime_get());

	return new_state;
}
Example #7
0
static void therm_est_update_timer_trips(struct therm_estimator *est)
{
	struct thermal_trip_info *trip_state;
	struct therm_est_timer_trip_info *timer_info;
	s64 now, delay, min_delay;
	int i;

	mutex_lock(&est->timer_trip_lock);
	min_delay = LLONG_MAX;
	now = ktime_to_ms(ktime_get());

	for (i = 0; i < est->num_timer_trips; i++) {
		timer_info = &est->timer_trips[i];
		trip_state = &est->trips[timer_info->trip];

		pr_debug("%s: i %d, trip %d, tripped %d, cur %d\n",
			__func__, i, timer_info->trip, trip_state->tripped,
			timer_info->cur);
		if ((timer_info->cur == TIMER_TRIP_INACTIVE) ||
			(__get_timer_trip_delay(timer_info, now, &delay) < 0))
			continue;

		if (delay > 0)
			min_delay = min(min_delay, delay);
		pr_debug("%s: delay %lld, min_delay %lld\n",
			__func__, delay, min_delay);
	}
	mutex_unlock(&est->timer_trip_lock);

	cancel_delayed_work(&est->timer_trip_work);
	if (min_delay != LLONG_MAX)
		queue_delayed_work(est->workqueue, &est->timer_trip_work,
				   msecs_to_jiffies(min_delay));
}
static ssize_t cm3323_poll_delay_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t size)
{
	struct cm3323_p *data = dev_get_drvdata(dev);
	int64_t new_delay;
	int ret;

	ret = kstrtoll(buf, 10, &new_delay);
	if (ret) {
		pr_err("[SENSOR]: %s - Invalid Argument\n", __func__);
		return ret;
	}

	mutex_lock(&data->power_lock);
	if (new_delay != ktime_to_ms(data->poll_delay)) {
		data->poll_delay = ns_to_ktime(new_delay * NSEC_PER_MSEC);
		if (data->power_state & LIGHT_ENABLED) {
			cm3323_light_disable(data);
			cm3323_light_enable(data);
		}
		pr_info("[SENSOR]: %s - poll_delay = %lld\n",
			__func__, new_delay);
	}
	mutex_unlock(&data->power_lock);

	return size;
}
static void cm3323_work_func_light(struct work_struct *work)
{
	struct cm3323_p *data = container_of(work, struct cm3323_p,
						    work_light);

	mutex_lock(&data->read_lock);
	cm3323_i2c_read_word(data, REG_RED, &data->color[0]);
	cm3323_i2c_read_word(data, REG_GREEN, &data->color[1]);
	cm3323_i2c_read_word(data, REG_BLUE, &data->color[2]);
	cm3323_i2c_read_word(data, REG_WHITE, &data->color[3]);
	mutex_unlock(&data->read_lock);

	input_report_rel(data->input, REL_RED, data->color[0] + 1);
	input_report_rel(data->input, REL_GREEN, data->color[1] + 1);
	input_report_rel(data->input, REL_BLUE, data->color[2] + 1);
	input_report_rel(data->input, REL_WHITE, data->color[3] + 1);
	input_sync(data->input);

	if ((ktime_to_ms(data->poll_delay) * (int64_t)data->time_count)
		>= ((int64_t)LIGHT_LOG_TIME * MSEC_PER_SEC)) {
		pr_info("[SENSOR]: %s - r = %u g = %u b = %u w = %u\n",
			__func__, data->color[0], data->color[1],
			data->color[2], data->color[3]);
		data->time_count = 0;
	} else
		data->time_count++;
}
static int __init aic3008_modinit(void)
{
	AUD_DBG("Start aic3008_modinit\n");
	drv_up_time = ktime_to_ms(ktime_get());
	spi_aic3008_init();
	return 0;
}
Example #11
0
static int therm_est_get_trip_temp(struct thermal_zone_device *thz,
				   int trip, unsigned long *temp)
{
	struct therm_estimator *est = thz->devdata;
	struct therm_est_timer_trip_info *timer_info;
	int ret;

	ret = __get_trip_temp(thz, trip, temp);
	if (ret & (TIMER_TRIP_STATE_START | TIMER_TRIP_STATE_DOWN)) {
		timer_info = __find_timer_trip(est, trip);

		mutex_lock(&est->timer_trip_lock);
		timer_info->last_tripped = ktime_to_ms(ktime_get());

		if (ret & TIMER_TRIP_STATE_START) {
			timer_info->cur = TIMER_TRIP_INACTIVE + 1;
		} else if (ret & TIMER_TRIP_STATE_DOWN) {
			if (--timer_info->cur < TIMER_TRIP_INACTIVE)
				timer_info->cur = TIMER_TRIP_INACTIVE;
		}
		mutex_unlock(&est->timer_trip_lock);

		/* Update limits, because trip temp was changed by timer trip
		 * changing. */
		therm_est_update_limits(est);
	}

	return 0;
}
int cq_item_1_func(void* data)
{		
	int i;
	ktime_t start_time, stop_time,delta;
	long long delta_us, delta_ms;
	struct ts_cmd_node cmd;
	
	cmd.command = TS_TEST_CMD;
	cmd.cmd_param.prv_params = data;
	TS_LOG_INFO("called paras:%d\n", (int)cmd.cmd_param.prv_params);

	for(i=0; i<100; i++)
	{
		init_completion(&cq_test_sync_1);
		start_time = ktime_get();
		if (NO_ERR == put_one_cmd(&cmd)) {	
			if(wait_for_completion_timeout(&cq_test_sync_1, 5*HZ)){
				stop_time = ktime_get();
				delta = ktime_sub(stop_time, start_time);
				delta_us = (long long)ktime_to_us(delta);
				delta_ms = (long long)ktime_to_ms(delta);
				TS_LOG_INFO("CMD PROCESS ELAPSED TIME: %lldms%lldus\n", delta_ms, delta_us);
			}
			else
				TS_LOG_ERR("ts thread process TEST CMD expire 5 sec\n");
		}else			
			TS_LOG_ERR("put cmd error\n");
	}
	return 0;
}
static int k303c_acc_set_odr(struct k303c_acc_p *data)
{
	int ret = 0, i;
	unsigned char buf, new_odr, mask, temp;

	pr_info("%s\n", __func__);

	/* Following, looks for the longest possible odr interval scrolling the
	 * odr_table vector from the end (shortest interval) backward (longest
	 * interval), to support the poll_interval requested by the system.
	 * It must be the longest interval lower then the poll interval.*/
	for (i = ARRAY_SIZE(k303c_acc_odr_table) - 1; i >= 0; i--) {
		if ((k303c_acc_odr_table[i].cutoff_ms <=
			ktime_to_ms(data->poll_delay)) || (i == 0))
			break;
	}

	if (data->recog_flag == ON)
		i = ARRAY_SIZE(k303c_acc_odr_table) - 1;

	new_odr = k303c_acc_odr_table[i].mask;

	mask = K303C_ACC_ODR_MASK;
	ret = k303c_acc_i2c_read(data, CTRL1_REG, &temp, 1);
	buf = ((mask & new_odr) | ((~mask) & temp));
	ret += k303c_acc_i2c_write(data, CTRL1_REG, buf);

	pr_info("%s - change odr %d\n", __func__, i);
	return ret;
}
Example #14
0
int tegra_cpuquiet_force_gmode(void)
{
    cputime64_t on_time = 0;

	if (no_lp)
		return -EBUSY;
		
	if (!is_g_cluster_present())
		return -EBUSY;

	if (cpq_state == TEGRA_CPQ_DISABLED)
		return -EBUSY;

	if (is_lp_cluster()) {
		mutex_lock(tegra3_cpu_lock);

		if (switch_clk_to_gmode()) {
			pr_err(CPUQUIET_TAG "tegra_cpuquiet_force_gmode - switch_clk_to_gmode failed\n");
    		mutex_unlock(tegra3_cpu_lock);
    		return -EBUSY;
		}
		
		on_time = ktime_to_ms(ktime_get()) - lp_on_time;
		show_status("LP -> off - force", on_time, -1);

    	mutex_unlock(tegra3_cpu_lock);

		if (!manual_hotplug)
			cpuquiet_device_free();
	}
	
	return 0;
}
/*
 * row_add_request() - Add request to the scheduler
 * @q:	requests queue
 * @rq:	request to add
 *
 */
static void row_add_request(struct request_queue *q,
			    struct request *rq)
{
	struct row_data *rd = (struct row_data *)q->elevator->elevator_data;
	struct row_queue *rqueue = RQ_ROWQ(rq);

	list_add_tail(&rq->queuelist, &rqueue->fifo);
	rd->nr_reqs[rq_data_dir(rq)]++;
	rq_set_fifo_time(rq, jiffies); /* for statistics*/

	if (queue_idling_enabled[rqueue->prio]) {
		if (delayed_work_pending(&rd->read_idle.idle_work))
			(void)cancel_delayed_work(
				&rd->read_idle.idle_work);
		if (ktime_to_ms(ktime_sub(ktime_get(),
				rqueue->idle_data.last_insert_time)) <
				rd->read_idle.freq) {
			rqueue->idle_data.begin_idling = true;
			row_log_rowq(rd, rqueue->prio, "Enable idling");
		} else {
			rqueue->idle_data.begin_idling = false;
			row_log_rowq(rd, rqueue->prio, "Disable idling");
		}

		rqueue->idle_data.last_insert_time = ktime_get();
	}
	row_log_rowq(rd, rqueue->prio, "added request");
}
/* Doubletap2wake main function */
static void detect_doubletap2wake(int x, int y, bool st)
{
        bool single_touch = st;
#if DT2W_DEBUG
        pr_info(LOGTAG"x,y(%4d,%4d) single:%s\n",
                x, y, (single_touch) ? "true" : "false");
#endif
	if ((single_touch) && (dt2w_switch > 0) && (exec_count) && (touch_cnt)) {
		touch_cnt = false;
		if (touch_nr == 0) {
			new_touch(x, y);
		} else if (touch_nr == 1) {
			if ((calc_feather(x, x_pre) < DT2W_FEATHER) &&
			    (calc_feather(y, y_pre) < DT2W_FEATHER) &&
			    ((ktime_to_ms(ktime_get())-tap_time_pre) < DT2W_TIME))
				touch_nr++;
			else {
				doubletap2wake_reset();
				new_touch(x, y);
			}
		} else {
			doubletap2wake_reset();
			new_touch(x, y);
		}
		if ((touch_nr > 1)) {
			pr_info(LOGTAG"ON\n");
			exec_count = false;
			doubletap2wake_pwrtrigger();
			doubletap2wake_reset();
		}
	}
}
Example #17
0
static u32 get_num_interrupts_per_s(void)
{
	int cpu;
	int i;
	u64 num_irqs = 0;
	ktime_t now;
	static ktime_t last;
	unsigned int delta;
	u32 irqs = 0;

	now = ktime_get();

	for_each_possible_cpu(cpu) {
		for (i = 0; i < NR_IRQS; i++)
			num_irqs += kstat_irqs_cpu(i, cpu);
	}
	pr_debug("%s: total num irqs: %lld, previous %lld\n",
					__func__, num_irqs, old_num_irqs);

	if (old_num_irqs > 0) {
		delta = (u32)ktime_to_ms(ktime_sub(now, last)) / 1000;
		delta = (delta > 0) ? delta : 1;
		irqs = ((u32)(num_irqs - old_num_irqs)) / delta;
	}

	old_num_irqs = num_irqs;
	last = now;

	pr_debug("delta irqs per sec:%d\n", irqs);

	return irqs;
}
Example #18
0
static void min_cpus_change(void)
{
	bool g_cluster = false;
    cputime64_t on_time = 0;
	
	if (cpq_state == TEGRA_CPQ_DISABLED)
		return;

	mutex_lock(tegra3_cpu_lock);

	if ((tegra_cpq_min_cpus() >= 2) && is_lp_cluster()) {
		if (switch_clk_to_gmode()){
			pr_err(CPUQUIET_TAG "min_cpus_change - switch_clk_to_gmode failed\n");
			mutex_unlock(tegra3_cpu_lock);
			return;
		}
		
		on_time = ktime_to_ms(ktime_get()) - lp_on_time;
		show_status("LP -> off - min_cpus_change", on_time, -1);

		g_cluster = true;
	}

	tegra_cpu_set_speed_cap(NULL);
	mutex_unlock(tegra3_cpu_lock);

	schedule_work(&minmax_work);

	if (g_cluster && !manual_hotplug)
		cpuquiet_device_free();
}
static int long_seq_test_calc_throughput(struct test_data *td)
{
	unsigned long fraction, integer;
	unsigned long mtime, byte_count;

	mtime = ktime_to_ms(utd->test_info.test_duration);
	byte_count = utd->test_info.test_byte_count;

	pr_info("%s: time is %lu msec, size is %lu.%lu MiB", __func__, mtime,
				LONG_TEST_SIZE_INTEGER(byte_count),
				LONG_TEST_SIZE_FRACTION(byte_count));

	/* we first multiply in order not to lose precision */
	mtime *= MB_MSEC_RATIO_APPROXIMATION;
	/* divide values to get a MiB/sec integer value with one
	   digit of precision
	   */
	fraction = integer = (byte_count * 10) / mtime;
	integer /= 10;
	/* and calculate the MiB value fraction */
	fraction -= integer * 10;

	pr_info("%s: Throughput: %lu.%lu MiB/sec\n", __func__, integer,
				fraction);

	return 0;
}
static int __devinit aic3008_probe(struct snd_soc_codec *codec)
{
	AUD_INFO("aic3008_probe() start... aic3008_codec:%p", codec);
	int ret = 0;

	struct aic3008_priv *aic3008 = snd_soc_codec_get_drvdata(codec);
	aic3008->codec = codec;
	aic3008->codec->control_data = (void *)codec_spi_dev;

	if (!aic3008) {
		AUD_ERR("%s: Codec not registered, SPI device not yet probed\n",
				&aic3008->codec->name);
		return -ENODEV;
	}
	aic3008_sw_reset(codec); // local call to reset codec
	aic3008_set_bias_level(codec, SND_SOC_BIAS_STANDBY);

	// request space for SPI commands data of AIC3008
	aic3008_uplink = init_2d_array(IO_CTL_ROW_MAX, IO_CTL_COL_MAX);
	aic3008_downlink = init_2d_array(IO_CTL_ROW_MAX, IO_CTL_COL_MAX);
	aic3008_minidsp = init_2d_array(MINIDSP_ROW_MAX, MINIDSP_COL_MAX);
	bulk_tx = kcalloc(MINIDSP_COL_MAX * 2 , sizeof(uint8_t), GFP_KERNEL);

	AUD_INFO("Audio Codec Driver init complete in %lld ms\n",
			 ktime_to_ms(ktime_get()) - drv_up_time);
	return ret;
}
void mdss_qpic_reset(void)
{
	u32 time_end;

	QPIC_OUTP(QPIC_REG_QPIC_LCDC_RESET, 1 << 0);
	/*                                            */
	usleep(100);
	time_end = (u32)ktime_to_ms(ktime_get()) + QPIC_MAX_VSYNC_WAIT_TIME;
	while (((QPIC_INP(QPIC_REG_QPIC_LCDC_STTS) & (1 << 8)) == 0)) {
		if ((u32)ktime_to_ms(ktime_get()) > time_end) {
			pr_err("%s reset not finished", __func__);
			break;
		}
		/*                                            */
		usleep(100);
	}
}
static int mp_decision(void)
{
	static bool first_call = true;
	int new_state = 0;
	int nr_cpu_online;
	int index;
	unsigned int rq_depth;
	static cputime64_t total_time = 0;
	static cputime64_t last_time;
	cputime64_t current_time;
	cputime64_t this_time = 0;

	current_time = ktime_to_ms(ktime_get());
	if (first_call) {
		first_call = false;
	} else {
		this_time = current_time - last_time;
	}
	total_time += this_time;

	rq_depth = rq_info.rq_avg;
	//pr_info(" rq_deptch = %u", rq_depth);
	nr_cpu_online = num_online_cpus();

	if (nr_cpu_online) {
		index = (nr_cpu_online - 1) * 2;
		if ((nr_cpu_online < 4) &&
			(rq_depth >= NwNs_Threshold[index])) {
			if (total_time >= TwTs_Threshold[index]) {
				new_state = 1;
			}
		} else if (rq_depth <= NwNs_Threshold[index+1]) {
			if (total_time >= TwTs_Threshold[index+1] ) {
				new_state = 0;
			}
		} else {
			total_time = 0;
		}
	} else {
		total_time = 0;
	}

	last_time = ktime_to_ms(ktime_get());

	return new_state;
}
void mdss_qpic_reset(void)
{
	u32 time_end;

	QPIC_OUTP(QPIC_REG_QPIC_LCDC_RESET, 1 << 0);
	/* wait 100 us after reset as suggested by hw */
	usleep(100);
	time_end = (u32)ktime_to_ms(ktime_get()) + QPIC_MAX_VSYNC_WAIT_TIME;
	while (((QPIC_INP(QPIC_REG_QPIC_LCDC_STTS) & (1 << 8)) == 0)) {
		if ((u32)ktime_to_ms(ktime_get()) > time_end) {
			pr_err("%s reset not finished", __func__);
			break;
		}
		/* yield 100 us for next polling by experiment*/
		usleep(100);
	}
}
Example #24
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;
}
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;
}
Example #26
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;
}
Example #27
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;
}
Example #28
0
static void aic3254_powerdown(void)
{
	int64_t t1, t2;
#if defined(CONFIG_ARCH_MSM7X30)
	struct ecodec_aic3254_state *drv = &codec_clk;
#endif


	if (aic3254_tx_mode != UPLINK_OFF || aic3254_rx_mode != DOWNLINK_OFF)
		return;

	t1 = ktime_to_ms(ktime_get());

	spi_aic3254_prevent_sleep();
	if (aic3254_uplink != NULL) {
		pr_aud_info("power off AIC3254 len(%d)++\n",
			(aic3254_uplink[POWER_OFF][0].data-1));
		aic3254_config(&aic3254_uplink[POWER_OFF][1],
				aic3254_uplink[POWER_OFF][0].data);
	} else {
		pr_aud_info("power off AIC3254 len(%d)++\n",
			(ARRAY_SIZE(CODEC_POWER_OFF)));
		aic3254_config(CODEC_POWER_OFF, ARRAY_SIZE(CODEC_POWER_OFF));
	}

#if defined(CONFIG_ARCH_MSM7X30)
	if (drv->enabled) {
		/* Disable MI2S RX master block */
		/* Disable MI2S RX bit clock */
		clk_disable(drv->rx_sclk);
		clk_disable(drv->rx_mclk);
		drv->enabled = 0;
		pr_aud_info("%s: disable CLK\n", __func__);
	}
#endif

	spi_aic3254_allow_sleep();

	t2 = ktime_to_ms(ktime_get())-t1;
	pr_aud_info("power off AIC3254 %lldms --\n", t2);
	return;
}
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;
}
Example #30
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;
}