Release 4.11 drivers/staging/greybus/vibrator.c

/*
 * Greybus Vibrator protocol driver.
 *
 * Copyright 2014 Google Inc.
 * Copyright 2014 Linaro Ltd.
 *
 * Released under the GPLv2 only.
 */

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ann Chen
27
51.92%
2
50.00%
Greg Kroah-Hartman
25
48.08%
2
50.00%
Total
52
100.00%
4
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ann Chen
80
74.77%
2
40.00%
Greg Kroah-Hartman
27
25.23%
3
60.00%
Total
107
100.00%
5
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ann Chen
41
100.00%
1
100.00%
Total
41
100.00%
1
100.00%



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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
107
100.00%
1
100.00%
Total
107
100.00%
1
100.00%

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
152
49.67%
6
54.55%
Johan Hovold
136
44.44%
2
18.18%
Ann Chen
15
4.90%
2
18.18%
Alex Elder
3
0.98%
1
9.09%
Total
306
100.00%
11
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ann Chen
34
37.36%
2
33.33%
Greg Kroah-Hartman
29
31.87%
2
33.33%
Johan Hovold
28
30.77%
2
33.33%
Total
91
100.00%
6
100.00%


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;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
30
53.57%
3
60.00%
Johan Hovold
26
46.43%
2
40.00%
Total
56
100.00%
5
100.00%


module_init(gb_vibrator_init);



static __exit void gb_vibrator_exit(void)
{
	greybus_deregister(&gb_vibrator_driver);
	class_unregister(&vibrator_class);
	ida_destroy(&minors);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
24
88.89%
3
75.00%
Johan Hovold
3
11.11%
1
25.00%
Total
27
100.00%
4
100.00%


module_exit(gb_vibrator_exit);

MODULE_LICENSE("GPL v2");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Greg Kroah-Hartman
524
54.24%
12
54.55%
Johan Hovold
229
23.71%
4
18.18%
Ann Chen
204
21.12%
2
9.09%
Alex Elder
5
0.52%
3
13.64%
Viresh Kumar
4
0.41%
1
4.55%
Total
966
100.00%
22
100.00%
Directory: drivers/staging/greybus

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.