[mirror_ubuntu-artful-kernel.git] / include / linux / pwm.h

#ifndef __LINUX_PWM_H
#define __LINUX_PWM_H

#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/of.h>

struct pwm_device;
struct seq_file;

#if IS_ENABLED(CONFIG_PWM)
/*
 * pwm_request - request a PWM device
 */
struct pwm_device *pwm_request(int pwm_id, const char *label);

/*
 * pwm_free - free a PWM device
 */
void pwm_free(struct pwm_device *pwm);

/*
 * pwm_config - change a PWM device configuration
 */
int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns);

/*
 * pwm_enable - start a PWM output toggling
 */
int pwm_enable(struct pwm_device *pwm);

/*
 * pwm_disable - stop a PWM output toggling
 */
void pwm_disable(struct pwm_device *pwm);
#else
static inline struct pwm_device *pwm_request(int pwm_id, const char *label)
{
	return ERR_PTR(-ENODEV);
}

static inline void pwm_free(struct pwm_device *pwm)
{
}

static inline int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
{
	return -EINVAL;
}

static inline int pwm_enable(struct pwm_device *pwm)
{
	return -EINVAL;
}

static inline void pwm_disable(struct pwm_device *pwm)
{
}
#endif

struct pwm_chip;

/**
 * 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,
};

enum {
	PWMF_REQUESTED = 1 << 0,
	PWMF_ENABLED = 1 << 1,
	PWMF_EXPORTED = 1 << 2,
};

/**
 * 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
 * @lock: used to serialize accesses to the PWM device where necessary
 * @period: period of the PWM signal (in nanoseconds)
 * @duty_cycle: duty cycle of the PWM signal (in nanoseconds)
 * @polarity: polarity of the PWM signal
 */
struct pwm_device {
	const char *label;
	unsigned long flags;
	unsigned int hwpwm;
	unsigned int pwm;
	struct pwm_chip *chip;
	void *chip_data;
	struct mutex lock;

	unsigned int period;
	unsigned int duty_cycle;
	enum pwm_polarity polarity;
};

static inline bool pwm_is_enabled(const struct pwm_device *pwm)
{
	return test_bit(PWMF_ENABLED, &pwm->flags);
}

static inline void pwm_set_period(struct pwm_device *pwm, unsigned int period)
{
	if (pwm)
		pwm->period = period;
}

static inline unsigned int pwm_get_period(const struct pwm_device *pwm)
{
	return pwm ? pwm->period : 0;
}

static inline void pwm_set_duty_cycle(struct pwm_device *pwm, unsigned int duty)
{
	if (pwm)
		pwm->duty_cycle = duty;
}

static inline unsigned int pwm_get_duty_cycle(const struct pwm_device *pwm)
{
	return pwm ? pwm->duty_cycle : 0;
}

/*
 * pwm_set_polarity - configure the polarity of a PWM signal
 */
int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity);

static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm)
{
	return pwm ? pwm->polarity : PWM_POLARITY_NORMAL;
}

/**
 * struct pwm_ops - PWM controller operations
 * @request: optional hook for requesting a PWM
 * @free: optional hook for freeing a PWM
 * @config: configure duty cycles and period length for this PWM
 * @set_polarity: configure the polarity of this PWM
 * @enable: enable PWM output toggling
 * @disable: disable PWM output toggling
 * @dbg_show: optional routine to show contents in debugfs
 * @owner: helps prevent removal of modules exporting active PWMs
 */
struct pwm_ops {
	int (*request)(struct pwm_chip *chip, struct pwm_device *pwm);
	void (*free)(struct pwm_chip *chip, struct pwm_device *pwm);
	int (*config)(struct pwm_chip *chip, struct pwm_device *pwm,
		      int duty_ns, int period_ns);
	int (*set_polarity)(struct pwm_chip *chip, struct pwm_device *pwm,
			    enum pwm_polarity polarity);
	int (*enable)(struct pwm_chip *chip, struct pwm_device *pwm);
	void (*disable)(struct pwm_chip *chip, struct pwm_device *pwm);
#ifdef CONFIG_DEBUG_FS
	void (*dbg_show)(struct pwm_chip *chip, struct seq_file *s);
#endif
	struct module *owner;
};

/**
 * struct pwm_chip - abstract a PWM controller
 * @dev: device providing the PWMs
 * @list: list node for internal use
 * @ops: callbacks for this PWM controller
 * @base: number of first PWM controlled by this chip
 * @npwm: number of PWMs controlled by this chip
 * @pwms: array of PWM devices allocated by the framework
 * @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
 * @can_sleep: must be true if the .config(), .enable() or .disable()
 *             operations may sleep
 */
struct pwm_chip {
	struct device *dev;
	struct list_head list;
	const struct pwm_ops *ops;
	int base;
	unsigned int npwm;

	struct pwm_device *pwms;

	struct pwm_device * (*of_xlate)(struct pwm_chip *pc,
					const struct of_phandle_args *args);
	unsigned int of_pwm_n_cells;
	bool can_sleep;
};

#if IS_ENABLED(CONFIG_PWM)
int pwm_set_chip_data(struct pwm_device *pwm, void *data);
void *pwm_get_chip_data(struct pwm_device *pwm);

int pwmchip_add_with_polarity(struct pwm_chip *chip,
			      enum pwm_polarity polarity);
int pwmchip_add(struct pwm_chip *chip);
int pwmchip_remove(struct pwm_chip *chip);
struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
					 unsigned int index,
					 const char *label);

struct pwm_device *of_pwm_xlate_with_flags(struct pwm_chip *pc,
		const struct of_phandle_args *args);

struct pwm_device *pwm_get(struct device *dev, const char *con_id);
struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id);
void pwm_put(struct pwm_device *pwm);

struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id);
struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
				   const char *con_id);
void devm_pwm_put(struct device *dev, struct pwm_device *pwm);

bool pwm_can_sleep(struct pwm_device *pwm);
#else
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_add_inversed(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)
{
	return ERR_PTR(-ENODEV);
}

static inline struct pwm_device *pwm_get(struct device *dev,
					 const char *consumer)
{
	return ERR_PTR(-ENODEV);
}

static inline struct pwm_device *of_pwm_get(struct device_node *np,
					    const char *con_id)
{
	return ERR_PTR(-ENODEV);
}

static inline void pwm_put(struct pwm_device *pwm)
{
}

static inline struct pwm_device *devm_pwm_get(struct device *dev,
					      const char *consumer)
{
	return ERR_PTR(-ENODEV);
}

static inline struct pwm_device *devm_of_pwm_get(struct device *dev,
						 struct device_node *np,
						 const char *con_id)
{
	return ERR_PTR(-ENODEV);
}

static inline void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
{
}

static inline bool pwm_can_sleep(struct pwm_device *pwm)
{
	return false;
}
#endif

struct pwm_lookup {
	struct list_head list;
	const char *provider;
	unsigned int index;
	const char *dev_id;
	const char *con_id;
	unsigned int period;
	enum pwm_polarity polarity;
};

#define PWM_LOOKUP(_provider, _index, _dev_id, _con_id, _period, _polarity) \
	{						\
		.provider = _provider,			\
		.index = _index,			\
		.dev_id = _dev_id,			\
		.con_id = _con_id,			\
		.period = _period,			\
		.polarity = _polarity			\
	}

#if IS_ENABLED(CONFIG_PWM)
void pwm_add_table(struct pwm_lookup *table, size_t num);
void pwm_remove_table(struct pwm_lookup *table, size_t num);
#else
static inline void pwm_add_table(struct pwm_lookup *table, size_t num)
{
}

static inline void pwm_remove_table(struct pwm_lookup *table, size_t num)
{
}
#endif

#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 */

#endif /* __LINUX_PWM_H */
Commit	Line	Data
1a189b97 RK	1	#ifndef __LINUX_PWM_H
	2	#define __LINUX_PWM_H
	3
0bcf168b	4	#include <linux/err.h>
d1cd2142	5	#include <linux/mutex.h>
7299ab70 TR	6	#include <linux/of.h>
7299ab70 TR	7
1a189b97	8	struct pwm_device;
62099abf	9	struct seq_file;
1a189b97	10
557fe99d	11	#if IS_ENABLED(CONFIG_PWM)
1a189b97 RK	12	/*
	13	* pwm_request - request a PWM device
	14	*/
	15	struct pwm_device pwm_request(int pwm_id, const char label);
	16
	17	/*
	18	* pwm_free - free a PWM device
	19	*/
	20	void pwm_free(struct pwm_device *pwm);
	21
	22	/*
	23	* pwm_config - change a PWM device configuration
	24	*/
	25	int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns);
	26
	27	/*
	28	* pwm_enable - start a PWM output toggling
	29	*/
	30	int pwm_enable(struct pwm_device *pwm);
	31
	32	/*
	33	* pwm_disable - stop a PWM output toggling
	34	*/
	35	void pwm_disable(struct pwm_device *pwm);
0bcf168b TB	36	#else
	37	static inline struct pwm_device pwm_request(int pwm_id, const char label)
	38	{
	39	return ERR_PTR(-ENODEV);
	40	}
	41
	42	static inline void pwm_free(struct pwm_device *pwm)
	43	{
	44	}
	45
	46	static inline int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns)
	47	{
	48	return -EINVAL;
	49	}
	50
	51	static inline int pwm_enable(struct pwm_device *pwm)
	52	{
	53	return -EINVAL;
	54	}
	55
	56	static inline void pwm_disable(struct pwm_device *pwm)
	57	{
	58	}
	59	#endif
1a189b97	60
0c2498f1 SH	61	struct pwm_chip;
0c2498f1 SH	62
0aa0869c PA	63	/**
	64	* enum pwm_polarity - polarity of a PWM signal
	65	* @PWM_POLARITY_NORMAL: a high signal for the duration of the duty-
	66	* cycle, followed by a low signal for the remainder of the pulse
	67	* period
	68	* @PWM_POLARITY_INVERSED: a low signal for the duration of the duty-
	69	* cycle, followed by a high signal for the remainder of the pulse
	70	* period
	71	*/
	72	enum pwm_polarity {
	73	PWM_POLARITY_NORMAL,
	74	PWM_POLARITY_INVERSED,
	75	};
	76
f051c466 TR	77	enum {
	78	PWMF_REQUESTED = 1 << 0,
	79	PWMF_ENABLED = 1 << 1,
76abbdde	80	PWMF_EXPORTED = 1 << 2,
f051c466 TR	81	};
f051c466 TR	82
04883802 TR	83	/**
	84	* struct pwm_device - PWM channel object
	85	* @label: name of the PWM device
	86	* @flags: flags associated with the PWM device
	87	* @hwpwm: per-chip relative index of the PWM device
	88	* @pwm: global index of the PWM device
	89	* @chip: PWM chip providing this PWM device
	90	* @chip_data: chip-private data associated with the PWM device
d1cd2142	91	* @lock: used to serialize accesses to the PWM device where necessary
04883802 TR	92	* @period: period of the PWM signal (in nanoseconds)
	93	* @duty_cycle: duty cycle of the PWM signal (in nanoseconds)
	94	* @polarity: polarity of the PWM signal
	95	*/
f051c466	96	struct pwm_device {
6bc7064a TR	97	const char *label;
	98	unsigned long flags;
	99	unsigned int hwpwm;
	100	unsigned int pwm;
	101	struct pwm_chip *chip;
	102	void *chip_data;
d1cd2142	103	struct mutex lock;
6bc7064a TR	104
	105	unsigned int period;
	106	unsigned int duty_cycle;
	107	enum pwm_polarity polarity;
f051c466 TR	108	};
f051c466 TR	109
5c31252c BB	110	static inline bool pwm_is_enabled(const struct pwm_device *pwm)
	111	{
	112	return test_bit(PWMF_ENABLED, &pwm->flags);
	113	}
	114
f051c466 TR	115	static inline void pwm_set_period(struct pwm_device *pwm, unsigned int period)
	116	{
	117	if (pwm)
	118	pwm->period = period;
	119	}
	120
a1cf4217	121	static inline unsigned int pwm_get_period(const struct pwm_device *pwm)
f051c466 TR	122	{
	123	return pwm ? pwm->period : 0;
	124	}
	125
76abbdde HS	126	static inline void pwm_set_duty_cycle(struct pwm_device *pwm, unsigned int duty)
	127	{
	128	if (pwm)
	129	pwm->duty_cycle = duty;
	130	}
	131
a1cf4217	132	static inline unsigned int pwm_get_duty_cycle(const struct pwm_device *pwm)
76abbdde HS	133	{
	134	return pwm ? pwm->duty_cycle : 0;
	135	}
	136
0aa0869c PA	137	/*
	138	* pwm_set_polarity - configure the polarity of a PWM signal
	139	*/
	140	int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity);
	141
011e7631 BB	142	static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm)
	143	{
	144	return pwm ? pwm->polarity : PWM_POLARITY_NORMAL;
	145	}
	146
0c2498f1 SH	147	/**
	148	* struct pwm_ops - PWM controller operations
	149	* @request: optional hook for requesting a PWM
	150	* @free: optional hook for freeing a PWM
	151	* @config: configure duty cycles and period length for this PWM
0aa0869c	152	* @set_polarity: configure the polarity of this PWM
0c2498f1 SH	153	* @enable: enable PWM output toggling
0c2498f1 SH	154	* @disable: disable PWM output toggling
62099abf	155	* @dbg_show: optional routine to show contents in debugfs
0c2498f1 SH	156	* @owner: helps prevent removal of modules exporting active PWMs
	157	*/
	158	struct pwm_ops {
6bc7064a TR	159	int (request)(struct pwm_chip chip, struct pwm_device *pwm);
	160	void (free)(struct pwm_chip chip, struct pwm_device *pwm);
	161	int (config)(struct pwm_chip chip, struct pwm_device *pwm,
	162	int duty_ns, int period_ns);
	163	int (set_polarity)(struct pwm_chip chip, struct pwm_device *pwm,
	164	enum pwm_polarity polarity);
	165	int (enable)(struct pwm_chip chip, struct pwm_device *pwm);
	166	void (disable)(struct pwm_chip chip, struct pwm_device *pwm);
62099abf	167	#ifdef CONFIG_DEBUG_FS
6bc7064a	168	void (dbg_show)(struct pwm_chip chip, struct seq_file *s);
62099abf	169	#endif
6bc7064a	170	struct module *owner;
0c2498f1 SH	171	};
	172
	173	/**
f051c466 TR	174	* struct pwm_chip - abstract a PWM controller
	175	* @dev: device providing the PWMs
	176	* @list: list node for internal use
	177	* @ops: callbacks for this PWM controller
	178	* @base: number of first PWM controlled by this chip
	179	* @npwm: number of PWMs controlled by this chip
	180	* @pwms: array of PWM devices allocated by the framework
04883802 TR	181	* @of_xlate: request a PWM device given a device tree PWM specifier
04883802 TR	182	* @of_pwm_n_cells: number of cells expected in the device tree PWM specifier
6e69ab13 FV	183	* @can_sleep: must be true if the .config(), .enable() or .disable()
6e69ab13 FV	184	* operations may sleep
0c2498f1 SH	185	*/
0c2498f1 SH	186	struct pwm_chip {
6bc7064a TR	187	struct device *dev;
	188	struct list_head list;
	189	const struct pwm_ops *ops;
	190	int base;
	191	unsigned int npwm;
	192
	193	struct pwm_device *pwms;
	194
	195	struct pwm_device * (of_xlate)(struct pwm_chip pc,
	196	const struct of_phandle_args *args);
	197	unsigned int of_pwm_n_cells;
	198	bool can_sleep;
0c2498f1 SH	199	};
0c2498f1 SH	200
0bcf168b	201	#if IS_ENABLED(CONFIG_PWM)
f051c466 TR	202	int pwm_set_chip_data(struct pwm_device pwm, void data);
	203	void pwm_get_chip_data(struct pwm_device pwm);
	204
b6a00fae TK	205	int pwmchip_add_with_polarity(struct pwm_chip *chip,
b6a00fae TK	206	enum pwm_polarity polarity);
0c2498f1 SH	207	int pwmchip_add(struct pwm_chip *chip);
0c2498f1 SH	208	int pwmchip_remove(struct pwm_chip *chip);
f051c466 TR	209	struct pwm_device pwm_request_from_chip(struct pwm_chip chip,
	210	unsigned int index,
	211	const char *label);
8138d2dd	212
83af2402 PA	213	struct pwm_device of_pwm_xlate_with_flags(struct pwm_chip pc,
	214	const struct of_phandle_args *args);
	215
d4c0c470	216	struct pwm_device pwm_get(struct device dev, const char *con_id);
8eb96127	217	struct pwm_device of_pwm_get(struct device_node np, const char *con_id);
8138d2dd TR	218	void pwm_put(struct pwm_device *pwm);
8138d2dd TR	219
d4c0c470	220	struct pwm_device devm_pwm_get(struct device dev, const char *con_id);
261a5edd PU	221	struct pwm_device devm_of_pwm_get(struct device dev, struct device_node *np,
261a5edd PU	222	const char *con_id);
6354316d	223	void devm_pwm_put(struct device dev, struct pwm_device pwm);
6e69ab13 FV	224
6e69ab13 FV	225	bool pwm_can_sleep(struct pwm_device *pwm);
0bcf168b TB	226	#else
	227	static inline int pwm_set_chip_data(struct pwm_device pwm, void data)
	228	{
	229	return -EINVAL;
	230	}
	231
	232	static inline void pwm_get_chip_data(struct pwm_device pwm)
	233	{
	234	return NULL;
	235	}
	236
	237	static inline int pwmchip_add(struct pwm_chip *chip)
	238	{
	239	return -EINVAL;
	240	}
	241
b6a00fae TK	242	static inline int pwmchip_add_inversed(struct pwm_chip *chip)
	243	{
	244	return -EINVAL;
	245	}
	246
0bcf168b TB	247	static inline int pwmchip_remove(struct pwm_chip *chip)
	248	{
	249	return -EINVAL;
	250	}
	251
	252	static inline struct pwm_device pwm_request_from_chip(struct pwm_chip chip,
	253	unsigned int index,
	254	const char *label)
	255	{
	256	return ERR_PTR(-ENODEV);
	257	}
	258
	259	static inline struct pwm_device pwm_get(struct device dev,
	260	const char *consumer)
	261	{
	262	return ERR_PTR(-ENODEV);
	263	}
	264
8eb96127 PU	265	static inline struct pwm_device of_pwm_get(struct device_node np,
	266	const char *con_id)
	267	{
	268	return ERR_PTR(-ENODEV);
	269	}
	270
0bcf168b TB	271	static inline void pwm_put(struct pwm_device *pwm)
	272	{
	273	}
	274
	275	static inline struct pwm_device devm_pwm_get(struct device dev,
	276	const char *consumer)
	277	{
	278	return ERR_PTR(-ENODEV);
	279	}
	280
261a5edd PU	281	static inline struct pwm_device devm_of_pwm_get(struct device dev,
	282	struct device_node *np,
	283	const char *con_id)
	284	{
	285	return ERR_PTR(-ENODEV);
	286	}
	287
0bcf168b TB	288	static inline void devm_pwm_put(struct device dev, struct pwm_device pwm)
	289	{
	290	}
6e69ab13 FV	291
	292	static inline bool pwm_can_sleep(struct pwm_device *pwm)
	293	{
	294	return false;
	295	}
0bcf168b	296	#endif
6354316d	297
8138d2dd TR	298	struct pwm_lookup {
	299	struct list_head list;
	300	const char *provider;
	301	unsigned int index;
	302	const char *dev_id;
	303	const char *con_id;
3796ce1d AB	304	unsigned int period;
3796ce1d AB	305	enum pwm_polarity polarity;
8138d2dd TR	306	};
8138d2dd TR	307
42844029	308	#define PWM_LOOKUP(_provider, _index, _dev_id, _con_id, _period, _polarity) \
8138d2dd TR	309	{ \
	310	.provider = _provider, \
	311	.index = _index, \
	312	.dev_id = _dev_id, \
	313	.con_id = _con_id, \
42844029 AB	314	.period = _period, \
42844029 AB	315	.polarity = _polarity \
8138d2dd TR	316	}
8138d2dd TR	317
0bcf168b	318	#if IS_ENABLED(CONFIG_PWM)
8138d2dd	319	void pwm_add_table(struct pwm_lookup *table, size_t num);
efb0de55	320	void pwm_remove_table(struct pwm_lookup *table, size_t num);
0bcf168b TB	321	#else
	322	static inline void pwm_add_table(struct pwm_lookup *table, size_t num)
	323	{
	324	}
efb0de55 SK	325
	326	static inline void pwm_remove_table(struct pwm_lookup *table, size_t num)
	327	{
	328	}
0c2498f1 SH	329	#endif
0c2498f1 SH	330
76abbdde HS	331	#ifdef CONFIG_PWM_SYSFS
	332	void pwmchip_sysfs_export(struct pwm_chip *chip);
	333	void pwmchip_sysfs_unexport(struct pwm_chip *chip);
	334	#else
	335	static inline void pwmchip_sysfs_export(struct pwm_chip *chip)
	336	{
	337	}
	338
	339	static inline void pwmchip_sysfs_unexport(struct pwm_chip *chip)
	340	{
	341	}
	342	#endif /* CONFIG_PWM_SYSFS */
	343
5243ef8b	344	#endif /* __LINUX_PWM_H */