![Greg Kroah-Hartman](/assets/img/avatar_default.png)
Now that the SPDX tag is in all greybus files, that identifies the license in a specific and legally-defined manner. So the extra GPL text wording can be removed as it is no longer needed at all. This is done on a quest to remove the 700+ different ways that files in the kernel describe the GPL license text. And there's unneeded stuff like the address (sometimes incorrect) for the FSF which is never needed. No copyright headers or other non-license-description text was removed. Cc: Vaibhav Hiremath <hvaibhav.linux@gmail.com> Reviewed-by: Alex Elder <elder@linaro.org> Acked-by: Vaibhav Agarwal <vaibhav.sr@gmail.com> Acked-by: David Lin <dtwlin@gmail.com> Acked-by: Johan Hovold <johan@kernel.org> Acked-by: Viresh Kumar <viresh.kumar@linaro.org> Acked-by: Mark Greer <mgreer@animalcreek.com> Acked-by: Rui Miguel Silva <rmfrfs@gmail.com> Acked-by: "Bryan O'Donoghue" <pure.logic@nexus-software.ie> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
251 lines
5.4 KiB
C
251 lines
5.4 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Greybus Vibrator protocol driver.
|
|
*
|
|
* Copyright 2014 Google Inc.
|
|
* Copyright 2014 Linaro Ltd.
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/module.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/device.h>
|
|
#include <linux/kdev_t.h>
|
|
#include <linux/idr.h>
|
|
#include <linux/pm_runtime.h>
|
|
|
|
#include "greybus.h"
|
|
|
|
struct gb_vibrator_device {
|
|
struct gb_connection *connection;
|
|
struct device *dev;
|
|
int minor; /* vibrator minor number */
|
|
struct delayed_work delayed_work;
|
|
};
|
|
|
|
/* Greybus Vibrator operation types */
|
|
#define GB_VIBRATOR_TYPE_ON 0x02
|
|
#define GB_VIBRATOR_TYPE_OFF 0x03
|
|
|
|
static int turn_off(struct gb_vibrator_device *vib)
|
|
{
|
|
struct gb_bundle *bundle = vib->connection->bundle;
|
|
int ret;
|
|
|
|
ret = gb_operation_sync(vib->connection, GB_VIBRATOR_TYPE_OFF,
|
|
NULL, 0, NULL, 0);
|
|
|
|
gb_pm_runtime_put_autosuspend(bundle);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int turn_on(struct gb_vibrator_device *vib, u16 timeout_ms)
|
|
{
|
|
struct gb_bundle *bundle = vib->connection->bundle;
|
|
int ret;
|
|
|
|
ret = gb_pm_runtime_get_sync(bundle);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/* Vibrator was switched ON earlier */
|
|
if (cancel_delayed_work_sync(&vib->delayed_work))
|
|
turn_off(vib);
|
|
|
|
ret = gb_operation_sync(vib->connection, GB_VIBRATOR_TYPE_ON,
|
|
NULL, 0, NULL, 0);
|
|
if (ret) {
|
|
gb_pm_runtime_put_autosuspend(bundle);
|
|
return ret;
|
|
}
|
|
|
|
schedule_delayed_work(&vib->delayed_work, msecs_to_jiffies(timeout_ms));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void gb_vibrator_worker(struct work_struct *work)
|
|
{
|
|
struct delayed_work *delayed_work = to_delayed_work(work);
|
|
struct gb_vibrator_device *vib =
|
|
container_of(delayed_work,
|
|
struct gb_vibrator_device,
|
|
delayed_work);
|
|
|
|
turn_off(vib);
|
|
}
|
|
|
|
static ssize_t timeout_store(struct device *dev, struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct gb_vibrator_device *vib = dev_get_drvdata(dev);
|
|
unsigned long val;
|
|
int retval;
|
|
|
|
retval = kstrtoul(buf, 10, &val);
|
|
if (retval < 0) {
|
|
dev_err(dev, "could not parse timeout value %d\n", retval);
|
|
return retval;
|
|
}
|
|
|
|
if (val)
|
|
retval = turn_on(vib, (u16)val);
|
|
else
|
|
retval = turn_off(vib);
|
|
if (retval)
|
|
return retval;
|
|
|
|
return count;
|
|
}
|
|
static DEVICE_ATTR_WO(timeout);
|
|
|
|
static struct attribute *vibrator_attrs[] = {
|
|
&dev_attr_timeout.attr,
|
|
NULL,
|
|
};
|
|
ATTRIBUTE_GROUPS(vibrator);
|
|
|
|
static struct class vibrator_class = {
|
|
.name = "vibrator",
|
|
.owner = THIS_MODULE,
|
|
.dev_groups = vibrator_groups,
|
|
};
|
|
|
|
static DEFINE_IDA(minors);
|
|
|
|
static int gb_vibrator_probe(struct gb_bundle *bundle,
|
|
const struct greybus_bundle_id *id)
|
|
{
|
|
struct greybus_descriptor_cport *cport_desc;
|
|
struct gb_connection *connection;
|
|
struct gb_vibrator_device *vib;
|
|
struct device *dev;
|
|
int retval;
|
|
|
|
if (bundle->num_cports != 1)
|
|
return -ENODEV;
|
|
|
|
cport_desc = &bundle->cport_desc[0];
|
|
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_VIBRATOR)
|
|
return -ENODEV;
|
|
|
|
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
|
|
if (!vib)
|
|
return -ENOMEM;
|
|
|
|
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
|
|
NULL);
|
|
if (IS_ERR(connection)) {
|
|
retval = PTR_ERR(connection);
|
|
goto err_free_vib;
|
|
}
|
|
gb_connection_set_data(connection, vib);
|
|
|
|
vib->connection = connection;
|
|
|
|
greybus_set_drvdata(bundle, vib);
|
|
|
|
retval = gb_connection_enable(connection);
|
|
if (retval)
|
|
goto err_connection_destroy;
|
|
|
|
/*
|
|
* For now we create a device in sysfs for the vibrator, but odds are
|
|
* there is a "real" device somewhere in the kernel for this, but I
|
|
* can't find it at the moment...
|
|
*/
|
|
vib->minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
|
|
if (vib->minor < 0) {
|
|
retval = vib->minor;
|
|
goto err_connection_disable;
|
|
}
|
|
dev = device_create(&vibrator_class, &bundle->dev,
|
|
MKDEV(0, 0), vib, "vibrator%d", vib->minor);
|
|
if (IS_ERR(dev)) {
|
|
retval = -EINVAL;
|
|
goto err_ida_remove;
|
|
}
|
|
vib->dev = dev;
|
|
|
|
INIT_DELAYED_WORK(&vib->delayed_work, gb_vibrator_worker);
|
|
|
|
gb_pm_runtime_put_autosuspend(bundle);
|
|
|
|
return 0;
|
|
|
|
err_ida_remove:
|
|
ida_simple_remove(&minors, vib->minor);
|
|
err_connection_disable:
|
|
gb_connection_disable(connection);
|
|
err_connection_destroy:
|
|
gb_connection_destroy(connection);
|
|
err_free_vib:
|
|
kfree(vib);
|
|
|
|
return retval;
|
|
}
|
|
|
|
static void gb_vibrator_disconnect(struct gb_bundle *bundle)
|
|
{
|
|
struct gb_vibrator_device *vib = greybus_get_drvdata(bundle);
|
|
int ret;
|
|
|
|
ret = gb_pm_runtime_get_sync(bundle);
|
|
if (ret)
|
|
gb_pm_runtime_get_noresume(bundle);
|
|
|
|
if (cancel_delayed_work_sync(&vib->delayed_work))
|
|
turn_off(vib);
|
|
|
|
device_unregister(vib->dev);
|
|
ida_simple_remove(&minors, vib->minor);
|
|
gb_connection_disable(vib->connection);
|
|
gb_connection_destroy(vib->connection);
|
|
kfree(vib);
|
|
}
|
|
|
|
static const struct greybus_bundle_id gb_vibrator_id_table[] = {
|
|
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_VIBRATOR) },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(greybus, gb_vibrator_id_table);
|
|
|
|
static struct greybus_driver gb_vibrator_driver = {
|
|
.name = "vibrator",
|
|
.probe = gb_vibrator_probe,
|
|
.disconnect = gb_vibrator_disconnect,
|
|
.id_table = gb_vibrator_id_table,
|
|
};
|
|
|
|
static __init int gb_vibrator_init(void)
|
|
{
|
|
int retval;
|
|
|
|
retval = class_register(&vibrator_class);
|
|
if (retval)
|
|
return retval;
|
|
|
|
retval = greybus_register(&gb_vibrator_driver);
|
|
if (retval)
|
|
goto err_class_unregister;
|
|
|
|
return 0;
|
|
|
|
err_class_unregister:
|
|
class_unregister(&vibrator_class);
|
|
|
|
return retval;
|
|
}
|
|
module_init(gb_vibrator_init);
|
|
|
|
static __exit void gb_vibrator_exit(void)
|
|
{
|
|
greybus_deregister(&gb_vibrator_driver);
|
|
class_unregister(&vibrator_class);
|
|
ida_destroy(&minors);
|
|
}
|
|
module_exit(gb_vibrator_exit);
|
|
|
|
MODULE_LICENSE("GPL v2");
|