[mirror_ubuntu-hirsute-kernel.git] / drivers / gnss / sirf.c

// SPDX-License-Identifier: GPL-2.0
/*
 * SiRFstar GNSS receiver driver
 *
 * Copyright (C) 2018 Johan Hovold <johan@kernel.org>
 */

#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/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

struct sirf_data {
	struct gnss_device *gdev;
	struct serdev_device *serdev;
	speed_t	speed;
	struct regulator *vcc;
	struct gpio_desc *on_off;
	struct gpio_desc *wakeup;
	int irq;
	bool active;
	wait_queue_head_t power_wait;
};

static int sirf_open(struct gnss_device *gdev)
{
	struct sirf_data *data = gnss_get_drvdata(gdev);
	struct serdev_device *serdev = data->serdev;
	int ret;

	ret = serdev_device_open(serdev);
	if (ret)
		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);
		pm_runtime_put_noidle(&serdev->dev);
		goto err_close;
	}

	return 0;

err_close:
	serdev_device_close(serdev);

	return ret;
}

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);

	pm_runtime_put(&serdev->dev);
}

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, 0);
	if (ret < 0)
		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;

	return gnss_insert_raw(gdev, buf, count);
}

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(struct sirf_data *data, bool active,
					unsigned long timeout)
{
	int ret;

	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;

	while (retries-- > 0) {
		sirf_pulse_on_off(data);
		ret = sirf_wait_for_power_state(data, active, timeout);
		if (ret < 0) {
			if (ret == -ETIMEDOUT)
				continue;

			return ret;
		}

		break;
	}

	if (retries == 0)
		return -ETIMEDOUT;

	return 0;
}

static int sirf_runtime_suspend(struct device *dev)
{
	struct sirf_data *data = dev_get_drvdata(dev);

	if (!data->on_off)
		return regulator_disable(data->vcc);

	return sirf_set_active(data, false);
}

static int sirf_runtime_resume(struct device *dev)
{
	struct sirf_data *data = dev_get_drvdata(dev);

	if (!data->on_off)
		return regulator_enable(data->vcc);

	return sirf_set_active(data, true);
}

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;

	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->on_off = devm_gpiod_get_optional(dev, "sirf,onoff",
			GPIOD_OUT_LOW);
	if (IS_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))
			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;
		}
	}

	if (data->wakeup) {
		ret = gpiod_to_irq(data->wakeup);
		if (ret < 0)
			goto err_put_device;

		data->irq = ret;

		ret = devm_request_threaded_irq(dev, data->irq, NULL,
				sirf_wakeup_handler,
				IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				"wakeup", data);
		if (ret)
			goto err_put_device;
	}

	if (data->on_off) {
		ret = regulator_enable(data->vcc);
		if (ret)
			goto err_put_device;

		/* Wait for chip to boot into hibernate mode */
		msleep(SIRF_BOOT_DELAY);
	}

	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_disable_vcc;
	}

	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_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->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,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 <johan@kernel.org>");
MODULE_DESCRIPTION("SiRFstar GNSS receiver driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
d2efbbd1 JH	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* SiRFstar GNSS receiver driver
	4	*
	5	* Copyright (C) 2018 Johan Hovold <johan@kernel.org>
	6	*/
	7
	8	#include <linux/errno.h>
	9	#include <linux/gnss.h>
	10	#include <linux/gpio/consumer.h>
	11	#include <linux/init.h>
	12	#include <linux/interrupt.h>
	13	#include <linux/kernel.h>
	14	#include <linux/module.h>
	15	#include <linux/of.h>
	16	#include <linux/pm.h>
	17	#include <linux/pm_runtime.h>
	18	#include <linux/regulator/consumer.h>
	19	#include <linux/serdev.h>
	20	#include <linux/slab.h>
	21	#include <linux/wait.h>
	22
	23	#define SIRF_BOOT_DELAY 500
	24	#define SIRF_ON_OFF_PULSE_TIME 100
	25	#define SIRF_ACTIVATE_TIMEOUT 200
	26	#define SIRF_HIBERNATE_TIMEOUT 200
	27
	28	struct sirf_data {
	29	struct gnss_device *gdev;
	30	struct serdev_device *serdev;
	31	speed_t speed;
	32	struct regulator *vcc;
	33	struct gpio_desc *on_off;
	34	struct gpio_desc *wakeup;
	35	int irq;
	36	bool active;
	37	wait_queue_head_t power_wait;
	38	};
	39
	40	static int sirf_open(struct gnss_device *gdev)
	41	{
	42	struct sirf_data *data = gnss_get_drvdata(gdev);
	43	struct serdev_device *serdev = data->serdev;
	44	int ret;
	45
	46	ret = serdev_device_open(serdev);
	47	if (ret)
	48	return ret;
	49
	50	serdev_device_set_baudrate(serdev, data->speed);
	51	serdev_device_set_flow_control(serdev, false);
	52
	53	ret = pm_runtime_get_sync(&serdev->dev);
	54	if (ret < 0) {
	55	dev_err(&gdev->dev, "failed to runtime resume: %d\n", ret);
	56	pm_runtime_put_noidle(&serdev->dev);
	57	goto err_close;
	58	}
	59
	60	return 0;
	61
	62	err_close:
	63	serdev_device_close(serdev);
	64
65	return ret;
66	}
67
68	static void sirf_close(struct gnss_device *gdev)
69	{
70	struct sirf_data *data = gnss_get_drvdata(gdev);
71	struct serdev_device *serdev = data->serdev;
72
73	serdev_device_close(serdev);
74
75	pm_runtime_put(&serdev->dev);
76	}
77
78	static int sirf_write_raw(struct gnss_device gdev, const unsigned char buf,
79	size_t count)
80	{
81	struct sirf_data *data = gnss_get_drvdata(gdev);
82	struct serdev_device *serdev = data->serdev;
83	int ret;
84
85	/* write is only buffered synchronously */
86	ret = serdev_device_write(serdev, buf, count, 0);
87	if (ret < 0)
88	return ret;
89
90	/* FIXME: determine if interrupted? */
91	serdev_device_wait_until_sent(serdev, 0);
92
93	return count;
94	}
95
96	static const struct gnss_operations sirf_gnss_ops = {
97	.open = sirf_open,
98	.close = sirf_close,
99	.write_raw = sirf_write_raw,
100	};
101
102	static int sirf_receive_buf(struct serdev_device *serdev,
103	const unsigned char *buf, size_t count)
104	{
105	struct sirf_data *data = serdev_device_get_drvdata(serdev);
106	struct gnss_device *gdev = data->gdev;
107
108	return gnss_insert_raw(gdev, buf, count);
109	}
110
111	static const struct serdev_device_ops sirf_serdev_ops = {
112	.receive_buf = sirf_receive_buf,
113	.write_wakeup = serdev_device_write_wakeup,
114	};
115
116	static irqreturn_t sirf_wakeup_handler(int irq, void *dev_id)
117	{
118	struct sirf_data *data = dev_id;
119	struct device *dev = &data->serdev->dev;
120	int ret;
121
122	ret = gpiod_get_value_cansleep(data->wakeup);
123	dev_dbg(dev, "%s - wakeup = %d\n", __func__, ret);
124	if (ret < 0)
125	goto out;
126
127	data->active = !!ret;
128	wake_up_interruptible(&data->power_wait);
129	out:
130	return IRQ_HANDLED;
131	}
132
133	static int sirf_wait_for_power_state(struct sirf_data *data, bool active,
134	unsigned long timeout)
135	{
136	int ret;
137
138	ret = wait_event_interruptible_timeout(data->power_wait,
139	data->active == active, msecs_to_jiffies(timeout));
140	if (ret < 0)
141	return ret;
142
143	if (ret == 0) {
144	dev_warn(&data->serdev->dev, "timeout waiting for active state = %d\n",
145	active);
146	return -ETIMEDOUT;
147	}
148
149	return 0;
150	}
151
152	static void sirf_pulse_on_off(struct sirf_data *data)
153	{
154	gpiod_set_value_cansleep(data->on_off, 1);
155	msleep(SIRF_ON_OFF_PULSE_TIME);
156	gpiod_set_value_cansleep(data->on_off, 0);
157	}
158
159	static int sirf_set_active(struct sirf_data *data, bool active)
160	{
161	unsigned long timeout;
162	int retries = 3;
163	int ret;
164
165	if (active)
166	timeout = SIRF_ACTIVATE_TIMEOUT;
167	else
168	timeout = SIRF_HIBERNATE_TIMEOUT;
169
170	while (retries-- > 0) {
171	sirf_pulse_on_off(data);
172	ret = sirf_wait_for_power_state(data, active, timeout);
173	if (ret < 0) {
174	if (ret == -ETIMEDOUT)
175	continue;
176
177	return ret;
178	}
179
180	break;
181	}
182
183	if (retries == 0)
184	return -ETIMEDOUT;
185
186	return 0;
187	}
188
189	static int sirf_runtime_suspend(struct device *dev)
190	{
191	struct sirf_data *data = dev_get_drvdata(dev);
192
193	if (!data->on_off)
194	return regulator_disable(data->vcc);
195
196	return sirf_set_active(data, false);
197	}
198
199	static int sirf_runtime_resume(struct device *dev)
200	{
201	struct sirf_data *data = dev_get_drvdata(dev);
202
203	if (!data->on_off)
204	return regulator_enable(data->vcc);
205
206	return sirf_set_active(data, true);
207	}
208
209	static int __maybe_unused sirf_suspend(struct device *dev)
210	{
211	struct sirf_data *data = dev_get_drvdata(dev);
212	int ret = 0;
213
214	if (!pm_runtime_suspended(dev))
215	ret = sirf_runtime_suspend(dev);
216
217	if (data->wakeup)
218	disable_irq(data->irq);
219
220	return ret;
221	}
222
223	static int __maybe_unused sirf_resume(struct device *dev)
224	{
225	struct sirf_data *data = dev_get_drvdata(dev);
226	int ret = 0;
227
228	if (data->wakeup)
229	enable_irq(data->irq);
230
231	if (!pm_runtime_suspended(dev))
232	ret = sirf_runtime_resume(dev);
233
234	return ret;
235	}
236
237	static const struct dev_pm_ops sirf_pm_ops = {
238	SET_SYSTEM_SLEEP_PM_OPS(sirf_suspend, sirf_resume)
239	SET_RUNTIME_PM_OPS(sirf_runtime_suspend, sirf_runtime_resume, NULL)
240	};
241
242	static int sirf_parse_dt(struct serdev_device *serdev)
243	{
244	struct sirf_data *data = serdev_device_get_drvdata(serdev);
245	struct device_node *node = serdev->dev.of_node;
246	u32 speed = 9600;
247
248	of_property_read_u32(node, "current-speed", &speed);
249
250	data->speed = speed;
251
252	return 0;
253	}
254
255	static int sirf_probe(struct serdev_device *serdev)
256	{
257	struct device *dev = &serdev->dev;
258	struct gnss_device *gdev;
259	struct sirf_data *data;
260	int ret;
261
262	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
263	if (!data)
264	return -ENOMEM;
265
266	gdev = gnss_allocate_device(dev);
267	if (!gdev)
268	return -ENOMEM;
269
10f14663	270	gdev->type = GNSS_TYPE_SIRF;
d2efbbd1 JH	271	gdev->ops = &sirf_gnss_ops;
	272	gnss_set_drvdata(gdev, data);
	273
	274	data->serdev = serdev;
	275	data->gdev = gdev;
	276
	277	init_waitqueue_head(&data->power_wait);
	278
	279	serdev_device_set_drvdata(serdev, data);
	280	serdev_device_set_client_ops(serdev, &sirf_serdev_ops);
	281
	282	ret = sirf_parse_dt(serdev);
	283	if (ret)
	284	goto err_put_device;
	285
	286	data->vcc = devm_regulator_get(dev, "vcc");
	287	if (IS_ERR(data->vcc)) {
	288	ret = PTR_ERR(data->vcc);
	289	goto err_put_device;
	290	}
	291
	292	data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff",
	293	GPIOD_OUT_LOW);
	294	if (IS_ERR(data->on_off))
	295	goto err_put_device;
	296
	297	if (data->on_off) {
	298	data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup",
	299	GPIOD_IN);
	300	if (IS_ERR(data->wakeup))
	301	goto err_put_device;
	302
	303	/*
	304	* Configurations where WAKEUP has been left not connected,
	305	* are currently not supported.
	306	*/
	307	if (!data->wakeup) {
	308	dev_err(dev, "no wakeup gpio specified\n");
	309	ret = -ENODEV;
	310	goto err_put_device;
	311	}
	312	}
	313
	314	if (data->wakeup) {
	315	ret = gpiod_to_irq(data->wakeup);
	316	if (ret < 0)
	317	goto err_put_device;
	318
	319	data->irq = ret;
	320
	321	ret = devm_request_threaded_irq(dev, data->irq, NULL,
	322	sirf_wakeup_handler,
	323	IRQF_TRIGGER_RISING \| IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
	324	"wakeup", data);
	325	if (ret)
	326	goto err_put_device;
	327	}
	328
	329	if (data->on_off) {
	330	ret = regulator_enable(data->vcc);
	331	if (ret)
	332	goto err_put_device;
	333
	334	/* Wait for chip to boot into hibernate mode */
335	msleep(SIRF_BOOT_DELAY);
336	}
337
338	if (IS_ENABLED(CONFIG_PM)) {
339	pm_runtime_set_suspended(dev); /* clear runtime_error flag */
340	pm_runtime_enable(dev);
341	} else {
342	ret = sirf_runtime_resume(dev);
343	if (ret < 0)
344	goto err_disable_vcc;
345	}
346
347	ret = gnss_register_device(gdev);
348	if (ret)
349	goto err_disable_rpm;
350
351	return 0;
352
353	err_disable_rpm:
354	if (IS_ENABLED(CONFIG_PM))
355	pm_runtime_disable(dev);
356	else
357	sirf_runtime_suspend(dev);
358	err_disable_vcc:
359	if (data->on_off)
360	regulator_disable(data->vcc);
361	err_put_device:
362	gnss_put_device(data->gdev);
363
364	return ret;
365	}
366
367	static void sirf_remove(struct serdev_device *serdev)
368	{
369	struct sirf_data *data = serdev_device_get_drvdata(serdev);
370
371	gnss_deregister_device(data->gdev);
372
373	if (IS_ENABLED(CONFIG_PM))
374	pm_runtime_disable(&serdev->dev);
375	else
376	sirf_runtime_suspend(&serdev->dev);
377
378	if (data->on_off)
379	regulator_disable(data->vcc);
380
381	gnss_put_device(data->gdev);
382	};
383
384	#ifdef CONFIG_OF
385	static const struct of_device_id sirf_of_match[] = {
386	{ .compatible = "fastrax,uc430" },
387	{ .compatible = "linx,r4" },
388	{ .compatible = "wi2wi,w2sg0008i" },
389	{ .compatible = "wi2wi,w2sg0084i" },
390	{},
391	};
392	MODULE_DEVICE_TABLE(of, sirf_of_match);
393	#endif
394
395	static struct serdev_device_driver sirf_driver = {
396	.driver = {
397	.name = "gnss-sirf",
398	.of_match_table = of_match_ptr(sirf_of_match),
399	.pm = &sirf_pm_ops,
400	},
401	.probe = sirf_probe,
402	.remove = sirf_remove,
403	};
404	module_serdev_device_driver(sirf_driver);
405
406	MODULE_AUTHOR("Johan Hovold <johan@kernel.org>");
407	MODULE_DESCRIPTION("SiRFstar GNSS receiver driver");
408	MODULE_LICENSE("GPL v2");