Commit ccd0e496 authored by Andreas Kemnade's avatar Andreas Kemnade Committed by Johan Hovold
Browse files

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: default avatarAndreas Kemnade <andreas@kemnade.info>
[ johan: simplify sirf_set_active(), style changes ]
Signed-off-by: default avatarJohan Hovold <johan@kernel.org>
parent 196d9184

drivers/gnss/sirf.c

+102 −27
Original line number Diff line number Diff line
@@ -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" },

	{},

CRA Git | Maintained and supported by SUSTech CRA and CCSE