[linux-2.6-block.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/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

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

	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;

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

			return ret;
		}

		break;
	} while (retries--);

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