drivers/gnss/sirf.c

29  * If no data arrives for this time, we assume that the chip is off.
32  * low value. Also power saving settings (like send data only on movement)
58 static int sirf_serdev_open(struct sirf_data *data)
62 	mutex_lock(&data->serdev_mutex);
63 	if (++data->serdev_count == 1) {
64 		ret = serdev_device_open(data->serdev);
66 			data->serdev_count--;
70 		serdev_device_set_baudrate(data->serdev, data->speed);
71 		serdev_device_set_flow_control(data->serdev, false);
75 	mutex_unlock(&data->serdev_mutex);
80 static void sirf_serdev_close(struct sirf_data *data)
82 	mutex_lock(&data->serdev_mutex);
83 	if (--data->serdev_count == 0)
84 		serdev_device_close(data->serdev);
85 	mutex_unlock(&data->serdev_mutex);
90 	struct sirf_data *data = gnss_get_drvdata(gdev);
91 	struct serdev_device *serdev = data->serdev;
94 	mutex_lock(&data->gdev_mutex);
95 	data->open = true;
96 	mutex_unlock(&data->gdev_mutex);
98 	ret = sirf_serdev_open(data);
100 		mutex_lock(&data->gdev_mutex);
101 		data->open = false;
102 		mutex_unlock(&data->gdev_mutex);
116 	sirf_serdev_close(data);
118 	mutex_lock(&data->gdev_mutex);
119 	data->open = false;
120 	mutex_unlock(&data->gdev_mutex);
127 	struct sirf_data *data = gnss_get_drvdata(gdev);
128 	struct serdev_device *serdev = data->serdev;
130 	sirf_serdev_close(data);
134 	mutex_lock(&data->gdev_mutex);
135 	data->open = false;
136 	mutex_unlock(&data->gdev_mutex);
142 	struct sirf_data *data = gnss_get_drvdata(gdev);
143 	struct serdev_device *serdev = data->serdev;
166 	struct sirf_data *data = serdev_device_get_drvdata(serdev);
167 	struct gnss_device *gdev = data->gdev;
170 	if (!data->wakeup && !data->active) {
171 		data->active = true;
172 		wake_up_interruptible(&data->power_wait);
175 	mutex_lock(&data->gdev_mutex);
176 	if (data->open)
178 	mutex_unlock(&data->gdev_mutex);
190 	struct sirf_data *data = dev_id;
191 	struct device *dev = &data->serdev->dev;
194 	ret = gpiod_get_value_cansleep(data->wakeup);
199 	data->active = ret;
200 	wake_up_interruptible(&data->power_wait);
205 static int sirf_wait_for_power_state_nowakeup(struct sirf_data *data,
214 	/* Wait for data reception or timeout. */
215 	data->active = false;
216 	ret = wait_event_interruptible_timeout(data->power_wait,
217 			data->active, msecs_to_jiffies(SIRF_REPORT_CYCLE));
230 static int sirf_wait_for_power_state(struct sirf_data *data, bool active,
235 	if (!data->wakeup)
236 		return sirf_wait_for_power_state_nowakeup(data, active, timeout);
238 	ret = wait_event_interruptible_timeout(data->power_wait,
239 			data->active == active, msecs_to_jiffies(timeout));
244 		dev_warn(&data->serdev->dev, "timeout waiting for active state = %d\n",
252 static void sirf_pulse_on_off(struct sirf_data *data)
254 	gpiod_set_value_cansleep(data->on_off, 1);
256 	gpiod_set_value_cansleep(data->on_off, 0);
259 static int sirf_set_active(struct sirf_data *data, bool active)
270 	if (!data->wakeup) {
271 		ret = sirf_serdev_open(data);
277 		sirf_pulse_on_off(data);
278 		ret = sirf_wait_for_power_state(data, active, timeout);
281 	if (!data->wakeup)
282 		sirf_serdev_close(data);
292 	struct sirf_data *data = dev_get_drvdata(dev);
296 	if (data->on_off)
297 		ret = sirf_set_active(data, false);
299 		ret = regulator_disable(data->vcc);
304 	ret = regulator_disable(data->lna);
311 	if (data->on_off)
312 		ret2 = sirf_set_active(data, true);
314 		ret2 = regulator_enable(data->vcc);
326 	struct sirf_data *data = dev_get_drvdata(dev);
329 	ret = regulator_enable(data->lna);
333 	if (data->on_off)
334 		ret = sirf_set_active(data, true);
336 		ret = regulator_enable(data->vcc);
344 	regulator_disable(data->lna);
351 	struct sirf_data *data = dev_get_drvdata(dev);
357 	if (data->wakeup)
358 		disable_irq(data->irq);
365 	struct sirf_data *data = dev_get_drvdata(dev);
368 	if (data->wakeup)
369 		enable_irq(data->irq);
384 	struct sirf_data *data = serdev_device_get_drvdata(serdev);
390 	data->speed = speed;
399 	struct sirf_data *data;
402 	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
403 	if (!data)
412 	gnss_set_drvdata(gdev, data);
414 	data->serdev = serdev;
415 	data->gdev = gdev;
417 	mutex_init(&data->gdev_mutex);
418 	mutex_init(&data->serdev_mutex);
419 	init_waitqueue_head(&data->power_wait);
421 	serdev_device_set_drvdata(serdev, data);
428 	data->vcc = devm_regulator_get(dev, "vcc");
429 	if (IS_ERR(data->vcc)) {
430 		ret = PTR_ERR(data->vcc);
434 	data->lna = devm_regulator_get(dev, "lna");
435 	if (IS_ERR(data->lna)) {
436 		ret = PTR_ERR(data->lna);
440 	data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff",
442 	if (IS_ERR(data->on_off)) {
443 		ret = PTR_ERR(data->on_off);
447 	if (data->on_off) {
448 		data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup",
450 		if (IS_ERR(data->wakeup)) {
451 			ret = PTR_ERR(data->wakeup);
455 		ret = regulator_enable(data->vcc);
463 	if (data->wakeup) {
464 		ret = gpiod_get_value_cansleep(data->wakeup);
467 		data->active = ret;
469 		ret = gpiod_to_irq(data->wakeup);
472 		data->irq = ret;
474 		ret = request_threaded_irq(data->irq, NULL, sirf_wakeup_handler,
476 				"wakeup", data);
481 	if (data->on_off) {
482 		if (!data->wakeup) {
483 			data->active = false;
485 			ret = sirf_serdev_open(data);
490 			sirf_serdev_close(data);
494 		if (data->active) {
495 			ret = sirf_set_active(data, false);
525 	if (data->wakeup)
526 		free_irq(data->irq, data);
528 	if (data->on_off)
529 		regulator_disable(data->vcc);
531 	gnss_put_device(data->gdev);
538 	struct sirf_data *data = serdev_device_get_drvdata(serdev);
540 	gnss_deregister_device(data->gdev);
547 	if (data->wakeup)
548 		free_irq(data->irq, data);
550 	if (data->on_off)
551 		regulator_disable(data->vcc);
553 	gnss_put_device(data->gdev);