[deliverable/linux.git] / drivers / input / misc / pwm-beeper.c

/*
 *  Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
 *  PWM beeper driver
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under  the terms of the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the License, or (at your
 *  option) any later version.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

#include <linux/input.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pwm.h>
#include <linux/slab.h>

struct pwm_beeper {
	struct input_dev *input;
	struct pwm_device *pwm;
	unsigned long period;
};

#define HZ_TO_NANOSECONDS(x) (1000000000UL/(x))

static int pwm_beeper_event(struct input_dev *input,
			    unsigned int type, unsigned int code, int value)
{
	int ret = 0;
	struct pwm_beeper *beeper = input_get_drvdata(input);
	unsigned long period;

	if (type != EV_SND || value < 0)
		return -EINVAL;

	switch (code) {
	case SND_BELL:
		value = value ? 1000 : 0;
		break;
	case SND_TONE:
		break;
	default:
		return -EINVAL;
	}

	if (value == 0) {
		pwm_disable(beeper->pwm);
	} else {
		period = HZ_TO_NANOSECONDS(value);
		ret = pwm_config(beeper->pwm, period / 2, period);
		if (ret)
			return ret;
		ret = pwm_enable(beeper->pwm);
		if (ret)
			return ret;
		beeper->period = period;
	}

	return 0;
}

static int pwm_beeper_probe(struct platform_device *pdev)
{
	unsigned long pwm_id = (unsigned long)dev_get_platdata(&pdev->dev);
	struct pwm_beeper *beeper;
	int error;

	beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
	if (!beeper)
		return -ENOMEM;

	beeper->pwm = pwm_get(&pdev->dev, NULL);
	if (IS_ERR(beeper->pwm)) {
		dev_dbg(&pdev->dev, "unable to request PWM, trying legacy API\n");
		beeper->pwm = pwm_request(pwm_id, "pwm beeper");
	}

	if (IS_ERR(beeper->pwm)) {
		error = PTR_ERR(beeper->pwm);
		dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
		goto err_free;
	}

	beeper->input = input_allocate_device();
	if (!beeper->input) {
		dev_err(&pdev->dev, "Failed to allocate input device\n");
		error = -ENOMEM;
		goto err_pwm_free;
	}
	beeper->input->dev.parent = &pdev->dev;

	beeper->input->name = "pwm-beeper";
	beeper->input->phys = "pwm/input0";
	beeper->input->id.bustype = BUS_HOST;
	beeper->input->id.vendor = 0x001f;
	beeper->input->id.product = 0x0001;
	beeper->input->id.version = 0x0100;

	beeper->input->evbit[0] = BIT(EV_SND);
	beeper->input->sndbit[0] = BIT(SND_TONE) | BIT(SND_BELL);

	beeper->input->event = pwm_beeper_event;

	input_set_drvdata(beeper->input, beeper);

	error = input_register_device(beeper->input);
	if (error) {
		dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
		goto err_input_free;
	}

	platform_set_drvdata(pdev, beeper);

	return 0;

err_input_free:
	input_free_device(beeper->input);
err_pwm_free:
	pwm_free(beeper->pwm);
err_free:
	kfree(beeper);

	return error;
}

static int pwm_beeper_remove(struct platform_device *pdev)
{
	struct pwm_beeper *beeper = platform_get_drvdata(pdev);

	input_unregister_device(beeper->input);

	pwm_disable(beeper->pwm);
	pwm_free(beeper->pwm);

	kfree(beeper);

	return 0;
}

static int __maybe_unused pwm_beeper_suspend(struct device *dev)
{
	struct pwm_beeper *beeper = dev_get_drvdata(dev);

	if (beeper->period)
		pwm_disable(beeper->pwm);

	return 0;
}

static int __maybe_unused pwm_beeper_resume(struct device *dev)
{
	struct pwm_beeper *beeper = dev_get_drvdata(dev);

	if (beeper->period) {
		pwm_config(beeper->pwm, beeper->period / 2, beeper->period);
		pwm_enable(beeper->pwm);
	}

	return 0;
}

static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
			 pwm_beeper_suspend, pwm_beeper_resume);

#ifdef CONFIG_OF
static const struct of_device_id pwm_beeper_match[] = {
	{ .compatible = "pwm-beeper", },
	{ },
};
MODULE_DEVICE_TABLE(of, pwm_beeper_match);
#endif

static struct platform_driver pwm_beeper_driver = {
	.probe	= pwm_beeper_probe,
	.remove = pwm_beeper_remove,
	.driver = {
		.name	= "pwm-beeper",
		.pm	= &pwm_beeper_pm_ops,
		.of_match_table = of_match_ptr(pwm_beeper_match),
	},
};
module_platform_driver(pwm_beeper_driver);

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("PWM beeper driver");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:pwm-beeper");
Commit	Line	Data
e22739d0 LPC	1	/*
	2	* Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
	3	* PWM beeper driver
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by the
	7	* Free Software Foundation; either version 2 of the License, or (at your
	8	* option) any later version.
	9	*
	10	* You should have received a copy of the GNU General Public License along
	11	* with this program; if not, write to the Free Software Foundation, Inc.,
	12	* 675 Mass Ave, Cambridge, MA 02139, USA.
	13	*
	14	*/
	15
	16	#include <linux/input.h>
	17	#include <linux/module.h>
	18	#include <linux/kernel.h>
9dbe4c32	19	#include <linux/of.h>
e22739d0 LPC	20	#include <linux/platform_device.h>
	21	#include <linux/pwm.h>
	22	#include <linux/slab.h>
	23
	24	struct pwm_beeper {
	25	struct input_dev *input;
	26	struct pwm_device *pwm;
	27	unsigned long period;
	28	};
	29
	30	#define HZ_TO_NANOSECONDS(x) (1000000000UL/(x))
	31
	32	static int pwm_beeper_event(struct input_dev *input,
	33	unsigned int type, unsigned int code, int value)
	34	{
	35	int ret = 0;
	36	struct pwm_beeper *beeper = input_get_drvdata(input);
	37	unsigned long period;
	38
	39	if (type != EV_SND \|\| value < 0)
	40	return -EINVAL;
	41
	42	switch (code) {
	43	case SND_BELL:
	44	value = value ? 1000 : 0;
	45	break;
	46	case SND_TONE:
	47	break;
	48	default:
	49	return -EINVAL;
	50	}
	51
	52	if (value == 0) {
e22739d0 LPC	53	pwm_disable(beeper->pwm);
	54	} else {
	55	period = HZ_TO_NANOSECONDS(value);
	56	ret = pwm_config(beeper->pwm, period / 2, period);
	57	if (ret)
	58	return ret;
	59	ret = pwm_enable(beeper->pwm);
	60	if (ret)
	61	return ret;
	62	beeper->period = period;
	63	}
	64
	65	return 0;
	66	}
	67
5298cc4c	68	static int pwm_beeper_probe(struct platform_device *pdev)
e22739d0	69	{
c838cb3d	70	unsigned long pwm_id = (unsigned long)dev_get_platdata(&pdev->dev);
e22739d0 LPC	71	struct pwm_beeper *beeper;
	72	int error;
	73
	74	beeper = kzalloc(sizeof(*beeper), GFP_KERNEL);
	75	if (!beeper)
	76	return -ENOMEM;
	77
d56a289b SH	78	beeper->pwm = pwm_get(&pdev->dev, NULL);
	79	if (IS_ERR(beeper->pwm)) {
	80	dev_dbg(&pdev->dev, "unable to request PWM, trying legacy API\n");
	81	beeper->pwm = pwm_request(pwm_id, "pwm beeper");
	82	}
e22739d0 LPC	83
	84	if (IS_ERR(beeper->pwm)) {
	85	error = PTR_ERR(beeper->pwm);
	86	dev_err(&pdev->dev, "Failed to request pwm device: %d\n", error);
	87	goto err_free;
	88	}
	89
	90	beeper->input = input_allocate_device();
	91	if (!beeper->input) {
	92	dev_err(&pdev->dev, "Failed to allocate input device\n");
	93	error = -ENOMEM;
	94	goto err_pwm_free;
	95	}
	96	beeper->input->dev.parent = &pdev->dev;
	97
	98	beeper->input->name = "pwm-beeper";
	99	beeper->input->phys = "pwm/input0";
	100	beeper->input->id.bustype = BUS_HOST;
	101	beeper->input->id.vendor = 0x001f;
	102	beeper->input->id.product = 0x0001;
	103	beeper->input->id.version = 0x0100;
	104
	105	beeper->input->evbit[0] = BIT(EV_SND);
	106	beeper->input->sndbit[0] = BIT(SND_TONE) \| BIT(SND_BELL);
	107
	108	beeper->input->event = pwm_beeper_event;
	109
	110	input_set_drvdata(beeper->input, beeper);
	111
	112	error = input_register_device(beeper->input);
	113	if (error) {
	114	dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
	115	goto err_input_free;
	116	}
	117
	118	platform_set_drvdata(pdev, beeper);
	119
	120	return 0;
	121
	122	err_input_free:
	123	input_free_device(beeper->input);
	124	err_pwm_free:
	125	pwm_free(beeper->pwm);
	126	err_free:
	127	kfree(beeper);
	128
	129	return error;
	130	}
	131
e2619cf7	132	static int pwm_beeper_remove(struct platform_device *pdev)
e22739d0 LPC	133	{
	134	struct pwm_beeper *beeper = platform_get_drvdata(pdev);
	135
e22739d0 LPC	136	input_unregister_device(beeper->input);
	137
	138	pwm_disable(beeper->pwm);
	139	pwm_free(beeper->pwm);
	140
	141	kfree(beeper);
	142
	143	return 0;
	144	}
	145
97a652a8	146	static int __maybe_unused pwm_beeper_suspend(struct device *dev)
e22739d0 LPC	147	{
	148	struct pwm_beeper *beeper = dev_get_drvdata(dev);
	149
	150	if (beeper->period)
	151	pwm_disable(beeper->pwm);
	152
	153	return 0;
	154	}
	155
97a652a8	156	static int __maybe_unused pwm_beeper_resume(struct device *dev)
e22739d0 LPC	157	{
	158	struct pwm_beeper *beeper = dev_get_drvdata(dev);
	159
	160	if (beeper->period) {
	161	pwm_config(beeper->pwm, beeper->period / 2, beeper->period);
	162	pwm_enable(beeper->pwm);
	163	}
	164
	165	return 0;
	166	}
	167
	168	static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
	169	pwm_beeper_suspend, pwm_beeper_resume);
	170
d56a289b SH	171	#ifdef CONFIG_OF
	172	static const struct of_device_id pwm_beeper_match[] = {
	173	{ .compatible = "pwm-beeper", },
	174	{ },
	175	};
544edf56	176	MODULE_DEVICE_TABLE(of, pwm_beeper_match);
d56a289b SH	177	#endif
d56a289b SH	178
e22739d0 LPC	179	static struct platform_driver pwm_beeper_driver = {
e22739d0 LPC	180	.probe = pwm_beeper_probe,
1cb0aa88	181	.remove = pwm_beeper_remove,
e22739d0 LPC	182	.driver = {
e22739d0 LPC	183	.name = "pwm-beeper",
ceb5b6c8	184	.pm = &pwm_beeper_pm_ops,
d56a289b	185	.of_match_table = of_match_ptr(pwm_beeper_match),
e22739d0 LPC	186	},
e22739d0 LPC	187	};
840a746b	188	module_platform_driver(pwm_beeper_driver);
e22739d0 LPC	189
	190	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	191	MODULE_DESCRIPTION("PWM beeper driver");
	192	MODULE_LICENSE("GPL");
	193	MODULE_ALIAS("platform:pwm-beeper");