gnss: sirf: add support for configurations without wakeup signal

Some Wi2Wi devices do not have a wakeup output, so device state can
only be indirectly detected by looking whether there is communication
over the serial lines.
This approach requires a report cycle set to a value less than 2 seconds
to be reliable.

Signed-off-by: Andreas Kemnade <andreas@kemnade.info>
[ johan: simplify sirf_set_active(), style changes ]
Signed-off-by: Johan Hovold <johan@kernel.org>

diff --git a/drivers/gnss/sirf.c b/drivers/gnss/sirf.c
index 49bc021325e91e3f84bc5476d113d84b6c9bbd4d..703d9f17c58387cec0b50e9f9a7c923638f936f9 100644 (file)
--- a/drivers/gnss/sirf.c
+++ b/drivers/gnss/sirf.c
@@ -25,6 +25,15 @@
 #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;
@@ -39,9 +48,42 @@ struct sirf_data {
        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);
@@ -52,7 +94,7 @@ static int sirf_open(struct gnss_device *gdev)
        data->open = true;
        mutex_unlock(&data->gdev_mutex);
 
-       ret = serdev_device_open(serdev);
+       ret = sirf_serdev_open(data);
        if (ret) {
                mutex_lock(&data->gdev_mutex);
                data->open = false;
@@ -60,10 +102,6 @@ static int sirf_open(struct gnss_device *gdev)
                return ret;
        }
 
-
-       serdev_device_set_baudrate(serdev, data->speed);
-       serdev_device_set_flow_control(serdev, false);
-
        ret = pm_runtime_get_sync(&serdev->dev);
        if (ret < 0) {
                dev_err(&gdev->dev, "failed to runtime resume: %d\n", ret);
@@ -74,7 +112,7 @@ static int sirf_open(struct gnss_device *gdev)
        return 0;
 
 err_close:
-       serdev_device_close(serdev);
+       sirf_serdev_close(data);
 
        mutex_lock(&data->gdev_mutex);
        data->open = false;
@@ -88,7 +126,7 @@ static void sirf_close(struct gnss_device *gdev)
        struct sirf_data *data = gnss_get_drvdata(gdev);
        struct serdev_device *serdev = data->serdev;
 
-       serdev_device_close(serdev);
+       sirf_serdev_close(data);
 
        pm_runtime_put(&serdev->dev);
 
@@ -128,6 +166,11 @@ static int sirf_receive_buf(struct serdev_device *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);
@@ -158,11 +201,39 @@ 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)
@@ -195,21 +266,22 @@ static int sirf_set_active(struct sirf_data *data, bool active)
        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);
-               if (ret < 0) {
-                       if (ret == -ETIMEDOUT)
-                               continue;
-
-                       return ret;
-               }
+       } while (ret == -ETIMEDOUT && retries--);
 
-               break;
-       } while (retries--);
+       if (!data->wakeup)
+               sirf_serdev_close(data);
 
-       if (retries < 0)
-               return -ETIMEDOUT;
+       if (ret)
+               return ret;
 
        return 0;
 }
@@ -303,6 +375,7 @@ static int sirf_probe(struct serdev_device *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);
@@ -329,16 +402,6 @@ static int sirf_probe(struct serdev_device *serdev)
                if (IS_ERR(data->wakeup))
                        goto err_put_device;
 
-               /*
-                * Configurations where WAKEUP has been left not connected,
-                * are currently not supported.
-                */
-               if (!data->wakeup) {
-                       dev_err(dev, "no wakeup gpio specified\n");
-                       ret = -ENODEV;
-                       goto err_put_device;
-               }
-
                ret = regulator_enable(data->vcc);
                if (ret)
                        goto err_put_device;
@@ -366,6 +429,17 @@ static int sirf_probe(struct serdev_device *serdev)
        }
 
        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);
@@ -433,6 +507,7 @@ static void sirf_remove(struct serdev_device *serdev)
 static const struct of_device_id sirf_of_match[] = {
        { .compatible = "fastrax,uc430" },
        { .compatible = "linx,r4" },
+       { .compatible = "wi2wi,w2sg0004" },
        { .compatible = "wi2wi,w2sg0008i" },
        { .compatible = "wi2wi,w2sg0084i" },
        {},