Branch data     Line data    Source code

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