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

	/*
	 * FIXME: pwm_apply_args() should be removed when switching to
	 * the atomic PWM API.
	 */
	pwm_apply_args(beeper->pwm);

	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
cfae56f1 BB	90	/*
	91	* FIXME: pwm_apply_args() should be removed when switching to
	92	* the atomic PWM API.
	93	*/
	94	pwm_apply_args(beeper->pwm);
	95
e22739d0 LPC	96	beeper->input = input_allocate_device();
	97	if (!beeper->input) {
	98	dev_err(&pdev->dev, "Failed to allocate input device\n");
	99	error = -ENOMEM;
	100	goto err_pwm_free;
	101	}
	102	beeper->input->dev.parent = &pdev->dev;
	103
	104	beeper->input->name = "pwm-beeper";
	105	beeper->input->phys = "pwm/input0";
	106	beeper->input->id.bustype = BUS_HOST;
	107	beeper->input->id.vendor = 0x001f;
	108	beeper->input->id.product = 0x0001;
	109	beeper->input->id.version = 0x0100;
	110
	111	beeper->input->evbit[0] = BIT(EV_SND);
	112	beeper->input->sndbit[0] = BIT(SND_TONE) \| BIT(SND_BELL);
	113
	114	beeper->input->event = pwm_beeper_event;
	115
	116	input_set_drvdata(beeper->input, beeper);
	117
	118	error = input_register_device(beeper->input);
	119	if (error) {
	120	dev_err(&pdev->dev, "Failed to register input device: %d\n", error);
	121	goto err_input_free;
	122	}
	123
	124	platform_set_drvdata(pdev, beeper);
	125
	126	return 0;
	127
	128	err_input_free:
	129	input_free_device(beeper->input);
	130	err_pwm_free:
	131	pwm_free(beeper->pwm);
	132	err_free:
	133	kfree(beeper);
	134
	135	return error;
	136	}
	137
e2619cf7	138	static int pwm_beeper_remove(struct platform_device *pdev)
e22739d0 LPC	139	{
	140	struct pwm_beeper *beeper = platform_get_drvdata(pdev);
	141
e22739d0 LPC	142	input_unregister_device(beeper->input);
	143
	144	pwm_disable(beeper->pwm);
	145	pwm_free(beeper->pwm);
	146
	147	kfree(beeper);
	148
	149	return 0;
	150	}
	151
97a652a8	152	static int __maybe_unused pwm_beeper_suspend(struct device *dev)
e22739d0 LPC	153	{
	154	struct pwm_beeper *beeper = dev_get_drvdata(dev);
	155
	156	if (beeper->period)
	157	pwm_disable(beeper->pwm);
	158
	159	return 0;
	160	}
	161
97a652a8	162	static int __maybe_unused pwm_beeper_resume(struct device *dev)
e22739d0 LPC	163	{
	164	struct pwm_beeper *beeper = dev_get_drvdata(dev);
	165
	166	if (beeper->period) {
	167	pwm_config(beeper->pwm, beeper->period / 2, beeper->period);
	168	pwm_enable(beeper->pwm);
	169	}
	170
	171	return 0;
	172	}
	173
	174	static SIMPLE_DEV_PM_OPS(pwm_beeper_pm_ops,
	175	pwm_beeper_suspend, pwm_beeper_resume);
	176
d56a289b SH	177	#ifdef CONFIG_OF
	178	static const struct of_device_id pwm_beeper_match[] = {
	179	{ .compatible = "pwm-beeper", },
	180	{ },
	181	};
544edf56	182	MODULE_DEVICE_TABLE(of, pwm_beeper_match);
d56a289b SH	183	#endif
d56a289b SH	184
e22739d0 LPC	185	static struct platform_driver pwm_beeper_driver = {
e22739d0 LPC	186	.probe = pwm_beeper_probe,
1cb0aa88	187	.remove = pwm_beeper_remove,
e22739d0 LPC	188	.driver = {
e22739d0 LPC	189	.name = "pwm-beeper",
ceb5b6c8	190	.pm = &pwm_beeper_pm_ops,
d56a289b	191	.of_match_table = of_match_ptr(pwm_beeper_match),
e22739d0 LPC	192	},
e22739d0 LPC	193	};
840a746b	194	module_platform_driver(pwm_beeper_driver);
e22739d0 LPC	195
	196	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	197	MODULE_DESCRIPTION("PWM beeper driver");
	198	MODULE_LICENSE("GPL");
	199	MODULE_ALIAS("platform:pwm-beeper");