mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-27 19:29:37 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
Besides one new driver being added for the PWM controller found in various Spreadtrum SoCs, this series of changes brings a slew of, mostly minor, fixes and cleanups for existing drivers, as well as some enhancements to the core code. Lastly, Uwe is added to the PWM subsystem entry of the MAINTAINERS file, making official his role as a reviewer. -----BEGIN PGP SIGNATURE----- iQJNBAABCAA3FiEEiOrDCAFJzPfAjcif3SOs138+s6EFAl2ON5UZHHRoaWVycnku cmVkaW5nQGdtYWlsLmNvbQAKCRDdI6zXfz6zoVg2EAC2QP51EywsDVQd8ZFvXBZB SL2RN9EWY0nHFnjGL2VSEOvsWWoE2HgrzXbWuiKDSkpRMTGtz/R1VznmBegZpVz/ eKP1ebFU+1EQ2A1GB4VLGslGVs0R7uvQap7KMRf+nD6qzstwWlz5nPP8E/4dipAX fYZBU37sTvAXycVosqAOiGaJvwfbo0ExysCD0bWccp52O06osgbZwGDhShDRTQv0 wOLR/rPbYXbVMyETlO8gjHVGU/N6cAq0SDR2VGcXqIe3H86K3R7ec8TEhcLJy6R5 nLX9Wx+gMyiWJGrU+s5i682VUdzQeLE4sH9c47M8qqreM4ytXfdttMeg3hgmalra eVm4uWtJ2+ZDRSl+yqJ8GfuSVGV4S9uQNlJ0OkAizmz+mU2WGeM1v8aOFlGokSi0 mxt+EZFdS7M0rZpWU0Fv01urxdhhVgsFXkD72xldV2vnIP6afhzGgKN3S6zbwzAQ WOgTHgVmcenM4hRcEmV8n7nF6f8BIA5RSNx+jrrkRD4gwHwDAiEK7hWJTCDXisB9 J6HgChqztrNtnyZMOealHxEgTtJqRUVX69mo9NaUeYps2Qg4y1gStLC3b1YnJZcI sTCrKhVjhFn1bNOe1UBSvcehIorL3mFV203TBgJJaMMhoJYE28XqYTNkGVDZ2bLP DdyExtL1Dx7IxEwS7IGOwA== =C9sW -----END PGP SIGNATURE----- Merge tag 'pwm/for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm Pull pwm updates from Thierry Reding: "Besides one new driver being added for the PWM controller found in various Spreadtrum SoCs, this series of changes brings a slew of, mostly minor, fixes and cleanups for existing drivers, as well as some enhancements to the core code. Lastly, Uwe is added to the PWM subsystem entry of the MAINTAINERS file, making official his role as a reviewer" * tag 'pwm/for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm: (34 commits) MAINTAINERS: Add myself as reviewer for the PWM subsystem MAINTAINERS: Add patchwork link for PWM entry MAINTAINERS: Add a selection of PWM related keywords to the PWM entry pwm: mediatek: Add MT7629 compatible string dt-bindings: pwm: Update bindings for MT7629 SoC pwm: mediatek: Update license and switch to SPDX tag pwm: mediatek: Use pwm_mediatek as common prefix pwm: mediatek: Allocate the clks array dynamically pwm: mediatek: Remove the has_clks field pwm: mediatek: Drop the check for of_device_get_match_data() pwm: atmel: Consolidate driver data initialization pwm: atmel: Remove unneeded check for match data pwm: atmel: Remove platform_device_id and use only dt bindings pwm: stm32-lp: Add check in case requested period cannot be achieved pwm: Ensure pwm_apply_state() doesn't modify the state argument pwm: fsl-ftm: Don't update the state for the caller of pwm_apply_state() pwm: sun4i: Don't update the state for the caller of pwm_apply_state() pwm: rockchip: Don't update the state for the caller of pwm_apply_state() pwm: Let pwm_get_state() return the last implemented state pwm: Introduce local struct pwm_chip in pwm_apply_state() ...
257 lines
5.9 KiB
C
257 lines
5.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Expose a PWM controlled by the ChromeOS EC to the host processor.
|
|
*
|
|
* Copyright (C) 2016 Google, Inc.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/platform_data/cros_ec_commands.h>
|
|
#include <linux/platform_data/cros_ec_proto.h>
|
|
#include <linux/platform_device.h>
|
|
#include <linux/pwm.h>
|
|
#include <linux/slab.h>
|
|
|
|
/**
|
|
* struct cros_ec_pwm_device - Driver data for EC PWM
|
|
*
|
|
* @dev: Device node
|
|
* @ec: Pointer to EC device
|
|
* @chip: PWM controller chip
|
|
*/
|
|
struct cros_ec_pwm_device {
|
|
struct device *dev;
|
|
struct cros_ec_device *ec;
|
|
struct pwm_chip chip;
|
|
};
|
|
|
|
static inline struct cros_ec_pwm_device *pwm_to_cros_ec_pwm(struct pwm_chip *c)
|
|
{
|
|
return container_of(c, struct cros_ec_pwm_device, chip);
|
|
}
|
|
|
|
static int cros_ec_pwm_set_duty(struct cros_ec_device *ec, u8 index, u16 duty)
|
|
{
|
|
struct {
|
|
struct cros_ec_command msg;
|
|
struct ec_params_pwm_set_duty params;
|
|
} __packed buf;
|
|
struct ec_params_pwm_set_duty *params = &buf.params;
|
|
struct cros_ec_command *msg = &buf.msg;
|
|
|
|
memset(&buf, 0, sizeof(buf));
|
|
|
|
msg->version = 0;
|
|
msg->command = EC_CMD_PWM_SET_DUTY;
|
|
msg->insize = 0;
|
|
msg->outsize = sizeof(*params);
|
|
|
|
params->duty = duty;
|
|
params->pwm_type = EC_PWM_TYPE_GENERIC;
|
|
params->index = index;
|
|
|
|
return cros_ec_cmd_xfer_status(ec, msg);
|
|
}
|
|
|
|
static int __cros_ec_pwm_get_duty(struct cros_ec_device *ec, u8 index,
|
|
u32 *result)
|
|
{
|
|
struct {
|
|
struct cros_ec_command msg;
|
|
union {
|
|
struct ec_params_pwm_get_duty params;
|
|
struct ec_response_pwm_get_duty resp;
|
|
};
|
|
} __packed buf;
|
|
struct ec_params_pwm_get_duty *params = &buf.params;
|
|
struct ec_response_pwm_get_duty *resp = &buf.resp;
|
|
struct cros_ec_command *msg = &buf.msg;
|
|
int ret;
|
|
|
|
memset(&buf, 0, sizeof(buf));
|
|
|
|
msg->version = 0;
|
|
msg->command = EC_CMD_PWM_GET_DUTY;
|
|
msg->insize = sizeof(*resp);
|
|
msg->outsize = sizeof(*params);
|
|
|
|
params->pwm_type = EC_PWM_TYPE_GENERIC;
|
|
params->index = index;
|
|
|
|
ret = cros_ec_cmd_xfer_status(ec, msg);
|
|
if (result)
|
|
*result = msg->result;
|
|
if (ret < 0)
|
|
return ret;
|
|
|
|
return resp->duty;
|
|
}
|
|
|
|
static int cros_ec_pwm_get_duty(struct cros_ec_device *ec, u8 index)
|
|
{
|
|
return __cros_ec_pwm_get_duty(ec, index, NULL);
|
|
}
|
|
|
|
static int cros_ec_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
const struct pwm_state *state)
|
|
{
|
|
struct cros_ec_pwm_device *ec_pwm = pwm_to_cros_ec_pwm(chip);
|
|
int duty_cycle;
|
|
|
|
/* The EC won't let us change the period */
|
|
if (state->period != EC_PWM_MAX_DUTY)
|
|
return -EINVAL;
|
|
|
|
/*
|
|
* EC doesn't separate the concept of duty cycle and enabled, but
|
|
* kernel does. Translate.
|
|
*/
|
|
duty_cycle = state->enabled ? state->duty_cycle : 0;
|
|
|
|
return cros_ec_pwm_set_duty(ec_pwm->ec, pwm->hwpwm, duty_cycle);
|
|
}
|
|
|
|
static void cros_ec_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
struct pwm_state *state)
|
|
{
|
|
struct cros_ec_pwm_device *ec_pwm = pwm_to_cros_ec_pwm(chip);
|
|
int ret;
|
|
|
|
ret = cros_ec_pwm_get_duty(ec_pwm->ec, pwm->hwpwm);
|
|
if (ret < 0) {
|
|
dev_err(chip->dev, "error getting initial duty: %d\n", ret);
|
|
return;
|
|
}
|
|
|
|
state->enabled = (ret > 0);
|
|
state->period = EC_PWM_MAX_DUTY;
|
|
|
|
/* Note that "disabled" and "duty cycle == 0" are treated the same */
|
|
state->duty_cycle = ret;
|
|
}
|
|
|
|
static struct pwm_device *
|
|
cros_ec_pwm_xlate(struct pwm_chip *pc, const struct of_phandle_args *args)
|
|
{
|
|
struct pwm_device *pwm;
|
|
|
|
if (args->args[0] >= pc->npwm)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
pwm = pwm_request_from_chip(pc, args->args[0], NULL);
|
|
if (IS_ERR(pwm))
|
|
return pwm;
|
|
|
|
/* The EC won't let us change the period */
|
|
pwm->args.period = EC_PWM_MAX_DUTY;
|
|
|
|
return pwm;
|
|
}
|
|
|
|
static const struct pwm_ops cros_ec_pwm_ops = {
|
|
.get_state = cros_ec_pwm_get_state,
|
|
.apply = cros_ec_pwm_apply,
|
|
.owner = THIS_MODULE,
|
|
};
|
|
|
|
static int cros_ec_num_pwms(struct cros_ec_device *ec)
|
|
{
|
|
int i, ret;
|
|
|
|
/* The index field is only 8 bits */
|
|
for (i = 0; i <= U8_MAX; i++) {
|
|
u32 result = 0;
|
|
|
|
ret = __cros_ec_pwm_get_duty(ec, i, &result);
|
|
/* We want to parse EC protocol errors */
|
|
if (ret < 0 && !(ret == -EPROTO && result))
|
|
return ret;
|
|
|
|
/*
|
|
* We look for SUCCESS, INVALID_COMMAND, or INVALID_PARAM
|
|
* responses; everything else is treated as an error.
|
|
*/
|
|
if (result == EC_RES_INVALID_COMMAND)
|
|
return -ENODEV;
|
|
else if (result == EC_RES_INVALID_PARAM)
|
|
return i;
|
|
else if (result)
|
|
return -EPROTO;
|
|
}
|
|
|
|
return U8_MAX;
|
|
}
|
|
|
|
static int cros_ec_pwm_probe(struct platform_device *pdev)
|
|
{
|
|
struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
|
|
struct device *dev = &pdev->dev;
|
|
struct cros_ec_pwm_device *ec_pwm;
|
|
struct pwm_chip *chip;
|
|
int ret;
|
|
|
|
if (!ec) {
|
|
dev_err(dev, "no parent EC device\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
ec_pwm = devm_kzalloc(dev, sizeof(*ec_pwm), GFP_KERNEL);
|
|
if (!ec_pwm)
|
|
return -ENOMEM;
|
|
chip = &ec_pwm->chip;
|
|
ec_pwm->ec = ec;
|
|
|
|
/* PWM chip */
|
|
chip->dev = dev;
|
|
chip->ops = &cros_ec_pwm_ops;
|
|
chip->of_xlate = cros_ec_pwm_xlate;
|
|
chip->of_pwm_n_cells = 1;
|
|
chip->base = -1;
|
|
ret = cros_ec_num_pwms(ec);
|
|
if (ret < 0) {
|
|
dev_err(dev, "Couldn't find PWMs: %d\n", ret);
|
|
return ret;
|
|
}
|
|
chip->npwm = ret;
|
|
dev_dbg(dev, "Probed %u PWMs\n", chip->npwm);
|
|
|
|
ret = pwmchip_add(chip);
|
|
if (ret < 0) {
|
|
dev_err(dev, "cannot register PWM: %d\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
platform_set_drvdata(pdev, ec_pwm);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int cros_ec_pwm_remove(struct platform_device *dev)
|
|
{
|
|
struct cros_ec_pwm_device *ec_pwm = platform_get_drvdata(dev);
|
|
struct pwm_chip *chip = &ec_pwm->chip;
|
|
|
|
return pwmchip_remove(chip);
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
static const struct of_device_id cros_ec_pwm_of_match[] = {
|
|
{ .compatible = "google,cros-ec-pwm" },
|
|
{},
|
|
};
|
|
MODULE_DEVICE_TABLE(of, cros_ec_pwm_of_match);
|
|
#endif
|
|
|
|
static struct platform_driver cros_ec_pwm_driver = {
|
|
.probe = cros_ec_pwm_probe,
|
|
.remove = cros_ec_pwm_remove,
|
|
.driver = {
|
|
.name = "cros-ec-pwm",
|
|
.of_match_table = of_match_ptr(cros_ec_pwm_of_match),
|
|
},
|
|
};
|
|
module_platform_driver(cros_ec_pwm_driver);
|
|
|
|
MODULE_ALIAS("platform:cros-ec-pwm");
|
|
MODULE_DESCRIPTION("ChromeOS EC PWM driver");
|
|
MODULE_LICENSE("GPL v2");
|