License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 14:07:57 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2008-04-13 20:41:55 +00:00
|
|
|
#ifndef __LINUX_PWM_H
|
|
|
|
#define __LINUX_PWM_H
|
|
|
|
|
2012-09-12 10:01:46 +00:00
|
|
|
#include <linux/err.h>
|
2015-10-17 00:40:58 +00:00
|
|
|
#include <linux/mutex.h>
|
2011-12-14 10:10:32 +00:00
|
|
|
#include <linux/of.h>
|
|
|
|
|
2011-01-28 08:40:40 +00:00
|
|
|
struct pwm_chip;
|
|
|
|
|
2012-07-24 14:05:32 +00:00
|
|
|
/**
|
|
|
|
* enum pwm_polarity - polarity of a PWM signal
|
|
|
|
* @PWM_POLARITY_NORMAL: a high signal for the duration of the duty-
|
|
|
|
* cycle, followed by a low signal for the remainder of the pulse
|
|
|
|
* period
|
|
|
|
* @PWM_POLARITY_INVERSED: a low signal for the duration of the duty-
|
|
|
|
* cycle, followed by a high signal for the remainder of the pulse
|
|
|
|
* period
|
|
|
|
*/
|
|
|
|
enum pwm_polarity {
|
|
|
|
PWM_POLARITY_NORMAL,
|
|
|
|
PWM_POLARITY_INVERSED,
|
|
|
|
};
|
|
|
|
|
2016-04-14 19:17:21 +00:00
|
|
|
/**
|
|
|
|
* struct pwm_args - board-dependent PWM arguments
|
|
|
|
* @period: reference period
|
|
|
|
* @polarity: reference polarity
|
|
|
|
*
|
|
|
|
* This structure describes board-dependent arguments attached to a PWM
|
|
|
|
* device. These arguments are usually retrieved from the PWM lookup table or
|
|
|
|
* device tree.
|
|
|
|
*
|
|
|
|
* Do not confuse this with the PWM state: PWM arguments represent the initial
|
|
|
|
* configuration that users want to use on this PWM device rather than the
|
|
|
|
* current PWM hardware state.
|
|
|
|
*/
|
|
|
|
struct pwm_args {
|
2020-06-02 22:31:16 +00:00
|
|
|
u64 period;
|
2016-04-14 19:17:21 +00:00
|
|
|
enum pwm_polarity polarity;
|
|
|
|
};
|
|
|
|
|
2011-12-14 10:12:23 +00:00
|
|
|
enum {
|
|
|
|
PWMF_REQUESTED = 1 << 0,
|
2016-04-14 19:17:39 +00:00
|
|
|
PWMF_EXPORTED = 1 << 1,
|
2011-12-14 10:12:23 +00:00
|
|
|
};
|
|
|
|
|
2016-04-14 19:17:38 +00:00
|
|
|
/*
|
|
|
|
* struct pwm_state - state of a PWM channel
|
|
|
|
* @period: PWM period (in nanoseconds)
|
|
|
|
* @duty_cycle: PWM duty cycle (in nanoseconds)
|
|
|
|
* @polarity: PWM polarity
|
2016-04-14 19:17:39 +00:00
|
|
|
* @enabled: PWM enabled status
|
2021-05-07 13:18:42 +00:00
|
|
|
* @usage_power: If set, the PWM driver is only required to maintain the power
|
|
|
|
* output but has more freedom regarding signal form.
|
|
|
|
* If supported, the signal can be optimized, for example to
|
|
|
|
* improve EMI by phase shifting individual channels.
|
2016-04-14 19:17:38 +00:00
|
|
|
*/
|
|
|
|
struct pwm_state {
|
2020-06-02 22:31:16 +00:00
|
|
|
u64 period;
|
|
|
|
u64 duty_cycle;
|
2016-04-14 19:17:38 +00:00
|
|
|
enum pwm_polarity polarity;
|
2016-04-14 19:17:39 +00:00
|
|
|
bool enabled;
|
2021-05-07 13:18:42 +00:00
|
|
|
bool usage_power;
|
2016-04-14 19:17:38 +00:00
|
|
|
};
|
|
|
|
|
2015-07-27 09:58:32 +00:00
|
|
|
/**
|
|
|
|
* struct pwm_device - PWM channel object
|
|
|
|
* @label: name of the PWM device
|
|
|
|
* @flags: flags associated with the PWM device
|
|
|
|
* @hwpwm: per-chip relative index of the PWM device
|
|
|
|
* @pwm: global index of the PWM device
|
|
|
|
* @chip: PWM chip providing this PWM device
|
|
|
|
* @chip_data: chip-private data associated with the PWM device
|
2016-04-14 19:17:21 +00:00
|
|
|
* @args: PWM arguments
|
2020-02-10 21:35:18 +00:00
|
|
|
* @state: last applied state
|
|
|
|
* @last: last implemented state (for PWM_DEBUG)
|
2015-07-27 09:58:32 +00:00
|
|
|
*/
|
2011-12-14 10:12:23 +00:00
|
|
|
struct pwm_device {
|
2015-07-27 09:57:28 +00:00
|
|
|
const char *label;
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int hwpwm;
|
|
|
|
unsigned int pwm;
|
|
|
|
struct pwm_chip *chip;
|
|
|
|
void *chip_data;
|
|
|
|
|
2016-04-14 19:17:21 +00:00
|
|
|
struct pwm_args args;
|
2016-04-14 19:17:38 +00:00
|
|
|
struct pwm_state state;
|
2020-02-10 21:35:18 +00:00
|
|
|
struct pwm_state last;
|
2011-12-14 10:12:23 +00:00
|
|
|
};
|
|
|
|
|
2016-04-14 19:17:38 +00:00
|
|
|
/**
|
|
|
|
* pwm_get_state() - retrieve the current PWM state
|
|
|
|
* @pwm: PWM device
|
|
|
|
* @state: state to fill with the current PWM state
|
2021-04-06 07:30:36 +00:00
|
|
|
*
|
|
|
|
* The returned PWM state represents the state that was applied by a previous call to
|
|
|
|
* pwm_apply_state(). Drivers may have to slightly tweak that state before programming it to
|
|
|
|
* hardware. If pwm_apply_state() was never called, this returns either the current hardware
|
|
|
|
* state (if supported) or the default settings.
|
2016-04-14 19:17:38 +00:00
|
|
|
*/
|
|
|
|
static inline void pwm_get_state(const struct pwm_device *pwm,
|
|
|
|
struct pwm_state *state)
|
|
|
|
{
|
|
|
|
*state = pwm->state;
|
|
|
|
}
|
|
|
|
|
2015-07-01 08:21:47 +00:00
|
|
|
static inline bool pwm_is_enabled(const struct pwm_device *pwm)
|
|
|
|
{
|
2016-04-14 19:17:39 +00:00
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
|
|
|
|
return state.enabled;
|
2015-07-01 08:21:47 +00:00
|
|
|
}
|
|
|
|
|
2020-06-02 22:31:16 +00:00
|
|
|
static inline void pwm_set_period(struct pwm_device *pwm, u64 period)
|
2011-12-14 10:12:23 +00:00
|
|
|
{
|
|
|
|
if (pwm)
|
2016-04-14 19:17:38 +00:00
|
|
|
pwm->state.period = period;
|
2011-12-14 10:12:23 +00:00
|
|
|
}
|
|
|
|
|
2020-06-02 22:31:16 +00:00
|
|
|
static inline u64 pwm_get_period(const struct pwm_device *pwm)
|
2011-12-14 10:12:23 +00:00
|
|
|
{
|
2016-04-14 19:17:38 +00:00
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
|
|
|
|
return state.period;
|
2011-12-14 10:12:23 +00:00
|
|
|
}
|
|
|
|
|
2013-06-11 17:38:59 +00:00
|
|
|
static inline void pwm_set_duty_cycle(struct pwm_device *pwm, unsigned int duty)
|
|
|
|
{
|
|
|
|
if (pwm)
|
2016-04-14 19:17:38 +00:00
|
|
|
pwm->state.duty_cycle = duty;
|
2013-06-11 17:38:59 +00:00
|
|
|
}
|
|
|
|
|
2020-06-02 22:31:16 +00:00
|
|
|
static inline u64 pwm_get_duty_cycle(const struct pwm_device *pwm)
|
2013-06-11 17:38:59 +00:00
|
|
|
{
|
2016-04-14 19:17:38 +00:00
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
|
|
|
|
return state.duty_cycle;
|
2013-06-11 17:38:59 +00:00
|
|
|
}
|
|
|
|
|
2015-07-01 08:21:49 +00:00
|
|
|
static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm)
|
|
|
|
{
|
2016-04-14 19:17:38 +00:00
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
|
|
|
|
return state.polarity;
|
2015-07-01 08:21:49 +00:00
|
|
|
}
|
|
|
|
|
2016-04-14 19:17:21 +00:00
|
|
|
static inline void pwm_get_args(const struct pwm_device *pwm,
|
|
|
|
struct pwm_args *args)
|
|
|
|
{
|
|
|
|
*args = pwm->args;
|
|
|
|
}
|
|
|
|
|
2016-06-14 09:13:09 +00:00
|
|
|
/**
|
|
|
|
* pwm_init_state() - prepare a new state to be applied with pwm_apply_state()
|
|
|
|
* @pwm: PWM device
|
|
|
|
* @state: state to fill with the prepared PWM state
|
|
|
|
*
|
|
|
|
* This functions prepares a state that can later be tweaked and applied
|
|
|
|
* to the PWM device with pwm_apply_state(). This is a convenient function
|
|
|
|
* that first retrieves the current PWM state and the replaces the period
|
|
|
|
* and polarity fields with the reference values defined in pwm->args.
|
|
|
|
* Once the function returns, you can adjust the ->enabled and ->duty_cycle
|
|
|
|
* fields according to your needs before calling pwm_apply_state().
|
|
|
|
*
|
|
|
|
* ->duty_cycle is initially set to zero to avoid cases where the current
|
|
|
|
* ->duty_cycle value exceed the pwm_args->period one, which would trigger
|
|
|
|
* an error if the user calls pwm_apply_state() without adjusting ->duty_cycle
|
|
|
|
* first.
|
|
|
|
*/
|
|
|
|
static inline void pwm_init_state(const struct pwm_device *pwm,
|
|
|
|
struct pwm_state *state)
|
|
|
|
{
|
|
|
|
struct pwm_args args;
|
|
|
|
|
|
|
|
/* First get the current state. */
|
|
|
|
pwm_get_state(pwm, state);
|
|
|
|
|
|
|
|
/* Then fill it with the reference config */
|
|
|
|
pwm_get_args(pwm, &args);
|
|
|
|
|
|
|
|
state->period = args.period;
|
|
|
|
state->polarity = args.polarity;
|
|
|
|
state->duty_cycle = 0;
|
2021-05-07 13:18:42 +00:00
|
|
|
state->usage_power = false;
|
2016-06-14 09:13:09 +00:00
|
|
|
}
|
|
|
|
|
2016-06-14 09:13:10 +00:00
|
|
|
/**
|
|
|
|
* pwm_get_relative_duty_cycle() - Get a relative duty cycle value
|
|
|
|
* @state: PWM state to extract the duty cycle from
|
|
|
|
* @scale: target scale of the relative duty cycle
|
|
|
|
*
|
|
|
|
* This functions converts the absolute duty cycle stored in @state (expressed
|
|
|
|
* in nanosecond) into a value relative to the period.
|
|
|
|
*
|
|
|
|
* For example if you want to get the duty_cycle expressed in percent, call:
|
|
|
|
*
|
|
|
|
* pwm_get_state(pwm, &state);
|
|
|
|
* duty = pwm_get_relative_duty_cycle(&state, 100);
|
|
|
|
*/
|
|
|
|
static inline unsigned int
|
|
|
|
pwm_get_relative_duty_cycle(const struct pwm_state *state, unsigned int scale)
|
|
|
|
{
|
|
|
|
if (!state->period)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return DIV_ROUND_CLOSEST_ULL((u64)state->duty_cycle * scale,
|
|
|
|
state->period);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pwm_set_relative_duty_cycle() - Set a relative duty cycle value
|
|
|
|
* @state: PWM state to fill
|
|
|
|
* @duty_cycle: relative duty cycle value
|
|
|
|
* @scale: scale in which @duty_cycle is expressed
|
|
|
|
*
|
|
|
|
* This functions converts a relative into an absolute duty cycle (expressed
|
|
|
|
* in nanoseconds), and puts the result in state->duty_cycle.
|
|
|
|
*
|
|
|
|
* For example if you want to configure a 50% duty cycle, call:
|
|
|
|
*
|
|
|
|
* pwm_init_state(pwm, &state);
|
|
|
|
* pwm_set_relative_duty_cycle(&state, 50, 100);
|
|
|
|
* pwm_apply_state(pwm, &state);
|
|
|
|
*
|
|
|
|
* This functions returns -EINVAL if @duty_cycle and/or @scale are
|
|
|
|
* inconsistent (@scale == 0 or @duty_cycle > @scale).
|
|
|
|
*/
|
|
|
|
static inline int
|
|
|
|
pwm_set_relative_duty_cycle(struct pwm_state *state, unsigned int duty_cycle,
|
|
|
|
unsigned int scale)
|
|
|
|
{
|
|
|
|
if (!scale || duty_cycle > scale)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
state->duty_cycle = DIV_ROUND_CLOSEST_ULL((u64)duty_cycle *
|
|
|
|
state->period,
|
|
|
|
scale);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-05-23 17:45:00 +00:00
|
|
|
/**
|
|
|
|
* struct pwm_capture - PWM capture data
|
|
|
|
* @period: period of the PWM signal (in nanoseconds)
|
|
|
|
* @duty_cycle: duty cycle of the PWM signal (in nanoseconds)
|
|
|
|
*/
|
|
|
|
struct pwm_capture {
|
|
|
|
unsigned int period;
|
|
|
|
unsigned int duty_cycle;
|
|
|
|
};
|
|
|
|
|
2011-01-28 08:40:40 +00:00
|
|
|
/**
|
|
|
|
* struct pwm_ops - PWM controller operations
|
|
|
|
* @request: optional hook for requesting a PWM
|
|
|
|
* @free: optional hook for freeing a PWM
|
2016-06-08 09:21:23 +00:00
|
|
|
* @capture: capture and report PWM signal
|
2019-10-04 13:32:07 +00:00
|
|
|
* @apply: atomically apply a new PWM config
|
2016-04-14 19:17:40 +00:00
|
|
|
* @get_state: get the current PWM state. This function is only
|
|
|
|
* called once per PWM device when the PWM chip is
|
|
|
|
* registered.
|
2011-01-28 08:40:40 +00:00
|
|
|
* @owner: helps prevent removal of modules exporting active PWMs
|
|
|
|
*/
|
|
|
|
struct pwm_ops {
|
2015-07-27 09:57:28 +00:00
|
|
|
int (*request)(struct pwm_chip *chip, struct pwm_device *pwm);
|
|
|
|
void (*free)(struct pwm_chip *chip, struct pwm_device *pwm);
|
2016-06-08 09:21:23 +00:00
|
|
|
int (*capture)(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
|
|
struct pwm_capture *result, unsigned long timeout);
|
2016-04-14 19:17:41 +00:00
|
|
|
int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm,
|
2019-08-24 15:37:07 +00:00
|
|
|
const struct pwm_state *state);
|
2016-04-14 19:17:40 +00:00
|
|
|
void (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm,
|
|
|
|
struct pwm_state *state);
|
2015-07-27 09:57:28 +00:00
|
|
|
struct module *owner;
|
2011-01-28 08:40:40 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2011-12-14 10:12:23 +00:00
|
|
|
* struct pwm_chip - abstract a PWM controller
|
|
|
|
* @dev: device providing the PWMs
|
|
|
|
* @ops: callbacks for this PWM controller
|
|
|
|
* @base: number of first PWM controlled by this chip
|
|
|
|
* @npwm: number of PWMs controlled by this chip
|
2015-07-27 09:58:32 +00:00
|
|
|
* @of_xlate: request a PWM device given a device tree PWM specifier
|
|
|
|
* @of_pwm_n_cells: number of cells expected in the device tree PWM specifier
|
2019-01-07 19:49:41 +00:00
|
|
|
* @list: list node for internal use
|
|
|
|
* @pwms: array of PWM devices allocated by the framework
|
2011-01-28 08:40:40 +00:00
|
|
|
*/
|
|
|
|
struct pwm_chip {
|
2015-07-27 09:57:28 +00:00
|
|
|
struct device *dev;
|
|
|
|
const struct pwm_ops *ops;
|
|
|
|
int base;
|
|
|
|
unsigned int npwm;
|
|
|
|
|
|
|
|
struct pwm_device * (*of_xlate)(struct pwm_chip *pc,
|
|
|
|
const struct of_phandle_args *args);
|
|
|
|
unsigned int of_pwm_n_cells;
|
2019-01-07 19:49:41 +00:00
|
|
|
|
|
|
|
/* only used internally by the PWM framework */
|
|
|
|
struct list_head list;
|
|
|
|
struct pwm_device *pwms;
|
2011-01-28 08:40:40 +00:00
|
|
|
};
|
|
|
|
|
2012-09-12 10:01:46 +00:00
|
|
|
#if IS_ENABLED(CONFIG_PWM)
|
2016-04-14 19:17:41 +00:00
|
|
|
/* PWM user APIs */
|
|
|
|
struct pwm_device *pwm_request(int pwm_id, const char *label);
|
|
|
|
void pwm_free(struct pwm_device *pwm);
|
2019-08-24 15:37:07 +00:00
|
|
|
int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state);
|
2016-04-14 19:17:41 +00:00
|
|
|
int pwm_adjust_config(struct pwm_device *pwm);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pwm_config() - change a PWM device configuration
|
|
|
|
* @pwm: PWM device
|
|
|
|
* @duty_ns: "on" time (in nanoseconds)
|
|
|
|
* @period_ns: duration (in nanoseconds) of one cycle
|
|
|
|
*
|
|
|
|
* Returns: 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
static inline int pwm_config(struct pwm_device *pwm, int duty_ns,
|
|
|
|
int period_ns)
|
|
|
|
{
|
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
if (!pwm)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-05-27 16:45:49 +00:00
|
|
|
if (duty_ns < 0 || period_ns < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2016-04-14 19:17:41 +00:00
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
if (state.duty_cycle == duty_ns && state.period == period_ns)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
state.duty_cycle = duty_ns;
|
|
|
|
state.period = period_ns;
|
|
|
|
return pwm_apply_state(pwm, &state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pwm_enable() - start a PWM output toggling
|
|
|
|
* @pwm: PWM device
|
|
|
|
*
|
|
|
|
* Returns: 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
static inline int pwm_enable(struct pwm_device *pwm)
|
|
|
|
{
|
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
if (!pwm)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
if (state.enabled)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
state.enabled = true;
|
|
|
|
return pwm_apply_state(pwm, &state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* pwm_disable() - stop a PWM output toggling
|
|
|
|
* @pwm: PWM device
|
|
|
|
*/
|
|
|
|
static inline void pwm_disable(struct pwm_device *pwm)
|
|
|
|
{
|
|
|
|
struct pwm_state state;
|
|
|
|
|
|
|
|
if (!pwm)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pwm_get_state(pwm, &state);
|
|
|
|
if (!state.enabled)
|
|
|
|
return;
|
|
|
|
|
|
|
|
state.enabled = false;
|
|
|
|
pwm_apply_state(pwm, &state);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* PWM provider APIs */
|
2016-06-08 09:21:23 +00:00
|
|
|
int pwm_capture(struct pwm_device *pwm, struct pwm_capture *result,
|
|
|
|
unsigned long timeout);
|
2011-12-14 10:12:23 +00:00
|
|
|
int pwm_set_chip_data(struct pwm_device *pwm, void *data);
|
|
|
|
void *pwm_get_chip_data(struct pwm_device *pwm);
|
|
|
|
|
2011-01-28 08:40:40 +00:00
|
|
|
int pwmchip_add(struct pwm_chip *chip);
|
2021-07-07 16:28:35 +00:00
|
|
|
void pwmchip_remove(struct pwm_chip *chip);
|
2021-04-07 08:01:54 +00:00
|
|
|
|
|
|
|
int devm_pwmchip_add(struct device *dev, struct pwm_chip *chip);
|
|
|
|
|
2011-12-14 10:12:23 +00:00
|
|
|
struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
|
|
|
|
unsigned int index,
|
|
|
|
const char *label);
|
2012-03-26 06:42:48 +00:00
|
|
|
|
2012-11-21 07:40:44 +00:00
|
|
|
struct pwm_device *of_pwm_xlate_with_flags(struct pwm_chip *pc,
|
|
|
|
const struct of_phandle_args *args);
|
2021-10-25 17:09:23 +00:00
|
|
|
struct pwm_device *of_pwm_single_xlate(struct pwm_chip *pc,
|
|
|
|
const struct of_phandle_args *args);
|
2012-11-21 07:40:44 +00:00
|
|
|
|
2012-12-21 09:43:57 +00:00
|
|
|
struct pwm_device *pwm_get(struct device *dev, const char *con_id);
|
2019-04-18 09:37:47 +00:00
|
|
|
struct pwm_device *of_pwm_get(struct device *dev, struct device_node *np,
|
|
|
|
const char *con_id);
|
2012-03-26 06:42:48 +00:00
|
|
|
void pwm_put(struct pwm_device *pwm);
|
|
|
|
|
2012-12-21 09:43:57 +00:00
|
|
|
struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id);
|
2012-12-21 09:43:59 +00:00
|
|
|
struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
|
|
|
|
const char *con_id);
|
2019-06-12 08:36:07 +00:00
|
|
|
struct pwm_device *devm_fwnode_pwm_get(struct device *dev,
|
|
|
|
struct fwnode_handle *fwnode,
|
|
|
|
const char *con_id);
|
2012-09-12 10:01:46 +00:00
|
|
|
#else
|
2016-04-14 19:17:41 +00:00
|
|
|
static inline struct pwm_device *pwm_request(int pwm_id, const char *label)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pwm_free(struct pwm_device *pwm)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pwm_apply_state(struct pwm_device *pwm,
|
|
|
|
const struct pwm_state *state)
|
|
|
|
{
|
2021-09-09 09:48:49 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pwm_adjust_config(struct pwm_device *pwm)
|
|
|
|
{
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pwm_config(struct pwm_device *pwm, int duty_ns,
|
|
|
|
int period_ns)
|
|
|
|
{
|
2021-09-09 09:48:49 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-06-08 09:21:23 +00:00
|
|
|
static inline int pwm_capture(struct pwm_device *pwm,
|
|
|
|
struct pwm_capture *result,
|
|
|
|
unsigned long timeout)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-14 19:17:41 +00:00
|
|
|
static inline int pwm_enable(struct pwm_device *pwm)
|
|
|
|
{
|
2021-09-09 09:48:49 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pwm_disable(struct pwm_device *pwm)
|
|
|
|
{
|
2021-09-09 09:48:49 +00:00
|
|
|
might_sleep();
|
2016-04-14 19:17:41 +00:00
|
|
|
}
|
|
|
|
|
2012-09-12 10:01:46 +00:00
|
|
|
static inline int pwm_set_chip_data(struct pwm_device *pwm, void *data)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void *pwm_get_chip_data(struct pwm_device *pwm)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pwmchip_add(struct pwm_chip *chip)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int pwmchip_remove(struct pwm_chip *chip)
|
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
|
|
|
|
unsigned int index,
|
|
|
|
const char *label)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-09-12 10:01:46 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct pwm_device *pwm_get(struct device *dev,
|
|
|
|
const char *consumer)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-09-12 10:01:46 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2019-04-18 09:37:47 +00:00
|
|
|
static inline struct pwm_device *of_pwm_get(struct device *dev,
|
|
|
|
struct device_node *np,
|
2012-12-21 09:43:58 +00:00
|
|
|
const char *con_id)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-12-21 09:43:58 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2012-09-12 10:01:46 +00:00
|
|
|
static inline void pwm_put(struct pwm_device *pwm)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-09-12 10:01:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline struct pwm_device *devm_pwm_get(struct device *dev,
|
|
|
|
const char *consumer)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-09-12 10:01:46 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2012-12-21 09:43:59 +00:00
|
|
|
static inline struct pwm_device *devm_of_pwm_get(struct device *dev,
|
|
|
|
struct device_node *np,
|
|
|
|
const char *con_id)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2012-12-21 09:43:59 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
|
|
|
|
2019-06-12 08:36:07 +00:00
|
|
|
static inline struct pwm_device *
|
|
|
|
devm_fwnode_pwm_get(struct device *dev, struct fwnode_handle *fwnode,
|
|
|
|
const char *con_id)
|
|
|
|
{
|
2021-09-09 09:48:48 +00:00
|
|
|
might_sleep();
|
2019-06-12 08:36:07 +00:00
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
2012-09-12 10:01:46 +00:00
|
|
|
#endif
|
2012-08-01 10:20:58 +00:00
|
|
|
|
2016-04-14 19:17:41 +00:00
|
|
|
static inline void pwm_apply_args(struct pwm_device *pwm)
|
|
|
|
{
|
2016-06-22 07:25:14 +00:00
|
|
|
struct pwm_state state = { };
|
|
|
|
|
2016-04-14 19:17:41 +00:00
|
|
|
/*
|
|
|
|
* PWM users calling pwm_apply_args() expect to have a fresh config
|
|
|
|
* where the polarity and period are set according to pwm_args info.
|
|
|
|
* The problem is, polarity can only be changed when the PWM is
|
|
|
|
* disabled.
|
|
|
|
*
|
|
|
|
* PWM drivers supporting hardware readout may declare the PWM device
|
|
|
|
* as enabled, and prevent polarity setting, which changes from the
|
|
|
|
* existing behavior, where all PWM devices are declared as disabled
|
|
|
|
* at startup (even if they are actually enabled), thus authorizing
|
|
|
|
* polarity setting.
|
|
|
|
*
|
2016-06-22 07:25:14 +00:00
|
|
|
* To fulfill this requirement, we apply a new state which disables
|
|
|
|
* the PWM device and set the reference period and polarity config.
|
2016-04-14 19:17:41 +00:00
|
|
|
*
|
|
|
|
* Note that PWM users requiring a smooth handover between the
|
|
|
|
* bootloader and the kernel (like critical regulators controlled by
|
|
|
|
* PWM devices) will have to switch to the atomic API and avoid calling
|
|
|
|
* pwm_apply_args().
|
|
|
|
*/
|
2016-06-22 07:25:14 +00:00
|
|
|
|
|
|
|
state.enabled = false;
|
|
|
|
state.polarity = pwm->args.polarity;
|
|
|
|
state.period = pwm->args.period;
|
2021-05-07 13:18:42 +00:00
|
|
|
state.usage_power = false;
|
2016-06-22 07:25:14 +00:00
|
|
|
|
|
|
|
pwm_apply_state(pwm, &state);
|
2016-04-14 19:17:41 +00:00
|
|
|
}
|
|
|
|
|
2012-03-26 06:42:48 +00:00
|
|
|
struct pwm_lookup {
|
|
|
|
struct list_head list;
|
|
|
|
const char *provider;
|
|
|
|
unsigned int index;
|
|
|
|
const char *dev_id;
|
|
|
|
const char *con_id;
|
2014-05-19 20:42:32 +00:00
|
|
|
unsigned int period;
|
|
|
|
enum pwm_polarity polarity;
|
2017-01-22 16:14:08 +00:00
|
|
|
const char *module; /* optional, may be NULL */
|
2012-03-26 06:42:48 +00:00
|
|
|
};
|
|
|
|
|
2017-01-22 16:14:08 +00:00
|
|
|
#define PWM_LOOKUP_WITH_MODULE(_provider, _index, _dev_id, _con_id, \
|
|
|
|
_period, _polarity, _module) \
|
|
|
|
{ \
|
|
|
|
.provider = _provider, \
|
|
|
|
.index = _index, \
|
|
|
|
.dev_id = _dev_id, \
|
|
|
|
.con_id = _con_id, \
|
|
|
|
.period = _period, \
|
|
|
|
.polarity = _polarity, \
|
|
|
|
.module = _module, \
|
2012-03-26 06:42:48 +00:00
|
|
|
}
|
|
|
|
|
2017-01-22 16:14:08 +00:00
|
|
|
#define PWM_LOOKUP(_provider, _index, _dev_id, _con_id, _period, _polarity) \
|
|
|
|
PWM_LOOKUP_WITH_MODULE(_provider, _index, _dev_id, _con_id, _period, \
|
|
|
|
_polarity, NULL)
|
|
|
|
|
2012-09-12 10:01:46 +00:00
|
|
|
#if IS_ENABLED(CONFIG_PWM)
|
2012-03-26 06:42:48 +00:00
|
|
|
void pwm_add_table(struct pwm_lookup *table, size_t num);
|
2015-05-05 09:34:18 +00:00
|
|
|
void pwm_remove_table(struct pwm_lookup *table, size_t num);
|
2012-09-12 10:01:46 +00:00
|
|
|
#else
|
|
|
|
static inline void pwm_add_table(struct pwm_lookup *table, size_t num)
|
|
|
|
{
|
|
|
|
}
|
2015-05-05 09:34:18 +00:00
|
|
|
|
|
|
|
static inline void pwm_remove_table(struct pwm_lookup *table, size_t num)
|
|
|
|
{
|
|
|
|
}
|
2011-01-28 08:40:40 +00:00
|
|
|
#endif
|
|
|
|
|
2013-06-11 17:38:59 +00:00
|
|
|
#ifdef CONFIG_PWM_SYSFS
|
|
|
|
void pwmchip_sysfs_export(struct pwm_chip *chip);
|
|
|
|
void pwmchip_sysfs_unexport(struct pwm_chip *chip);
|
|
|
|
#else
|
|
|
|
static inline void pwmchip_sysfs_export(struct pwm_chip *chip)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void pwmchip_sysfs_unexport(struct pwm_chip *chip)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_PWM_SYSFS */
|
|
|
|
|
2009-01-18 17:42:45 +00:00
|
|
|
#endif /* __LINUX_PWM_H */
|