Release 4.11 drivers/staging/greybus/pwm.c

Directory: drivers/staging/greybus
/*
 * PWM Greybus 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/pwm.h>

#include "greybus.h"
#include "gbphy.h"


struct gb_pwm_chip {
	
struct gb_connection	*connection;
	
u8			pwm_max;	/* max pwm number */

	
struct pwm_chip		chip;
	
struct pwm_chip		*pwm;
};

#define pwm_chip_to_gb_pwm_chip(chip) \
	container_of(chip, struct gb_pwm_chip, chip)




static int gb_pwm_count_operation(struct gb_pwm_chip *pwmc)
{
	struct gb_pwm_count_response response;
	int ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_PWM_COUNT,
				NULL, 0, &response, sizeof(response));
	if (ret)
		return ret;
	pwmc->pwm_max = response.count;
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 46 77.97% 1 50.00%
Greg Kroah-Hartman 13 22.03% 1 50.00%
Total 59 100.00% 2 100.00%



static int gb_pwm_activate_operation(struct gb_pwm_chip *pwmc,
				     u8 which)
{
	struct gb_pwm_activate_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		return ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ACTIVATE,
				&request, sizeof(request), NULL, 0);

	gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 45 45.00% 1 33.33%
Axel Haslam 42 42.00% 1 33.33%
Greg Kroah-Hartman 13 13.00% 1 33.33%
Total 100 100.00% 3 100.00%



static int gb_pwm_deactivate_operation(struct gb_pwm_chip *pwmc,
				       u8 which)
{
	struct gb_pwm_deactivate_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		return ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DEACTIVATE,
				&request, sizeof(request), NULL, 0);

	gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 45 45.00% 1 33.33%
Axel Haslam 42 42.00% 1 33.33%
Greg Kroah-Hartman 13 13.00% 1 33.33%
Total 100 100.00% 3 100.00%



static int gb_pwm_config_operation(struct gb_pwm_chip *pwmc,
				   u8 which, u32 duty, u32 period)
{
	struct gb_pwm_config_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;
	request.duty = cpu_to_le32(duty);
	request.period = cpu_to_le32(period);

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		return ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_CONFIG,
				&request, sizeof(request), NULL, 0);

	gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 57 45.97% 1 25.00%
Axel Haslam 42 33.87% 1 25.00%
Greg Kroah-Hartman 19 15.32% 1 25.00%
Alex Elder 6 4.84% 1 25.00%
Total 124 100.00% 4 100.00%



static int gb_pwm_set_polarity_operation(struct gb_pwm_chip *pwmc,
					 u8 which, u8 polarity)
{
	struct gb_pwm_polarity_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;
	request.polarity = polarity;

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		return ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_POLARITY,
				&request, sizeof(request), NULL, 0);

	gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 49 44.95% 1 33.33%
Axel Haslam 42 38.53% 1 33.33%
Greg Kroah-Hartman 18 16.51% 1 33.33%
Total 109 100.00% 3 100.00%



static int gb_pwm_enable_operation(struct gb_pwm_chip *pwmc,
				   u8 which)
{
	struct gb_pwm_enable_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		return ret;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ENABLE,
				&request, sizeof(request), NULL, 0);
	if (ret)
		gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Axel Haslam 46 44.23% 1 33.33%
Matt Porter 45 43.27% 1 33.33%
Greg Kroah-Hartman 13 12.50% 1 33.33%
Total 104 100.00% 3 100.00%



static int gb_pwm_disable_operation(struct gb_pwm_chip *pwmc,
				    u8 which)
{
	struct gb_pwm_disable_request request;
	struct gbphy_device *gbphy_dev;
	int ret;

	if (which > pwmc->pwm_max)
		return -EINVAL;

	request.which = which;

	ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DISABLE,
				&request, sizeof(request), NULL, 0);

	gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
	gbphy_runtime_put_autosuspend(gbphy_dev);

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 45 52.33% 1 33.33%
Axel Haslam 29 33.72% 1 33.33%
Greg Kroah-Hartman 12 13.95% 1 33.33%
Total 86 100.00% 3 100.00%



static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	return gb_pwm_activate_operation(pwmc, pwm->hwpwm);
}Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%

;



static void gb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	if (pwm_is_enabled(pwm))
		dev_warn(chip->dev, "freeing PWM device without disabling\n");

	gb_pwm_deactivate_operation(pwmc, pwm->hwpwm);
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 50 98.04% 1 50.00%
Greg Kroah-Hartman 1 1.96% 1 50.00%
Total 51 100.00% 2 100.00%



static int gb_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
			 int duty_ns, int period_ns)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	return gb_pwm_config_operation(pwmc, pwm->hwpwm, duty_ns, period_ns);
}Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 46 100.00% 1 100.00%
Total 46 100.00% 1 100.00%

;



static int gb_pwm_set_polarity(struct pwm_chip *chip, struct pwm_device *pwm,
			       enum pwm_polarity polarity)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	return gb_pwm_set_polarity_operation(pwmc, pwm->hwpwm, polarity);
}Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 42 100.00% 1 100.00%
Total 42 100.00% 1 100.00%

;



static int gb_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	return gb_pwm_enable_operation(pwmc, pwm->hwpwm);
}Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 36 100.00% 1 100.00%
Total 36 100.00% 1 100.00%

;



static void gb_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
{
	struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);

	gb_pwm_disable_operation(pwmc, pwm->hwpwm);
}Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%

;


static const struct pwm_ops gb_pwm_ops = {
	.request = gb_pwm_request,
	.free = gb_pwm_free,
	.config = gb_pwm_config,
	.set_polarity = gb_pwm_set_polarity,
	.enable = gb_pwm_enable,
	.disable = gb_pwm_disable,
	.owner = THIS_MODULE,
};



static int gb_pwm_probe(struct gbphy_device *gbphy_dev,
			const struct gbphy_device_id *id)
{
	struct gb_connection *connection;
	struct gb_pwm_chip *pwmc;
	struct pwm_chip *pwm;
	int ret;

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

	connection = gb_connection_create(gbphy_dev->bundle,
					  le16_to_cpu(gbphy_dev->cport_desc->id),
					  NULL);
	if (IS_ERR(connection)) {
		ret = PTR_ERR(connection);
		goto exit_pwmc_free;
	}

	pwmc->connection = connection;
	gb_connection_set_data(connection, pwmc);
	gb_gbphy_set_data(gbphy_dev, pwmc);

	ret = gb_connection_enable(connection);
	if (ret)
		goto exit_connection_destroy;

	/* Query number of pwms present */
	ret = gb_pwm_count_operation(pwmc);
	if (ret)
		goto exit_connection_disable;

	pwm = &pwmc->chip;

	pwm->dev = &gbphy_dev->dev;
	pwm->ops = &gb_pwm_ops;
	pwm->base = -1;			/* Allocate base dynamically */
	pwm->npwm = pwmc->pwm_max + 1;

	ret = pwmchip_add(pwm);
	if (ret) {
		dev_err(&gbphy_dev->dev,
			"failed to register PWM: %d\n", ret);
		goto exit_connection_disable;
	}

	gbphy_runtime_put_autosuspend(gbphy_dev);
	return 0;

exit_connection_disable:
	gb_connection_disable(connection);
exit_connection_destroy:
	gb_connection_destroy(connection);
exit_pwmc_free:
	kfree(pwmc);
	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 130 52.85% 1 11.11%
Greg Kroah-Hartman 90 36.59% 3 33.33%
Sandeep Patil 9 3.66% 1 11.11%
Johan Hovold 9 3.66% 2 22.22%
Axel Haslam 5 2.03% 1 11.11%
Alex Elder 3 1.22% 1 11.11%
Total 246 100.00% 9 100.00%



static void gb_pwm_remove(struct gbphy_device *gbphy_dev)
{
	struct gb_pwm_chip *pwmc = gb_gbphy_get_data(gbphy_dev);
	struct gb_connection *connection = pwmc->connection;
	int ret;

	ret = gbphy_runtime_get_sync(gbphy_dev);
	if (ret)
		gbphy_runtime_get_noresume(gbphy_dev);

	pwmchip_remove(&pwmc->chip);
	gb_connection_disable(connection);
	gb_connection_destroy(connection);
	kfree(pwmc);
}

Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 28 38.89% 1 20.00%
Greg Kroah-Hartman 21 29.17% 2 40.00%
Axel Haslam 19 26.39% 1 20.00%
Sandeep Patil 4 5.56% 1 20.00%
Total 72 100.00% 5 100.00%


static const struct gbphy_device_id gb_pwm_id_table[] = {
	{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_PWM) },
	{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_pwm_id_table);


static struct gbphy_driver pwm_driver = {
	.name		= "pwm",
	.probe		= gb_pwm_probe,
	.remove		= gb_pwm_remove,
	.id_table	= gb_pwm_id_table,
};


module_gbphy_driver(pwm_driver);
MODULE_LICENSE("GPL v2");
Overall Contributors
Person Tokens Prop Commits CommitProp
Matt Porter 846 60.17% 1 6.67%
Axel Haslam 267 18.99% 1 6.67%
Greg Kroah-Hartman 245 17.43% 7 46.67%
Sandeep Patil 19 1.35% 1 6.67%
Viresh Kumar 11 0.78% 1 6.67%
Johan Hovold 9 0.64% 2 13.33%
Alex Elder 9 0.64% 2 13.33%
Total 1406 100.00% 15 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.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Matt Porter	46	77.97%	1	50.00%
Greg Kroah-Hartman	13	22.03%	1	50.00%
Total	59	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 drivers/staging/greybus/pwm.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
