forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
581 lines
12 KiB
581 lines
12 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
/* |
|
* SiRFstar GNSS receiver driver |
|
* |
|
* Copyright (C) 2018 Johan Hovold <[email protected]> |
|
*/ |
|
|
|
#include <linux/errno.h> |
|
#include <linux/gnss.h> |
|
#include <linux/gpio/consumer.h> |
|
#include <linux/init.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/of.h> |
|
#include <linux/pm.h> |
|
#include <linux/pm_runtime.h> |
|
#include <linux/regulator/consumer.h> |
|
#include <linux/sched.h> |
|
#include <linux/serdev.h> |
|
#include <linux/slab.h> |
|
#include <linux/wait.h> |
|
|
|
#define SIRF_BOOT_DELAY 500 |
|
#define SIRF_ON_OFF_PULSE_TIME 100 |
|
#define SIRF_ACTIVATE_TIMEOUT 200 |
|
#define SIRF_HIBERNATE_TIMEOUT 200 |
|
/* |
|
* If no data arrives for this time, we assume that the chip is off. |
|
* REVISIT: The report cycle is configurable and can be several minutes long, |
|
* so this will only work reliably if the report cycle is set to a reasonable |
|
* low value. Also power saving settings (like send data only on movement) |
|
* might things work even worse. |
|
* Workaround might be to parse shutdown or bootup messages. |
|
*/ |
|
#define SIRF_REPORT_CYCLE 2000 |
|
|
|
struct sirf_data { |
|
struct gnss_device *gdev; |
|
struct serdev_device *serdev; |
|
speed_t speed; |
|
struct regulator *vcc; |
|
struct regulator *lna; |
|
struct gpio_desc *on_off; |
|
struct gpio_desc *wakeup; |
|
int irq; |
|
bool active; |
|
|
|
struct mutex gdev_mutex; |
|
bool open; |
|
|
|
struct mutex serdev_mutex; |
|
int serdev_count; |
|
|
|
wait_queue_head_t power_wait; |
|
}; |
|
|
|
static int sirf_serdev_open(struct sirf_data *data) |
|
{ |
|
int ret = 0; |
|
|
|
mutex_lock(&data->serdev_mutex); |
|
if (++data->serdev_count == 1) { |
|
ret = serdev_device_open(data->serdev); |
|
if (ret) { |
|
data->serdev_count--; |
|
goto out_unlock; |
|
} |
|
|
|
serdev_device_set_baudrate(data->serdev, data->speed); |
|
serdev_device_set_flow_control(data->serdev, false); |
|
} |
|
|
|
out_unlock: |
|
mutex_unlock(&data->serdev_mutex); |
|
|
|
return ret; |
|
} |
|
|
|
static void sirf_serdev_close(struct sirf_data *data) |
|
{ |
|
mutex_lock(&data->serdev_mutex); |
|
if (--data->serdev_count == 0) |
|
serdev_device_close(data->serdev); |
|
mutex_unlock(&data->serdev_mutex); |
|
} |
|
|
|
static int sirf_open(struct gnss_device *gdev) |
|
{ |
|
struct sirf_data *data = gnss_get_drvdata(gdev); |
|
struct serdev_device *serdev = data->serdev; |
|
int ret; |
|
|
|
mutex_lock(&data->gdev_mutex); |
|
data->open = true; |
|
mutex_unlock(&data->gdev_mutex); |
|
|
|
ret = sirf_serdev_open(data); |
|
if (ret) { |
|
mutex_lock(&data->gdev_mutex); |
|
data->open = false; |
|
mutex_unlock(&data->gdev_mutex); |
|
return ret; |
|
} |
|
|
|
ret = pm_runtime_get_sync(&serdev->dev); |
|
if (ret < 0) { |
|
dev_err(&gdev->dev, "failed to runtime resume: %d\n", ret); |
|
pm_runtime_put_noidle(&serdev->dev); |
|
goto err_close; |
|
} |
|
|
|
return 0; |
|
|
|
err_close: |
|
sirf_serdev_close(data); |
|
|
|
mutex_lock(&data->gdev_mutex); |
|
data->open = false; |
|
mutex_unlock(&data->gdev_mutex); |
|
|
|
return ret; |
|
} |
|
|
|
static void sirf_close(struct gnss_device *gdev) |
|
{ |
|
struct sirf_data *data = gnss_get_drvdata(gdev); |
|
struct serdev_device *serdev = data->serdev; |
|
|
|
sirf_serdev_close(data); |
|
|
|
pm_runtime_put(&serdev->dev); |
|
|
|
mutex_lock(&data->gdev_mutex); |
|
data->open = false; |
|
mutex_unlock(&data->gdev_mutex); |
|
} |
|
|
|
static int sirf_write_raw(struct gnss_device *gdev, const unsigned char *buf, |
|
size_t count) |
|
{ |
|
struct sirf_data *data = gnss_get_drvdata(gdev); |
|
struct serdev_device *serdev = data->serdev; |
|
int ret; |
|
|
|
/* write is only buffered synchronously */ |
|
ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT); |
|
if (ret < 0 || ret < count) |
|
return ret; |
|
|
|
/* FIXME: determine if interrupted? */ |
|
serdev_device_wait_until_sent(serdev, 0); |
|
|
|
return count; |
|
} |
|
|
|
static const struct gnss_operations sirf_gnss_ops = { |
|
.open = sirf_open, |
|
.close = sirf_close, |
|
.write_raw = sirf_write_raw, |
|
}; |
|
|
|
static int sirf_receive_buf(struct serdev_device *serdev, |
|
const unsigned char *buf, size_t count) |
|
{ |
|
struct sirf_data *data = serdev_device_get_drvdata(serdev); |
|
struct gnss_device *gdev = data->gdev; |
|
int ret = 0; |
|
|
|
if (!data->wakeup && !data->active) { |
|
data->active = true; |
|
wake_up_interruptible(&data->power_wait); |
|
} |
|
|
|
mutex_lock(&data->gdev_mutex); |
|
if (data->open) |
|
ret = gnss_insert_raw(gdev, buf, count); |
|
mutex_unlock(&data->gdev_mutex); |
|
|
|
return ret; |
|
} |
|
|
|
static const struct serdev_device_ops sirf_serdev_ops = { |
|
.receive_buf = sirf_receive_buf, |
|
.write_wakeup = serdev_device_write_wakeup, |
|
}; |
|
|
|
static irqreturn_t sirf_wakeup_handler(int irq, void *dev_id) |
|
{ |
|
struct sirf_data *data = dev_id; |
|
struct device *dev = &data->serdev->dev; |
|
int ret; |
|
|
|
ret = gpiod_get_value_cansleep(data->wakeup); |
|
dev_dbg(dev, "%s - wakeup = %d\n", __func__, ret); |
|
if (ret < 0) |
|
goto out; |
|
|
|
data->active = ret; |
|
wake_up_interruptible(&data->power_wait); |
|
out: |
|
return IRQ_HANDLED; |
|
} |
|
|
|
static int sirf_wait_for_power_state_nowakeup(struct sirf_data *data, |
|
bool active, |
|
unsigned long timeout) |
|
{ |
|
int ret; |
|
|
|
/* Wait for state change (including any shutdown messages). */ |
|
msleep(timeout); |
|
|
|
/* Wait for data reception or timeout. */ |
|
data->active = false; |
|
ret = wait_event_interruptible_timeout(data->power_wait, |
|
data->active, msecs_to_jiffies(SIRF_REPORT_CYCLE)); |
|
if (ret < 0) |
|
return ret; |
|
|
|
if (ret > 0 && !active) |
|
return -ETIMEDOUT; |
|
|
|
if (ret == 0 && active) |
|
return -ETIMEDOUT; |
|
|
|
return 0; |
|
} |
|
|
|
static int sirf_wait_for_power_state(struct sirf_data *data, bool active, |
|
unsigned long timeout) |
|
{ |
|
int ret; |
|
|
|
if (!data->wakeup) |
|
return sirf_wait_for_power_state_nowakeup(data, active, timeout); |
|
|
|
ret = wait_event_interruptible_timeout(data->power_wait, |
|
data->active == active, msecs_to_jiffies(timeout)); |
|
if (ret < 0) |
|
return ret; |
|
|
|
if (ret == 0) { |
|
dev_warn(&data->serdev->dev, "timeout waiting for active state = %d\n", |
|
active); |
|
return -ETIMEDOUT; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static void sirf_pulse_on_off(struct sirf_data *data) |
|
{ |
|
gpiod_set_value_cansleep(data->on_off, 1); |
|
msleep(SIRF_ON_OFF_PULSE_TIME); |
|
gpiod_set_value_cansleep(data->on_off, 0); |
|
} |
|
|
|
static int sirf_set_active(struct sirf_data *data, bool active) |
|
{ |
|
unsigned long timeout; |
|
int retries = 3; |
|
int ret; |
|
|
|
if (active) |
|
timeout = SIRF_ACTIVATE_TIMEOUT; |
|
else |
|
timeout = SIRF_HIBERNATE_TIMEOUT; |
|
|
|
if (!data->wakeup) { |
|
ret = sirf_serdev_open(data); |
|
if (ret) |
|
return ret; |
|
} |
|
|
|
do { |
|
sirf_pulse_on_off(data); |
|
ret = sirf_wait_for_power_state(data, active, timeout); |
|
} while (ret == -ETIMEDOUT && retries--); |
|
|
|
if (!data->wakeup) |
|
sirf_serdev_close(data); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
return 0; |
|
} |
|
|
|
static int sirf_runtime_suspend(struct device *dev) |
|
{ |
|
struct sirf_data *data = dev_get_drvdata(dev); |
|
int ret2; |
|
int ret; |
|
|
|
if (data->on_off) |
|
ret = sirf_set_active(data, false); |
|
else |
|
ret = regulator_disable(data->vcc); |
|
|
|
if (ret) |
|
return ret; |
|
|
|
ret = regulator_disable(data->lna); |
|
if (ret) |
|
goto err_reenable; |
|
|
|
return 0; |
|
|
|
err_reenable: |
|
if (data->on_off) |
|
ret2 = sirf_set_active(data, true); |
|
else |
|
ret2 = regulator_enable(data->vcc); |
|
|
|
if (ret2) |
|
dev_err(dev, |
|
"failed to reenable power on failed suspend: %d\n", |
|
ret2); |
|
|
|
return ret; |
|
} |
|
|
|
static int sirf_runtime_resume(struct device *dev) |
|
{ |
|
struct sirf_data *data = dev_get_drvdata(dev); |
|
int ret; |
|
|
|
ret = regulator_enable(data->lna); |
|
if (ret) |
|
return ret; |
|
|
|
if (data->on_off) |
|
ret = sirf_set_active(data, true); |
|
else |
|
ret = regulator_enable(data->vcc); |
|
|
|
if (ret) |
|
goto err_disable_lna; |
|
|
|
return 0; |
|
|
|
err_disable_lna: |
|
regulator_disable(data->lna); |
|
|
|
return ret; |
|
} |
|
|
|
static int __maybe_unused sirf_suspend(struct device *dev) |
|
{ |
|
struct sirf_data *data = dev_get_drvdata(dev); |
|
int ret = 0; |
|
|
|
if (!pm_runtime_suspended(dev)) |
|
ret = sirf_runtime_suspend(dev); |
|
|
|
if (data->wakeup) |
|
disable_irq(data->irq); |
|
|
|
return ret; |
|
} |
|
|
|
static int __maybe_unused sirf_resume(struct device *dev) |
|
{ |
|
struct sirf_data *data = dev_get_drvdata(dev); |
|
int ret = 0; |
|
|
|
if (data->wakeup) |
|
enable_irq(data->irq); |
|
|
|
if (!pm_runtime_suspended(dev)) |
|
ret = sirf_runtime_resume(dev); |
|
|
|
return ret; |
|
} |
|
|
|
static const struct dev_pm_ops sirf_pm_ops = { |
|
SET_SYSTEM_SLEEP_PM_OPS(sirf_suspend, sirf_resume) |
|
SET_RUNTIME_PM_OPS(sirf_runtime_suspend, sirf_runtime_resume, NULL) |
|
}; |
|
|
|
static int sirf_parse_dt(struct serdev_device *serdev) |
|
{ |
|
struct sirf_data *data = serdev_device_get_drvdata(serdev); |
|
struct device_node *node = serdev->dev.of_node; |
|
u32 speed = 9600; |
|
|
|
of_property_read_u32(node, "current-speed", &speed); |
|
|
|
data->speed = speed; |
|
|
|
return 0; |
|
} |
|
|
|
static int sirf_probe(struct serdev_device *serdev) |
|
{ |
|
struct device *dev = &serdev->dev; |
|
struct gnss_device *gdev; |
|
struct sirf_data *data; |
|
int ret; |
|
|
|
data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); |
|
if (!data) |
|
return -ENOMEM; |
|
|
|
gdev = gnss_allocate_device(dev); |
|
if (!gdev) |
|
return -ENOMEM; |
|
|
|
gdev->type = GNSS_TYPE_SIRF; |
|
gdev->ops = &sirf_gnss_ops; |
|
gnss_set_drvdata(gdev, data); |
|
|
|
data->serdev = serdev; |
|
data->gdev = gdev; |
|
|
|
mutex_init(&data->gdev_mutex); |
|
mutex_init(&data->serdev_mutex); |
|
init_waitqueue_head(&data->power_wait); |
|
|
|
serdev_device_set_drvdata(serdev, data); |
|
serdev_device_set_client_ops(serdev, &sirf_serdev_ops); |
|
|
|
ret = sirf_parse_dt(serdev); |
|
if (ret) |
|
goto err_put_device; |
|
|
|
data->vcc = devm_regulator_get(dev, "vcc"); |
|
if (IS_ERR(data->vcc)) { |
|
ret = PTR_ERR(data->vcc); |
|
goto err_put_device; |
|
} |
|
|
|
data->lna = devm_regulator_get(dev, "lna"); |
|
if (IS_ERR(data->lna)) { |
|
ret = PTR_ERR(data->lna); |
|
goto err_put_device; |
|
} |
|
|
|
data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff", |
|
GPIOD_OUT_LOW); |
|
if (IS_ERR(data->on_off)) { |
|
ret = PTR_ERR(data->on_off); |
|
goto err_put_device; |
|
} |
|
|
|
if (data->on_off) { |
|
data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup", |
|
GPIOD_IN); |
|
if (IS_ERR(data->wakeup)) { |
|
ret = PTR_ERR(data->wakeup); |
|
goto err_put_device; |
|
} |
|
|
|
ret = regulator_enable(data->vcc); |
|
if (ret) |
|
goto err_put_device; |
|
|
|
/* Wait for chip to boot into hibernate mode. */ |
|
msleep(SIRF_BOOT_DELAY); |
|
} |
|
|
|
if (data->wakeup) { |
|
ret = gpiod_get_value_cansleep(data->wakeup); |
|
if (ret < 0) |
|
goto err_disable_vcc; |
|
data->active = ret; |
|
|
|
ret = gpiod_to_irq(data->wakeup); |
|
if (ret < 0) |
|
goto err_disable_vcc; |
|
data->irq = ret; |
|
|
|
ret = request_threaded_irq(data->irq, NULL, sirf_wakeup_handler, |
|
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, |
|
"wakeup", data); |
|
if (ret) |
|
goto err_disable_vcc; |
|
} |
|
|
|
if (data->on_off) { |
|
if (!data->wakeup) { |
|
data->active = false; |
|
|
|
ret = sirf_serdev_open(data); |
|
if (ret) |
|
goto err_disable_vcc; |
|
|
|
msleep(SIRF_REPORT_CYCLE); |
|
sirf_serdev_close(data); |
|
} |
|
|
|
/* Force hibernate mode if already active. */ |
|
if (data->active) { |
|
ret = sirf_set_active(data, false); |
|
if (ret) { |
|
dev_err(dev, "failed to set hibernate mode: %d\n", |
|
ret); |
|
goto err_free_irq; |
|
} |
|
} |
|
} |
|
|
|
if (IS_ENABLED(CONFIG_PM)) { |
|
pm_runtime_set_suspended(dev); /* clear runtime_error flag */ |
|
pm_runtime_enable(dev); |
|
} else { |
|
ret = sirf_runtime_resume(dev); |
|
if (ret < 0) |
|
goto err_free_irq; |
|
} |
|
|
|
ret = gnss_register_device(gdev); |
|
if (ret) |
|
goto err_disable_rpm; |
|
|
|
return 0; |
|
|
|
err_disable_rpm: |
|
if (IS_ENABLED(CONFIG_PM)) |
|
pm_runtime_disable(dev); |
|
else |
|
sirf_runtime_suspend(dev); |
|
err_free_irq: |
|
if (data->wakeup) |
|
free_irq(data->irq, data); |
|
err_disable_vcc: |
|
if (data->on_off) |
|
regulator_disable(data->vcc); |
|
err_put_device: |
|
gnss_put_device(data->gdev); |
|
|
|
return ret; |
|
} |
|
|
|
static void sirf_remove(struct serdev_device *serdev) |
|
{ |
|
struct sirf_data *data = serdev_device_get_drvdata(serdev); |
|
|
|
gnss_deregister_device(data->gdev); |
|
|
|
if (IS_ENABLED(CONFIG_PM)) |
|
pm_runtime_disable(&serdev->dev); |
|
else |
|
sirf_runtime_suspend(&serdev->dev); |
|
|
|
if (data->wakeup) |
|
free_irq(data->irq, data); |
|
|
|
if (data->on_off) |
|
regulator_disable(data->vcc); |
|
|
|
gnss_put_device(data->gdev); |
|
}; |
|
|
|
#ifdef CONFIG_OF |
|
static const struct of_device_id sirf_of_match[] = { |
|
{ .compatible = "fastrax,uc430" }, |
|
{ .compatible = "linx,r4" }, |
|
{ .compatible = "wi2wi,w2sg0004" }, |
|
{ .compatible = "wi2wi,w2sg0008i" }, |
|
{ .compatible = "wi2wi,w2sg0084i" }, |
|
{}, |
|
}; |
|
MODULE_DEVICE_TABLE(of, sirf_of_match); |
|
#endif |
|
|
|
static struct serdev_device_driver sirf_driver = { |
|
.driver = { |
|
.name = "gnss-sirf", |
|
.of_match_table = of_match_ptr(sirf_of_match), |
|
.pm = &sirf_pm_ops, |
|
}, |
|
.probe = sirf_probe, |
|
.remove = sirf_remove, |
|
}; |
|
module_serdev_device_driver(sirf_driver); |
|
|
|
MODULE_AUTHOR("Johan Hovold <[email protected]>"); |
|
MODULE_DESCRIPTION("SiRFstar GNSS receiver driver"); |
|
MODULE_LICENSE("GPL v2");
|
|
|