cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

leds.h (18697B)


      1/* SPDX-License-Identifier: GPL-2.0-only */
      2/*
      3 * Driver model for leds and led triggers
      4 *
      5 * Copyright (C) 2005 John Lenz <lenz@cs.wisc.edu>
      6 * Copyright (C) 2005 Richard Purdie <rpurdie@openedhand.com>
      7 */
      8#ifndef __LINUX_LEDS_H_INCLUDED
      9#define __LINUX_LEDS_H_INCLUDED
     10
     11#include <dt-bindings/leds/common.h>
     12#include <linux/device.h>
     13#include <linux/kernfs.h>
     14#include <linux/list.h>
     15#include <linux/mutex.h>
     16#include <linux/rwsem.h>
     17#include <linux/spinlock.h>
     18#include <linux/timer.h>
     19#include <linux/workqueue.h>
     20
     21struct device;
     22struct led_pattern;
     23struct device_node;
     24/*
     25 * LED Core
     26 */
     27
     28/* This is obsolete/useless. We now support variable maximum brightness. */
     29enum led_brightness {
     30	LED_OFF		= 0,
     31	LED_ON		= 1,
     32	LED_HALF	= 127,
     33	LED_FULL	= 255,
     34};
     35
     36enum led_default_state {
     37	LEDS_DEFSTATE_OFF	= 0,
     38	LEDS_DEFSTATE_ON	= 1,
     39	LEDS_DEFSTATE_KEEP	= 2,
     40};
     41
     42struct led_init_data {
     43	/* device fwnode handle */
     44	struct fwnode_handle *fwnode;
     45	/*
     46	 * default <color:function> tuple, for backward compatibility
     47	 * with in-driver hard-coded LED names used as a fallback when
     48	 * DT "label" property is absent; it should be set to NULL
     49	 * in new LED class drivers.
     50	 */
     51	const char *default_label;
     52	/*
     53	 * string to be used for devicename section of LED class device
     54	 * either for label based LED name composition path or for fwnode
     55	 * based when devname_mandatory is true
     56	 */
     57	const char *devicename;
     58	/*
     59	 * indicates if LED name should always comprise devicename section;
     60	 * only LEDs exposed by drivers of hot-pluggable devices should
     61	 * set it to true
     62	 */
     63	bool devname_mandatory;
     64};
     65
     66struct led_hw_trigger_type {
     67	int dummy;
     68};
     69
     70struct led_classdev {
     71	const char		*name;
     72	unsigned int brightness;
     73	unsigned int max_brightness;
     74	int			 flags;
     75
     76	/* Lower 16 bits reflect status */
     77#define LED_SUSPENDED		BIT(0)
     78#define LED_UNREGISTERING	BIT(1)
     79	/* Upper 16 bits reflect control information */
     80#define LED_CORE_SUSPENDRESUME	BIT(16)
     81#define LED_SYSFS_DISABLE	BIT(17)
     82#define LED_DEV_CAP_FLASH	BIT(18)
     83#define LED_HW_PLUGGABLE	BIT(19)
     84#define LED_PANIC_INDICATOR	BIT(20)
     85#define LED_BRIGHT_HW_CHANGED	BIT(21)
     86#define LED_RETAIN_AT_SHUTDOWN	BIT(22)
     87#define LED_INIT_DEFAULT_TRIGGER BIT(23)
     88
     89	/* set_brightness_work / blink_timer flags, atomic, private. */
     90	unsigned long		work_flags;
     91
     92#define LED_BLINK_SW			0
     93#define LED_BLINK_ONESHOT		1
     94#define LED_BLINK_ONESHOT_STOP		2
     95#define LED_BLINK_INVERT		3
     96#define LED_BLINK_BRIGHTNESS_CHANGE 	4
     97#define LED_BLINK_DISABLE		5
     98
     99	/* Set LED brightness level
    100	 * Must not sleep. Use brightness_set_blocking for drivers
    101	 * that can sleep while setting brightness.
    102	 */
    103	void		(*brightness_set)(struct led_classdev *led_cdev,
    104					  enum led_brightness brightness);
    105	/*
    106	 * Set LED brightness level immediately - it can block the caller for
    107	 * the time required for accessing a LED device register.
    108	 */
    109	int (*brightness_set_blocking)(struct led_classdev *led_cdev,
    110				       enum led_brightness brightness);
    111	/* Get LED brightness level */
    112	enum led_brightness (*brightness_get)(struct led_classdev *led_cdev);
    113
    114	/*
    115	 * Activate hardware accelerated blink, delays are in milliseconds
    116	 * and if both are zero then a sensible default should be chosen.
    117	 * The call should adjust the timings in that case and if it can't
    118	 * match the values specified exactly.
    119	 * Deactivate blinking again when the brightness is set to LED_OFF
    120	 * via the brightness_set() callback.
    121	 */
    122	int		(*blink_set)(struct led_classdev *led_cdev,
    123				     unsigned long *delay_on,
    124				     unsigned long *delay_off);
    125
    126	int (*pattern_set)(struct led_classdev *led_cdev,
    127			   struct led_pattern *pattern, u32 len, int repeat);
    128	int (*pattern_clear)(struct led_classdev *led_cdev);
    129
    130	struct device		*dev;
    131	const struct attribute_group	**groups;
    132
    133	struct list_head	 node;			/* LED Device list */
    134	const char		*default_trigger;	/* Trigger to use */
    135
    136	unsigned long		 blink_delay_on, blink_delay_off;
    137	struct timer_list	 blink_timer;
    138	int			 blink_brightness;
    139	int			 new_blink_brightness;
    140	void			(*flash_resume)(struct led_classdev *led_cdev);
    141
    142	struct work_struct	set_brightness_work;
    143	int			delayed_set_value;
    144
    145#ifdef CONFIG_LEDS_TRIGGERS
    146	/* Protects the trigger data below */
    147	struct rw_semaphore	 trigger_lock;
    148
    149	struct led_trigger	*trigger;
    150	struct list_head	 trig_list;
    151	void			*trigger_data;
    152	/* true if activated - deactivate routine uses it to do cleanup */
    153	bool			activated;
    154
    155	/* LEDs that have private triggers have this set */
    156	struct led_hw_trigger_type	*trigger_type;
    157#endif
    158
    159#ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
    160	int			 brightness_hw_changed;
    161	struct kernfs_node	*brightness_hw_changed_kn;
    162#endif
    163
    164	/* Ensures consistent access to the LED Flash Class device */
    165	struct mutex		led_access;
    166};
    167
    168/**
    169 * led_classdev_register_ext - register a new object of LED class with
    170 *			       init data
    171 * @parent: LED controller device this LED is driven by
    172 * @led_cdev: the led_classdev structure for this device
    173 * @init_data: the LED class device initialization data
    174 *
    175 * Register a new object of LED class, with name derived from init_data.
    176 *
    177 * Returns: 0 on success or negative error value on failure
    178 */
    179int led_classdev_register_ext(struct device *parent,
    180				     struct led_classdev *led_cdev,
    181				     struct led_init_data *init_data);
    182
    183/**
    184 * led_classdev_register - register a new object of LED class
    185 * @parent: LED controller device this LED is driven by
    186 * @led_cdev: the led_classdev structure for this device
    187 *
    188 * Register a new object of LED class, with name derived from the name property
    189 * of passed led_cdev argument.
    190 *
    191 * Returns: 0 on success or negative error value on failure
    192 */
    193static inline int led_classdev_register(struct device *parent,
    194					struct led_classdev *led_cdev)
    195{
    196	return led_classdev_register_ext(parent, led_cdev, NULL);
    197}
    198
    199int devm_led_classdev_register_ext(struct device *parent,
    200					  struct led_classdev *led_cdev,
    201					  struct led_init_data *init_data);
    202
    203static inline int devm_led_classdev_register(struct device *parent,
    204					     struct led_classdev *led_cdev)
    205{
    206	return devm_led_classdev_register_ext(parent, led_cdev, NULL);
    207}
    208void led_classdev_unregister(struct led_classdev *led_cdev);
    209void devm_led_classdev_unregister(struct device *parent,
    210				  struct led_classdev *led_cdev);
    211void led_classdev_suspend(struct led_classdev *led_cdev);
    212void led_classdev_resume(struct led_classdev *led_cdev);
    213
    214extern struct led_classdev *of_led_get(struct device_node *np, int index);
    215extern void led_put(struct led_classdev *led_cdev);
    216struct led_classdev *__must_check devm_of_led_get(struct device *dev,
    217						  int index);
    218
    219/**
    220 * led_blink_set - set blinking with software fallback
    221 * @led_cdev: the LED to start blinking
    222 * @delay_on: the time it should be on (in ms)
    223 * @delay_off: the time it should ble off (in ms)
    224 *
    225 * This function makes the LED blink, attempting to use the
    226 * hardware acceleration if possible, but falling back to
    227 * software blinking if there is no hardware blinking or if
    228 * the LED refuses the passed values.
    229 *
    230 * Note that if software blinking is active, simply calling
    231 * led_cdev->brightness_set() will not stop the blinking,
    232 * use led_classdev_brightness_set() instead.
    233 */
    234void led_blink_set(struct led_classdev *led_cdev, unsigned long *delay_on,
    235		   unsigned long *delay_off);
    236/**
    237 * led_blink_set_oneshot - do a oneshot software blink
    238 * @led_cdev: the LED to start blinking
    239 * @delay_on: the time it should be on (in ms)
    240 * @delay_off: the time it should ble off (in ms)
    241 * @invert: blink off, then on, leaving the led on
    242 *
    243 * This function makes the LED blink one time for delay_on +
    244 * delay_off time, ignoring the request if another one-shot
    245 * blink is already in progress.
    246 *
    247 * If invert is set, led blinks for delay_off first, then for
    248 * delay_on and leave the led on after the on-off cycle.
    249 */
    250void led_blink_set_oneshot(struct led_classdev *led_cdev,
    251			   unsigned long *delay_on, unsigned long *delay_off,
    252			   int invert);
    253/**
    254 * led_set_brightness - set LED brightness
    255 * @led_cdev: the LED to set
    256 * @brightness: the brightness to set it to
    257 *
    258 * Set an LED's brightness, and, if necessary, cancel the
    259 * software blink timer that implements blinking when the
    260 * hardware doesn't. This function is guaranteed not to sleep.
    261 */
    262void led_set_brightness(struct led_classdev *led_cdev, unsigned int brightness);
    263
    264/**
    265 * led_set_brightness_sync - set LED brightness synchronously
    266 * @led_cdev: the LED to set
    267 * @value: the brightness to set it to
    268 *
    269 * Set an LED's brightness immediately. This function will block
    270 * the caller for the time required for accessing device registers,
    271 * and it can sleep.
    272 *
    273 * Returns: 0 on success or negative error value on failure
    274 */
    275int led_set_brightness_sync(struct led_classdev *led_cdev, unsigned int value);
    276
    277/**
    278 * led_update_brightness - update LED brightness
    279 * @led_cdev: the LED to query
    280 *
    281 * Get an LED's current brightness and update led_cdev->brightness
    282 * member with the obtained value.
    283 *
    284 * Returns: 0 on success or negative error value on failure
    285 */
    286int led_update_brightness(struct led_classdev *led_cdev);
    287
    288/**
    289 * led_get_default_pattern - return default pattern
    290 *
    291 * @led_cdev: the LED to get default pattern for
    292 * @size:     pointer for storing the number of elements in returned array,
    293 *            modified only if return != NULL
    294 *
    295 * Return:    Allocated array of integers with default pattern from device tree
    296 *            or NULL.  Caller is responsible for kfree().
    297 */
    298u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size);
    299
    300/**
    301 * led_sysfs_disable - disable LED sysfs interface
    302 * @led_cdev: the LED to set
    303 *
    304 * Disable the led_cdev's sysfs interface.
    305 */
    306void led_sysfs_disable(struct led_classdev *led_cdev);
    307
    308/**
    309 * led_sysfs_enable - enable LED sysfs interface
    310 * @led_cdev: the LED to set
    311 *
    312 * Enable the led_cdev's sysfs interface.
    313 */
    314void led_sysfs_enable(struct led_classdev *led_cdev);
    315
    316/**
    317 * led_compose_name - compose LED class device name
    318 * @dev: LED controller device object
    319 * @init_data: the LED class device initialization data
    320 * @led_classdev_name: composed LED class device name
    321 *
    322 * Create LED class device name basing on the provided init_data argument.
    323 * The name can have <devicename:color:function> or <color:function>.
    324 * form, depending on the init_data configuration.
    325 *
    326 * Returns: 0 on success or negative error value on failure
    327 */
    328int led_compose_name(struct device *dev, struct led_init_data *init_data,
    329		     char *led_classdev_name);
    330
    331/**
    332 * led_sysfs_is_disabled - check if LED sysfs interface is disabled
    333 * @led_cdev: the LED to query
    334 *
    335 * Returns: true if the led_cdev's sysfs interface is disabled.
    336 */
    337static inline bool led_sysfs_is_disabled(struct led_classdev *led_cdev)
    338{
    339	return led_cdev->flags & LED_SYSFS_DISABLE;
    340}
    341
    342/*
    343 * LED Triggers
    344 */
    345/* Registration functions for simple triggers */
    346#define DEFINE_LED_TRIGGER(x)		static struct led_trigger *x;
    347#define DEFINE_LED_TRIGGER_GLOBAL(x)	struct led_trigger *x;
    348
    349#ifdef CONFIG_LEDS_TRIGGERS
    350
    351#define TRIG_NAME_MAX 50
    352
    353struct led_trigger {
    354	/* Trigger Properties */
    355	const char	 *name;
    356	int		(*activate)(struct led_classdev *led_cdev);
    357	void		(*deactivate)(struct led_classdev *led_cdev);
    358
    359	/* LED-private triggers have this set */
    360	struct led_hw_trigger_type *trigger_type;
    361
    362	/* LEDs under control by this trigger (for simple triggers) */
    363	spinlock_t	  leddev_list_lock;
    364	struct list_head  led_cdevs;
    365
    366	/* Link to next registered trigger */
    367	struct list_head  next_trig;
    368
    369	const struct attribute_group **groups;
    370};
    371
    372/*
    373 * Currently the attributes in struct led_trigger::groups are added directly to
    374 * the LED device. As this might change in the future, the following
    375 * macros abstract getting the LED device and its trigger_data from the dev
    376 * parameter passed to the attribute accessor functions.
    377 */
    378#define led_trigger_get_led(dev)	((struct led_classdev *)dev_get_drvdata((dev)))
    379#define led_trigger_get_drvdata(dev)	(led_get_trigger_data(led_trigger_get_led(dev)))
    380
    381/* Registration functions for complex triggers */
    382int led_trigger_register(struct led_trigger *trigger);
    383void led_trigger_unregister(struct led_trigger *trigger);
    384int devm_led_trigger_register(struct device *dev,
    385				     struct led_trigger *trigger);
    386
    387void led_trigger_register_simple(const char *name,
    388				struct led_trigger **trigger);
    389void led_trigger_unregister_simple(struct led_trigger *trigger);
    390void led_trigger_event(struct led_trigger *trigger,  enum led_brightness event);
    391void led_trigger_blink(struct led_trigger *trigger, unsigned long *delay_on,
    392		       unsigned long *delay_off);
    393void led_trigger_blink_oneshot(struct led_trigger *trigger,
    394			       unsigned long *delay_on,
    395			       unsigned long *delay_off,
    396			       int invert);
    397void led_trigger_set_default(struct led_classdev *led_cdev);
    398int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trigger);
    399void led_trigger_remove(struct led_classdev *led_cdev);
    400
    401static inline void led_set_trigger_data(struct led_classdev *led_cdev,
    402					void *trigger_data)
    403{
    404	led_cdev->trigger_data = trigger_data;
    405}
    406
    407static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
    408{
    409	return led_cdev->trigger_data;
    410}
    411
    412/**
    413 * led_trigger_rename_static - rename a trigger
    414 * @name: the new trigger name
    415 * @trig: the LED trigger to rename
    416 *
    417 * Change a LED trigger name by copying the string passed in
    418 * name into current trigger name, which MUST be large
    419 * enough for the new string.
    420 *
    421 * Note that name must NOT point to the same string used
    422 * during LED registration, as that could lead to races.
    423 *
    424 * This is meant to be used on triggers with statically
    425 * allocated name.
    426 */
    427void led_trigger_rename_static(const char *name, struct led_trigger *trig);
    428
    429#define module_led_trigger(__led_trigger) \
    430	module_driver(__led_trigger, led_trigger_register, \
    431		      led_trigger_unregister)
    432
    433#else
    434
    435/* Trigger has no members */
    436struct led_trigger {};
    437
    438/* Trigger inline empty functions */
    439static inline void led_trigger_register_simple(const char *name,
    440					struct led_trigger **trigger) {}
    441static inline void led_trigger_unregister_simple(struct led_trigger *trigger) {}
    442static inline void led_trigger_event(struct led_trigger *trigger,
    443				enum led_brightness event) {}
    444static inline void led_trigger_blink(struct led_trigger *trigger,
    445				      unsigned long *delay_on,
    446				      unsigned long *delay_off) {}
    447static inline void led_trigger_blink_oneshot(struct led_trigger *trigger,
    448				      unsigned long *delay_on,
    449				      unsigned long *delay_off,
    450				      int invert) {}
    451static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
    452static inline int led_trigger_set(struct led_classdev *led_cdev,
    453				  struct led_trigger *trigger)
    454{
    455	return 0;
    456}
    457
    458static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
    459static inline void led_set_trigger_data(struct led_classdev *led_cdev) {}
    460static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
    461{
    462	return NULL;
    463}
    464
    465#endif /* CONFIG_LEDS_TRIGGERS */
    466
    467/* Trigger specific functions */
    468#ifdef CONFIG_LEDS_TRIGGER_DISK
    469void ledtrig_disk_activity(bool write);
    470#else
    471static inline void ledtrig_disk_activity(bool write) {}
    472#endif
    473
    474#ifdef CONFIG_LEDS_TRIGGER_MTD
    475void ledtrig_mtd_activity(void);
    476#else
    477static inline void ledtrig_mtd_activity(void) {}
    478#endif
    479
    480#if defined(CONFIG_LEDS_TRIGGER_CAMERA) || defined(CONFIG_LEDS_TRIGGER_CAMERA_MODULE)
    481void ledtrig_flash_ctrl(bool on);
    482void ledtrig_torch_ctrl(bool on);
    483#else
    484static inline void ledtrig_flash_ctrl(bool on) {}
    485static inline void ledtrig_torch_ctrl(bool on) {}
    486#endif
    487
    488/*
    489 * Generic LED platform data for describing LED names and default triggers.
    490 */
    491struct led_info {
    492	const char	*name;
    493	const char	*default_trigger;
    494	int		flags;
    495};
    496
    497struct led_platform_data {
    498	int		num_leds;
    499	struct led_info	*leds;
    500};
    501
    502struct led_properties {
    503	u32		color;
    504	bool		color_present;
    505	const char	*function;
    506	u32		func_enum;
    507	bool		func_enum_present;
    508	const char	*label;
    509};
    510
    511struct gpio_desc;
    512typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,
    513				unsigned long *delay_on,
    514				unsigned long *delay_off);
    515
    516/* For the leds-gpio driver */
    517struct gpio_led {
    518	const char *name;
    519	const char *default_trigger;
    520	unsigned 	gpio;
    521	unsigned	active_low : 1;
    522	unsigned	retain_state_suspended : 1;
    523	unsigned	panic_indicator : 1;
    524	unsigned	default_state : 2;
    525	unsigned	retain_state_shutdown : 1;
    526	/* default_state should be one of LEDS_GPIO_DEFSTATE_(ON|OFF|KEEP) */
    527	struct gpio_desc *gpiod;
    528};
    529#define LEDS_GPIO_DEFSTATE_OFF		LEDS_DEFSTATE_OFF
    530#define LEDS_GPIO_DEFSTATE_ON		LEDS_DEFSTATE_ON
    531#define LEDS_GPIO_DEFSTATE_KEEP		LEDS_DEFSTATE_KEEP
    532
    533struct gpio_led_platform_data {
    534	int 		num_leds;
    535	const struct gpio_led *leds;
    536
    537#define GPIO_LED_NO_BLINK_LOW	0	/* No blink GPIO state low */
    538#define GPIO_LED_NO_BLINK_HIGH	1	/* No blink GPIO state high */
    539#define GPIO_LED_BLINK		2	/* Please, blink */
    540	gpio_blink_set_t	gpio_blink_set;
    541};
    542
    543#ifdef CONFIG_NEW_LEDS
    544struct platform_device *gpio_led_register_device(
    545		int id, const struct gpio_led_platform_data *pdata);
    546#else
    547static inline struct platform_device *gpio_led_register_device(
    548		int id, const struct gpio_led_platform_data *pdata)
    549{
    550	return 0;
    551}
    552#endif
    553
    554enum cpu_led_event {
    555	CPU_LED_IDLE_START,	/* CPU enters idle */
    556	CPU_LED_IDLE_END,	/* CPU idle ends */
    557	CPU_LED_START,		/* Machine starts, especially resume */
    558	CPU_LED_STOP,		/* Machine stops, especially suspend */
    559	CPU_LED_HALTED,		/* Machine shutdown */
    560};
    561#ifdef CONFIG_LEDS_TRIGGER_CPU
    562void ledtrig_cpu(enum cpu_led_event evt);
    563#else
    564static inline void ledtrig_cpu(enum cpu_led_event evt)
    565{
    566	return;
    567}
    568#endif
    569
    570#ifdef CONFIG_LEDS_BRIGHTNESS_HW_CHANGED
    571void led_classdev_notify_brightness_hw_changed(
    572	struct led_classdev *led_cdev, unsigned int brightness);
    573#else
    574static inline void led_classdev_notify_brightness_hw_changed(
    575	struct led_classdev *led_cdev, enum led_brightness brightness) { }
    576#endif
    577
    578/**
    579 * struct led_pattern - pattern interval settings
    580 * @delta_t: pattern interval delay, in milliseconds
    581 * @brightness: pattern interval brightness
    582 */
    583struct led_pattern {
    584	u32 delta_t;
    585	int brightness;
    586};
    587
    588enum led_audio {
    589	LED_AUDIO_MUTE,		/* master mute LED */
    590	LED_AUDIO_MICMUTE,	/* mic mute LED */
    591	NUM_AUDIO_LEDS
    592};
    593
    594#if IS_ENABLED(CONFIG_LEDS_TRIGGER_AUDIO)
    595enum led_brightness ledtrig_audio_get(enum led_audio type);
    596void ledtrig_audio_set(enum led_audio type, enum led_brightness state);
    597#else
    598static inline enum led_brightness ledtrig_audio_get(enum led_audio type)
    599{
    600	return LED_OFF;
    601}
    602static inline void ledtrig_audio_set(enum led_audio type,
    603				     enum led_brightness state)
    604{
    605}
    606#endif
    607
    608#endif		/* __LINUX_LEDS_H_INCLUDED */