mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-24 11:50:52 +07:00
LED updates for 5.4-rc1
-----BEGIN PGP SIGNATURE-----
iHUEABYIAB0WIQQUwxxKyE5l/npt8ARiEGxRG/Sl2wUCXYAIeQAKCRBiEGxRG/Sl
2/SzAQDEnoNxzV/R5kWFd+2kmFeY3cll0d99KMrWJ8om+kje6QD/cXxZHzFm+T1L
UPF66k76oOODV7cyndjXnTnRXbeCRAM=
=Szby
-----END PGP SIGNATURE-----
Merge tag 'leds-for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds
Pull LED updates from Jacek Anaszewski:
"In this cycle we've finally managed to contribute the patch set
sorting out LED naming issues. Besides that there are many changes
scattered among various LED class drivers and triggers.
LED naming related improvements:
- add new 'function' and 'color' fwnode properties and deprecate
'label' property which has been frequently abused for conveying
vendor specific names that have been available in sysfs anyway
- introduce a set of standard LED_FUNCTION* definitions
- introduce a set of standard LED_COLOR_ID* definitions
- add a new {devm_}led_classdev_register_ext() API with the
capability of automatic LED name composition basing on the
properties available in the passed fwnode; the function is
backwards compatible in a sense that it uses 'label' data, if
present in the fwnode, for creating LED name
- add tools/leds/get_led_device_info.sh script for retrieving LED
vendor, product and bus names, if applicable; it also performs
basic validation of an LED name
- update following drivers and their DT bindings to use the new LED
registration API:
- leds-an30259a, leds-gpio, leds-as3645a, leds-aat1290, leds-cr0014114,
leds-lm3601x, leds-lm3692x, leds-lp8860, leds-lt3593, leds-sc27xx-blt
Other LED class improvements:
- replace {devm_}led_classdev_register() macros with inlines
- allow to call led_classdev_unregister() unconditionally
- switch to use fwnode instead of be stuck with OF one
LED triggers improvements:
- led-triggers:
- fix dereferencing of null pointer
- fix a memory leak bug
- ledtrig-gpio:
- GPIO 0 is valid
Drop superseeded apu2/3 support from leds-apu since for apu2+ a newer,
more complete driver exists, based on a generic driver for the AMD
SOCs gpio-controller, supporting LEDs as well other devices:
- drop profile field from priv data
- drop iosize field from priv data
- drop enum_apu_led_platform_types
- drop superseeded apu2/3 led support
- add pr_fmt prefix for better log output
- fix error message on probing failure
Other misc fixes and improvements to existing LED class drivers:
- leds-ns2, leds-max77650:
- add of_node_put() before return
- leds-pwm, leds-is31fl32xx:
- use struct_size() helper
- leds-lm3697, leds-lm36274, leds-lm3532:
- switch to use fwnode_property_count_uXX()
- leds-lm3532:
- fix brightness control for i2c mode
- change the define for the fs current register
- fixes for the driver for stability
- add full scale current configuration
- dt: Add property for full scale current.
- avoid potentially unpaired regulator calls
- move static keyword to the front of declarations
- fix optional led-max-microamp prop error handling
- leds-max77650:
- add of_node_put() before return
- add MODULE_ALIAS()
- Switch to fwnode property API
- leds-as3645a:
- fix misuse of strlcpy
- leds-netxbig:
- add of_node_put() in netxbig_leds_get_of_pdata()
- remove legacy board-file support
- leds-is31fl319x:
- simplify getting the adapter of a client
- leds-ti-lmu-common:
- fix coccinelle issue
- move static keyword to the front of declaration
- leds-syscon:
- use resource managed variant of device register
- leds-ktd2692:
- fix a typo in the name of a constant
- leds-lp5562:
- allow firmware files up to the maximum length
- leds-an30259a:
- fix typo
- leds-pca953x:
- include the right header"
* tag 'leds-for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/j.anaszewski/linux-leds: (72 commits)
leds: lm3532: Fix optional led-max-microamp prop error handling
led: triggers: Fix dereferencing of null pointer
leds: ti-lmu-common: Move static keyword to the front of declaration
leds: lm3532: Move static keyword to the front of declarations
leds: trigger: gpio: GPIO 0 is valid
leds: pwm: Use struct_size() helper
leds: is31fl32xx: Use struct_size() helper
leds: ti-lmu-common: Fix coccinelle issue in TI LMU
leds: lm3532: Avoid potentially unpaired regulator calls
leds: syscon: Use resource managed variant of device register
leds: Replace {devm_}led_classdev_register() macros with inlines
leds: Allow to call led_classdev_unregister() unconditionally
leds: lm3532: Add full scale current configuration
dt: lm3532: Add property for full scale current.
leds: lm3532: Fixes for the driver for stability
leds: lm3532: Change the define for the fs current register
leds: lm3532: Fix brightness control for i2c mode
leds: Switch to use fwnode instead of be stuck with OF one
leds: max77650: Switch to fwnode property API
led: triggers: Fix a memory leak bug
...
This commit is contained in:
Linus Torvalds
commit
4feaab05dc
@ -39,7 +39,9 @@ ams,input-max-microamp: Maximum flash controller input current. The
|
||||
Optional properties of the flash child node
|
||||
===========================================
|
||||
|
||||
label : The label of the flash LED.
|
||||
function : See Documentation/devicetree/bindings/leds/common.txt.
|
||||
color : See Documentation/devicetree/bindings/leds/common.txt.
|
||||
label : See Documentation/devicetree/bindings/leds/common.txt (deprecated).
|
||||
|
||||
|
||||
Required properties of the indicator child node (1)
|
||||
@ -52,28 +54,32 @@ led-max-microamp: Maximum indicator current. The allowed values are
|
||||
Optional properties of the indicator child node
|
||||
===============================================
|
||||
|
||||
label : The label of the indicator LED.
|
||||
function : See Documentation/devicetree/bindings/leds/common.txt.
|
||||
color : See Documentation/devicetree/bindings/leds/common.txt.
|
||||
label : See Documentation/devicetree/bindings/leds/common.txt (deprecated).
|
||||
|
||||
|
||||
Example
|
||||
=======
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
as3645a@30 {
|
||||
#address-cells: 1
|
||||
#size-cells: 0
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
reg = <0x30>;
|
||||
compatible = "ams,as3645a";
|
||||
flash@0 {
|
||||
led@0 {
|
||||
reg = <0x0>;
|
||||
flash-timeout-us = <150000>;
|
||||
flash-max-microamp = <320000>;
|
||||
led-max-microamp = <60000>;
|
||||
ams,input-max-microamp = <1750000>;
|
||||
label = "as3645a:flash";
|
||||
function = LED_FUNCTION_FLASH;
|
||||
};
|
||||
indicator@1 {
|
||||
led@1 {
|
||||
reg = <0x1>;
|
||||
led-max-microamp = <10000>;
|
||||
label = "as3645a:indicator";
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
};
|
||||
};
|
||||
|
||||
@ -10,14 +10,30 @@ can influence the way of the LED device initialization, the LED components
|
||||
have to be tightly coupled with the LED device binding. They are represented
|
||||
by child nodes of the parent LED device binding.
|
||||
|
||||
|
||||
Optional properties for child nodes:
|
||||
- led-sources : List of device current outputs the LED is connected to. The
|
||||
outputs are identified by the numbers that must be defined
|
||||
in the LED device binding documentation.
|
||||
|
||||
- function: LED functon. Use one of the LED_FUNCTION_* prefixed definitions
|
||||
from the header include/dt-bindings/leds/common.h.
|
||||
If there is no matching LED_FUNCTION available, add a new one.
|
||||
|
||||
- color : Color of the LED. Use one of the LED_COLOR_ID_* prefixed definitions
|
||||
from the header include/dt-bindings/leds/common.h.
|
||||
If there is no matching LED_COLOR_ID available, add a new one.
|
||||
|
||||
- function-enumerator: Integer to be used when more than one instance
|
||||
of the same function is needed, differing only with
|
||||
an ordinal number.
|
||||
|
||||
- label : The label for this LED. If omitted, the label is taken from the node
|
||||
name (excluding the unit address). It has to uniquely identify
|
||||
a device, i.e. no other LED class device can be assigned the same
|
||||
label.
|
||||
label. This property is deprecated - use 'function' and 'color'
|
||||
properties instead. function-enumerator has no effect when this
|
||||
property is present.
|
||||
|
||||
- default-state : The initial state of the LED. Valid values are "on", "off",
|
||||
and "keep". If the LED is already on or off and the default-state property is
|
||||
@ -99,29 +115,59 @@ Required properties for trigger source:
|
||||
|
||||
* Examples
|
||||
|
||||
gpio-leds {
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@0 {
|
||||
compatible = "gpio-leds";
|
||||
|
||||
system-status {
|
||||
label = "Status";
|
||||
led0 {
|
||||
function = LED_FUNCTION_STATUS;
|
||||
linux,default-trigger = "heartbeat";
|
||||
gpios = <&gpio0 0 GPIO_ACTIVE_HIGH>;
|
||||
};
|
||||
|
||||
usb {
|
||||
led1 {
|
||||
function = LED_FUNCTION_USB;
|
||||
gpios = <&gpio0 1 GPIO_ACTIVE_HIGH>;
|
||||
trigger-sources = <&ohci_port1>, <&ehci_port1>;
|
||||
};
|
||||
};
|
||||
|
||||
max77693-led {
|
||||
led-controller@0 {
|
||||
compatible = "maxim,max77693-led";
|
||||
|
||||
camera-flash {
|
||||
label = "Flash";
|
||||
led {
|
||||
function = LED_FUNCTION_FLASH;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
led-sources = <0>, <1>;
|
||||
led-max-microamp = <50000>;
|
||||
flash-max-microamp = <320000>;
|
||||
flash-max-timeout-us = <500000>;
|
||||
};
|
||||
};
|
||||
|
||||
led-controller@30 {
|
||||
compatible = "panasonic,an30259a";
|
||||
reg = <0x30>;
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
|
||||
led@1 {
|
||||
reg = <1>;
|
||||
linux,default-trigger = "heartbeat";
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
function-enumerator = <1>;
|
||||
};
|
||||
|
||||
led@2 {
|
||||
reg = <2>;
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
function-enumerator = <2>;
|
||||
};
|
||||
|
||||
led@3 {
|
||||
reg = <3>;
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
function-enumerator = <3>;
|
||||
};
|
||||
};
|
||||
|
||||
@ -32,15 +32,18 @@ Required properties of the LED child node:
|
||||
formula: T = 8.82 * 10^9 * Ct.
|
||||
|
||||
Optional properties of the LED child node:
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- function : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
|
||||
Example (by Ct = 220nF, Rset = 160kohm and exynos4412-trats2 board with
|
||||
a switch that allows for routing strobe signal either from the host or from
|
||||
the camera sensor):
|
||||
|
||||
#include "exynos4412.dtsi"
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
aat1290 {
|
||||
led-controller {
|
||||
compatible = "skyworks,aat1290";
|
||||
flen-gpios = <&gpj1 1 GPIO_ACTIVE_HIGH>;
|
||||
enset-gpios = <&gpj1 2 GPIO_ACTIVE_HIGH>;
|
||||
@ -50,8 +53,9 @@ aat1290 {
|
||||
pinctrl-1 = <&camera_flash_host>;
|
||||
pinctrl-2 = <&camera_flash_isp>;
|
||||
|
||||
camera_flash: flash-led {
|
||||
label = "aat1290-flash";
|
||||
camera_flash: led {
|
||||
function = LED_FUNCTION_FLASH;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
led-max-microamp = <520833>;
|
||||
flash-max-microamp = <1012500>;
|
||||
flash-max-timeout-us = <1940000>;
|
||||
|
||||
@ -15,10 +15,19 @@ Required sub-node properties:
|
||||
- reg: Pin that the LED is connected to. Must be 1, 2, or 3.
|
||||
|
||||
Optional sub-node properties:
|
||||
- label: see Documentation/devicetree/bindings/leds/common.txt
|
||||
- linux,default-trigger: see Documentation/devicetree/bindings/leds/common.txt
|
||||
- function :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label :
|
||||
see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
- linux,default-trigger :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
|
||||
Example:
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@30 {
|
||||
compatible = "panasonic,an30259a";
|
||||
reg = <0x30>;
|
||||
@ -28,16 +37,19 @@ led-controller@30 {
|
||||
led@1 {
|
||||
reg = <1>;
|
||||
linux,default-trigger = "heartbeat";
|
||||
label = "red:indicator";
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
color = <LED_COLOR_ID_RED>;
|
||||
};
|
||||
|
||||
led@2 {
|
||||
reg = <2>;
|
||||
label = "green:indicator";
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
color = <LED_COLOR_ID_GREEN>;
|
||||
};
|
||||
|
||||
led@3 {
|
||||
reg = <3>;
|
||||
label = "blue:indicator";
|
||||
function = LED_FUNCTION_INDICATOR;
|
||||
color = <LED_COLOR_ID_BLUE>;
|
||||
};
|
||||
};
|
||||
|
||||
@ -11,14 +11,20 @@ Property rules described in Documentation/devicetree/bindings/spi/spi-bus.txt
|
||||
apply. In particular, "reg" and "spi-max-frequency" properties must be given.
|
||||
|
||||
LED sub-node properties:
|
||||
- label :
|
||||
- function :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label :
|
||||
see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
- linux,default-trigger : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
|
||||
Example
|
||||
-------
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@0 {
|
||||
compatible = "crane,cr0014114";
|
||||
reg = <0>;
|
||||
@ -28,27 +34,33 @@ led-controller@0 {
|
||||
|
||||
led@0 {
|
||||
reg = <0>;
|
||||
label = "red:coin";
|
||||
function = "coin";
|
||||
color = <LED_COLOR_ID_RED>;
|
||||
};
|
||||
led@1 {
|
||||
reg = <1>;
|
||||
label = "green:coin";
|
||||
function = "coin";
|
||||
color = <LED_COLOR_ID_GREEN>;
|
||||
};
|
||||
led@2 {
|
||||
reg = <2>;
|
||||
label = "blue:coin";
|
||||
function = "coin";
|
||||
color = <LED_COLOR_ID_BLUE>;
|
||||
};
|
||||
led@3 {
|
||||
reg = <3>;
|
||||
label = "red:bill";
|
||||
function = "bill";
|
||||
color = <LED_COLOR_ID_RED>;
|
||||
};
|
||||
led@4 {
|
||||
reg = <4>;
|
||||
label = "green:bill";
|
||||
function = "bill";
|
||||
color = <LED_COLOR_ID_GREEN>;
|
||||
};
|
||||
led@5 {
|
||||
reg = <5>;
|
||||
label = "blue:bill";
|
||||
function = "bill";
|
||||
color = <LED_COLOR_ID_BLUE>;
|
||||
};
|
||||
...
|
||||
};
|
||||
|
||||
@ -10,8 +10,12 @@ LED sub-node properties:
|
||||
- gpios : Should specify the LED's GPIO, see "gpios property" in
|
||||
Documentation/devicetree/bindings/gpio/gpio.txt. Active low LEDs should be
|
||||
indicated using flags in the GPIO specifier.
|
||||
- label : (optional)
|
||||
- function : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
- linux,default-trigger : (optional)
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- default-state: (optional) The initial state of the LED.
|
||||
@ -27,30 +31,34 @@ LED sub-node properties:
|
||||
Examples:
|
||||
|
||||
#include <dt-bindings/gpio/gpio.h>
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
leds {
|
||||
compatible = "gpio-leds";
|
||||
hdd {
|
||||
label = "Disk Activity";
|
||||
led0 {
|
||||
gpios = <&mcu_pio 0 GPIO_ACTIVE_LOW>;
|
||||
linux,default-trigger = "disk-activity";
|
||||
function = LED_FUNCTION_DISK;
|
||||
};
|
||||
|
||||
fault {
|
||||
led1 {
|
||||
gpios = <&mcu_pio 1 GPIO_ACTIVE_HIGH>;
|
||||
/* Keep LED on if BIOS detected hardware fault */
|
||||
default-state = "keep";
|
||||
function = LED_FUNCTION_FAULT;
|
||||
};
|
||||
};
|
||||
|
||||
run-control {
|
||||
compatible = "gpio-leds";
|
||||
red {
|
||||
led0 {
|
||||
gpios = <&mpc8572 6 GPIO_ACTIVE_HIGH>;
|
||||
color = <LED_COLOR_ID_RED>;
|
||||
default-state = "off";
|
||||
};
|
||||
green {
|
||||
led1 {
|
||||
gpios = <&mpc8572 7 GPIO_ACTIVE_HIGH>;
|
||||
color = <LED_COLOR_ID_GREEN>;
|
||||
default-state = "on";
|
||||
};
|
||||
};
|
||||
@ -58,9 +66,10 @@ run-control {
|
||||
leds {
|
||||
compatible = "gpio-leds";
|
||||
|
||||
charger-led {
|
||||
led0 {
|
||||
gpios = <&gpio1 2 GPIO_ACTIVE_HIGH>;
|
||||
linux,default-trigger = "max8903-charger-charging";
|
||||
retain-state-suspended;
|
||||
function = LED_FUNCTION_CHARGE;
|
||||
};
|
||||
};
|
||||
|
||||
@ -62,6 +62,9 @@ Optional LED child properties:
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- linux,default-trigger :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
- led-max-microamp : Defines the full scale current value for each control
|
||||
bank. The range is from 5000uA-29800uA in increments
|
||||
of 800uA.
|
||||
|
||||
Example:
|
||||
led-controller@38 {
|
||||
@ -85,6 +88,7 @@ led-controller@38 {
|
||||
reg = <0>;
|
||||
led-sources = <2>;
|
||||
ti,led-mode = <1>;
|
||||
led-max-microamp = <21800>;
|
||||
label = ":backlight";
|
||||
linux,default-trigger = "backlight";
|
||||
};
|
||||
|
||||
@ -22,9 +22,14 @@ Required properties for flash LED child nodes:
|
||||
- led-max-microamp : Range from 2.4mA - 376mA
|
||||
|
||||
Optional child properties:
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- function : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
|
||||
Example:
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@64 {
|
||||
compatible = "ti,lm36010";
|
||||
#address-cells = <1>;
|
||||
@ -33,7 +38,8 @@ led-controller@64 {
|
||||
|
||||
led@0 {
|
||||
reg = <1>;
|
||||
label = "white:torch";
|
||||
function = LED_FUNCTION_TORCH;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
led-max-microamp = <376000>;
|
||||
flash-max-microamp = <1500000>;
|
||||
flash-max-timeout-us = <1600000>;
|
||||
|
||||
@ -26,12 +26,16 @@ Required child properties:
|
||||
3 - Will enable the LED3 sync (LM36923 only)
|
||||
|
||||
Optional child properties:
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- function : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
- linux,default-trigger :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
|
||||
Example:
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@36 {
|
||||
compatible = "ti,lm3692x";
|
||||
reg = <0x36>;
|
||||
@ -43,7 +47,8 @@ led-controller@36 {
|
||||
|
||||
led@0 {
|
||||
reg = <0>;
|
||||
label = "white:backlight_cluster";
|
||||
function = LED_FUNCTION_BACKLIGHT;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
linux,default-trigger = "backlight";
|
||||
};
|
||||
}
|
||||
|
||||
@ -20,12 +20,16 @@ Required child properties:
|
||||
- reg : 0
|
||||
|
||||
Optional child properties:
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- function : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- color : see Documentation/devicetree/bindings/leds/common.txt
|
||||
- label : see Documentation/devicetree/bindings/leds/common.txt (deprecated)
|
||||
- linux,default-trigger :
|
||||
see Documentation/devicetree/bindings/leds/common.txt
|
||||
|
||||
Example:
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller@2d {
|
||||
compatible = "ti,lp8860";
|
||||
#address-cells = <1>;
|
||||
@ -36,7 +40,8 @@ led-controller@2d {
|
||||
|
||||
led@0 {
|
||||
reg = <0>;
|
||||
label = "white:backlight";
|
||||
function = LED_FUNCTION_BACKLIGHT;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
linux,default-trigger = "backlight";
|
||||
};
|
||||
}
|
||||
|
||||
@ -9,8 +9,10 @@ The hardware supports only one LED. The properties of this LED are
|
||||
configured in a sub-node in the device node.
|
||||
|
||||
Optional sub-node properties:
|
||||
- function: See Documentation/devicetree/bindings/leds/common.txt
|
||||
- color: See Documentation/devicetree/bindings/leds/common.txt
|
||||
- label: A label for the LED. If none is given, the LED will be
|
||||
named "lt3595::".
|
||||
named "lt3595::" (deprecated)
|
||||
- linux,default-trigger: The default trigger for the LED.
|
||||
See Documentation/devicetree/bindings/leds/common.txt
|
||||
- default-state: The initial state of the LED.
|
||||
@ -21,12 +23,15 @@ be handled by its own device node.
|
||||
|
||||
Example:
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
led-controller {
|
||||
compatible = "lltc,lt3593";
|
||||
lltc,ctrl-gpios = <&gpio 0 GPIO_ACTIVE_HIGH>;
|
||||
|
||||
led {
|
||||
label = "white:backlight";
|
||||
function = LED_FUNCTION_BACKLIGHT;
|
||||
color = <LED_COLOR_ID_WHITE>;
|
||||
default-state = "on";
|
||||
};
|
||||
};
|
||||
|
||||
@ -14,7 +14,9 @@ Required child properties:
|
||||
- reg: Port this LED is connected to.
|
||||
|
||||
Optional child properties:
|
||||
- label: See Documentation/devicetree/bindings/leds/common.txt.
|
||||
- function: See Documentation/devicetree/bindings/leds/common.txt.
|
||||
- color: See Documentation/devicetree/bindings/leds/common.txt.
|
||||
- label: See Documentation/devicetree/bindings/leds/common.txt (deprecated).
|
||||
|
||||
Examples:
|
||||
|
||||
@ -25,17 +27,17 @@ led-controller@200 {
|
||||
reg = <0x200>;
|
||||
|
||||
led@0 {
|
||||
label = "red";
|
||||
color = <LED_COLOR_ID_RED>;
|
||||
reg = <0x0>;
|
||||
};
|
||||
|
||||
led@1 {
|
||||
label = "green";
|
||||
color = <LED_COLOR_ID_GREEN>;
|
||||
reg = <0x1>;
|
||||
};
|
||||
|
||||
led@2 {
|
||||
label = "blue";
|
||||
color = <LED_COLOR_ID_BLUE>;
|
||||
reg = <0x2>;
|
||||
};
|
||||
};
|
||||
|
||||
@ -43,9 +43,73 @@ LED Device Naming
|
||||
|
||||
Is currently of the form:
|
||||
|
||||
"devicename:colour:function"
|
||||
"devicename:color:function"
|
||||
|
||||
There have been calls for LED properties such as colour to be exported as
|
||||
- devicename:
|
||||
it should refer to a unique identifier created by the kernel,
|
||||
like e.g. phyN for network devices or inputN for input devices, rather
|
||||
than to the hardware; the information related to the product and the bus
|
||||
to which given device is hooked is available in sysfs and can be
|
||||
retrieved using get_led_device_info.sh script from tools/leds; generally
|
||||
this section is expected mostly for LEDs that are somehow associated with
|
||||
other devices.
|
||||
|
||||
- color:
|
||||
one of LED_COLOR_ID_* definitions from the header
|
||||
include/dt-bindings/leds/common.h.
|
||||
|
||||
- function:
|
||||
one of LED_FUNCTION_* definitions from the header
|
||||
include/dt-bindings/leds/common.h.
|
||||
|
||||
If required color or function is missing, please submit a patch
|
||||
to linux-leds@vger.kernel.org.
|
||||
|
||||
It is possible that more than one LED with the same color and function will
|
||||
be required for given platform, differing only with an ordinal number.
|
||||
In this case it is preferable to just concatenate the predefined LED_FUNCTION_*
|
||||
name with required "-N" suffix in the driver. fwnode based drivers can use
|
||||
function-enumerator property for that and then the concatenation will be handled
|
||||
automatically by the LED core upon LED class device registration.
|
||||
|
||||
LED subsystem has also a protection against name clash, that may occur
|
||||
when LED class device is created by a driver of hot-pluggable device and
|
||||
it doesn't provide unique devicename section. In this case numerical
|
||||
suffix (e.g. "_1", "_2", "_3" etc.) is added to the requested LED class
|
||||
device name.
|
||||
|
||||
There might be still LED class drivers around using vendor or product name
|
||||
for devicename, but this approach is now deprecated as it doesn't convey
|
||||
any added value. Product information can be found in other places in sysfs
|
||||
(see tools/leds/get_led_device_info.sh).
|
||||
|
||||
Examples of proper LED names:
|
||||
|
||||
- "red:disk"
|
||||
- "white:flash"
|
||||
- "red:indicator"
|
||||
- "phy1:green:wlan"
|
||||
- "phy3::wlan"
|
||||
- ":kbd_backlight"
|
||||
- "input5::kbd_backlight"
|
||||
- "input3::numlock"
|
||||
- "input3::scrolllock"
|
||||
- "input3::capslock"
|
||||
- "mmc1::status"
|
||||
- "white:status"
|
||||
|
||||
get_led_device_info.sh script can be used for verifying if the LED name
|
||||
meets the requirements pointed out here. It performs validation of the LED class
|
||||
devicename sections and gives hints on expected value for a section in case
|
||||
the validation fails for it. So far the script supports validation
|
||||
of associations between LEDs and following types of devices:
|
||||
|
||||
- input devices
|
||||
- ieee80211 compliant USB devices
|
||||
|
||||
The script is open to extensions.
|
||||
|
||||
There have been calls for LED properties such as color to be exported as
|
||||
individual led class attributes. As a solution which doesn't incur as much
|
||||
overhead, I suggest these become part of the device name. The naming scheme
|
||||
above leaves scope for further attributes should they be needed. If sections
|
||||
|
||||
@ -134,22 +134,13 @@ static inline void gizmo_writel(struct tegra_ahb *ahb, u32 value, u32 offset)
|
||||
}
|
||||
|
||||
#ifdef CONFIG_TEGRA_IOMMU_SMMU
|
||||
static int tegra_ahb_match_by_smmu(struct device *dev, const void *data)
|
||||
{
|
||||
struct tegra_ahb *ahb = dev_get_drvdata(dev);
|
||||
const struct device_node *dn = data;
|
||||
|
||||
return (ahb->dev->of_node == dn) ? 1 : 0;
|
||||
}
|
||||
|
||||
int tegra_ahb_enable_smmu(struct device_node *dn)
|
||||
{
|
||||
struct device *dev;
|
||||
u32 val;
|
||||
struct tegra_ahb *ahb;
|
||||
|
||||
dev = driver_find_device(&tegra_ahb_driver.driver, NULL, dn,
|
||||
tegra_ahb_match_by_smmu);
|
||||
dev = driver_find_device_by_of_node(&tegra_ahb_driver.driver, dn);
|
||||
if (!dev)
|
||||
return -EPROBE_DEFER;
|
||||
ahb = dev_get_drvdata(dev);
|
||||
|
||||
@ -342,30 +342,6 @@ struct device *bus_find_device(struct bus_type *bus,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bus_find_device);
|
||||
|
||||
static int match_name(struct device *dev, const void *data)
|
||||
{
|
||||
const char *name = data;
|
||||
|
||||
return sysfs_streq(name, dev_name(dev));
|
||||
}
|
||||
|
||||
/**
|
||||
* bus_find_device_by_name - device iterator for locating a particular device of a specific name
|
||||
* @bus: bus type
|
||||
* @start: Device to begin with
|
||||
* @name: name of the device to match
|
||||
*
|
||||
* This is similar to the bus_find_device() function above, but it handles
|
||||
* searching by a name automatically, no need to write another strcmp matching
|
||||
* function.
|
||||
*/
|
||||
struct device *bus_find_device_by_name(struct bus_type *bus,
|
||||
struct device *start, const char *name)
|
||||
{
|
||||
return bus_find_device(bus, start, (void *)name, match_name);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(bus_find_device_by_name);
|
||||
|
||||
/**
|
||||
* subsys_find_device_by_id - find a device with a specific enumeration number
|
||||
* @subsys: subsystem
|
||||
|
||||
@ -2944,13 +2944,6 @@ struct device *device_create_with_groups(struct class *class,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_create_with_groups);
|
||||
|
||||
static int __match_devt(struct device *dev, const void *data)
|
||||
{
|
||||
const dev_t *devt = data;
|
||||
|
||||
return dev->devt == *devt;
|
||||
}
|
||||
|
||||
/**
|
||||
* device_destroy - removes a device that was created with device_create()
|
||||
* @class: pointer to the struct class that this device was registered with
|
||||
@ -2963,7 +2956,7 @@ void device_destroy(struct class *class, dev_t devt)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(class, NULL, &devt, __match_devt);
|
||||
dev = class_find_device_by_devt(class, devt);
|
||||
if (dev) {
|
||||
put_device(dev);
|
||||
device_unregister(dev);
|
||||
@ -3434,8 +3427,38 @@ void device_set_of_node_from_dev(struct device *dev, const struct device *dev2)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_set_of_node_from_dev);
|
||||
|
||||
int device_match_name(struct device *dev, const void *name)
|
||||
{
|
||||
return sysfs_streq(dev_name(dev), name);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_match_name);
|
||||
|
||||
int device_match_of_node(struct device *dev, const void *np)
|
||||
{
|
||||
return dev->of_node == np;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_match_of_node);
|
||||
|
||||
int device_match_fwnode(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev_fwnode(dev) == fwnode;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_match_fwnode);
|
||||
|
||||
int device_match_devt(struct device *dev, const void *pdevt)
|
||||
{
|
||||
return dev->devt == *(dev_t *)pdevt;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_match_devt);
|
||||
|
||||
int device_match_acpi_dev(struct device *dev, const void *adev)
|
||||
{
|
||||
return ACPI_COMPANION(dev) == adev;
|
||||
}
|
||||
EXPORT_SYMBOL(device_match_acpi_dev);
|
||||
|
||||
int device_match_any(struct device *dev, const void *unused)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(device_match_any);
|
||||
|
||||
@ -133,19 +133,13 @@ static struct bus_type *generic_match_buses[] = {
|
||||
NULL,
|
||||
};
|
||||
|
||||
static int device_fwnode_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev_fwnode(dev) == fwnode;
|
||||
}
|
||||
|
||||
static void *device_connection_fwnode_match(struct device_connection *con)
|
||||
{
|
||||
struct bus_type *bus;
|
||||
struct device *dev;
|
||||
|
||||
for (bus = generic_match_buses[0]; bus; bus++) {
|
||||
dev = bus_find_device(bus, NULL, (void *)con->fwnode,
|
||||
device_fwnode_match);
|
||||
dev = bus_find_device_by_fwnode(bus, con->fwnode);
|
||||
if (dev && !strncmp(dev_name(dev), con->id, strlen(con->id)))
|
||||
return dev;
|
||||
|
||||
|
||||
@ -1202,6 +1202,20 @@ struct bus_type platform_bus_type = {
|
||||
};
|
||||
EXPORT_SYMBOL_GPL(platform_bus_type);
|
||||
|
||||
/**
|
||||
* platform_find_device_by_driver - Find a platform device with a given
|
||||
* driver.
|
||||
* @start: The device to start the search from.
|
||||
* @drv: The device driver to look for.
|
||||
*/
|
||||
struct device *platform_find_device_by_driver(struct device *start,
|
||||
const struct device_driver *drv)
|
||||
{
|
||||
return bus_find_device(&platform_bus_type, start, drv,
|
||||
(void *)platform_match);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(platform_find_device_by_driver);
|
||||
|
||||
int __init platform_bus_init(void)
|
||||
{
|
||||
int error;
|
||||
|
||||
@ -19,11 +19,6 @@ static struct class *fpga_bridge_class;
|
||||
/* Lock for adding/removing bridges to linked lists*/
|
||||
static spinlock_t bridge_list_lock;
|
||||
|
||||
static int fpga_bridge_of_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/**
|
||||
* fpga_bridge_enable - Enable transactions on the bridge
|
||||
*
|
||||
@ -104,8 +99,7 @@ struct fpga_bridge *of_fpga_bridge_get(struct device_node *np,
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(fpga_bridge_class, NULL, np,
|
||||
fpga_bridge_of_node_match);
|
||||
dev = class_find_device_by_of_node(fpga_bridge_class, np);
|
||||
if (!dev)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
|
||||
@ -482,11 +482,6 @@ struct fpga_manager *fpga_mgr_get(struct device *dev)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(fpga_mgr_get);
|
||||
|
||||
static int fpga_mgr_of_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/**
|
||||
* of_fpga_mgr_get - Given a device node, get a reference to a fpga mgr.
|
||||
*
|
||||
@ -498,8 +493,7 @@ struct fpga_manager *of_fpga_mgr_get(struct device_node *node)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(fpga_mgr_class, NULL, node,
|
||||
fpga_mgr_of_node_match);
|
||||
dev = class_find_device_by_of_node(fpga_mgr_class, node);
|
||||
if (!dev)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
|
||||
@ -93,11 +93,6 @@ static struct bus_type mipi_dsi_bus_type = {
|
||||
.pm = &mipi_dsi_device_pm_ops,
|
||||
};
|
||||
|
||||
static int of_device_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/**
|
||||
* of_find_mipi_dsi_device_by_node() - find the MIPI DSI device matching a
|
||||
* device tree node
|
||||
@ -110,7 +105,7 @@ struct mipi_dsi_device *of_find_mipi_dsi_device_by_node(struct device_node *np)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&mipi_dsi_bus_type, NULL, np, of_device_match);
|
||||
dev = bus_find_device_by_of_node(&mipi_dsi_bus_type, np);
|
||||
|
||||
return dev ? to_mipi_dsi_device(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -242,9 +242,7 @@ static struct component_match *exynos_drm_match_add(struct device *dev)
|
||||
if (!info->driver || !(info->flags & DRM_COMPONENT_DRIVER))
|
||||
continue;
|
||||
|
||||
while ((d = bus_find_device(&platform_bus_type, p,
|
||||
&info->driver->driver,
|
||||
(void *)platform_bus_type.match))) {
|
||||
while ((d = platform_find_device_by_driver(p, &info->driver->driver))) {
|
||||
put_device(p);
|
||||
|
||||
if (!(info->flags & DRM_FIMC_DEVICE) ||
|
||||
@ -412,9 +410,8 @@ static void exynos_drm_unregister_devices(void)
|
||||
if (!info->driver || !(info->flags & DRM_VIRTUAL_DEVICE))
|
||||
continue;
|
||||
|
||||
while ((dev = bus_find_device(&platform_bus_type, NULL,
|
||||
&info->driver->driver,
|
||||
(void *)platform_bus_type.match))) {
|
||||
while ((dev = platform_find_device_by_driver(NULL,
|
||||
&info->driver->driver))) {
|
||||
put_device(dev);
|
||||
platform_device_unregister(to_platform_device(dev));
|
||||
}
|
||||
|
||||
@ -477,8 +477,7 @@ static int mcde_probe(struct platform_device *pdev)
|
||||
struct device_driver *drv = &mcde_component_drivers[i]->driver;
|
||||
struct device *p = NULL, *d;
|
||||
|
||||
while ((d = bus_find_device(&platform_bus_type, p, drv,
|
||||
(void *)platform_bus_type.match))) {
|
||||
while ((d = platform_find_device_by_driver(p, drv))) {
|
||||
put_device(p);
|
||||
component_match_add(dev, &match, mcde_compare_dev, d);
|
||||
p = d;
|
||||
|
||||
@ -330,8 +330,7 @@ static struct component_match *rockchip_drm_match_add(struct device *dev)
|
||||
struct device *p = NULL, *d;
|
||||
|
||||
do {
|
||||
d = bus_find_device(&platform_bus_type, p, &drv->driver,
|
||||
(void *)platform_bus_type.match);
|
||||
d = platform_find_device_by_driver(p, &drv->driver);
|
||||
put_device(p);
|
||||
p = d;
|
||||
|
||||
|
||||
@ -237,8 +237,7 @@ static void vc4_match_add_drivers(struct device *dev,
|
||||
struct device_driver *drv = &drivers[i]->driver;
|
||||
struct device *p = NULL, *d;
|
||||
|
||||
while ((d = bus_find_device(&platform_bus_type, p, drv,
|
||||
(void *)platform_bus_type.match))) {
|
||||
while ((d = platform_find_device_by_driver(p, drv))) {
|
||||
put_device(p);
|
||||
component_match_add(dev, match, compare_dev, d);
|
||||
p = d;
|
||||
|
||||
@ -37,11 +37,6 @@ static int coresight_alloc_conns(struct device *dev,
|
||||
return 0;
|
||||
}
|
||||
|
||||
int coresight_device_fwnode_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev_fwnode(dev) == fwnode;
|
||||
}
|
||||
|
||||
static struct device *
|
||||
coresight_find_device_by_fwnode(struct fwnode_handle *fwnode)
|
||||
{
|
||||
@ -51,8 +46,7 @@ coresight_find_device_by_fwnode(struct fwnode_handle *fwnode)
|
||||
* If we have a non-configurable replicator, it will be found on the
|
||||
* platform bus.
|
||||
*/
|
||||
dev = bus_find_device(&platform_bus_type, NULL,
|
||||
fwnode, coresight_device_fwnode_match);
|
||||
dev = bus_find_device_by_fwnode(&platform_bus_type, fwnode);
|
||||
if (dev)
|
||||
return dev;
|
||||
|
||||
@ -60,8 +54,7 @@ coresight_find_device_by_fwnode(struct fwnode_handle *fwnode)
|
||||
* We have a configurable component - circle through the AMBA bus
|
||||
* looking for the device that matches the endpoint node.
|
||||
*/
|
||||
return bus_find_device(&amba_bustype, NULL,
|
||||
fwnode, coresight_device_fwnode_match);
|
||||
return bus_find_device_by_fwnode(&amba_bustype, fwnode);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OF
|
||||
|
||||
@ -202,6 +202,4 @@ static inline void *coresight_get_uci_data(const struct amba_id *id)
|
||||
|
||||
void coresight_release_platform_data(struct coresight_platform_data *pdata);
|
||||
|
||||
int coresight_device_fwnode_match(struct device *dev, const void *fwnode);
|
||||
|
||||
#endif
|
||||
|
||||
@ -1046,9 +1046,7 @@ static void coresight_fixup_device_conns(struct coresight_device *csdev)
|
||||
struct coresight_connection *conn = &csdev->pdata->conns[i];
|
||||
struct device *dev = NULL;
|
||||
|
||||
dev = bus_find_device(&coresight_bustype, NULL,
|
||||
(void *)conn->child_fwnode,
|
||||
coresight_device_fwnode_match);
|
||||
dev = bus_find_device_by_fwnode(&coresight_bustype, conn->child_fwnode);
|
||||
if (dev) {
|
||||
conn->child_dev = to_coresight_device(dev);
|
||||
/* and put reference from 'bus_find_device()' */
|
||||
|
||||
@ -789,12 +789,6 @@ static int intel_th_populate(struct intel_th *th)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int match_devt(struct device *dev, const void *data)
|
||||
{
|
||||
dev_t devt = (dev_t)(unsigned long)(void *)data;
|
||||
return dev->devt == devt;
|
||||
}
|
||||
|
||||
static int intel_th_output_open(struct inode *inode, struct file *file)
|
||||
{
|
||||
const struct file_operations *fops;
|
||||
@ -802,9 +796,7 @@ static int intel_th_output_open(struct inode *inode, struct file *file)
|
||||
struct device *dev;
|
||||
int err;
|
||||
|
||||
dev = bus_find_device(&intel_th_bus, NULL,
|
||||
(void *)(unsigned long)inode->i_rdev,
|
||||
match_devt);
|
||||
dev = bus_find_device_by_devt(&intel_th_bus, inode->i_rdev);
|
||||
if (!dev || !dev->driver)
|
||||
return -ENODEV;
|
||||
|
||||
|
||||
@ -89,13 +89,6 @@ static struct class stm_class = {
|
||||
.dev_groups = stm_groups,
|
||||
};
|
||||
|
||||
static int stm_dev_match(struct device *dev, const void *data)
|
||||
{
|
||||
const char *name = data;
|
||||
|
||||
return sysfs_streq(name, dev_name(dev));
|
||||
}
|
||||
|
||||
/**
|
||||
* stm_find_device() - find stm device by name
|
||||
* @buf: character buffer containing the name
|
||||
@ -116,7 +109,7 @@ struct stm_device *stm_find_device(const char *buf)
|
||||
if (!stm_core_up)
|
||||
return NULL;
|
||||
|
||||
dev = class_find_device(&stm_class, NULL, buf, stm_dev_match);
|
||||
dev = class_find_device_by_name(&stm_class, buf);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
|
||||
@ -457,18 +457,12 @@ static struct pci_driver amd_mp2_pci_driver = {
|
||||
};
|
||||
module_pci_driver(amd_mp2_pci_driver);
|
||||
|
||||
static int amd_mp2_device_match(struct device *dev, const void *data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct amd_mp2_dev *amd_mp2_find_device(void)
|
||||
{
|
||||
struct device *dev;
|
||||
struct pci_dev *pci_dev;
|
||||
|
||||
dev = driver_find_device(&amd_mp2_pci_driver.driver, NULL, NULL,
|
||||
amd_mp2_device_match);
|
||||
dev = driver_find_next_device(&amd_mp2_pci_driver.driver, NULL);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
|
||||
@ -344,27 +344,10 @@ u32 i2c_acpi_find_bus_speed(struct device *dev)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(i2c_acpi_find_bus_speed);
|
||||
|
||||
static int i2c_acpi_find_match_adapter(struct device *dev, const void *data)
|
||||
{
|
||||
struct i2c_adapter *adapter = i2c_verify_adapter(dev);
|
||||
|
||||
if (!adapter)
|
||||
return 0;
|
||||
|
||||
return ACPI_HANDLE(dev) == (acpi_handle)data;
|
||||
}
|
||||
|
||||
static int i2c_acpi_find_match_device(struct device *dev, const void *data)
|
||||
{
|
||||
return ACPI_COMPANION(dev) == data;
|
||||
}
|
||||
|
||||
struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle)
|
||||
{
|
||||
struct device *dev;
|
||||
struct device *dev = bus_find_device_by_acpi_dev(&i2c_bus_type, handle);
|
||||
|
||||
dev = bus_find_device(&i2c_bus_type, NULL, handle,
|
||||
i2c_acpi_find_match_adapter);
|
||||
return dev ? i2c_verify_adapter(dev) : NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(i2c_acpi_find_adapter_by_handle);
|
||||
@ -373,8 +356,7 @@ static struct i2c_client *i2c_acpi_find_client_by_adev(struct acpi_device *adev)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&i2c_bus_type, NULL, adev,
|
||||
i2c_acpi_find_match_device);
|
||||
dev = bus_find_device_by_acpi_dev(&i2c_bus_type, adev);
|
||||
return dev ? i2c_verify_client(dev) : NULL;
|
||||
}
|
||||
|
||||
|
||||
@ -113,11 +113,6 @@ void of_i2c_register_devices(struct i2c_adapter *adap)
|
||||
of_node_put(bus);
|
||||
}
|
||||
|
||||
static int of_dev_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
static int of_dev_or_parent_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
if (dev->of_node == data)
|
||||
@ -135,7 +130,7 @@ struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
|
||||
struct device *dev;
|
||||
struct i2c_client *client;
|
||||
|
||||
dev = bus_find_device(&i2c_bus_type, NULL, node, of_dev_node_match);
|
||||
dev = bus_find_device_by_of_node(&i2c_bus_type, node);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
|
||||
@ -4501,19 +4501,13 @@ static const struct acpi_device_id hns_roce_acpi_match[] = {
|
||||
};
|
||||
MODULE_DEVICE_TABLE(acpi, hns_roce_acpi_match);
|
||||
|
||||
static int hns_roce_node_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev->fwnode == fwnode;
|
||||
}
|
||||
|
||||
static struct
|
||||
platform_device *hns_roce_find_pdev(struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
/* get the 'device' corresponding to the matching 'fwnode' */
|
||||
dev = bus_find_device(&platform_bus_type, NULL,
|
||||
fwnode, hns_roce_node_match);
|
||||
dev = bus_find_device_by_fwnode(&platform_bus_type, fwnode);
|
||||
/* get the platform device */
|
||||
return dev ? to_platform_device(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -2503,16 +2503,11 @@ arm_smmu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
|
||||
|
||||
static struct platform_driver arm_smmu_driver;
|
||||
|
||||
static int arm_smmu_match_node(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->fwnode == data;
|
||||
}
|
||||
|
||||
static
|
||||
struct arm_smmu_device *arm_smmu_get_by_fwnode(struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct device *dev = driver_find_device(&arm_smmu_driver.driver, NULL,
|
||||
fwnode, arm_smmu_match_node);
|
||||
struct device *dev = driver_find_device_by_fwnode(&arm_smmu_driver.driver,
|
||||
fwnode);
|
||||
put_device(dev);
|
||||
return dev ? dev_get_drvdata(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -1299,16 +1299,11 @@ static bool arm_smmu_capable(enum iommu_cap cap)
|
||||
}
|
||||
}
|
||||
|
||||
static int arm_smmu_match_node(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->fwnode == data;
|
||||
}
|
||||
|
||||
static
|
||||
struct arm_smmu_device *arm_smmu_get_by_fwnode(struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct device *dev = driver_find_device(&arm_smmu_driver.driver, NULL,
|
||||
fwnode, arm_smmu_match_node);
|
||||
struct device *dev = driver_find_device_by_fwnode(&arm_smmu_driver.driver,
|
||||
fwnode);
|
||||
put_device(dev);
|
||||
return dev ? dev_get_drvdata(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -74,9 +74,12 @@ config LEDS_APU
|
||||
depends on LEDS_CLASS
|
||||
depends on X86 && DMI
|
||||
help
|
||||
This driver makes the PC Engines APU/APU2/APU3 front panel LEDs
|
||||
This driver makes the PC Engines APU1 front panel LEDs
|
||||
accessible from userspace programs through the LED subsystem.
|
||||
|
||||
If you're looking for APU2/3, use the pcengines-apu2 driver.
|
||||
(symbol CONFIG_PCENGINES_APU2)
|
||||
|
||||
To compile this driver as a module, choose M here: the
|
||||
module will be called leds-apu.
|
||||
|
||||
@ -587,6 +590,7 @@ config LEDS_NETXBIG
|
||||
tristate "LED support for Big Network series LEDs"
|
||||
depends on LEDS_CLASS
|
||||
depends on MACH_KIRKWOOD
|
||||
depends on OF_GPIO
|
||||
default y
|
||||
help
|
||||
This option enables support for LEDs found on the LaCie 2Big
|
||||
|
||||
@ -282,8 +282,9 @@ static void led_flash_init_sysfs_groups(struct led_classdev_flash *fled_cdev)
|
||||
led_cdev->groups = flash_groups;
|
||||
}
|
||||
|
||||
int led_classdev_flash_register(struct device *parent,
|
||||
struct led_classdev_flash *fled_cdev)
|
||||
int led_classdev_flash_register_ext(struct device *parent,
|
||||
struct led_classdev_flash *fled_cdev,
|
||||
struct led_init_data *init_data)
|
||||
{
|
||||
struct led_classdev *led_cdev;
|
||||
const struct led_flash_ops *ops;
|
||||
@ -309,13 +310,13 @@ int led_classdev_flash_register(struct device *parent,
|
||||
}
|
||||
|
||||
/* Register led class device */
|
||||
ret = led_classdev_register(parent, led_cdev);
|
||||
ret = led_classdev_register_ext(parent, led_cdev, init_data);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(led_classdev_flash_register);
|
||||
EXPORT_SYMBOL_GPL(led_classdev_flash_register_ext);
|
||||
|
||||
void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev)
|
||||
{
|
||||
|
||||
@ -14,6 +14,7 @@
|
||||
#include <linux/leds.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/property.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/timer.h>
|
||||
@ -213,13 +214,6 @@ static int led_resume(struct device *dev)
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(leds_class_dev_pm_ops, led_suspend, led_resume);
|
||||
|
||||
static int match_name(struct device *dev, const void *data)
|
||||
{
|
||||
if (!dev_name(dev))
|
||||
return 0;
|
||||
return !strcmp(dev_name(dev), (char *)data);
|
||||
}
|
||||
|
||||
static int led_classdev_next_name(const char *init_name, char *name,
|
||||
size_t len)
|
||||
{
|
||||
@ -230,7 +224,7 @@ static int led_classdev_next_name(const char *init_name, char *name,
|
||||
strlcpy(name, init_name, len);
|
||||
|
||||
while ((ret < len) &&
|
||||
(dev = class_find_device(leds_class, NULL, name, match_name))) {
|
||||
(dev = class_find_device_by_name(leds_class, name))) {
|
||||
put_device(dev);
|
||||
ret = snprintf(name, len, "%s_%u", init_name, ++i);
|
||||
}
|
||||
@ -242,31 +236,48 @@ static int led_classdev_next_name(const char *init_name, char *name,
|
||||
}
|
||||
|
||||
/**
|
||||
* of_led_classdev_register - register a new object of led_classdev class.
|
||||
* led_classdev_register_ext - register a new object of led_classdev class
|
||||
* with init data.
|
||||
*
|
||||
* @parent: parent of LED device
|
||||
* @led_cdev: the led_classdev structure for this device.
|
||||
* @np: DT node describing this LED
|
||||
* @init_data: LED class device initialization data
|
||||
*/
|
||||
int of_led_classdev_register(struct device *parent, struct device_node *np,
|
||||
struct led_classdev *led_cdev)
|
||||
int led_classdev_register_ext(struct device *parent,
|
||||
struct led_classdev *led_cdev,
|
||||
struct led_init_data *init_data)
|
||||
{
|
||||
char name[LED_MAX_NAME_SIZE];
|
||||
char composed_name[LED_MAX_NAME_SIZE];
|
||||
char final_name[LED_MAX_NAME_SIZE];
|
||||
const char *proposed_name = composed_name;
|
||||
int ret;
|
||||
|
||||
ret = led_classdev_next_name(led_cdev->name, name, sizeof(name));
|
||||
if (init_data) {
|
||||
if (init_data->devname_mandatory && !init_data->devicename) {
|
||||
dev_err(parent, "Mandatory device name is missing");
|
||||
return -EINVAL;
|
||||
}
|
||||
ret = led_compose_name(parent, init_data, composed_name);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
} else {
|
||||
proposed_name = led_cdev->name;
|
||||
}
|
||||
|
||||
ret = led_classdev_next_name(proposed_name, final_name, sizeof(final_name));
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
mutex_init(&led_cdev->led_access);
|
||||
mutex_lock(&led_cdev->led_access);
|
||||
led_cdev->dev = device_create_with_groups(leds_class, parent, 0,
|
||||
led_cdev, led_cdev->groups, "%s", name);
|
||||
led_cdev, led_cdev->groups, "%s", final_name);
|
||||
if (IS_ERR(led_cdev->dev)) {
|
||||
mutex_unlock(&led_cdev->led_access);
|
||||
return PTR_ERR(led_cdev->dev);
|
||||
}
|
||||
led_cdev->dev->of_node = np;
|
||||
if (init_data && init_data->fwnode)
|
||||
led_cdev->dev->fwnode = init_data->fwnode;
|
||||
|
||||
if (ret)
|
||||
dev_warn(parent, "Led %s renamed to %s due to name collision",
|
||||
@ -276,6 +287,7 @@ int of_led_classdev_register(struct device *parent, struct device_node *np,
|
||||
ret = led_add_brightness_hw_changed(led_cdev);
|
||||
if (ret) {
|
||||
device_unregister(led_cdev->dev);
|
||||
led_cdev->dev = NULL;
|
||||
mutex_unlock(&led_cdev->led_access);
|
||||
return ret;
|
||||
}
|
||||
@ -311,7 +323,7 @@ int of_led_classdev_register(struct device *parent, struct device_node *np,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_led_classdev_register);
|
||||
EXPORT_SYMBOL_GPL(led_classdev_register_ext);
|
||||
|
||||
/**
|
||||
* led_classdev_unregister - unregisters a object of led_properties class.
|
||||
@ -321,6 +333,9 @@ EXPORT_SYMBOL_GPL(of_led_classdev_register);
|
||||
*/
|
||||
void led_classdev_unregister(struct led_classdev *led_cdev)
|
||||
{
|
||||
if (IS_ERR_OR_NULL(led_cdev->dev))
|
||||
return;
|
||||
|
||||
#ifdef CONFIG_LEDS_TRIGGERS
|
||||
down_write(&led_cdev->trigger_lock);
|
||||
if (led_cdev->trigger)
|
||||
@ -356,14 +371,15 @@ static void devm_led_classdev_release(struct device *dev, void *res)
|
||||
}
|
||||
|
||||
/**
|
||||
* devm_of_led_classdev_register - resource managed led_classdev_register()
|
||||
* devm_led_classdev_register_ext - resource managed led_classdev_register_ext()
|
||||
*
|
||||
* @parent: parent of LED device
|
||||
* @led_cdev: the led_classdev structure for this device.
|
||||
* @init_data: LED class device initialization data
|
||||
*/
|
||||
int devm_of_led_classdev_register(struct device *parent,
|
||||
struct device_node *np,
|
||||
struct led_classdev *led_cdev)
|
||||
int devm_led_classdev_register_ext(struct device *parent,
|
||||
struct led_classdev *led_cdev,
|
||||
struct led_init_data *init_data)
|
||||
{
|
||||
struct led_classdev **dr;
|
||||
int rc;
|
||||
@ -372,7 +388,7 @@ int devm_of_led_classdev_register(struct device *parent,
|
||||
if (!dr)
|
||||
return -ENOMEM;
|
||||
|
||||
rc = of_led_classdev_register(parent, np, led_cdev);
|
||||
rc = led_classdev_register_ext(parent, led_cdev, init_data);
|
||||
if (rc) {
|
||||
devres_free(dr);
|
||||
return rc;
|
||||
@ -383,7 +399,7 @@ int devm_of_led_classdev_register(struct device *parent,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(devm_of_led_classdev_register);
|
||||
EXPORT_SYMBOL_GPL(devm_led_classdev_register_ext);
|
||||
|
||||
static int devm_led_classdev_match(struct device *dev, void *res, void *data)
|
||||
{
|
||||
|
||||
@ -13,8 +13,10 @@
|
||||
#include <linux/module.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/property.h>
|
||||
#include <linux/rwsem.h>
|
||||
#include <linux/slab.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
#include "leds.h"
|
||||
|
||||
DECLARE_RWSEM(leds_list_lock);
|
||||
@ -23,6 +25,18 @@ EXPORT_SYMBOL_GPL(leds_list_lock);
|
||||
LIST_HEAD(leds_list);
|
||||
EXPORT_SYMBOL_GPL(leds_list);
|
||||
|
||||
const char * const led_colors[LED_COLOR_ID_MAX] = {
|
||||
[LED_COLOR_ID_WHITE] = "white",
|
||||
[LED_COLOR_ID_RED] = "red",
|
||||
[LED_COLOR_ID_GREEN] = "green",
|
||||
[LED_COLOR_ID_BLUE] = "blue",
|
||||
[LED_COLOR_ID_AMBER] = "amber",
|
||||
[LED_COLOR_ID_VIOLET] = "violet",
|
||||
[LED_COLOR_ID_YELLOW] = "yellow",
|
||||
[LED_COLOR_ID_IR] = "ir",
|
||||
};
|
||||
EXPORT_SYMBOL_GPL(led_colors);
|
||||
|
||||
static int __led_set_brightness(struct led_classdev *led_cdev,
|
||||
enum led_brightness value)
|
||||
{
|
||||
@ -310,14 +324,11 @@ EXPORT_SYMBOL_GPL(led_update_brightness);
|
||||
|
||||
u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size)
|
||||
{
|
||||
struct device_node *np = dev_of_node(led_cdev->dev);
|
||||
struct fwnode_handle *fwnode = led_cdev->dev->fwnode;
|
||||
u32 *pattern;
|
||||
int count;
|
||||
|
||||
if (!np)
|
||||
return NULL;
|
||||
|
||||
count = of_property_count_u32_elems(np, "led-pattern");
|
||||
count = fwnode_property_count_u32(fwnode, "led-pattern");
|
||||
if (count < 0)
|
||||
return NULL;
|
||||
|
||||
@ -325,7 +336,7 @@ u32 *led_get_default_pattern(struct led_classdev *led_cdev, unsigned int *size)
|
||||
if (!pattern)
|
||||
return NULL;
|
||||
|
||||
if (of_property_read_u32_array(np, "led-pattern", pattern, count)) {
|
||||
if (fwnode_property_read_u32_array(fwnode, "led-pattern", pattern, count)) {
|
||||
kfree(pattern);
|
||||
return NULL;
|
||||
}
|
||||
@ -353,3 +364,116 @@ void led_sysfs_enable(struct led_classdev *led_cdev)
|
||||
led_cdev->flags &= ~LED_SYSFS_DISABLE;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(led_sysfs_enable);
|
||||
|
||||
static void led_parse_fwnode_props(struct device *dev,
|
||||
struct fwnode_handle *fwnode,
|
||||
struct led_properties *props)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!fwnode)
|
||||
return;
|
||||
|
||||
if (fwnode_property_present(fwnode, "label")) {
|
||||
ret = fwnode_property_read_string(fwnode, "label", &props->label);
|
||||
if (ret)
|
||||
dev_err(dev, "Error parsing 'label' property (%d)\n", ret);
|
||||
return;
|
||||
}
|
||||
|
||||
if (fwnode_property_present(fwnode, "color")) {
|
||||
ret = fwnode_property_read_u32(fwnode, "color", &props->color);
|
||||
if (ret)
|
||||
dev_err(dev, "Error parsing 'color' property (%d)\n", ret);
|
||||
else if (props->color >= LED_COLOR_ID_MAX)
|
||||
dev_err(dev, "LED color identifier out of range\n");
|
||||
else
|
||||
props->color_present = true;
|
||||
}
|
||||
|
||||
|
||||
if (!fwnode_property_present(fwnode, "function"))
|
||||
return;
|
||||
|
||||
ret = fwnode_property_read_string(fwnode, "function", &props->function);
|
||||
if (ret) {
|
||||
dev_err(dev,
|
||||
"Error parsing 'function' property (%d)\n",
|
||||
ret);
|
||||
}
|
||||
|
||||
if (!fwnode_property_present(fwnode, "function-enumerator"))
|
||||
return;
|
||||
|
||||
ret = fwnode_property_read_u32(fwnode, "function-enumerator",
|
||||
&props->func_enum);
|
||||
if (ret) {
|
||||
dev_err(dev,
|
||||
"Error parsing 'function-enumerator' property (%d)\n",
|
||||
ret);
|
||||
} else {
|
||||
props->func_enum_present = true;
|
||||
}
|
||||
}
|
||||
|
||||
int led_compose_name(struct device *dev, struct led_init_data *init_data,
|
||||
char *led_classdev_name)
|
||||
{
|
||||
struct led_properties props = {};
|
||||
struct fwnode_handle *fwnode = init_data->fwnode;
|
||||
const char *devicename = init_data->devicename;
|
||||
|
||||
if (!led_classdev_name)
|
||||
return -EINVAL;
|
||||
|
||||
led_parse_fwnode_props(dev, fwnode, &props);
|
||||
|
||||
if (props.label) {
|
||||
/*
|
||||
* If init_data.devicename is NULL, then it indicates that
|
||||
* DT label should be used as-is for LED class device name.
|
||||
* Otherwise the label is prepended with devicename to compose
|
||||
* the final LED class device name.
|
||||
*/
|
||||
if (!devicename) {
|
||||
strscpy(led_classdev_name, props.label,
|
||||
LED_MAX_NAME_SIZE);
|
||||
} else {
|
||||
snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
|
||||
devicename, props.label);
|
||||
}
|
||||
} else if (props.function || props.color_present) {
|
||||
char tmp_buf[LED_MAX_NAME_SIZE];
|
||||
|
||||
if (props.func_enum_present) {
|
||||
snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s-%d",
|
||||
props.color_present ? led_colors[props.color] : "",
|
||||
props.function ?: "", props.func_enum);
|
||||
} else {
|
||||
snprintf(tmp_buf, LED_MAX_NAME_SIZE, "%s:%s",
|
||||
props.color_present ? led_colors[props.color] : "",
|
||||
props.function ?: "");
|
||||
}
|
||||
if (init_data->devname_mandatory) {
|
||||
snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
|
||||
devicename, tmp_buf);
|
||||
} else {
|
||||
strscpy(led_classdev_name, tmp_buf, LED_MAX_NAME_SIZE);
|
||||
|
||||
}
|
||||
} else if (init_data->default_label) {
|
||||
if (!devicename) {
|
||||
dev_err(dev, "Legacy LED naming requires devicename segment");
|
||||
return -EINVAL;
|
||||
}
|
||||
snprintf(led_classdev_name, LED_MAX_NAME_SIZE, "%s:%s",
|
||||
devicename, init_data->default_label);
|
||||
} else if (is_of_node(fwnode)) {
|
||||
strscpy(led_classdev_name, to_of_node(fwnode)->name,
|
||||
LED_MAX_NAME_SIZE);
|
||||
} else
|
||||
return -EINVAL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(led_compose_name);
|
||||
|
||||
@ -167,12 +167,13 @@ int led_trigger_set(struct led_classdev *led_cdev, struct led_trigger *trig)
|
||||
trig->deactivate(led_cdev);
|
||||
err_activate:
|
||||
|
||||
led_cdev->trigger = NULL;
|
||||
led_cdev->trigger_data = NULL;
|
||||
write_lock_irqsave(&led_cdev->trigger->leddev_list_lock, flags);
|
||||
list_del(&led_cdev->trig_list);
|
||||
write_unlock_irqrestore(&led_cdev->trigger->leddev_list_lock, flags);
|
||||
led_cdev->trigger = NULL;
|
||||
led_cdev->trigger_data = NULL;
|
||||
led_set_brightness(led_cdev, LED_OFF);
|
||||
kfree(event);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -42,6 +42,8 @@
|
||||
#define AAT1290_FLASH_TM_NUM_LEVELS 16
|
||||
#define AAT1290_MM_CURRENT_SCALE_SIZE 15
|
||||
|
||||
#define AAT1290_NAME "aat1290"
|
||||
|
||||
|
||||
struct aat1290_led_config_data {
|
||||
/* maximum LED current in movie mode */
|
||||
@ -75,7 +77,6 @@ struct aat1290_led {
|
||||
int *mm_current_scale;
|
||||
/* device mode */
|
||||
bool movie_mode;
|
||||
|
||||
/* brightness cache */
|
||||
unsigned int torch_brightness;
|
||||
};
|
||||
@ -215,7 +216,6 @@ static int aat1290_led_parse_dt(struct aat1290_led *led,
|
||||
struct aat1290_led_config_data *cfg,
|
||||
struct device_node **sub_node)
|
||||
{
|
||||
struct led_classdev *led_cdev = &led->fled_cdev.led_cdev;
|
||||
struct device *dev = &led->pdev->dev;
|
||||
struct device_node *child_node;
|
||||
#if IS_ENABLED(CONFIG_V4L2_FLASH_LED_CLASS)
|
||||
@ -254,9 +254,6 @@ static int aat1290_led_parse_dt(struct aat1290_led *led,
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
led_cdev->name = of_get_property(child_node, "label", NULL) ? :
|
||||
child_node->name;
|
||||
|
||||
ret = of_property_read_u32(child_node, "led-max-microamp",
|
||||
&cfg->max_mm_current);
|
||||
/*
|
||||
@ -428,7 +425,7 @@ static void aat1290_init_v4l2_flash_config(struct aat1290_led *led,
|
||||
struct led_classdev *led_cdev = &led->fled_cdev.led_cdev;
|
||||
struct led_flash_setting *s;
|
||||
|
||||
strlcpy(v4l2_sd_cfg->dev_name, led_cdev->name,
|
||||
strlcpy(v4l2_sd_cfg->dev_name, led_cdev->dev->kobj.name,
|
||||
sizeof(v4l2_sd_cfg->dev_name));
|
||||
|
||||
s = &v4l2_sd_cfg->intensity;
|
||||
@ -466,6 +463,7 @@ static int aat1290_led_probe(struct platform_device *pdev)
|
||||
struct aat1290_led *led;
|
||||
struct led_classdev *led_cdev;
|
||||
struct led_classdev_flash *fled_cdev;
|
||||
struct led_init_data init_data = {};
|
||||
struct aat1290_led_config_data led_cfg = {};
|
||||
struct v4l2_flash_config v4l2_sd_cfg = {};
|
||||
int ret;
|
||||
@ -494,8 +492,12 @@ static int aat1290_led_probe(struct platform_device *pdev)
|
||||
|
||||
aat1290_init_flash_timeout(led, &led_cfg);
|
||||
|
||||
init_data.fwnode = of_fwnode_handle(sub_node);
|
||||
init_data.devicename = AAT1290_NAME;
|
||||
|
||||
/* Register LED Flash class device */
|
||||
ret = led_classdev_flash_register(&pdev->dev, fled_cdev);
|
||||
ret = led_classdev_flash_register_ext(&pdev->dev, fled_cdev,
|
||||
&init_data);
|
||||
if (ret < 0)
|
||||
goto err_flash_register;
|
||||
|
||||
|
||||
@ -13,7 +13,6 @@
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
#define AN30259A_MAX_LEDS 3
|
||||
|
||||
@ -54,6 +53,8 @@
|
||||
#define AN30259A_BLINK_MAX_TIME 7500 /* ms */
|
||||
#define AN30259A_SLOPE_RESOLUTION 500 /* ms */
|
||||
|
||||
#define AN30259A_NAME "an30259a"
|
||||
|
||||
#define STATE_OFF 0
|
||||
#define STATE_KEEP 1
|
||||
#define STATE_ON 2
|
||||
@ -62,11 +63,11 @@ struct an30259a;
|
||||
|
||||
struct an30259a_led {
|
||||
struct an30259a *chip;
|
||||
struct fwnode_handle *fwnode;
|
||||
struct led_classdev cdev;
|
||||
u32 num;
|
||||
u32 default_state;
|
||||
bool sloping;
|
||||
char label[LED_MAX_NAME_SIZE];
|
||||
};
|
||||
|
||||
struct an30259a {
|
||||
@ -226,14 +227,7 @@ static int an30259a_dt_init(struct i2c_client *client,
|
||||
|
||||
led->num = source;
|
||||
led->chip = chip;
|
||||
|
||||
if (of_property_read_string(child, "label", &str))
|
||||
snprintf(led->label, sizeof(led->label), "an30259a::");
|
||||
else
|
||||
snprintf(led->label, sizeof(led->label), "an30259a:%s",
|
||||
str);
|
||||
|
||||
led->cdev.name = led->label;
|
||||
led->fwnode = of_fwnode_handle(child);
|
||||
|
||||
if (!of_property_read_string(child, "default-state", &str)) {
|
||||
if (!strcmp(str, "on"))
|
||||
@ -312,13 +306,20 @@ static int an30259a_probe(struct i2c_client *client)
|
||||
chip->regmap = devm_regmap_init_i2c(client, &an30259a_regmap_config);
|
||||
|
||||
for (i = 0; i < chip->num_leds; i++) {
|
||||
struct led_init_data init_data = {};
|
||||
|
||||
an30259a_init_default_state(&chip->leds[i]);
|
||||
chip->leds[i].cdev.brightness_set_blocking =
|
||||
an30259a_brightness_set;
|
||||
chip->leds[i].cdev.blink_set = an30259a_blink_set;
|
||||
|
||||
err = devm_led_classdev_register(&client->dev,
|
||||
&chip->leds[i].cdev);
|
||||
init_data.fwnode = chip->leds[i].fwnode;
|
||||
init_data.devicename = AN30259A_NAME;
|
||||
init_data.default_label = ":";
|
||||
|
||||
err = devm_led_classdev_register_ext(&client->dev,
|
||||
&chip->leds[i].cdev,
|
||||
&init_data);
|
||||
if (err < 0)
|
||||
goto exit;
|
||||
}
|
||||
@ -353,7 +354,7 @@ MODULE_DEVICE_TABLE(i2c, an30259a_id);
|
||||
|
||||
static struct i2c_driver an30259a_driver = {
|
||||
.driver = {
|
||||
.name = "leds-an32059a",
|
||||
.name = "leds-an30259a",
|
||||
.of_match_table = of_match_ptr(an30259a_match_table),
|
||||
},
|
||||
.probe_new = an30259a_probe,
|
||||
@ -364,5 +365,5 @@ static struct i2c_driver an30259a_driver = {
|
||||
module_i2c_driver(an30259a_driver);
|
||||
|
||||
MODULE_AUTHOR("Simon Shields <simon@lineageos.org>");
|
||||
MODULE_DESCRIPTION("AN32059A LED driver");
|
||||
MODULE_DESCRIPTION("AN30259A LED driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
||||
@ -31,6 +31,8 @@
|
||||
* POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
||||
|
||||
#include <linux/dmi.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
@ -47,12 +49,6 @@
|
||||
#define APU1_NUM_GPIO 3
|
||||
#define APU1_IOSIZE sizeof(u8)
|
||||
|
||||
#define APU2_FCH_ACPI_MMIO_BASE 0xFED80000
|
||||
#define APU2_FCH_GPIO_BASE (APU2_FCH_ACPI_MMIO_BASE + 0x1500)
|
||||
#define APU2_GPIO_BIT_WRITE 22
|
||||
#define APU2_APU2_NUM_GPIO 4
|
||||
#define APU2_IOSIZE sizeof(u32)
|
||||
|
||||
/* LED access parameters */
|
||||
struct apu_param {
|
||||
void __iomem *addr; /* for ioread/iowrite */
|
||||
@ -72,19 +68,9 @@ struct apu_led_profile {
|
||||
unsigned long offset; /* for devm_ioremap */
|
||||
};
|
||||
|
||||
/* Supported platform types */
|
||||
enum apu_led_platform_types {
|
||||
APU1_LED_PLATFORM,
|
||||
APU2_LED_PLATFORM,
|
||||
};
|
||||
|
||||
struct apu_led_pdata {
|
||||
struct platform_device *pdev;
|
||||
struct apu_led_priv *pled;
|
||||
const struct apu_led_profile *profile;
|
||||
enum apu_led_platform_types platform;
|
||||
int num_led_instances;
|
||||
int iosize; /* for devm_ioremap() */
|
||||
spinlock_t lock;
|
||||
};
|
||||
|
||||
@ -96,19 +82,6 @@ static const struct apu_led_profile apu1_led_profile[] = {
|
||||
{ "apu:green:3", LED_OFF, APU1_FCH_GPIO_BASE + 2 * APU1_IOSIZE },
|
||||
};
|
||||
|
||||
static const struct apu_led_profile apu2_led_profile[] = {
|
||||
{ "apu2:green:1", LED_ON, APU2_FCH_GPIO_BASE + 68 * APU2_IOSIZE },
|
||||
{ "apu2:green:2", LED_OFF, APU2_FCH_GPIO_BASE + 69 * APU2_IOSIZE },
|
||||
{ "apu2:green:3", LED_OFF, APU2_FCH_GPIO_BASE + 70 * APU2_IOSIZE },
|
||||
};
|
||||
|
||||
/* Same as apu2_led_profile, but with "3" in the LED names. */
|
||||
static const struct apu_led_profile apu3_led_profile[] = {
|
||||
{ "apu3:green:1", LED_ON, APU2_FCH_GPIO_BASE + 68 * APU2_IOSIZE },
|
||||
{ "apu3:green:2", LED_OFF, APU2_FCH_GPIO_BASE + 69 * APU2_IOSIZE },
|
||||
{ "apu3:green:3", LED_OFF, APU2_FCH_GPIO_BASE + 70 * APU2_IOSIZE },
|
||||
};
|
||||
|
||||
static const struct dmi_system_id apu_led_dmi_table[] __initconst = {
|
||||
{
|
||||
.ident = "apu",
|
||||
@ -117,54 +90,6 @@ static const struct dmi_system_id apu_led_dmi_table[] __initconst = {
|
||||
DMI_MATCH(DMI_PRODUCT_NAME, "APU")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU2 with "Legacy" bios < 4.0.8 */
|
||||
{
|
||||
.ident = "apu2",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "APU2")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU2 with "Legacy" bios >= 4.0.8 */
|
||||
{
|
||||
.ident = "apu2",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "apu2")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU2 with "Mainline" bios */
|
||||
{
|
||||
.ident = "apu2",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "PC Engines apu2")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU3 with "Legacy" bios < 4.0.8 */
|
||||
{
|
||||
.ident = "apu3",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "APU3")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU3 with "Legacy" bios >= 4.0.8 */
|
||||
{
|
||||
.ident = "apu3",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "apu3")
|
||||
}
|
||||
},
|
||||
/* PC Engines APU2 with "Mainline" bios */
|
||||
{
|
||||
.ident = "apu3",
|
||||
.matches = {
|
||||
DMI_MATCH(DMI_SYS_VENDOR, "PC Engines"),
|
||||
DMI_MATCH(DMI_BOARD_NAME, "PC Engines apu3")
|
||||
}
|
||||
},
|
||||
{}
|
||||
};
|
||||
MODULE_DEVICE_TABLE(dmi, apu_led_dmi_table);
|
||||
@ -178,52 +103,30 @@ static void apu1_led_brightness_set(struct led_classdev *led, enum led_brightnes
|
||||
spin_unlock(&apu_led->lock);
|
||||
}
|
||||
|
||||
static void apu2_led_brightness_set(struct led_classdev *led, enum led_brightness value)
|
||||
{
|
||||
struct apu_led_priv *pled = cdev_to_priv(led);
|
||||
u32 value_new;
|
||||
|
||||
spin_lock(&apu_led->lock);
|
||||
|
||||
value_new = ioread32(pled->param.addr);
|
||||
|
||||
if (value)
|
||||
value_new &= ~BIT(APU2_GPIO_BIT_WRITE);
|
||||
else
|
||||
value_new |= BIT(APU2_GPIO_BIT_WRITE);
|
||||
|
||||
iowrite32(value_new, pled->param.addr);
|
||||
|
||||
spin_unlock(&apu_led->lock);
|
||||
}
|
||||
|
||||
static int apu_led_config(struct device *dev, struct apu_led_pdata *apuld)
|
||||
{
|
||||
int i;
|
||||
int err;
|
||||
|
||||
apu_led->pled = devm_kcalloc(dev,
|
||||
apu_led->num_led_instances, sizeof(struct apu_led_priv),
|
||||
ARRAY_SIZE(apu1_led_profile), sizeof(struct apu_led_priv),
|
||||
GFP_KERNEL);
|
||||
|
||||
if (!apu_led->pled)
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < apu_led->num_led_instances; i++) {
|
||||
for (i = 0; i < ARRAY_SIZE(apu1_led_profile); i++) {
|
||||
struct apu_led_priv *pled = &apu_led->pled[i];
|
||||
struct led_classdev *led_cdev = &pled->cdev;
|
||||
|
||||
led_cdev->name = apu_led->profile[i].name;
|
||||
led_cdev->brightness = apu_led->profile[i].brightness;
|
||||
led_cdev->name = apu1_led_profile[i].name;
|
||||
led_cdev->brightness = apu1_led_profile[i].brightness;
|
||||
led_cdev->max_brightness = 1;
|
||||
led_cdev->flags = LED_CORE_SUSPENDRESUME;
|
||||
if (apu_led->platform == APU1_LED_PLATFORM)
|
||||
led_cdev->brightness_set = apu1_led_brightness_set;
|
||||
else if (apu_led->platform == APU2_LED_PLATFORM)
|
||||
led_cdev->brightness_set = apu2_led_brightness_set;
|
||||
|
||||
pled->param.addr = devm_ioremap(dev,
|
||||
apu_led->profile[i].offset, apu_led->iosize);
|
||||
apu1_led_profile[i].offset, APU1_IOSIZE);
|
||||
if (!pled->param.addr) {
|
||||
err = -ENOMEM;
|
||||
goto error;
|
||||
@ -233,7 +136,7 @@ static int apu_led_config(struct device *dev, struct apu_led_pdata *apuld)
|
||||
if (err)
|
||||
goto error;
|
||||
|
||||
led_cdev->brightness_set(led_cdev, apu_led->profile[i].brightness);
|
||||
apu1_led_brightness_set(led_cdev, apu1_led_profile[i].brightness);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -254,28 +157,6 @@ static int __init apu_led_probe(struct platform_device *pdev)
|
||||
|
||||
apu_led->pdev = pdev;
|
||||
|
||||
if (dmi_match(DMI_PRODUCT_NAME, "APU")) {
|
||||
apu_led->profile = apu1_led_profile;
|
||||
apu_led->platform = APU1_LED_PLATFORM;
|
||||
apu_led->num_led_instances = ARRAY_SIZE(apu1_led_profile);
|
||||
apu_led->iosize = APU1_IOSIZE;
|
||||
} else if (dmi_match(DMI_BOARD_NAME, "APU2") ||
|
||||
dmi_match(DMI_BOARD_NAME, "apu2") ||
|
||||
dmi_match(DMI_BOARD_NAME, "PC Engines apu2")) {
|
||||
apu_led->profile = apu2_led_profile;
|
||||
apu_led->platform = APU2_LED_PLATFORM;
|
||||
apu_led->num_led_instances = ARRAY_SIZE(apu2_led_profile);
|
||||
apu_led->iosize = APU2_IOSIZE;
|
||||
} else if (dmi_match(DMI_BOARD_NAME, "APU3") ||
|
||||
dmi_match(DMI_BOARD_NAME, "apu3") ||
|
||||
dmi_match(DMI_BOARD_NAME, "PC Engines apu3")) {
|
||||
apu_led->profile = apu3_led_profile;
|
||||
/* Otherwise identical to APU2. */
|
||||
apu_led->platform = APU2_LED_PLATFORM;
|
||||
apu_led->num_led_instances = ARRAY_SIZE(apu3_led_profile);
|
||||
apu_led->iosize = APU2_IOSIZE;
|
||||
}
|
||||
|
||||
spin_lock_init(&apu_led->lock);
|
||||
return apu_led_config(&pdev->dev, apu_led);
|
||||
}
|
||||
@ -291,19 +172,9 @@ static int __init apu_led_init(void)
|
||||
struct platform_device *pdev;
|
||||
int err;
|
||||
|
||||
if (!dmi_match(DMI_SYS_VENDOR, "PC Engines")) {
|
||||
pr_err("No PC Engines board detected\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
if (!(dmi_match(DMI_PRODUCT_NAME, "APU") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "APU2") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "apu2") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "PC Engines apu2") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "APU3") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "apu3") ||
|
||||
dmi_match(DMI_PRODUCT_NAME, "PC Engines apu3"))) {
|
||||
pr_err("Unknown PC Engines board: %s\n",
|
||||
dmi_get_system_info(DMI_PRODUCT_NAME));
|
||||
if (!(dmi_match(DMI_SYS_VENDOR, "PC Engines") &&
|
||||
dmi_match(DMI_PRODUCT_NAME, "APU"))) {
|
||||
pr_err("No PC Engines APUv1 board detected. For APUv2,3 support, enable CONFIG_PCENGINES_APU2\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
@ -326,7 +197,7 @@ static void __exit apu_led_exit(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < apu_led->num_led_instances; i++)
|
||||
for (i = 0; i < ARRAY_SIZE(apu1_led_profile); i++)
|
||||
led_classdev_unregister(&apu_led->pled[i].cdev);
|
||||
|
||||
platform_device_unregister(apu_led->pdev);
|
||||
@ -337,6 +208,6 @@ module_init(apu_led_init);
|
||||
module_exit(apu_led_exit);
|
||||
|
||||
MODULE_AUTHOR("Alan Mizrahi");
|
||||
MODULE_DESCRIPTION("PC Engines APU family LED driver");
|
||||
MODULE_DESCRIPTION("PC Engines APU1 front LED driver");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS("platform:leds_apu");
|
||||
|
||||
@ -124,11 +124,6 @@ struct as3645a_config {
|
||||
u32 peak;
|
||||
};
|
||||
|
||||
struct as3645a_names {
|
||||
char flash[32];
|
||||
char indicator[32];
|
||||
};
|
||||
|
||||
struct as3645a {
|
||||
struct i2c_client *client;
|
||||
|
||||
@ -484,12 +479,10 @@ static int as3645a_detect(struct as3645a *flash)
|
||||
}
|
||||
|
||||
static int as3645a_parse_node(struct as3645a *flash,
|
||||
struct as3645a_names *names,
|
||||
struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct as3645a_config *cfg = &flash->cfg;
|
||||
struct fwnode_handle *child;
|
||||
const char *name;
|
||||
int rval;
|
||||
|
||||
fwnode_for_each_child_node(fwnode, child) {
|
||||
@ -517,17 +510,6 @@ static int as3645a_parse_node(struct as3645a *flash,
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
rval = fwnode_property_read_string(flash->flash_node, "label", &name);
|
||||
if (!rval) {
|
||||
strlcpy(names->flash, name, sizeof(names->flash));
|
||||
} else if (is_of_node(fwnode)) {
|
||||
snprintf(names->flash, sizeof(names->flash),
|
||||
"%pOFn:flash", to_of_node(fwnode));
|
||||
} else {
|
||||
dev_err(&flash->client->dev, "flash node has no label!\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rval = fwnode_property_read_u32(flash->flash_node, "flash-timeout-us",
|
||||
&cfg->flash_timeout_us);
|
||||
if (rval < 0) {
|
||||
@ -565,17 +547,6 @@ static int as3645a_parse_node(struct as3645a *flash,
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
rval = fwnode_property_read_string(flash->indicator_node, "label",
|
||||
&name);
|
||||
if (!rval) {
|
||||
strlcpy(names->indicator, name, sizeof(names->indicator));
|
||||
} else if (is_of_node(fwnode)) {
|
||||
snprintf(names->indicator, sizeof(names->indicator),
|
||||
"%pOFn:indicator", to_of_node(fwnode));
|
||||
} else {
|
||||
dev_err(&flash->client->dev, "indicator node has no label!\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
rval = fwnode_property_read_u32(flash->indicator_node,
|
||||
"led-max-microamp",
|
||||
@ -595,21 +566,25 @@ static int as3645a_parse_node(struct as3645a *flash,
|
||||
return rval;
|
||||
}
|
||||
|
||||
static int as3645a_led_class_setup(struct as3645a *flash,
|
||||
struct as3645a_names *names)
|
||||
static int as3645a_led_class_setup(struct as3645a *flash)
|
||||
{
|
||||
struct led_classdev *fled_cdev = &flash->fled.led_cdev;
|
||||
struct led_classdev *iled_cdev = &flash->iled_cdev;
|
||||
struct led_init_data init_data = {};
|
||||
struct led_flash_setting *cfg;
|
||||
int rval;
|
||||
|
||||
iled_cdev->name = names->indicator;
|
||||
iled_cdev->brightness_set_blocking = as3645a_set_indicator_brightness;
|
||||
iled_cdev->max_brightness =
|
||||
flash->cfg.indicator_max_ua / AS_INDICATOR_INTENSITY_STEP;
|
||||
iled_cdev->flags = LED_CORE_SUSPENDRESUME;
|
||||
|
||||
rval = led_classdev_register(&flash->client->dev, iled_cdev);
|
||||
init_data.fwnode = flash->indicator_node;
|
||||
init_data.devicename = AS_NAME;
|
||||
init_data.default_label = "indicator";
|
||||
|
||||
rval = led_classdev_register_ext(&flash->client->dev, iled_cdev,
|
||||
&init_data);
|
||||
if (rval < 0)
|
||||
return rval;
|
||||
|
||||
@ -627,7 +602,6 @@ static int as3645a_led_class_setup(struct as3645a *flash,
|
||||
|
||||
flash->fled.ops = &as3645a_led_flash_ops;
|
||||
|
||||
fled_cdev->name = names->flash;
|
||||
fled_cdev->brightness_set_blocking = as3645a_set_assist_brightness;
|
||||
/* Value 0 is off in LED class. */
|
||||
fled_cdev->max_brightness =
|
||||
@ -635,14 +609,22 @@ static int as3645a_led_class_setup(struct as3645a *flash,
|
||||
flash->cfg.assist_max_ua) + 1;
|
||||
fled_cdev->flags = LED_DEV_CAP_FLASH | LED_CORE_SUSPENDRESUME;
|
||||
|
||||
rval = led_classdev_flash_register(&flash->client->dev, &flash->fled);
|
||||
if (rval) {
|
||||
init_data.fwnode = flash->flash_node;
|
||||
init_data.devicename = AS_NAME;
|
||||
init_data.default_label = "flash";
|
||||
|
||||
rval = led_classdev_flash_register_ext(&flash->client->dev,
|
||||
&flash->fled, &init_data);
|
||||
if (rval)
|
||||
goto out_err;
|
||||
|
||||
return rval;
|
||||
|
||||
out_err:
|
||||
led_classdev_unregister(iled_cdev);
|
||||
dev_err(&flash->client->dev,
|
||||
"led_classdev_flash_register() failed, error %d\n",
|
||||
rval);
|
||||
}
|
||||
|
||||
return rval;
|
||||
}
|
||||
|
||||
@ -667,8 +649,9 @@ static int as3645a_v4l2_setup(struct as3645a *flash)
|
||||
},
|
||||
};
|
||||
|
||||
strlcpy(cfg.dev_name, led->name, sizeof(cfg.dev_name));
|
||||
strlcpy(cfgind.dev_name, flash->iled_cdev.name, sizeof(cfg.dev_name));
|
||||
strlcpy(cfg.dev_name, led->dev->kobj.name, sizeof(cfg.dev_name));
|
||||
strlcpy(cfgind.dev_name, flash->iled_cdev.dev->kobj.name,
|
||||
sizeof(cfgind.dev_name));
|
||||
|
||||
flash->vf = v4l2_flash_init(
|
||||
&flash->client->dev, flash->flash_node, &flash->fled, NULL,
|
||||
@ -689,7 +672,6 @@ static int as3645a_v4l2_setup(struct as3645a *flash)
|
||||
|
||||
static int as3645a_probe(struct i2c_client *client)
|
||||
{
|
||||
struct as3645a_names names;
|
||||
struct as3645a *flash;
|
||||
int rval;
|
||||
|
||||
@ -702,7 +684,7 @@ static int as3645a_probe(struct i2c_client *client)
|
||||
|
||||
flash->client = client;
|
||||
|
||||
rval = as3645a_parse_node(flash, &names, dev_fwnode(&client->dev));
|
||||
rval = as3645a_parse_node(flash, dev_fwnode(&client->dev));
|
||||
if (rval < 0)
|
||||
return rval;
|
||||
|
||||
@ -717,7 +699,7 @@ static int as3645a_probe(struct i2c_client *client)
|
||||
if (rval)
|
||||
goto out_mutex_destroy;
|
||||
|
||||
rval = as3645a_led_class_setup(flash, &names);
|
||||
rval = as3645a_led_class_setup(flash);
|
||||
if (rval)
|
||||
goto out_mutex_destroy;
|
||||
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
#include <linux/of_device.h>
|
||||
#include <linux/spi/spi.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
/*
|
||||
* CR0014114 SPI protocol descrtiption:
|
||||
@ -40,8 +39,9 @@
|
||||
#define CR_FW_DELAY_MSEC 10
|
||||
#define CR_RECOUNT_DELAY (HZ * 3600)
|
||||
|
||||
#define CR_DEV_NAME "cr0014114"
|
||||
|
||||
struct cr0014114_led {
|
||||
char name[LED_MAX_NAME_SIZE];
|
||||
struct cr0014114 *priv;
|
||||
struct led_classdev ldev;
|
||||
u8 brightness;
|
||||
@ -167,8 +167,7 @@ static int cr0014114_set_sync(struct led_classdev *ldev,
|
||||
struct cr0014114_led,
|
||||
ldev);
|
||||
|
||||
dev_dbg(led->priv->dev, "Set brightness of %s to %d\n",
|
||||
led->name, brightness);
|
||||
dev_dbg(led->priv->dev, "Set brightness to %d\n", brightness);
|
||||
|
||||
mutex_lock(&led->priv->lock);
|
||||
led->brightness = (u8)brightness;
|
||||
@ -183,42 +182,32 @@ static int cr0014114_probe_dt(struct cr0014114 *priv)
|
||||
size_t i = 0;
|
||||
struct cr0014114_led *led;
|
||||
struct fwnode_handle *child;
|
||||
struct device_node *np;
|
||||
struct led_init_data init_data = {};
|
||||
int ret;
|
||||
const char *str;
|
||||
|
||||
device_for_each_child_node(priv->dev, child) {
|
||||
np = to_of_node(child);
|
||||
led = &priv->leds[i];
|
||||
|
||||
ret = fwnode_property_read_string(child, "label", &str);
|
||||
if (ret)
|
||||
snprintf(led->name, sizeof(led->name),
|
||||
"cr0014114::");
|
||||
else
|
||||
snprintf(led->name, sizeof(led->name),
|
||||
"cr0014114:%s", str);
|
||||
|
||||
fwnode_property_read_string(child, "linux,default-trigger",
|
||||
&led->ldev.default_trigger);
|
||||
|
||||
led->priv = priv;
|
||||
led->ldev.name = led->name;
|
||||
led->ldev.max_brightness = CR_MAX_BRIGHTNESS;
|
||||
led->ldev.brightness_set_blocking = cr0014114_set_sync;
|
||||
|
||||
ret = devm_of_led_classdev_register(priv->dev, np,
|
||||
&led->ldev);
|
||||
init_data.fwnode = child;
|
||||
init_data.devicename = CR_DEV_NAME;
|
||||
init_data.default_label = ":";
|
||||
|
||||
ret = devm_led_classdev_register_ext(priv->dev, &led->ldev,
|
||||
&init_data);
|
||||
if (ret) {
|
||||
dev_err(priv->dev,
|
||||
"failed to register LED device %s, err %d",
|
||||
led->name, ret);
|
||||
"failed to register LED device, err %d", ret);
|
||||
fwnode_handle_put(child);
|
||||
return ret;
|
||||
}
|
||||
|
||||
led->ldev.dev->of_node = np;
|
||||
|
||||
i++;
|
||||
}
|
||||
|
||||
|
||||
@ -73,11 +73,11 @@ static int gpio_blink_set(struct led_classdev *led_cdev,
|
||||
|
||||
static int create_gpio_led(const struct gpio_led *template,
|
||||
struct gpio_led_data *led_dat, struct device *parent,
|
||||
struct device_node *np, gpio_blink_set_t blink_set)
|
||||
struct fwnode_handle *fwnode, gpio_blink_set_t blink_set)
|
||||
{
|
||||
struct led_init_data init_data = {};
|
||||
int ret, state;
|
||||
|
||||
led_dat->cdev.name = template->name;
|
||||
led_dat->cdev.default_trigger = template->default_trigger;
|
||||
led_dat->can_sleep = gpiod_cansleep(led_dat->gpiod);
|
||||
if (!led_dat->can_sleep)
|
||||
@ -108,7 +108,16 @@ static int create_gpio_led(const struct gpio_led *template,
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return devm_of_led_classdev_register(parent, np, &led_dat->cdev);
|
||||
if (template->name) {
|
||||
led_dat->cdev.name = template->name;
|
||||
ret = devm_led_classdev_register(parent, &led_dat->cdev);
|
||||
} else {
|
||||
init_data.fwnode = fwnode;
|
||||
ret = devm_led_classdev_register_ext(parent, &led_dat->cdev,
|
||||
&init_data);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct gpio_leds_priv {
|
||||
@ -141,15 +150,6 @@ static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
|
||||
struct gpio_led_data *led_dat = &priv->leds[priv->num_leds];
|
||||
struct gpio_led led = {};
|
||||
const char *state = NULL;
|
||||
struct device_node *np = to_of_node(child);
|
||||
|
||||
ret = fwnode_property_read_string(child, "label", &led.name);
|
||||
if (ret && IS_ENABLED(CONFIG_OF) && np)
|
||||
led.name = np->name;
|
||||
if (!led.name) {
|
||||
fwnode_handle_put(child);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
|
||||
led.gpiod = devm_fwnode_get_gpiod_from_child(dev, NULL, child,
|
||||
GPIOD_ASIS,
|
||||
@ -181,7 +181,7 @@ static struct gpio_leds_priv *gpio_leds_create(struct platform_device *pdev)
|
||||
if (fwnode_property_present(child, "panic-indicator"))
|
||||
led.panic_indicator = 1;
|
||||
|
||||
ret = create_gpio_led(&led, led_dat, dev, np, NULL);
|
||||
ret = create_gpio_led(&led, led_dat, dev, child, NULL);
|
||||
if (ret < 0) {
|
||||
fwnode_handle_put(child);
|
||||
return ERR_PTR(ret);
|
||||
|
||||
@ -333,12 +333,11 @@ static int is31fl319x_probe(struct i2c_client *client,
|
||||
{
|
||||
struct is31fl319x_chip *is31;
|
||||
struct device *dev = &client->dev;
|
||||
struct i2c_adapter *adapter = to_i2c_adapter(dev->parent);
|
||||
int err;
|
||||
int i = 0;
|
||||
u32 aggregated_led_microamp = IS31FL319X_CURRENT_MAX;
|
||||
|
||||
if (!i2c_check_functionality(adapter, I2C_FUNC_I2C))
|
||||
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
|
||||
return -EIO;
|
||||
|
||||
is31 = devm_kzalloc(&client->dev, sizeof(*is31), GFP_KERNEL);
|
||||
|
||||
@ -324,12 +324,6 @@ static int is31fl32xx_init_regs(struct is31fl32xx_priv *priv)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline size_t sizeof_is31fl32xx_priv(int num_leds)
|
||||
{
|
||||
return sizeof(struct is31fl32xx_priv) +
|
||||
(sizeof(struct is31fl32xx_led_data) * num_leds);
|
||||
}
|
||||
|
||||
static int is31fl32xx_parse_child_dt(const struct device *dev,
|
||||
const struct device_node *child,
|
||||
struct is31fl32xx_led_data *led_data)
|
||||
@ -450,7 +444,7 @@ static int is31fl32xx_probe(struct i2c_client *client,
|
||||
if (!count)
|
||||
return -EINVAL;
|
||||
|
||||
priv = devm_kzalloc(dev, sizeof_is31fl32xx_priv(count),
|
||||
priv = devm_kzalloc(dev, struct_size(priv, leds, count),
|
||||
GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
/* Value related the movie mode */
|
||||
#define KTD2692_MOVIE_MODE_CURRENT_LEVELS 16
|
||||
#define KTD2692_MM_TO_FL_RATIO(x) ((x) / 3)
|
||||
#define KTD2962_MM_MIN_CURR_THRESHOLD_SCALE 8
|
||||
#define KTD2692_MM_MIN_CURR_THRESHOLD_SCALE 8
|
||||
|
||||
/* Value related the flash mode */
|
||||
#define KTD2692_FLASH_MODE_TIMEOUT_LEVELS 8
|
||||
@ -250,7 +250,7 @@ static void ktd2692_setup(struct ktd2692_context *led)
|
||||
ktd2692_expresswire_reset(led);
|
||||
gpiod_direction_output(led->aux_gpio, KTD2692_LOW);
|
||||
|
||||
ktd2692_expresswire_write(led, (KTD2962_MM_MIN_CURR_THRESHOLD_SCALE - 1)
|
||||
ktd2692_expresswire_write(led, (KTD2692_MM_MIN_CURR_THRESHOLD_SCALE - 1)
|
||||
| KTD2692_REG_MM_MIN_CURR_THRESHOLD_BASE);
|
||||
ktd2692_expresswire_write(led, KTD2692_FLASH_MODE_CURR_PERCENT(45)
|
||||
| KTD2692_REG_FLASH_CURRENT_BASE);
|
||||
|
||||
@ -23,11 +23,11 @@
|
||||
#define LM3532_REG_PWM_B_CFG 0x14
|
||||
#define LM3532_REG_PWM_C_CFG 0x15
|
||||
#define LM3532_REG_ZONE_CFG_A 0x16
|
||||
#define LM3532_REG_CTRL_A_BRT 0x17
|
||||
#define LM3532_REG_CTRL_A_FS_CURR 0x17
|
||||
#define LM3532_REG_ZONE_CFG_B 0x18
|
||||
#define LM3532_REG_CTRL_B_BRT 0x19
|
||||
#define LM3532_REG_CTRL_B_FS_CURR 0x19
|
||||
#define LM3532_REG_ZONE_CFG_C 0x1a
|
||||
#define LM3532_REG_CTRL_C_BRT 0x1b
|
||||
#define LM3532_REG_CTRL_C_FS_CURR 0x1b
|
||||
#define LM3532_REG_ENABLE 0x1d
|
||||
#define LM3532_ALS_CONFIG 0x23
|
||||
#define LM3532_REG_ZN_0_HI 0x60
|
||||
@ -38,9 +38,12 @@
|
||||
#define LM3532_REG_ZN_2_LO 0x65
|
||||
#define LM3532_REG_ZN_3_HI 0x66
|
||||
#define LM3532_REG_ZN_3_LO 0x67
|
||||
#define LM3532_REG_ZONE_TRGT_A 0x70
|
||||
#define LM3532_REG_ZONE_TRGT_B 0x75
|
||||
#define LM3532_REG_ZONE_TRGT_C 0x7a
|
||||
#define LM3532_REG_MAX 0x7e
|
||||
|
||||
/* Contorl Enable */
|
||||
/* Control Enable */
|
||||
#define LM3532_CTRL_A_ENABLE BIT(0)
|
||||
#define LM3532_CTRL_B_ENABLE BIT(1)
|
||||
#define LM3532_CTRL_C_ENABLE BIT(2)
|
||||
@ -86,6 +89,10 @@
|
||||
#define LM3532_NUM_AVG_VALS 8
|
||||
#define LM3532_NUM_IMP_VALS 32
|
||||
|
||||
#define LM3532_FS_CURR_MIN 5000
|
||||
#define LM3532_FS_CURR_MAX 29800
|
||||
#define LM3532_FS_CURR_STEP 800
|
||||
|
||||
/*
|
||||
* struct lm3532_als_data
|
||||
* @config - value of ALS configuration register
|
||||
@ -116,8 +123,11 @@ struct lm3532_als_data {
|
||||
* @priv - Pointer the device data structure
|
||||
* @control_bank - Control bank the LED is associated to
|
||||
* @mode - Mode of the LED string
|
||||
* @ctrl_brt_pointer - Zone target register that controls the sink
|
||||
* @num_leds - Number of LED strings are supported in this array
|
||||
* @full_scale_current - The full-scale current setting for the current sink.
|
||||
* @led_strings - The LED strings supported in this array
|
||||
* @enabled - Enabled status
|
||||
* @label - LED label
|
||||
*/
|
||||
struct lm3532_led {
|
||||
@ -126,7 +136,10 @@ struct lm3532_led {
|
||||
|
||||
int control_bank;
|
||||
int mode;
|
||||
int ctrl_brt_pointer;
|
||||
int num_leds;
|
||||
int full_scale_current;
|
||||
int enabled:1;
|
||||
u32 led_strings[LM3532_MAX_CONTROL_BANKS];
|
||||
char label[LED_MAX_NAME_SIZE];
|
||||
};
|
||||
@ -168,11 +181,11 @@ static const struct reg_default lm3532_reg_defs[] = {
|
||||
{LM3532_REG_PWM_B_CFG, 0x82},
|
||||
{LM3532_REG_PWM_C_CFG, 0x82},
|
||||
{LM3532_REG_ZONE_CFG_A, 0xf1},
|
||||
{LM3532_REG_CTRL_A_BRT, 0xf3},
|
||||
{LM3532_REG_CTRL_A_FS_CURR, 0xf3},
|
||||
{LM3532_REG_ZONE_CFG_B, 0xf1},
|
||||
{LM3532_REG_CTRL_B_BRT, 0xf3},
|
||||
{LM3532_REG_CTRL_B_FS_CURR, 0xf3},
|
||||
{LM3532_REG_ZONE_CFG_C, 0xf1},
|
||||
{LM3532_REG_CTRL_C_BRT, 0xf3},
|
||||
{LM3532_REG_CTRL_C_FS_CURR, 0xf3},
|
||||
{LM3532_REG_ENABLE, 0xf8},
|
||||
{LM3532_ALS_CONFIG, 0x44},
|
||||
{LM3532_REG_ZN_0_HI, 0x35},
|
||||
@ -195,7 +208,7 @@ static const struct regmap_config lm3532_regmap_config = {
|
||||
.cache_type = REGCACHE_FLAT,
|
||||
};
|
||||
|
||||
const static int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
|
||||
static const int als_imp_table[LM3532_NUM_IMP_VALS] = {37000, 18500, 12330,
|
||||
92500, 7400, 6170, 5290,
|
||||
4630, 4110, 3700, 3360,
|
||||
3080, 2850, 2640, 2440,
|
||||
@ -252,7 +265,7 @@ static int lm3532_get_index(const int table[], int size, int value)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
const static int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
|
||||
static const int als_avrg_table[LM3532_NUM_AVG_VALS] = {17920, 35840, 71680,
|
||||
1433360, 286720, 573440,
|
||||
1146880, 2293760};
|
||||
static int lm3532_get_als_avg_index(int avg_time)
|
||||
@ -267,7 +280,7 @@ static int lm3532_get_als_avg_index(int avg_time)
|
||||
avg_time);
|
||||
}
|
||||
|
||||
const static int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
|
||||
static const int ramp_table[LM3532_NUM_RAMP_VALS] = { 8, 1024, 2048, 4096, 8192,
|
||||
16384, 32768, 65536};
|
||||
static int lm3532_get_ramp_index(int ramp_time)
|
||||
{
|
||||
@ -281,11 +294,15 @@ static int lm3532_get_ramp_index(int ramp_time)
|
||||
ramp_time);
|
||||
}
|
||||
|
||||
/* Caller must take care of locking */
|
||||
static int lm3532_led_enable(struct lm3532_led *led_data)
|
||||
{
|
||||
int ctrl_en_val = BIT(led_data->control_bank);
|
||||
int ret;
|
||||
|
||||
if (led_data->enabled)
|
||||
return 0;
|
||||
|
||||
ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
|
||||
ctrl_en_val, ctrl_en_val);
|
||||
if (ret) {
|
||||
@ -293,22 +310,38 @@ static int lm3532_led_enable(struct lm3532_led *led_data)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return regulator_enable(led_data->priv->regulator);
|
||||
ret = regulator_enable(led_data->priv->regulator);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
led_data->enabled = 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Caller must take care of locking */
|
||||
static int lm3532_led_disable(struct lm3532_led *led_data)
|
||||
{
|
||||
int ctrl_en_val = BIT(led_data->control_bank);
|
||||
int ret;
|
||||
|
||||
if (!led_data->enabled)
|
||||
return 0;
|
||||
|
||||
ret = regmap_update_bits(led_data->priv->regmap, LM3532_REG_ENABLE,
|
||||
ctrl_en_val, ~ctrl_en_val);
|
||||
ctrl_en_val, 0);
|
||||
if (ret) {
|
||||
dev_err(led_data->priv->dev, "Failed to set ctrl:%d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
return regulator_disable(led_data->priv->regulator);
|
||||
ret = regulator_disable(led_data->priv->regulator);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
led_data->enabled = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int lm3532_brightness_set(struct led_classdev *led_cdev,
|
||||
@ -321,7 +354,7 @@ static int lm3532_brightness_set(struct led_classdev *led_cdev,
|
||||
|
||||
mutex_lock(&led->priv->lock);
|
||||
|
||||
if (led->mode == LM3532_BL_MODE_ALS) {
|
||||
if (led->mode == LM3532_ALS_CTRL) {
|
||||
if (brt_val > LED_OFF)
|
||||
ret = lm3532_led_enable(led);
|
||||
else
|
||||
@ -339,8 +372,8 @@ static int lm3532_brightness_set(struct led_classdev *led_cdev,
|
||||
if (ret)
|
||||
goto unlock;
|
||||
|
||||
brightness_reg = LM3532_REG_CTRL_A_BRT + led->control_bank * 2;
|
||||
brt_val = brt_val / LM3532_BRT_VAL_ADJUST;
|
||||
brightness_reg = LM3532_REG_ZONE_TRGT_A + led->control_bank * 5 +
|
||||
(led->ctrl_brt_pointer >> 2);
|
||||
|
||||
ret = regmap_write(led->priv->regmap, brightness_reg, brt_val);
|
||||
|
||||
@ -356,8 +389,43 @@ static int lm3532_init_registers(struct lm3532_led *led)
|
||||
unsigned int output_cfg_val = 0;
|
||||
unsigned int output_cfg_shift = 0;
|
||||
unsigned int output_cfg_mask = 0;
|
||||
unsigned int brightness_config_reg;
|
||||
unsigned int brightness_config_val;
|
||||
int fs_current_reg;
|
||||
int fs_current_val;
|
||||
int ret, i;
|
||||
|
||||
if (drvdata->enable_gpio)
|
||||
gpiod_direction_output(drvdata->enable_gpio, 1);
|
||||
|
||||
brightness_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;
|
||||
/*
|
||||
* This could be hard coded to the default value but the control
|
||||
* brightness register may have changed during boot.
|
||||
*/
|
||||
ret = regmap_read(drvdata->regmap, brightness_config_reg,
|
||||
&led->ctrl_brt_pointer);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
led->ctrl_brt_pointer &= LM3532_ZONE_MASK;
|
||||
brightness_config_val = led->ctrl_brt_pointer | led->mode;
|
||||
ret = regmap_write(drvdata->regmap, brightness_config_reg,
|
||||
brightness_config_val);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
if (led->full_scale_current) {
|
||||
fs_current_reg = LM3532_REG_CTRL_A_FS_CURR + led->control_bank * 2;
|
||||
fs_current_val = (led->full_scale_current - LM3532_FS_CURR_MIN) /
|
||||
LM3532_FS_CURR_STEP;
|
||||
|
||||
ret = regmap_write(drvdata->regmap, fs_current_reg,
|
||||
fs_current_val);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
for (i = 0; i < led->num_leds; i++) {
|
||||
output_cfg_shift = led->led_strings[i] * 2;
|
||||
output_cfg_val |= (led->control_bank << output_cfg_shift);
|
||||
@ -382,7 +450,6 @@ static int lm3532_als_configure(struct lm3532_data *priv,
|
||||
struct lm3532_als_data *als = priv->als_data;
|
||||
u32 als_vmin, als_vmax, als_vstep;
|
||||
int zone_reg = LM3532_REG_ZN_0_HI;
|
||||
int brightnes_config_reg;
|
||||
int ret;
|
||||
int i;
|
||||
|
||||
@ -411,14 +478,7 @@ static int lm3532_als_configure(struct lm3532_data *priv,
|
||||
als->config = (als->als_avrg_time | (LM3532_ENABLE_ALS) |
|
||||
(als->als_input_mode << LM3532_ALS_SEL_SHIFT));
|
||||
|
||||
ret = regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
brightnes_config_reg = LM3532_REG_ZONE_CFG_A + led->control_bank * 2;
|
||||
|
||||
return regmap_update_bits(priv->regmap, brightnes_config_reg,
|
||||
LM3532_I2C_CTRL, LM3532_ALS_CTRL);
|
||||
return regmap_write(priv->regmap, LM3532_ALS_CONFIG, als->config);
|
||||
}
|
||||
|
||||
static int lm3532_parse_als(struct lm3532_data *priv)
|
||||
@ -541,18 +601,27 @@ static int lm3532_parse_node(struct lm3532_data *priv)
|
||||
goto child_out;
|
||||
}
|
||||
|
||||
if (fwnode_property_present(child, "led-max-microamp") &&
|
||||
fwnode_property_read_u32(child, "led-max-microamp",
|
||||
&led->full_scale_current))
|
||||
dev_err(&priv->client->dev,
|
||||
"Failed getting led-max-microamp\n");
|
||||
else
|
||||
led->full_scale_current = min(led->full_scale_current,
|
||||
LM3532_FS_CURR_MAX);
|
||||
|
||||
if (led->mode == LM3532_BL_MODE_ALS) {
|
||||
led->mode = LM3532_ALS_CTRL;
|
||||
ret = lm3532_parse_als(priv);
|
||||
if (ret)
|
||||
dev_err(&priv->client->dev, "Failed to parse als\n");
|
||||
else
|
||||
lm3532_als_configure(priv, led);
|
||||
} else {
|
||||
led->mode = LM3532_I2C_CTRL;
|
||||
}
|
||||
|
||||
led->num_leds = fwnode_property_read_u32_array(child,
|
||||
"led-sources",
|
||||
NULL, 0);
|
||||
|
||||
led->num_leds = fwnode_property_count_u32(child, "led-sources");
|
||||
if (led->num_leds > LM3532_MAX_LED_STRINGS) {
|
||||
dev_err(&priv->client->dev, "To many LED string defined\n");
|
||||
continue;
|
||||
@ -590,7 +659,13 @@ static int lm3532_parse_node(struct lm3532_data *priv)
|
||||
goto child_out;
|
||||
}
|
||||
|
||||
lm3532_init_registers(led);
|
||||
ret = lm3532_init_registers(led);
|
||||
if (ret) {
|
||||
dev_err(&priv->client->dev, "register init err: %d\n",
|
||||
ret);
|
||||
fwnode_handle_put(child);
|
||||
goto child_out;
|
||||
}
|
||||
|
||||
i++;
|
||||
}
|
||||
@ -637,9 +712,6 @@ static int lm3532_probe(struct i2c_client *client,
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (drvdata->enable_gpio)
|
||||
gpiod_direction_output(drvdata->enable_gpio, 1);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
@ -10,7 +10,6 @@
|
||||
#include <linux/module.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/slab.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
#define LM3601X_LED_IR 0x0
|
||||
#define LM3601X_LED_TORCH 0x1
|
||||
@ -90,8 +89,6 @@ struct lm3601x_led {
|
||||
struct regmap *regmap;
|
||||
struct mutex lock;
|
||||
|
||||
char led_name[LED_MAX_NAME_SIZE];
|
||||
|
||||
unsigned int flash_timeout;
|
||||
unsigned int last_flag;
|
||||
|
||||
@ -322,10 +319,12 @@ static const struct led_flash_ops flash_ops = {
|
||||
.fault_get = lm3601x_flash_fault_get,
|
||||
};
|
||||
|
||||
static int lm3601x_register_leds(struct lm3601x_led *led)
|
||||
static int lm3601x_register_leds(struct lm3601x_led *led,
|
||||
struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct led_classdev *led_cdev;
|
||||
struct led_flash_setting *setting;
|
||||
struct led_init_data init_data = {};
|
||||
|
||||
led->fled_cdev.ops = &flash_ops;
|
||||
|
||||
@ -342,20 +341,25 @@ static int lm3601x_register_leds(struct lm3601x_led *led)
|
||||
setting->val = led->flash_current_max;
|
||||
|
||||
led_cdev = &led->fled_cdev.led_cdev;
|
||||
led_cdev->name = led->led_name;
|
||||
led_cdev->brightness_set_blocking = lm3601x_brightness_set;
|
||||
led_cdev->max_brightness = DIV_ROUND_UP(led->torch_current_max,
|
||||
LM3601X_TORCH_REG_DIV);
|
||||
led_cdev->flags |= LED_DEV_CAP_FLASH;
|
||||
|
||||
return led_classdev_flash_register(&led->client->dev, &led->fled_cdev);
|
||||
init_data.fwnode = fwnode;
|
||||
init_data.devicename = led->client->name;
|
||||
init_data.default_label = (led->led_mode == LM3601X_LED_TORCH) ?
|
||||
"torch" : "infrared";
|
||||
|
||||
return led_classdev_flash_register_ext(&led->client->dev,
|
||||
&led->fled_cdev, &init_data);
|
||||
}
|
||||
|
||||
static int lm3601x_parse_node(struct lm3601x_led *led)
|
||||
static int lm3601x_parse_node(struct lm3601x_led *led,
|
||||
struct fwnode_handle **fwnode)
|
||||
{
|
||||
struct fwnode_handle *child = NULL;
|
||||
int ret = -ENODEV;
|
||||
const char *name;
|
||||
|
||||
child = device_get_next_child_node(&led->client->dev, child);
|
||||
if (!child) {
|
||||
@ -376,17 +380,6 @@ static int lm3601x_parse_node(struct lm3601x_led *led)
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
ret = fwnode_property_read_string(child, "label", &name);
|
||||
if (ret) {
|
||||
if (led->led_mode == LM3601X_LED_TORCH)
|
||||
name = "torch";
|
||||
else
|
||||
name = "infrared";
|
||||
}
|
||||
|
||||
snprintf(led->led_name, sizeof(led->led_name),
|
||||
"%s:%s", led->client->name, name);
|
||||
|
||||
ret = fwnode_property_read_u32(child, "led-max-microamp",
|
||||
&led->torch_current_max);
|
||||
if (ret) {
|
||||
@ -411,6 +404,8 @@ static int lm3601x_parse_node(struct lm3601x_led *led)
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
*fwnode = child;
|
||||
|
||||
out_err:
|
||||
fwnode_handle_put(child);
|
||||
return ret;
|
||||
@ -419,6 +414,7 @@ static int lm3601x_parse_node(struct lm3601x_led *led)
|
||||
static int lm3601x_probe(struct i2c_client *client)
|
||||
{
|
||||
struct lm3601x_led *led;
|
||||
struct fwnode_handle *fwnode;
|
||||
int ret;
|
||||
|
||||
led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
|
||||
@ -428,7 +424,7 @@ static int lm3601x_probe(struct i2c_client *client)
|
||||
led->client = client;
|
||||
i2c_set_clientdata(client, led);
|
||||
|
||||
ret = lm3601x_parse_node(led);
|
||||
ret = lm3601x_parse_node(led, &fwnode);
|
||||
if (ret)
|
||||
return -ENODEV;
|
||||
|
||||
@ -442,7 +438,7 @@ static int lm3601x_probe(struct i2c_client *client)
|
||||
|
||||
mutex_init(&led->lock);
|
||||
|
||||
return lm3601x_register_leds(led);
|
||||
return lm3601x_register_leds(led, fwnode);
|
||||
}
|
||||
|
||||
static int lm3601x_remove(struct i2c_client *client)
|
||||
|
||||
@ -90,9 +90,7 @@ static int lm36274_parse_dt(struct lm36274 *lm36274_data)
|
||||
snprintf(label, sizeof(label),
|
||||
"%s:%s", lm36274_data->pdev->name, name);
|
||||
|
||||
lm36274_data->num_leds = fwnode_property_read_u32_array(child,
|
||||
"led-sources",
|
||||
NULL, 0);
|
||||
lm36274_data->num_leds = fwnode_property_count_u32(child, "led-sources");
|
||||
if (lm36274_data->num_leds <= 0)
|
||||
return -ENODEV;
|
||||
|
||||
|
||||
@ -13,7 +13,6 @@
|
||||
#include <linux/regmap.h>
|
||||
#include <linux/regulator/consumer.h>
|
||||
#include <linux/slab.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
#define LM36922_MODEL 0
|
||||
#define LM36923_MODEL 1
|
||||
@ -103,7 +102,6 @@
|
||||
* @regmap - Devices register map
|
||||
* @enable_gpio - VDDIO/EN gpio to enable communication interface
|
||||
* @regulator - LED supply regulator pointer
|
||||
* @label - LED label
|
||||
* @led_enable - LED sync to be enabled
|
||||
* @model_id - Current device model ID enumerated
|
||||
*/
|
||||
@ -114,7 +112,6 @@ struct lm3692x_led {
|
||||
struct regmap *regmap;
|
||||
struct gpio_desc *enable_gpio;
|
||||
struct regulator *regulator;
|
||||
char label[LED_MAX_NAME_SIZE];
|
||||
int led_enable;
|
||||
int model_id;
|
||||
};
|
||||
@ -325,7 +322,7 @@ static int lm3692x_init(struct lm3692x_led *led)
|
||||
static int lm3692x_probe_dt(struct lm3692x_led *led)
|
||||
{
|
||||
struct fwnode_handle *child = NULL;
|
||||
const char *name;
|
||||
struct led_init_data init_data = {};
|
||||
int ret;
|
||||
|
||||
led->enable_gpio = devm_gpiod_get_optional(&led->client->dev,
|
||||
@ -350,30 +347,23 @@ static int lm3692x_probe_dt(struct lm3692x_led *led)
|
||||
fwnode_property_read_string(child, "linux,default-trigger",
|
||||
&led->led_dev.default_trigger);
|
||||
|
||||
ret = fwnode_property_read_string(child, "label", &name);
|
||||
if (ret)
|
||||
snprintf(led->label, sizeof(led->label),
|
||||
"%s::", led->client->name);
|
||||
else
|
||||
snprintf(led->label, sizeof(led->label),
|
||||
"%s:%s", led->client->name, name);
|
||||
|
||||
ret = fwnode_property_read_u32(child, "reg", &led->led_enable);
|
||||
if (ret) {
|
||||
dev_err(&led->client->dev, "reg DT property missing\n");
|
||||
return ret;
|
||||
}
|
||||
|
||||
led->led_dev.name = led->label;
|
||||
init_data.fwnode = child;
|
||||
init_data.devicename = led->client->name;
|
||||
init_data.default_label = ":";
|
||||
|
||||
ret = devm_led_classdev_register(&led->client->dev, &led->led_dev);
|
||||
ret = devm_led_classdev_register_ext(&led->client->dev, &led->led_dev,
|
||||
&init_data);
|
||||
if (ret) {
|
||||
dev_err(&led->client->dev, "led register err: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
|
||||
led->led_dev.dev->of_node = to_of_node(child);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -244,10 +244,7 @@ static int lm3697_probe_dt(struct lm3697 *priv)
|
||||
led->lmu_data.lsb_brightness_reg = LM3697_CTRL_A_BRT_LSB +
|
||||
led->control_bank * 2;
|
||||
|
||||
led->num_leds = fwnode_property_read_u32_array(child,
|
||||
"led-sources",
|
||||
NULL, 0);
|
||||
|
||||
led->num_leds = fwnode_property_count_u32(child, "led-sources");
|
||||
if (led->num_leds > LM3697_MAX_LED_STRINGS) {
|
||||
dev_err(&priv->client->dev, "To many LED strings defined\n");
|
||||
continue;
|
||||
|
||||
@ -260,7 +260,11 @@ static void lp5562_firmware_loaded(struct lp55xx_chip *chip)
|
||||
{
|
||||
const struct firmware *fw = chip->fw;
|
||||
|
||||
if (fw->size > LP5562_PROGRAM_LENGTH) {
|
||||
/*
|
||||
* the firmware is encoded in ascii hex character, with 2 chars
|
||||
* per byte
|
||||
*/
|
||||
if (fw->size > (LP5562_PROGRAM_LENGTH * 2)) {
|
||||
dev_err(&chip->cl->dev, "firmware data size overflow: %zu\n",
|
||||
fw->size);
|
||||
return;
|
||||
|
||||
@ -18,7 +18,6 @@
|
||||
#include <linux/of_gpio.h>
|
||||
#include <linux/gpio/consumer.h>
|
||||
#include <linux/slab.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
#define LP8860_DISP_CL1_BRT_MSB 0x00
|
||||
#define LP8860_DISP_CL1_BRT_LSB 0x01
|
||||
@ -83,6 +82,8 @@
|
||||
|
||||
#define LP8860_CLEAR_FAULTS 0x01
|
||||
|
||||
#define LP8860_NAME "lp8860"
|
||||
|
||||
/**
|
||||
* struct lp8860_led -
|
||||
* @lock - Lock for reading/writing the device
|
||||
@ -92,7 +93,6 @@
|
||||
* @eeprom_regmap - EEPROM register map
|
||||
* @enable_gpio - VDDIO/EN gpio to enable communication interface
|
||||
* @regulator - LED supply regulator pointer
|
||||
* @label - LED label
|
||||
*/
|
||||
struct lp8860_led {
|
||||
struct mutex lock;
|
||||
@ -102,7 +102,6 @@ struct lp8860_led {
|
||||
struct regmap *eeprom_regmap;
|
||||
struct gpio_desc *enable_gpio;
|
||||
struct regulator *regulator;
|
||||
char label[LED_MAX_NAME_SIZE];
|
||||
};
|
||||
|
||||
struct lp8860_eeprom_reg {
|
||||
@ -383,26 +382,20 @@ static int lp8860_probe(struct i2c_client *client,
|
||||
struct lp8860_led *led;
|
||||
struct device_node *np = client->dev.of_node;
|
||||
struct device_node *child_node;
|
||||
const char *name;
|
||||
struct led_init_data init_data = {};
|
||||
|
||||
led = devm_kzalloc(&client->dev, sizeof(*led), GFP_KERNEL);
|
||||
if (!led)
|
||||
return -ENOMEM;
|
||||
|
||||
for_each_available_child_of_node(np, child_node) {
|
||||
child_node = of_get_next_available_child(np, NULL);
|
||||
if (!child_node)
|
||||
return -EINVAL;
|
||||
|
||||
led->led_dev.default_trigger = of_get_property(child_node,
|
||||
"linux,default-trigger",
|
||||
NULL);
|
||||
|
||||
ret = of_property_read_string(child_node, "label", &name);
|
||||
if (!ret)
|
||||
snprintf(led->label, sizeof(led->label), "%s:%s",
|
||||
id->name, name);
|
||||
else
|
||||
snprintf(led->label, sizeof(led->label),
|
||||
"%s::display_cluster", id->name);
|
||||
}
|
||||
|
||||
led->enable_gpio = devm_gpiod_get_optional(&client->dev,
|
||||
"enable", GPIOD_OUT_LOW);
|
||||
if (IS_ERR(led->enable_gpio)) {
|
||||
@ -416,7 +409,6 @@ static int lp8860_probe(struct i2c_client *client,
|
||||
led->regulator = NULL;
|
||||
|
||||
led->client = client;
|
||||
led->led_dev.name = led->label;
|
||||
led->led_dev.brightness_set_blocking = lp8860_brightness_set;
|
||||
|
||||
mutex_init(&led->lock);
|
||||
@ -443,7 +435,12 @@ static int lp8860_probe(struct i2c_client *client,
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = devm_led_classdev_register(&client->dev, &led->led_dev);
|
||||
init_data.fwnode = of_fwnode_handle(child_node);
|
||||
init_data.devicename = LP8860_NAME;
|
||||
init_data.default_label = ":display_cluster";
|
||||
|
||||
ret = devm_led_classdev_register_ext(&client->dev, &led->led_dev,
|
||||
&init_data);
|
||||
if (ret) {
|
||||
dev_err(&client->dev, "led register err: %d\n", ret);
|
||||
return ret;
|
||||
|
||||
@ -10,10 +10,10 @@
|
||||
#include <linux/slab.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/of.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
#define LED_LT3593_NAME "lt3593"
|
||||
|
||||
struct lt3593_led_data {
|
||||
char name[LED_MAX_NAME_SIZE];
|
||||
struct led_classdev cdev;
|
||||
struct gpio_desc *gpiod;
|
||||
};
|
||||
@ -66,6 +66,7 @@ static int lt3593_led_probe(struct platform_device *pdev)
|
||||
struct lt3593_led_data *led_data;
|
||||
struct fwnode_handle *child;
|
||||
int ret, state = LEDS_GPIO_DEFSTATE_OFF;
|
||||
struct led_init_data init_data = {};
|
||||
const char *tmp;
|
||||
|
||||
if (!dev->of_node)
|
||||
@ -86,14 +87,6 @@ static int lt3593_led_probe(struct platform_device *pdev)
|
||||
|
||||
child = device_get_next_child_node(dev, NULL);
|
||||
|
||||
ret = fwnode_property_read_string(child, "label", &tmp);
|
||||
if (ret < 0)
|
||||
snprintf(led_data->name, sizeof(led_data->name),
|
||||
"lt3593::");
|
||||
else
|
||||
snprintf(led_data->name, sizeof(led_data->name),
|
||||
"lt3593:%s", tmp);
|
||||
|
||||
fwnode_property_read_string(child, "linux,default-trigger",
|
||||
&led_data->cdev.default_trigger);
|
||||
|
||||
@ -102,11 +95,14 @@ static int lt3593_led_probe(struct platform_device *pdev)
|
||||
state = LEDS_GPIO_DEFSTATE_ON;
|
||||
}
|
||||
|
||||
led_data->cdev.name = led_data->name;
|
||||
led_data->cdev.brightness_set_blocking = lt3593_led_set;
|
||||
led_data->cdev.brightness = state ? LED_FULL : LED_OFF;
|
||||
|
||||
ret = devm_led_classdev_register(dev, &led_data->cdev);
|
||||
init_data.fwnode = child;
|
||||
init_data.devicename = LED_LT3593_NAME;
|
||||
init_data.default_label = ":";
|
||||
|
||||
ret = devm_led_classdev_register_ext(dev, &led_data->cdev, &init_data);
|
||||
if (ret < 0) {
|
||||
fwnode_handle_put(child);
|
||||
return ret;
|
||||
|
||||
@ -62,7 +62,7 @@ static int max77650_led_brightness_set(struct led_classdev *cdev,
|
||||
|
||||
static int max77650_led_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct device_node *of_node, *child;
|
||||
struct fwnode_handle *child;
|
||||
struct max77650_led *leds, *led;
|
||||
struct device *dev;
|
||||
struct regmap *map;
|
||||
@ -71,10 +71,6 @@ static int max77650_led_probe(struct platform_device *pdev)
|
||||
u32 reg;
|
||||
|
||||
dev = &pdev->dev;
|
||||
of_node = dev->of_node;
|
||||
|
||||
if (!of_node)
|
||||
return -ENODEV;
|
||||
|
||||
leds = devm_kcalloc(dev, sizeof(*leds),
|
||||
MAX77650_LED_NUM_LEDS, GFP_KERNEL);
|
||||
@ -85,14 +81,16 @@ static int max77650_led_probe(struct platform_device *pdev)
|
||||
if (!map)
|
||||
return -ENODEV;
|
||||
|
||||
num_leds = of_get_child_count(of_node);
|
||||
num_leds = device_get_child_node_count(dev);
|
||||
if (!num_leds || num_leds > MAX77650_LED_NUM_LEDS)
|
||||
return -ENODEV;
|
||||
|
||||
for_each_child_of_node(of_node, child) {
|
||||
rv = of_property_read_u32(child, "reg", ®);
|
||||
if (rv || reg >= MAX77650_LED_NUM_LEDS)
|
||||
return -EINVAL;
|
||||
device_for_each_child_node(dev, child) {
|
||||
rv = fwnode_property_read_u32(child, "reg", ®);
|
||||
if (rv || reg >= MAX77650_LED_NUM_LEDS) {
|
||||
rv = -EINVAL;
|
||||
goto err_node_put;
|
||||
}
|
||||
|
||||
led = &leds[reg];
|
||||
led->map = map;
|
||||
@ -101,35 +99,40 @@ static int max77650_led_probe(struct platform_device *pdev)
|
||||
led->cdev.brightness_set_blocking = max77650_led_brightness_set;
|
||||
led->cdev.max_brightness = MAX77650_LED_MAX_BRIGHTNESS;
|
||||
|
||||
label = of_get_property(child, "label", NULL);
|
||||
if (!label) {
|
||||
rv = fwnode_property_read_string(child, "label", &label);
|
||||
if (rv) {
|
||||
led->cdev.name = "max77650::";
|
||||
} else {
|
||||
led->cdev.name = devm_kasprintf(dev, GFP_KERNEL,
|
||||
"max77650:%s", label);
|
||||
if (!led->cdev.name)
|
||||
return -ENOMEM;
|
||||
if (!led->cdev.name) {
|
||||
rv = -ENOMEM;
|
||||
goto err_node_put;
|
||||
}
|
||||
}
|
||||
|
||||
of_property_read_string(child, "linux,default-trigger",
|
||||
fwnode_property_read_string(child, "linux,default-trigger",
|
||||
&led->cdev.default_trigger);
|
||||
|
||||
rv = devm_of_led_classdev_register(dev, child, &led->cdev);
|
||||
rv = devm_led_classdev_register(dev, &led->cdev);
|
||||
if (rv)
|
||||
return rv;
|
||||
goto err_node_put;
|
||||
|
||||
rv = regmap_write(map, led->regA, MAX77650_LED_A_DEFAULT);
|
||||
if (rv)
|
||||
return rv;
|
||||
goto err_node_put;
|
||||
|
||||
rv = regmap_write(map, led->regB, MAX77650_LED_B_DEFAULT);
|
||||
if (rv)
|
||||
return rv;
|
||||
goto err_node_put;
|
||||
}
|
||||
|
||||
return regmap_write(map,
|
||||
MAX77650_REG_CNFG_LED_TOP,
|
||||
MAX77650_LED_TOP_DEFAULT);
|
||||
err_node_put:
|
||||
fwnode_handle_put(child);
|
||||
return rv;
|
||||
}
|
||||
|
||||
static struct platform_driver max77650_led_driver = {
|
||||
@ -143,3 +146,4 @@ module_platform_driver(max77650_led_driver);
|
||||
MODULE_DESCRIPTION("MAXIM 77650/77651 LED driver");
|
||||
MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_ALIAS("platform:max77650-led");
|
||||
|
||||
@ -15,7 +15,48 @@
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/of_gpio.h>
|
||||
#include <linux/leds.h>
|
||||
#include <linux/platform_data/leds-kirkwood-netxbig.h>
|
||||
|
||||
struct netxbig_gpio_ext {
|
||||
unsigned int *addr;
|
||||
int num_addr;
|
||||
unsigned int *data;
|
||||
int num_data;
|
||||
unsigned int enable;
|
||||
};
|
||||
|
||||
enum netxbig_led_mode {
|
||||
NETXBIG_LED_OFF,
|
||||
NETXBIG_LED_ON,
|
||||
NETXBIG_LED_SATA,
|
||||
NETXBIG_LED_TIMER1,
|
||||
NETXBIG_LED_TIMER2,
|
||||
NETXBIG_LED_MODE_NUM,
|
||||
};
|
||||
|
||||
#define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM
|
||||
|
||||
struct netxbig_led_timer {
|
||||
unsigned long delay_on;
|
||||
unsigned long delay_off;
|
||||
enum netxbig_led_mode mode;
|
||||
};
|
||||
|
||||
struct netxbig_led {
|
||||
const char *name;
|
||||
const char *default_trigger;
|
||||
int mode_addr;
|
||||
int *mode_val;
|
||||
int bright_addr;
|
||||
int bright_max;
|
||||
};
|
||||
|
||||
struct netxbig_led_platform_data {
|
||||
struct netxbig_gpio_ext *gpio_ext;
|
||||
struct netxbig_led_timer *timer;
|
||||
int num_timer;
|
||||
struct netxbig_led *leds;
|
||||
int num_leds;
|
||||
};
|
||||
|
||||
/*
|
||||
* GPIO extension bus.
|
||||
@ -306,7 +347,6 @@ static int create_netxbig_led(struct platform_device *pdev,
|
||||
return devm_led_classdev_register(&pdev->dev, &led_dat->cdev);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_OF_GPIO
|
||||
static int gpio_ext_get_of_pdata(struct device *dev, struct device_node *np,
|
||||
struct netxbig_gpio_ext *gpio_ext)
|
||||
{
|
||||
@ -388,12 +428,14 @@ static int netxbig_leds_get_of_pdata(struct device *dev,
|
||||
}
|
||||
|
||||
gpio_ext = devm_kzalloc(dev, sizeof(*gpio_ext), GFP_KERNEL);
|
||||
if (!gpio_ext)
|
||||
if (!gpio_ext) {
|
||||
of_node_put(gpio_ext_np);
|
||||
return -ENOMEM;
|
||||
}
|
||||
ret = gpio_ext_get_of_pdata(dev, gpio_ext_np, gpio_ext);
|
||||
of_node_put(gpio_ext_np);
|
||||
if (ret)
|
||||
return ret;
|
||||
of_node_put(gpio_ext_np);
|
||||
pdata->gpio_ext = gpio_ext;
|
||||
|
||||
/* Timers (optional) */
|
||||
@ -522,30 +564,20 @@ static const struct of_device_id of_netxbig_leds_match[] = {
|
||||
{},
|
||||
};
|
||||
MODULE_DEVICE_TABLE(of, of_netxbig_leds_match);
|
||||
#else
|
||||
static inline int
|
||||
netxbig_leds_get_of_pdata(struct device *dev,
|
||||
struct netxbig_led_platform_data *pdata)
|
||||
{
|
||||
return -ENODEV;
|
||||
}
|
||||
#endif /* CONFIG_OF_GPIO */
|
||||
|
||||
static int netxbig_led_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct netxbig_led_platform_data *pdata = dev_get_platdata(&pdev->dev);
|
||||
struct netxbig_led_platform_data *pdata;
|
||||
struct netxbig_led_data *leds_data;
|
||||
int i;
|
||||
int ret;
|
||||
|
||||
if (!pdata) {
|
||||
pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
|
||||
if (!pdata)
|
||||
return -ENOMEM;
|
||||
ret = netxbig_leds_get_of_pdata(&pdev->dev, pdata);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
leds_data = devm_kcalloc(&pdev->dev,
|
||||
pdata->num_leds, sizeof(*leds_data),
|
||||
@ -571,7 +603,7 @@ static struct platform_driver netxbig_led_driver = {
|
||||
.probe = netxbig_led_probe,
|
||||
.driver = {
|
||||
.name = "leds-netxbig",
|
||||
.of_match_table = of_match_ptr(of_netxbig_leds_match),
|
||||
.of_match_table = of_netxbig_leds_match,
|
||||
},
|
||||
};
|
||||
|
||||
|
||||
@ -245,7 +245,7 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
|
||||
struct device_node *np = dev->of_node;
|
||||
struct device_node *child;
|
||||
struct ns2_led *led, *leds;
|
||||
int num_leds = 0;
|
||||
int ret, num_leds = 0;
|
||||
|
||||
num_leds = of_get_child_count(np);
|
||||
if (!num_leds)
|
||||
@ -259,16 +259,16 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
|
||||
led = leds;
|
||||
for_each_child_of_node(np, child) {
|
||||
const char *string;
|
||||
int ret, i, num_modes;
|
||||
int i, num_modes;
|
||||
struct ns2_led_modval *modval;
|
||||
|
||||
ret = of_get_named_gpio(child, "cmd-gpio", 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
goto err_node_put;
|
||||
led->cmd = ret;
|
||||
ret = of_get_named_gpio(child, "slow-gpio", 0);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
goto err_node_put;
|
||||
led->slow = ret;
|
||||
ret = of_property_read_string(child, "label", &string);
|
||||
led->name = (ret == 0) ? string : child->name;
|
||||
@ -281,7 +281,8 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
|
||||
if (ret < 0 || ret % 3) {
|
||||
dev_err(dev,
|
||||
"Missing or malformed modes-map property\n");
|
||||
return -EINVAL;
|
||||
ret = -EINVAL;
|
||||
goto err_node_put;
|
||||
}
|
||||
|
||||
num_modes = ret / 3;
|
||||
@ -289,8 +290,10 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
|
||||
num_modes,
|
||||
sizeof(struct ns2_led_modval),
|
||||
GFP_KERNEL);
|
||||
if (!modval)
|
||||
return -ENOMEM;
|
||||
if (!modval) {
|
||||
ret = -ENOMEM;
|
||||
goto err_node_put;
|
||||
}
|
||||
|
||||
for (i = 0; i < num_modes; i++) {
|
||||
of_property_read_u32_index(child,
|
||||
@ -314,6 +317,10 @@ ns2_leds_get_of_pdata(struct device *dev, struct ns2_led_platform_data *pdata)
|
||||
pdata->num_leds = num_leds;
|
||||
|
||||
return 0;
|
||||
|
||||
err_node_put:
|
||||
of_node_put(child);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct of_device_id of_ns2_leds_match[] = {
|
||||
|
||||
@ -16,7 +16,7 @@
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <linux/leds-pca9532.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/gpio/driver.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/of_device.h>
|
||||
|
||||
|
||||
@ -65,12 +65,6 @@ static int led_pwm_set(struct led_classdev *led_cdev,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline size_t sizeof_pwm_leds_priv(int num_leds)
|
||||
{
|
||||
return sizeof(struct led_pwm_priv) +
|
||||
(sizeof(struct led_pwm_data) * num_leds);
|
||||
}
|
||||
|
||||
static int led_pwm_add(struct device *dev, struct led_pwm_priv *priv,
|
||||
struct led_pwm *led, struct fwnode_handle *fwnode)
|
||||
{
|
||||
@ -111,8 +105,7 @@ static int led_pwm_add(struct device *dev, struct led_pwm_priv *priv,
|
||||
if (!led_data->period && (led->pwm_period_ns > 0))
|
||||
led_data->period = led->pwm_period_ns;
|
||||
|
||||
ret = devm_of_led_classdev_register(dev, to_of_node(fwnode),
|
||||
&led_data->cdev);
|
||||
ret = devm_led_classdev_register(dev, &led_data->cdev);
|
||||
if (ret == 0) {
|
||||
priv->num_leds++;
|
||||
led_pwm_set(&led_data->cdev, led_data->cdev.brightness);
|
||||
@ -175,7 +168,7 @@ static int led_pwm_probe(struct platform_device *pdev)
|
||||
if (!count)
|
||||
return -EINVAL;
|
||||
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof_pwm_leds_priv(count),
|
||||
priv = devm_kzalloc(&pdev->dev, struct_size(priv, leds, count),
|
||||
GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
@ -6,7 +6,6 @@
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/regmap.h>
|
||||
#include <uapi/linux/uleds.h>
|
||||
|
||||
/* PMIC global control register definition */
|
||||
#define SC27XX_MODULE_EN0 0xc08
|
||||
@ -46,7 +45,7 @@
|
||||
#define SC27XX_DELTA_T_MAX (SC27XX_LEDS_STEP * 255)
|
||||
|
||||
struct sc27xx_led {
|
||||
char name[LED_MAX_NAME_SIZE];
|
||||
struct fwnode_handle *fwnode;
|
||||
struct led_classdev ldev;
|
||||
struct sc27xx_led_priv *priv;
|
||||
u8 line;
|
||||
@ -249,19 +248,24 @@ static int sc27xx_led_register(struct device *dev, struct sc27xx_led_priv *priv)
|
||||
|
||||
for (i = 0; i < SC27XX_LEDS_MAX; i++) {
|
||||
struct sc27xx_led *led = &priv->leds[i];
|
||||
struct led_init_data init_data = {};
|
||||
|
||||
if (!led->active)
|
||||
continue;
|
||||
|
||||
led->line = i;
|
||||
led->priv = priv;
|
||||
led->ldev.name = led->name;
|
||||
led->ldev.brightness_set_blocking = sc27xx_led_set;
|
||||
led->ldev.pattern_set = sc27xx_led_pattern_set;
|
||||
led->ldev.pattern_clear = sc27xx_led_pattern_clear;
|
||||
led->ldev.default_trigger = "pattern";
|
||||
|
||||
err = devm_led_classdev_register(dev, &led->ldev);
|
||||
init_data.fwnode = led->fwnode;
|
||||
init_data.devicename = "sc27xx";
|
||||
init_data.default_label = ":";
|
||||
|
||||
err = devm_led_classdev_register_ext(dev, &led->ldev,
|
||||
&init_data);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
@ -274,7 +278,6 @@ static int sc27xx_led_probe(struct platform_device *pdev)
|
||||
struct device *dev = &pdev->dev;
|
||||
struct device_node *np = dev->of_node, *child;
|
||||
struct sc27xx_led_priv *priv;
|
||||
const char *str;
|
||||
u32 base, count, reg;
|
||||
int err;
|
||||
|
||||
@ -316,15 +319,8 @@ static int sc27xx_led_probe(struct platform_device *pdev)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
priv->leds[reg].fwnode = of_fwnode_handle(child);
|
||||
priv->leds[reg].active = true;
|
||||
|
||||
err = of_property_read_string(child, "label", &str);
|
||||
if (err)
|
||||
snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
|
||||
"sc27xx::");
|
||||
else
|
||||
snprintf(priv->leds[reg].name, LED_MAX_NAME_SIZE,
|
||||
"sc27xx:%s", str);
|
||||
}
|
||||
|
||||
err = sc27xx_led_register(dev, priv);
|
||||
|
||||
@ -115,7 +115,7 @@ static int syscon_led_probe(struct platform_device *pdev)
|
||||
}
|
||||
sled->cdev.brightness_set = syscon_led_set;
|
||||
|
||||
ret = led_classdev_register(dev, &sled->cdev);
|
||||
ret = devm_led_classdev_register(dev, &sled->cdev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
|
||||
@ -11,10 +11,10 @@
|
||||
|
||||
#include <linux/leds-ti-lmu-common.h>
|
||||
|
||||
const static int ramp_table[16] = {2048, 262000, 524000, 1049000, 2090000,
|
||||
4194000, 8389000, 16780000, 33550000, 41940000,
|
||||
50330000, 58720000, 67110000, 83880000,
|
||||
100660000, 117440000};
|
||||
static const unsigned int ramp_table[16] = {2048, 262000, 524000, 1049000,
|
||||
2090000, 4194000, 8389000, 16780000, 33550000,
|
||||
41940000, 50330000, 58720000, 67110000,
|
||||
83880000, 100660000, 117440000};
|
||||
|
||||
static int ti_lmu_common_update_brightness(struct ti_lmu_bank *lmu_bank,
|
||||
int brightness)
|
||||
@ -54,7 +54,7 @@ int ti_lmu_common_set_brightness(struct ti_lmu_bank *lmu_bank, int brightness)
|
||||
}
|
||||
EXPORT_SYMBOL(ti_lmu_common_set_brightness);
|
||||
|
||||
static int ti_lmu_common_convert_ramp_to_index(unsigned int usec)
|
||||
static unsigned int ti_lmu_common_convert_ramp_to_index(unsigned int usec)
|
||||
{
|
||||
int size = ARRAY_SIZE(ramp_table);
|
||||
int i;
|
||||
@ -78,7 +78,7 @@ static int ti_lmu_common_convert_ramp_to_index(unsigned int usec)
|
||||
}
|
||||
}
|
||||
|
||||
return -EINVAL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ti_lmu_common_set_ramp(struct ti_lmu_bank *lmu_bank)
|
||||
@ -94,9 +94,6 @@ int ti_lmu_common_set_ramp(struct ti_lmu_bank *lmu_bank)
|
||||
ramp_down = ti_lmu_common_convert_ramp_to_index(lmu_bank->ramp_down_usec);
|
||||
}
|
||||
|
||||
if (ramp_up < 0 || ramp_down < 0)
|
||||
return -EINVAL;
|
||||
|
||||
ramp = (ramp_up << 4) | ramp_down;
|
||||
|
||||
return regmap_write(regmap, lmu_bank->runtime_ramp_reg, ramp);
|
||||
|
||||
@ -27,5 +27,6 @@ void led_set_brightness_nosleep(struct led_classdev *led_cdev,
|
||||
extern struct rw_semaphore leds_list_lock;
|
||||
extern struct list_head leds_list;
|
||||
extern struct list_head trigger_list;
|
||||
extern const char * const led_colors[LED_COLOR_ID_MAX];
|
||||
|
||||
#endif /* __LEDS_H_INCLUDED */
|
||||
|
||||
@ -131,10 +131,10 @@ static ssize_t gpio_trig_gpio_store(struct device *dev,
|
||||
if (gpio_data->gpio == gpio)
|
||||
return n;
|
||||
|
||||
if (!gpio) {
|
||||
if (gpio_data->gpio != 0)
|
||||
if (!gpio_is_valid(gpio)) {
|
||||
if (gpio_is_valid(gpio_data->gpio))
|
||||
free_irq(gpio_to_irq(gpio_data->gpio), led);
|
||||
gpio_data->gpio = 0;
|
||||
gpio_data->gpio = gpio;
|
||||
return n;
|
||||
}
|
||||
|
||||
@ -144,7 +144,7 @@ static ssize_t gpio_trig_gpio_store(struct device *dev,
|
||||
if (ret) {
|
||||
dev_err(dev, "request_irq failed with error %d\n", ret);
|
||||
} else {
|
||||
if (gpio_data->gpio != 0)
|
||||
if (gpio_is_valid(gpio_data->gpio))
|
||||
free_irq(gpio_to_irq(gpio_data->gpio), led);
|
||||
gpio_data->gpio = gpio;
|
||||
/* After changing the GPIO, we need to update the LED. */
|
||||
@ -172,6 +172,8 @@ static int gpio_trig_activate(struct led_classdev *led)
|
||||
return -ENOMEM;
|
||||
|
||||
gpio_data->led = led;
|
||||
gpio_data->gpio = -ENOENT;
|
||||
|
||||
led_set_trigger_data(led, gpio_data);
|
||||
|
||||
return 0;
|
||||
@ -181,7 +183,7 @@ static void gpio_trig_deactivate(struct led_classdev *led)
|
||||
{
|
||||
struct gpio_trig_data *gpio_data = led_get_trigger_data(led);
|
||||
|
||||
if (gpio_data->gpio != 0)
|
||||
if (gpio_is_valid(gpio_data->gpio))
|
||||
free_irq(gpio_to_irq(gpio_data->gpio), led);
|
||||
kfree(gpio_data);
|
||||
}
|
||||
|
||||
@ -87,16 +87,6 @@ static struct regmap_config altr_sysmgr_regmap_cfg = {
|
||||
.use_single_write = true,
|
||||
};
|
||||
|
||||
/**
|
||||
* sysmgr_match_phandle
|
||||
* Matching function used by driver_find_device().
|
||||
* Return: True if match is found, otherwise false.
|
||||
*/
|
||||
static int sysmgr_match_phandle(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == (const struct device_node *)data;
|
||||
}
|
||||
|
||||
/**
|
||||
* altr_sysmgr_regmap_lookup_by_phandle
|
||||
* Find the sysmgr previous configured in probe() and return regmap property.
|
||||
@ -117,8 +107,8 @@ struct regmap *altr_sysmgr_regmap_lookup_by_phandle(struct device_node *np,
|
||||
if (!sysmgr_np)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
dev = driver_find_device(&altr_sysmgr_driver.driver, NULL,
|
||||
(void *)sysmgr_np, sysmgr_match_phandle);
|
||||
dev = driver_find_device_by_of_node(&altr_sysmgr_driver.driver,
|
||||
(void *)sysmgr_np);
|
||||
of_node_put(sysmgr_np);
|
||||
if (!dev)
|
||||
return ERR_PTR(-EPROBE_DEFER);
|
||||
|
||||
@ -858,13 +858,6 @@ static ssize_t dev_state_show(struct device *device,
|
||||
}
|
||||
static DEVICE_ATTR_RO(dev_state);
|
||||
|
||||
static int match_devt(struct device *dev, const void *data)
|
||||
{
|
||||
const dev_t *devt = data;
|
||||
|
||||
return dev->devt == *devt;
|
||||
}
|
||||
|
||||
/**
|
||||
* dev_set_devstate: set to new device state and notify sysfs file.
|
||||
*
|
||||
@ -880,7 +873,7 @@ void mei_set_devstate(struct mei_device *dev, enum mei_dev_state state)
|
||||
|
||||
dev->dev_state = state;
|
||||
|
||||
clsdev = class_find_device(mei_class, NULL, &dev->cdev.dev, match_devt);
|
||||
clsdev = class_find_device_by_devt(mei_class, dev->cdev.dev);
|
||||
if (clsdev) {
|
||||
sysfs_notify(&clsdev->kobj, NULL, "dev_state");
|
||||
put_device(clsdev);
|
||||
|
||||
@ -405,17 +405,12 @@ int mux_control_deselect(struct mux_control *mux)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(mux_control_deselect);
|
||||
|
||||
static int of_dev_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/* Note this function returns a reference to the mux_chip dev. */
|
||||
static struct mux_chip *of_find_mux_chip_by_node(struct device_node *np)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(&mux_class, NULL, np, of_dev_node_match);
|
||||
dev = class_find_device_by_of_node(&mux_class, np);
|
||||
|
||||
return dev ? to_mux_chip(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -754,17 +754,11 @@ struct dsaf_misc_op *hns_misc_op_get(struct dsaf_device *dsaf_dev)
|
||||
return (void *)misc_op;
|
||||
}
|
||||
|
||||
static int hns_dsaf_dev_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev->fwnode == fwnode;
|
||||
}
|
||||
|
||||
struct
|
||||
platform_device *hns_dsaf_find_platform_device(struct fwnode_handle *fwnode)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&platform_bus_type, NULL,
|
||||
fwnode, hns_dsaf_dev_match);
|
||||
dev = bus_find_device_by_fwnode(&platform_bus_type, fwnode);
|
||||
return dev ? to_platform_device(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -262,11 +262,6 @@ static struct class mdio_bus_class = {
|
||||
};
|
||||
|
||||
#if IS_ENABLED(CONFIG_OF_MDIO)
|
||||
/* Helper function for of_mdio_find_bus */
|
||||
static int of_mdio_bus_match(struct device *dev, const void *mdio_bus_np)
|
||||
{
|
||||
return dev->of_node == mdio_bus_np;
|
||||
}
|
||||
/**
|
||||
* of_mdio_find_bus - Given an mii_bus node, find the mii_bus.
|
||||
* @mdio_bus_np: Pointer to the mii_bus.
|
||||
@ -287,9 +282,7 @@ struct mii_bus *of_mdio_find_bus(struct device_node *mdio_bus_np)
|
||||
if (!mdio_bus_np)
|
||||
return NULL;
|
||||
|
||||
d = class_find_device(&mdio_bus_class, NULL, mdio_bus_np,
|
||||
of_mdio_bus_match);
|
||||
|
||||
d = class_find_device_by_of_node(&mdio_bus_class, mdio_bus_np);
|
||||
return d ? to_mii_bus(d) : NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(of_mdio_find_bus);
|
||||
|
||||
@ -76,11 +76,6 @@ static struct bus_type nvmem_bus_type = {
|
||||
.name = "nvmem",
|
||||
};
|
||||
|
||||
static int of_nvmem_match(struct device *dev, const void *nvmem_np)
|
||||
{
|
||||
return dev->of_node == nvmem_np;
|
||||
}
|
||||
|
||||
static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
|
||||
{
|
||||
struct device *d;
|
||||
@ -88,7 +83,7 @@ static struct nvmem_device *of_nvmem_find(struct device_node *nvmem_np)
|
||||
if (!nvmem_np)
|
||||
return NULL;
|
||||
|
||||
d = bus_find_device(&nvmem_bus_type, NULL, nvmem_np, of_nvmem_match);
|
||||
d = bus_find_device_by_of_node(&nvmem_bus_type, nvmem_np);
|
||||
|
||||
if (!d)
|
||||
return NULL;
|
||||
|
||||
@ -280,12 +280,6 @@ int of_mdiobus_register(struct mii_bus *mdio, struct device_node *np)
|
||||
}
|
||||
EXPORT_SYMBOL(of_mdiobus_register);
|
||||
|
||||
/* Helper function for of_phy_find_device */
|
||||
static int of_phy_match(struct device *dev, const void *phy_np)
|
||||
{
|
||||
return dev->of_node == phy_np;
|
||||
}
|
||||
|
||||
/**
|
||||
* of_phy_find_device - Give a PHY node, find the phy_device
|
||||
* @phy_np: Pointer to the phy's device tree node
|
||||
@ -301,7 +295,7 @@ struct phy_device *of_phy_find_device(struct device_node *phy_np)
|
||||
if (!phy_np)
|
||||
return NULL;
|
||||
|
||||
d = bus_find_device(&mdio_bus_type, NULL, phy_np, of_phy_match);
|
||||
d = bus_find_device_by_of_node(&mdio_bus_type, phy_np);
|
||||
if (d) {
|
||||
mdiodev = to_mdio_device(d);
|
||||
if (mdiodev->flags & MDIO_DEVICE_FLAG_PHY)
|
||||
|
||||
@ -37,11 +37,6 @@ static const struct of_device_id of_skipped_node_table[] = {
|
||||
{} /* Empty terminated list */
|
||||
};
|
||||
|
||||
static int of_dev_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/**
|
||||
* of_find_device_by_node - Find the platform_device associated with a node
|
||||
* @np: Pointer to device tree node
|
||||
@ -55,7 +50,7 @@ struct platform_device *of_find_device_by_node(struct device_node *np)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&platform_bus_type, NULL, np, of_dev_node_match);
|
||||
dev = bus_find_device_by_of_node(&platform_bus_type, np);
|
||||
return dev ? to_platform_device(dev) : NULL;
|
||||
}
|
||||
EXPORT_SYMBOL(of_find_device_by_node);
|
||||
|
||||
@ -64,11 +64,6 @@ static struct resource *get_pci_domain_busn_res(int domain_nr)
|
||||
return &r->res;
|
||||
}
|
||||
|
||||
static int find_anything(struct device *dev, const void *data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Some device drivers need know if PCI is initiated.
|
||||
* Basically, we think PCI is not initiated when there
|
||||
@ -79,7 +74,7 @@ int no_pci_devices(void)
|
||||
struct device *dev;
|
||||
int no_devices;
|
||||
|
||||
dev = bus_find_device(&pci_bus_type, NULL, NULL, find_anything);
|
||||
dev = bus_find_next_device(&pci_bus_type, NULL);
|
||||
no_devices = (dev == NULL);
|
||||
put_device(dev);
|
||||
return no_devices;
|
||||
|
||||
@ -462,16 +462,11 @@ struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static int of_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
struct regulator_dev *of_find_regulator_by_node(struct device_node *np)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(®ulator_class, NULL, np, of_node_match);
|
||||
dev = class_find_device_by_of_node(®ulator_class, np);
|
||||
|
||||
return dev ? dev_to_rdev(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -663,21 +663,12 @@ void rtc_update_irq(struct rtc_device *rtc,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(rtc_update_irq);
|
||||
|
||||
static int __rtc_match(struct device *dev, const void *data)
|
||||
{
|
||||
const char *name = data;
|
||||
|
||||
if (strcmp(dev_name(dev), name) == 0)
|
||||
return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct rtc_device *rtc_class_open(const char *name)
|
||||
{
|
||||
struct device *dev;
|
||||
struct rtc_device *rtc = NULL;
|
||||
|
||||
dev = class_find_device(rtc_class, NULL, name, __rtc_match);
|
||||
dev = class_find_device_by_name(rtc_class, name);
|
||||
if (dev)
|
||||
rtc = to_rtc_device(dev);
|
||||
|
||||
|
||||
@ -581,11 +581,6 @@ int ccwgroup_driver_register(struct ccwgroup_driver *cdriver)
|
||||
}
|
||||
EXPORT_SYMBOL(ccwgroup_driver_register);
|
||||
|
||||
static int __ccwgroup_match_all(struct device *dev, const void *data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* ccwgroup_driver_unregister() - deregister a ccw group driver
|
||||
* @cdriver: driver to be deregistered
|
||||
@ -597,8 +592,7 @@ void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
|
||||
struct device *dev;
|
||||
|
||||
/* We don't want ccwgroup devices to live longer than their driver. */
|
||||
while ((dev = driver_find_device(&cdriver->driver, NULL, NULL,
|
||||
__ccwgroup_match_all))) {
|
||||
while ((dev = driver_find_next_device(&cdriver->driver, NULL))) {
|
||||
struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
|
||||
|
||||
ccwgroup_ungroup(gdev);
|
||||
@ -608,13 +602,6 @@ void ccwgroup_driver_unregister(struct ccwgroup_driver *cdriver)
|
||||
}
|
||||
EXPORT_SYMBOL(ccwgroup_driver_unregister);
|
||||
|
||||
static int __ccwgroupdev_check_busid(struct device *dev, const void *id)
|
||||
{
|
||||
const char *bus_id = id;
|
||||
|
||||
return (strcmp(bus_id, dev_name(dev)) == 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* get_ccwgroupdev_by_busid() - obtain device from a bus id
|
||||
* @gdrv: driver the device is owned by
|
||||
@ -631,8 +618,7 @@ struct ccwgroup_device *get_ccwgroupdev_by_busid(struct ccwgroup_driver *gdrv,
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = driver_find_device(&gdrv->driver, NULL, bus_id,
|
||||
__ccwgroupdev_check_busid);
|
||||
dev = driver_find_device_by_name(&gdrv->driver, bus_id);
|
||||
|
||||
return dev ? to_ccwgroupdev(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -1695,18 +1695,6 @@ int ccw_device_force_console(struct ccw_device *cdev)
|
||||
EXPORT_SYMBOL_GPL(ccw_device_force_console);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* get ccw_device matching the busid, but only if owned by cdrv
|
||||
*/
|
||||
static int
|
||||
__ccwdev_check_busid(struct device *dev, const void *id)
|
||||
{
|
||||
const char *bus_id = id;
|
||||
|
||||
return (strcmp(bus_id, dev_name(dev)) == 0);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* get_ccwdev_by_busid() - obtain device from a bus id
|
||||
* @cdrv: driver the device is owned by
|
||||
@ -1723,8 +1711,7 @@ struct ccw_device *get_ccwdev_by_busid(struct ccw_driver *cdrv,
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = driver_find_device(&cdrv->driver, NULL, (void *)bus_id,
|
||||
__ccwdev_check_busid);
|
||||
dev = driver_find_device_by_name(&cdrv->driver, bus_id);
|
||||
|
||||
return dev ? to_ccwdev(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -134,18 +134,6 @@ struct zcdn_device {
|
||||
static int zcdn_create(const char *name);
|
||||
static int zcdn_destroy(const char *name);
|
||||
|
||||
/* helper function, matches the name for find_zcdndev_by_name() */
|
||||
static int __match_zcdn_name(struct device *dev, const void *data)
|
||||
{
|
||||
return strcmp(dev_name(dev), (const char *)data) == 0;
|
||||
}
|
||||
|
||||
/* helper function, matches the devt value for find_zcdndev_by_devt() */
|
||||
static int __match_zcdn_devt(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->devt == *((dev_t *) data);
|
||||
}
|
||||
|
||||
/*
|
||||
* Find zcdn device by name.
|
||||
* Returns reference to the zcdn device which needs to be released
|
||||
@ -153,10 +141,7 @@ static int __match_zcdn_devt(struct device *dev, const void *data)
|
||||
*/
|
||||
static inline struct zcdn_device *find_zcdndev_by_name(const char *name)
|
||||
{
|
||||
struct device *dev =
|
||||
class_find_device(zcrypt_class, NULL,
|
||||
(void *) name,
|
||||
__match_zcdn_name);
|
||||
struct device *dev = class_find_device_by_name(zcrypt_class, name);
|
||||
|
||||
return dev ? to_zcdn_dev(dev) : NULL;
|
||||
}
|
||||
@ -168,10 +153,7 @@ static inline struct zcdn_device *find_zcdndev_by_name(const char *name)
|
||||
*/
|
||||
static inline struct zcdn_device *find_zcdndev_by_devt(dev_t devt)
|
||||
{
|
||||
struct device *dev =
|
||||
class_find_device(zcrypt_class, NULL,
|
||||
(void *) &devt,
|
||||
__match_zcdn_devt);
|
||||
struct device *dev = class_find_device_by_devt(zcrypt_class, devt);
|
||||
|
||||
return dev ? to_zcdn_dev(dev) : NULL;
|
||||
}
|
||||
|
||||
@ -372,15 +372,10 @@ static ssize_t proc_scsi_write(struct file *file, const char __user *buf,
|
||||
return err;
|
||||
}
|
||||
|
||||
static int always_match(struct device *dev, const void *data)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline struct device *next_scsi_device(struct device *start)
|
||||
{
|
||||
struct device *next = bus_find_device(&scsi_bus_type, start, NULL,
|
||||
always_match);
|
||||
struct device *next = bus_find_next_device(&scsi_bus_type, start);
|
||||
|
||||
put_device(start);
|
||||
return next;
|
||||
}
|
||||
|
||||
@ -3655,37 +3655,25 @@ EXPORT_SYMBOL_GPL(spi_write_then_read);
|
||||
/*-------------------------------------------------------------------------*/
|
||||
|
||||
#if IS_ENABLED(CONFIG_OF)
|
||||
static int __spi_of_device_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/* must call put_device() when done with returned spi_device device */
|
||||
struct spi_device *of_find_spi_device_by_node(struct device_node *node)
|
||||
{
|
||||
struct device *dev = bus_find_device(&spi_bus_type, NULL, node,
|
||||
__spi_of_device_match);
|
||||
struct device *dev = bus_find_device_by_of_node(&spi_bus_type, node);
|
||||
|
||||
return dev ? to_spi_device(dev) : NULL;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(of_find_spi_device_by_node);
|
||||
#endif /* IS_ENABLED(CONFIG_OF) */
|
||||
|
||||
#if IS_ENABLED(CONFIG_OF_DYNAMIC)
|
||||
static int __spi_of_controller_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
/* the spi controllers are not using spi_bus, so we find it with another way */
|
||||
static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = class_find_device(&spi_master_class, NULL, node,
|
||||
__spi_of_controller_match);
|
||||
dev = class_find_device_by_of_node(&spi_master_class, node);
|
||||
if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
|
||||
dev = class_find_device(&spi_slave_class, NULL, node,
|
||||
__spi_of_controller_match);
|
||||
dev = class_find_device_by_of_node(&spi_slave_class, node);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
@ -3756,11 +3744,6 @@ static int spi_acpi_controller_match(struct device *dev, const void *data)
|
||||
return ACPI_COMPANION(dev->parent) == data;
|
||||
}
|
||||
|
||||
static int spi_acpi_device_match(struct device *dev, const void *data)
|
||||
{
|
||||
return ACPI_COMPANION(dev) == data;
|
||||
}
|
||||
|
||||
static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev)
|
||||
{
|
||||
struct device *dev;
|
||||
@ -3780,8 +3763,7 @@ static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&spi_bus_type, NULL, adev, spi_acpi_device_match);
|
||||
|
||||
dev = bus_find_device_by_acpi_dev(&spi_bus_type, adev);
|
||||
return dev ? to_spi_device(dev) : NULL;
|
||||
}
|
||||
|
||||
|
||||
@ -2952,17 +2952,11 @@ void do_SAK(struct tty_struct *tty)
|
||||
|
||||
EXPORT_SYMBOL(do_SAK);
|
||||
|
||||
static int dev_match_devt(struct device *dev, const void *data)
|
||||
{
|
||||
const dev_t *devt = data;
|
||||
return dev->devt == *devt;
|
||||
}
|
||||
|
||||
/* Must put_device() after it's unused! */
|
||||
static struct device *tty_get_device(struct tty_struct *tty)
|
||||
{
|
||||
dev_t devt = tty_devnum(tty);
|
||||
return class_find_device(tty_class, NULL, &devt, dev_match_devt);
|
||||
return class_find_device_by_devt(tty_class, devt);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -942,17 +942,11 @@ static int parse_usbdevfs_streams(struct usb_dev_state *ps,
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int match_devt(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->devt == (dev_t)(unsigned long)(void *)data;
|
||||
}
|
||||
|
||||
static struct usb_device *usbdev_lookup_by_devt(dev_t devt)
|
||||
{
|
||||
struct device *dev;
|
||||
|
||||
dev = bus_find_device(&usb_bus_type, NULL,
|
||||
(void *) (unsigned long) devt, match_devt);
|
||||
dev = bus_find_device_by_devt(&usb_bus_type, devt);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
return to_usb_device(dev);
|
||||
|
||||
@ -85,16 +85,6 @@ enum usb_role usb_role_switch_get_role(struct usb_role_switch *sw)
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(usb_role_switch_get_role);
|
||||
|
||||
static int switch_fwnode_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev_fwnode(dev) == fwnode;
|
||||
}
|
||||
|
||||
static int switch_name_match(struct device *dev, const void *name)
|
||||
{
|
||||
return !strcmp((const char *)name, dev_name(dev));
|
||||
}
|
||||
|
||||
static void *usb_role_switch_match(struct device_connection *con, int ep,
|
||||
void *data)
|
||||
{
|
||||
@ -104,11 +94,9 @@ static void *usb_role_switch_match(struct device_connection *con, int ep,
|
||||
if (con->id && !fwnode_property_present(con->fwnode, con->id))
|
||||
return NULL;
|
||||
|
||||
dev = class_find_device(role_class, NULL, con->fwnode,
|
||||
switch_fwnode_match);
|
||||
dev = class_find_device_by_fwnode(role_class, con->fwnode);
|
||||
} else {
|
||||
dev = class_find_device(role_class, NULL, con->endpoint[ep],
|
||||
switch_name_match);
|
||||
dev = class_find_device_by_name(role_class, con->endpoint[ep]);
|
||||
}
|
||||
|
||||
return dev ? to_role_switch(dev) : ERR_PTR(-EPROBE_DEFER);
|
||||
|
||||
@ -205,16 +205,6 @@ static void typec_altmode_put_partner(struct altmode *altmode)
|
||||
put_device(&adev->dev);
|
||||
}
|
||||
|
||||
static int typec_port_fwnode_match(struct device *dev, const void *fwnode)
|
||||
{
|
||||
return dev_fwnode(dev) == fwnode;
|
||||
}
|
||||
|
||||
static int typec_port_name_match(struct device *dev, const void *name)
|
||||
{
|
||||
return !strcmp((const char *)name, dev_name(dev));
|
||||
}
|
||||
|
||||
static void *typec_port_match(struct device_connection *con, int ep, void *data)
|
||||
{
|
||||
struct device *dev;
|
||||
@ -224,11 +214,9 @@ static void *typec_port_match(struct device_connection *con, int ep, void *data)
|
||||
* we need to return ERR_PTR(-PROBE_DEFER) when there is no device.
|
||||
*/
|
||||
if (con->fwnode)
|
||||
return class_find_device(typec_class, NULL, con->fwnode,
|
||||
typec_port_fwnode_match);
|
||||
return class_find_device_by_fwnode(typec_class, con->fwnode);
|
||||
|
||||
dev = class_find_device(typec_class, NULL, con->endpoint[ep],
|
||||
typec_port_name_match);
|
||||
dev = class_find_device_by_name(typec_class, con->endpoint[ep]);
|
||||
|
||||
return dev ? dev : ERR_PTR(-EPROBE_DEFER);
|
||||
}
|
||||
|
||||
@ -3,8 +3,9 @@
|
||||
* This header provides macros for the common LEDs device tree bindings.
|
||||
*
|
||||
* Copyright (C) 2015, Samsung Electronics Co., Ltd.
|
||||
*
|
||||
* Author: Jacek Anaszewski <j.anaszewski@samsung.com>
|
||||
*
|
||||
* Copyright (C) 2019 Jacek Anaszewski <jacek.anaszewski@gmail.com>
|
||||
*/
|
||||
|
||||
#ifndef __DT_BINDINGS_LEDS_H
|
||||
@ -19,4 +20,56 @@
|
||||
#define LEDS_BOOST_ADAPTIVE 1
|
||||
#define LEDS_BOOST_FIXED 2
|
||||
|
||||
/* Standard LED colors */
|
||||
#define LED_COLOR_ID_WHITE 0
|
||||
#define LED_COLOR_ID_RED 1
|
||||
#define LED_COLOR_ID_GREEN 2
|
||||
#define LED_COLOR_ID_BLUE 3
|
||||
#define LED_COLOR_ID_AMBER 4
|
||||
#define LED_COLOR_ID_VIOLET 5
|
||||
#define LED_COLOR_ID_YELLOW 6
|
||||
#define LED_COLOR_ID_IR 7
|
||||
#define LED_COLOR_ID_MAX 8
|
||||
|
||||
/* Standard LED functions */
|
||||
#define LED_FUNCTION_ACTIVITY "activity"
|
||||
#define LED_FUNCTION_ALARM "alarm"
|
||||
#define LED_FUNCTION_BACKLIGHT "backlight"
|
||||
#define LED_FUNCTION_BLUETOOTH "bluetooth"
|
||||
#define LED_FUNCTION_BOOT "boot"
|
||||
#define LED_FUNCTION_CPU "cpu"
|
||||
#define LED_FUNCTION_CAPSLOCK "capslock"
|
||||
#define LED_FUNCTION_CHARGING "charging"
|
||||
#define LED_FUNCTION_DEBUG "debug"
|
||||
#define LED_FUNCTION_DISK "disk"
|
||||
#define LED_FUNCTION_DISK_ACTIVITY "disk-activity"
|
||||
#define LED_FUNCTION_DISK_ERR "disk-err"
|
||||
#define LED_FUNCTION_DISK_READ "disk-read"
|
||||
#define LED_FUNCTION_DISK_WRITE "disk-write"
|
||||
#define LED_FUNCTION_FAULT "fault"
|
||||
#define LED_FUNCTION_FLASH "flash"
|
||||
#define LED_FUNCTION_HEARTBEAT "heartbeat"
|
||||
#define LED_FUNCTION_INDICATOR "indicator"
|
||||
#define LED_FUNCTION_KBD_BACKLIGHT "kbd_backlight"
|
||||
#define LED_FUNCTION_LAN "lan"
|
||||
#define LED_FUNCTION_MAIL "mail"
|
||||
#define LED_FUNCTION_MTD "mtd"
|
||||
#define LED_FUNCTION_MICMUTE "micmute"
|
||||
#define LED_FUNCTION_MUTE "mute"
|
||||
#define LED_FUNCTION_NUMLOCK "numlock"
|
||||
#define LED_FUNCTION_PANIC "panic"
|
||||
#define LED_FUNCTION_PROGRAMMING "programming"
|
||||
#define LED_FUNCTION_POWER "power"
|
||||
#define LED_FUNCTION_RX "rx"
|
||||
#define LED_FUNCTION_SD "sd"
|
||||
#define LED_FUNCTION_SCROLLLOCK "scrolllock"
|
||||
#define LED_FUNCTION_STANDBY "standby"
|
||||
#define LED_FUNCTION_STATUS "status"
|
||||
#define LED_FUNCTION_TORCH "torch"
|
||||
#define LED_FUNCTION_TX "tx"
|
||||
#define LED_FUNCTION_USB "usb"
|
||||
#define LED_FUNCTION_WAN "wan"
|
||||
#define LED_FUNCTION_WLAN "wlan"
|
||||
#define LED_FUNCTION_WPS "wps"
|
||||
|
||||
#endif /* __DT_BINDINGS_LEDS_H */
|
||||
|
||||
@ -164,16 +164,100 @@ void subsys_dev_iter_init(struct subsys_dev_iter *iter,
|
||||
struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
|
||||
void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
|
||||
|
||||
int device_match_name(struct device *dev, const void *name);
|
||||
int device_match_of_node(struct device *dev, const void *np);
|
||||
int device_match_fwnode(struct device *dev, const void *fwnode);
|
||||
int device_match_devt(struct device *dev, const void *pdevt);
|
||||
int device_match_acpi_dev(struct device *dev, const void *adev);
|
||||
int device_match_any(struct device *dev, const void *unused);
|
||||
|
||||
int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
|
||||
int (*fn)(struct device *dev, void *data));
|
||||
struct device *bus_find_device(struct bus_type *bus, struct device *start,
|
||||
const void *data,
|
||||
int (*match)(struct device *dev, const void *data));
|
||||
struct device *bus_find_device_by_name(struct bus_type *bus,
|
||||
/**
|
||||
* bus_find_device_by_name - device iterator for locating a particular device
|
||||
* of a specific name.
|
||||
* @bus: bus type
|
||||
* @start: Device to begin with
|
||||
* @name: name of the device to match
|
||||
*/
|
||||
static inline struct device *bus_find_device_by_name(struct bus_type *bus,
|
||||
struct device *start,
|
||||
const char *name);
|
||||
const char *name)
|
||||
{
|
||||
return bus_find_device(bus, start, name, device_match_name);
|
||||
}
|
||||
|
||||
/**
|
||||
* bus_find_device_by_of_node : device iterator for locating a particular device
|
||||
* matching the of_node.
|
||||
* @bus: bus type
|
||||
* @np: of_node of the device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
bus_find_device_by_of_node(struct bus_type *bus, const struct device_node *np)
|
||||
{
|
||||
return bus_find_device(bus, NULL, np, device_match_of_node);
|
||||
}
|
||||
|
||||
/**
|
||||
* bus_find_device_by_fwnode : device iterator for locating a particular device
|
||||
* matching the fwnode.
|
||||
* @bus: bus type
|
||||
* @fwnode: fwnode of the device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
bus_find_device_by_fwnode(struct bus_type *bus, const struct fwnode_handle *fwnode)
|
||||
{
|
||||
return bus_find_device(bus, NULL, fwnode, device_match_fwnode);
|
||||
}
|
||||
|
||||
/**
|
||||
* bus_find_device_by_devt : device iterator for locating a particular device
|
||||
* matching the device type.
|
||||
* @bus: bus type
|
||||
* @devt: device type of the device to match.
|
||||
*/
|
||||
static inline struct device *bus_find_device_by_devt(struct bus_type *bus,
|
||||
dev_t devt)
|
||||
{
|
||||
return bus_find_device(bus, NULL, &devt, device_match_devt);
|
||||
}
|
||||
|
||||
/**
|
||||
* bus_find_next_device - Find the next device after a given device in a
|
||||
* given bus.
|
||||
*/
|
||||
static inline struct device *
|
||||
bus_find_next_device(struct bus_type *bus,struct device *cur)
|
||||
{
|
||||
return bus_find_device(bus, cur, NULL, device_match_any);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
struct acpi_device;
|
||||
|
||||
/**
|
||||
* bus_find_device_by_acpi_dev : device iterator for locating a particular device
|
||||
* matching the ACPI COMPANION device.
|
||||
* @bus: bus type
|
||||
* @adev: ACPI COMPANION device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
bus_find_device_by_acpi_dev(struct bus_type *bus, const struct acpi_device *adev)
|
||||
{
|
||||
return bus_find_device(bus, NULL, adev, device_match_acpi_dev);
|
||||
}
|
||||
#else
|
||||
static inline struct device *
|
||||
bus_find_device_by_acpi_dev(struct bus_type *bus, const void *adev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
|
||||
struct device *hint);
|
||||
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
|
||||
@ -342,6 +426,83 @@ struct device *driver_find_device(struct device_driver *drv,
|
||||
struct device *start, const void *data,
|
||||
int (*match)(struct device *dev, const void *data));
|
||||
|
||||
/**
|
||||
* driver_find_device_by_name - device iterator for locating a particular device
|
||||
* of a specific name.
|
||||
* @driver: the driver we're iterating
|
||||
* @name: name of the device to match
|
||||
*/
|
||||
static inline struct device *driver_find_device_by_name(struct device_driver *drv,
|
||||
const char *name)
|
||||
{
|
||||
return driver_find_device(drv, NULL, name, device_match_name);
|
||||
}
|
||||
|
||||
/**
|
||||
* driver_find_device_by_of_node- device iterator for locating a particular device
|
||||
* by of_node pointer.
|
||||
* @driver: the driver we're iterating
|
||||
* @np: of_node pointer to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
driver_find_device_by_of_node(struct device_driver *drv,
|
||||
const struct device_node *np)
|
||||
{
|
||||
return driver_find_device(drv, NULL, np, device_match_of_node);
|
||||
}
|
||||
|
||||
/**
|
||||
* driver_find_device_by_fwnode- device iterator for locating a particular device
|
||||
* by fwnode pointer.
|
||||
* @driver: the driver we're iterating
|
||||
* @fwnode: fwnode pointer to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
driver_find_device_by_fwnode(struct device_driver *drv,
|
||||
const struct fwnode_handle *fwnode)
|
||||
{
|
||||
return driver_find_device(drv, NULL, fwnode, device_match_fwnode);
|
||||
}
|
||||
|
||||
/**
|
||||
* driver_find_device_by_devt- device iterator for locating a particular device
|
||||
* by devt.
|
||||
* @driver: the driver we're iterating
|
||||
* @devt: devt pointer to match.
|
||||
*/
|
||||
static inline struct device *driver_find_device_by_devt(struct device_driver *drv,
|
||||
dev_t devt)
|
||||
{
|
||||
return driver_find_device(drv, NULL, &devt, device_match_devt);
|
||||
}
|
||||
|
||||
static inline struct device *driver_find_next_device(struct device_driver *drv,
|
||||
struct device *start)
|
||||
{
|
||||
return driver_find_device(drv, start, NULL, device_match_any);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
/**
|
||||
* driver_find_device_by_acpi_dev : device iterator for locating a particular
|
||||
* device matching the ACPI_COMPANION device.
|
||||
* @driver: the driver we're iterating
|
||||
* @adev: ACPI_COMPANION device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
driver_find_device_by_acpi_dev(struct device_driver *drv,
|
||||
const struct acpi_device *adev)
|
||||
{
|
||||
return driver_find_device(drv, NULL, adev, device_match_acpi_dev);
|
||||
}
|
||||
#else
|
||||
static inline struct device *
|
||||
driver_find_device_by_acpi_dev(struct device_driver *drv, const void *adev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
void driver_deferred_probe_add(struct device *dev);
|
||||
int driver_deferred_probe_check_state(struct device *dev);
|
||||
int driver_deferred_probe_check_state_continue(struct device *dev);
|
||||
@ -471,6 +632,76 @@ extern struct device *class_find_device(struct class *class,
|
||||
struct device *start, const void *data,
|
||||
int (*match)(struct device *, const void *));
|
||||
|
||||
/**
|
||||
* class_find_device_by_name - device iterator for locating a particular device
|
||||
* of a specific name.
|
||||
* @class: class type
|
||||
* @name: name of the device to match
|
||||
*/
|
||||
static inline struct device *class_find_device_by_name(struct class *class,
|
||||
const char *name)
|
||||
{
|
||||
return class_find_device(class, NULL, name, device_match_name);
|
||||
}
|
||||
|
||||
/**
|
||||
* class_find_device_by_of_node : device iterator for locating a particular device
|
||||
* matching the of_node.
|
||||
* @class: class type
|
||||
* @np: of_node of the device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
class_find_device_by_of_node(struct class *class, const struct device_node *np)
|
||||
{
|
||||
return class_find_device(class, NULL, np, device_match_of_node);
|
||||
}
|
||||
|
||||
/**
|
||||
* class_find_device_by_fwnode : device iterator for locating a particular device
|
||||
* matching the fwnode.
|
||||
* @class: class type
|
||||
* @fwnode: fwnode of the device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
class_find_device_by_fwnode(struct class *class,
|
||||
const struct fwnode_handle *fwnode)
|
||||
{
|
||||
return class_find_device(class, NULL, fwnode, device_match_fwnode);
|
||||
}
|
||||
|
||||
/**
|
||||
* class_find_device_by_devt : device iterator for locating a particular device
|
||||
* matching the device type.
|
||||
* @class: class type
|
||||
* @devt: device type of the device to match.
|
||||
*/
|
||||
static inline struct device *class_find_device_by_devt(struct class *class,
|
||||
dev_t devt)
|
||||
{
|
||||
return class_find_device(class, NULL, &devt, device_match_devt);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_ACPI
|
||||
struct acpi_device;
|
||||
/**
|
||||
* class_find_device_by_acpi_dev : device iterator for locating a particular
|
||||
* device matching the ACPI_COMPANION device.
|
||||
* @class: class type
|
||||
* @adev: ACPI_COMPANION device to match.
|
||||
*/
|
||||
static inline struct device *
|
||||
class_find_device_by_acpi_dev(struct class *class, const struct acpi_device *adev)
|
||||
{
|
||||
return class_find_device(class, NULL, adev, device_match_acpi_dev);
|
||||
}
|
||||
#else
|
||||
static inline struct device *
|
||||
class_find_device_by_acpi_dev(struct class *class, const void *adev)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
struct class_attribute {
|
||||
struct attribute attr;
|
||||
ssize_t (*show)(struct class *class, struct class_attribute *attr,
|
||||
|
||||
@ -86,15 +86,20 @@ static inline struct led_classdev_flash *lcdev_to_flcdev(
|
||||
}
|
||||
|
||||
/**
|
||||
* led_classdev_flash_register - register a new object of led_classdev class
|
||||
* with support for flash LEDs
|
||||
* @parent: the flash LED to register
|
||||
* led_classdev_flash_register_ext - register a new object of LED class with
|
||||
* init data and with support for flash LEDs
|
||||
* @parent: LED flash controller device this flash LED is driven by
|
||||
* @fled_cdev: the led_classdev_flash structure for this device
|
||||
* @init_data: the LED class flash device initialization data
|
||||
*
|
||||
* Returns: 0 on success or negative error value on failure
|
||||
*/
|
||||
extern int led_classdev_flash_register(struct device *parent,
|
||||
struct led_classdev_flash *fled_cdev);
|
||||
extern int led_classdev_flash_register_ext(struct device *parent,
|
||||
struct led_classdev_flash *fled_cdev,
|
||||
struct led_init_data *init_data);
|
||||
|
||||
#define led_classdev_flash_register(parent, fled_cdev) \
|
||||
led_classdev_flash_register_ext(parent, fled_cdev, NULL)
|
||||
|
||||
/**
|
||||
* led_classdev_flash_unregister - unregisters an object of led_classdev class
|
||||
|
||||
@ -8,6 +8,7 @@
|
||||
#ifndef __LINUX_LEDS_H_INCLUDED
|
||||
#define __LINUX_LEDS_H_INCLUDED
|
||||
|
||||
#include <dt-bindings/leds/common.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/kernfs.h>
|
||||
#include <linux/list.h>
|
||||
@ -30,6 +31,30 @@ enum led_brightness {
|
||||
LED_FULL = 255,
|
||||
};
|
||||
|
||||
struct led_init_data {
|
||||
/* device fwnode handle */
|
||||
struct fwnode_handle *fwnode;
|
||||
/*
|
||||
* default <color:function> tuple, for backward compatibility
|
||||
* with in-driver hard-coded LED names used as a fallback when
|
||||
* DT "label" property is absent; it should be set to NULL
|
||||
* in new LED class drivers.
|
||||
*/
|
||||
const char *default_label;
|
||||
/*
|
||||
* string to be used for devicename section of LED class device
|
||||
* either for label based LED name composition path or for fwnode
|
||||
* based when devname_mandatory is true
|
||||
*/
|
||||
const char *devicename;
|
||||
/*
|
||||
* indicates if LED name should always comprise devicename section;
|
||||
* only LEDs exposed by drivers of hot-pluggable devices should
|
||||
* set it to true
|
||||
*/
|
||||
bool devname_mandatory;
|
||||
};
|
||||
|
||||
struct led_classdev {
|
||||
const char *name;
|
||||
enum led_brightness brightness;
|
||||
@ -125,16 +150,46 @@ struct led_classdev {
|
||||
struct mutex led_access;
|
||||
};
|
||||
|
||||
extern int of_led_classdev_register(struct device *parent,
|
||||
struct device_node *np,
|
||||
struct led_classdev *led_cdev);
|
||||
#define led_classdev_register(parent, led_cdev) \
|
||||
of_led_classdev_register(parent, NULL, led_cdev)
|
||||
extern int devm_of_led_classdev_register(struct device *parent,
|
||||
struct device_node *np,
|
||||
struct led_classdev *led_cdev);
|
||||
#define devm_led_classdev_register(parent, led_cdev) \
|
||||
devm_of_led_classdev_register(parent, NULL, led_cdev)
|
||||
/**
|
||||
* led_classdev_register_ext - register a new object of LED class with
|
||||
* init data
|
||||
* @parent: LED controller device this LED is driven by
|
||||
* @led_cdev: the led_classdev structure for this device
|
||||
* @init_data: the LED class device initialization data
|
||||
*
|
||||
* Register a new object of LED class, with name derived from init_data.
|
||||
*
|
||||
* Returns: 0 on success or negative error value on failure
|
||||
*/
|
||||
extern int led_classdev_register_ext(struct device *parent,
|
||||
struct led_classdev *led_cdev,
|
||||
struct led_init_data *init_data);
|
||||
|
||||
/**
|
||||
* led_classdev_register - register a new object of LED class
|
||||
* @parent: LED controller device this LED is driven by
|
||||
* @led_cdev: the led_classdev structure for this device
|
||||
*
|
||||
* Register a new object of LED class, with name derived from the name property
|
||||
* of passed led_cdev argument.
|
||||
*
|
||||
* Returns: 0 on success or negative error value on failure
|
||||
*/
|
||||
static inline int led_classdev_register(struct device *parent,
|
||||
struct led_classdev *led_cdev)
|
||||
{
|
||||
return led_classdev_register_ext(parent, led_cdev, NULL);
|
||||
}
|
||||
|
||||
extern int devm_led_classdev_register_ext(struct device *parent,
|
||||
struct led_classdev *led_cdev,
|
||||
struct led_init_data *init_data);
|
||||
|
||||
static inline int devm_led_classdev_register(struct device *parent,
|
||||
struct led_classdev *led_cdev)
|
||||
{
|
||||
return devm_led_classdev_register_ext(parent, led_cdev, NULL);
|
||||
}
|
||||
extern void led_classdev_unregister(struct led_classdev *led_cdev);
|
||||
extern void devm_led_classdev_unregister(struct device *parent,
|
||||
struct led_classdev *led_cdev);
|
||||
@ -243,6 +298,22 @@ extern void led_sysfs_disable(struct led_classdev *led_cdev);
|
||||
*/
|
||||
extern void led_sysfs_enable(struct led_classdev *led_cdev);
|
||||
|
||||
/**
|
||||
* led_compose_name - compose LED class device name
|
||||
* @dev: LED controller device object
|
||||
* @child: child fwnode_handle describing a LED or a group of synchronized LEDs;
|
||||
* it must be provided only for fwnode based LEDs
|
||||
* @led_classdev_name: composed LED class device name
|
||||
*
|
||||
* Create LED class device name basing on the provided init_data argument.
|
||||
* The name can have <devicename:color:function> or <color:function>.
|
||||
* form, depending on the init_data configuration.
|
||||
*
|
||||
* Returns: 0 on success or negative error value on failure
|
||||
*/
|
||||
extern int led_compose_name(struct device *dev, struct led_init_data *init_data,
|
||||
char *led_classdev_name);
|
||||
|
||||
/**
|
||||
* led_sysfs_is_disabled - check if LED sysfs interface is disabled
|
||||
* @led_cdev: the LED to query
|
||||
@ -420,6 +491,15 @@ struct led_platform_data {
|
||||
struct led_info *leds;
|
||||
};
|
||||
|
||||
struct led_properties {
|
||||
u32 color;
|
||||
bool color_present;
|
||||
const char *function;
|
||||
u32 func_enum;
|
||||
bool func_enum_present;
|
||||
const char *label;
|
||||
};
|
||||
|
||||
struct gpio_desc;
|
||||
typedef int (*gpio_blink_set_t)(struct gpio_desc *desc, int state,
|
||||
unsigned long *delay_on,
|
||||
|
||||
@ -1,54 +0,0 @@
|
||||
/*
|
||||
* Platform data structure for netxbig LED driver
|
||||
*
|
||||
* This file is licensed under the terms of the GNU General Public
|
||||
* License version 2. This program is licensed "as is" without any
|
||||
* warranty of any kind, whether express or implied.
|
||||
*/
|
||||
|
||||
#ifndef __LEDS_KIRKWOOD_NETXBIG_H
|
||||
#define __LEDS_KIRKWOOD_NETXBIG_H
|
||||
|
||||
struct netxbig_gpio_ext {
|
||||
unsigned *addr;
|
||||
int num_addr;
|
||||
unsigned *data;
|
||||
int num_data;
|
||||
unsigned enable;
|
||||
};
|
||||
|
||||
enum netxbig_led_mode {
|
||||
NETXBIG_LED_OFF,
|
||||
NETXBIG_LED_ON,
|
||||
NETXBIG_LED_SATA,
|
||||
NETXBIG_LED_TIMER1,
|
||||
NETXBIG_LED_TIMER2,
|
||||
NETXBIG_LED_MODE_NUM,
|
||||
};
|
||||
|
||||
#define NETXBIG_LED_INVALID_MODE NETXBIG_LED_MODE_NUM
|
||||
|
||||
struct netxbig_led_timer {
|
||||
unsigned long delay_on;
|
||||
unsigned long delay_off;
|
||||
enum netxbig_led_mode mode;
|
||||
};
|
||||
|
||||
struct netxbig_led {
|
||||
const char *name;
|
||||
const char *default_trigger;
|
||||
int mode_addr;
|
||||
int *mode_val;
|
||||
int bright_addr;
|
||||
int bright_max;
|
||||
};
|
||||
|
||||
struct netxbig_led_platform_data {
|
||||
struct netxbig_gpio_ext *gpio_ext;
|
||||
struct netxbig_led_timer *timer;
|
||||
int num_timer;
|
||||
struct netxbig_led *leds;
|
||||
int num_leds;
|
||||
};
|
||||
|
||||
#endif /* __LEDS_KIRKWOOD_NETXBIG_H */
|
||||
@ -51,6 +51,9 @@ extern struct device platform_bus;
|
||||
extern void arch_setup_pdev_archdata(struct platform_device *);
|
||||
extern struct resource *platform_get_resource(struct platform_device *,
|
||||
unsigned int, unsigned int);
|
||||
extern struct device *
|
||||
platform_find_device_by_driver(struct device *start,
|
||||
const struct device_driver *drv);
|
||||
extern void __iomem *
|
||||
devm_platform_ioremap_resource(struct platform_device *pdev,
|
||||
unsigned int index);
|
||||
|
||||
@ -23,11 +23,6 @@
|
||||
LIST_HEAD(cfg802154_rdev_list);
|
||||
int cfg802154_rdev_list_generation;
|
||||
|
||||
static int wpan_phy_match(struct device *dev, const void *data)
|
||||
{
|
||||
return !strcmp(dev_name(dev), (const char *)data);
|
||||
}
|
||||
|
||||
struct wpan_phy *wpan_phy_find(const char *str)
|
||||
{
|
||||
struct device *dev;
|
||||
@ -35,7 +30,7 @@ struct wpan_phy *wpan_phy_find(const char *str)
|
||||
if (WARN_ON(!str))
|
||||
return NULL;
|
||||
|
||||
dev = class_find_device(&wpan_phy_class, NULL, str, wpan_phy_match);
|
||||
dev = class_find_device_by_name(&wpan_phy_class, str);
|
||||
if (!dev)
|
||||
return NULL;
|
||||
|
||||
|
||||
@ -422,11 +422,6 @@ static const struct dailink_match_data dailink_match[] = {
|
||||
},
|
||||
};
|
||||
|
||||
static int of_dev_node_match(struct device *dev, const void *data)
|
||||
{
|
||||
return dev->of_node == data;
|
||||
}
|
||||
|
||||
static int rockchip_sound_codec_node_match(struct device_node *np_codec)
|
||||
{
|
||||
struct device *dev;
|
||||
@ -438,8 +433,8 @@ static int rockchip_sound_codec_node_match(struct device_node *np_codec)
|
||||
continue;
|
||||
|
||||
if (dailink_match[i].bus_type) {
|
||||
dev = bus_find_device(dailink_match[i].bus_type, NULL,
|
||||
np_codec, of_dev_node_match);
|
||||
dev = bus_find_device_by_of_node(dailink_match[i].bus_type,
|
||||
np_codec);
|
||||
if (!dev)
|
||||
continue;
|
||||
put_device(dev);
|
||||
|
||||
201
tools/leds/get_led_device_info.sh
Executable file
201
tools/leds/get_led_device_info.sh
Executable file
@ -0,0 +1,201 @@
|
||||
#!/bin/sh
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
led_common_defs_path="include/dt-bindings/leds/common.h"
|
||||
|
||||
num_args=$#
|
||||
if [ $num_args -eq 1 ]; then
|
||||
linux_top=$(dirname `realpath $0` | awk -F/ \
|
||||
'{ \
|
||||
i=1; \
|
||||
while (i <= NF - 2) { \
|
||||
printf $i"/"; \
|
||||
i++; \
|
||||
}; \
|
||||
}')
|
||||
led_defs_path=$linux_top/$led_common_defs_path
|
||||
elif [ $num_args -eq 2 ]; then
|
||||
led_defs_path=`realpath $2`
|
||||
else
|
||||
echo "Usage: get_led_device_info.sh LED_CDEV_PATH [LED_COMMON_DEFS_PATH]"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ ! -f $led_defs_path ]; then
|
||||
echo "$led_defs_path doesn't exist"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
led_cdev_path=`echo $1 | sed s'/\/$//'`
|
||||
|
||||
ls "$led_cdev_path/brightness" > /dev/null 2>&1
|
||||
if [ $? -ne 0 ]; then
|
||||
echo "Device \"$led_cdev_path\" does not exist."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
bus=`readlink $led_cdev_path/device/subsystem | sed s'/.*\///'`
|
||||
usb_subdev=`readlink $led_cdev_path | grep usb | sed s'/\(.*usb[0-9]*\/[0-9]*-[0-9]*\)\/.*/\1/'`
|
||||
ls "$led_cdev_path/device/of_node/compatible" > /dev/null 2>&1
|
||||
of_node_missing=$?
|
||||
|
||||
if [ "$bus" = "input" ]; then
|
||||
input_node=`readlink $led_cdev_path/device | sed s'/.*\///'`
|
||||
if [ ! -z "$usb_subdev" ]; then
|
||||
bus="usb"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$bus" = "usb" ]; then
|
||||
usb_interface=`readlink $led_cdev_path | sed s'/.*\(usb[0-9]*\)/\1/' | cut -d\/ -f3`
|
||||
cd $led_cdev_path/../$usb_subdev
|
||||
driver=`readlink $usb_interface/driver | sed s'/.*\///'`
|
||||
if [ -d "$usb_interface/ieee80211" ]; then
|
||||
wifi_phy=`ls -l $usb_interface/ieee80211 | grep phy | awk '{print $9}'`
|
||||
fi
|
||||
idVendor=`cat idVendor`
|
||||
idProduct=`cat idProduct`
|
||||
manufacturer=`cat manufacturer`
|
||||
product=`cat product`
|
||||
elif [ "$bus" = "input" ]; then
|
||||
cd $led_cdev_path
|
||||
product=`cat device/name`
|
||||
driver=`cat device/device/driver/description`
|
||||
elif [ $of_node_missing -eq 0 ]; then
|
||||
cd $led_cdev_path
|
||||
compatible=`cat device/of_node/compatible`
|
||||
if [ "$compatible" = "gpio-leds" ]; then
|
||||
driver="leds-gpio"
|
||||
elif [ "$compatible" = "pwm-leds" ]; then
|
||||
driver="leds-pwm"
|
||||
else
|
||||
manufacturer=`echo $compatible | awk -F, '{print $1}'`
|
||||
product=`echo $compatible | awk -F, '{print $2}'`
|
||||
fi
|
||||
else
|
||||
echo "Unknown device type."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
printf "\n#####################################\n"
|
||||
printf "# LED class device hardware details #\n"
|
||||
printf "#####################################\n\n"
|
||||
|
||||
printf "bus:\t\t\t$bus\n"
|
||||
|
||||
if [ ! -z "$idVendor" ]; then
|
||||
printf "idVendor:\t\t$idVendor\n"
|
||||
fi
|
||||
|
||||
if [ ! -z "$idProduct" ]; then
|
||||
printf "idProduct:\t\t$idProduct\n"
|
||||
fi
|
||||
|
||||
if [ ! -z "$manufacturer" ]; then
|
||||
printf "manufacturer:\t\t$manufacturer\n"
|
||||
fi
|
||||
|
||||
if [ ! -z "$product" ]; then
|
||||
printf "product:\t\t$product\n"
|
||||
fi
|
||||
|
||||
if [ ! -z "$driver" ]; then
|
||||
printf "driver:\t\t\t$driver\n"
|
||||
fi
|
||||
|
||||
if [ ! -z "$input_node" ]; then
|
||||
printf "associated input node:\t$input_node\n"
|
||||
fi
|
||||
|
||||
printf "\n####################################\n"
|
||||
printf "# LED class device name validation #\n"
|
||||
printf "####################################\n\n"
|
||||
|
||||
led_name=`echo $led_cdev_path | sed s'/.*\///'`
|
||||
|
||||
num_sections=`echo $led_name | awk -F: '{print NF}'`
|
||||
|
||||
if [ $num_sections -eq 1 ]; then
|
||||
printf "\":\" delimiter not detected.\t[ FAILED ]\n"
|
||||
exit 1
|
||||
elif [ $num_sections -eq 2 ]; then
|
||||
color=`echo $led_name | cut -d: -f1`
|
||||
function=`echo $led_name | cut -d: -f2`
|
||||
elif [ $num_sections -eq 3 ]; then
|
||||
devicename=`echo $led_name | cut -d: -f1`
|
||||
color=`echo $led_name | cut -d: -f2`
|
||||
function=`echo $led_name | cut -d: -f3`
|
||||
else
|
||||
printf "Detected %d sections in the LED class device name - should the script be updated?\n" $num_sections
|
||||
exit 1
|
||||
fi
|
||||
|
||||
S_DEV="devicename"
|
||||
S_CLR="color "
|
||||
S_FUN="function "
|
||||
status_tab=20
|
||||
|
||||
print_msg_ok()
|
||||
{
|
||||
local section_name="$1"
|
||||
local section_val="$2"
|
||||
local msg="$3"
|
||||
printf "$section_name :\t%-${status_tab}.${status_tab}s %s %s\n" "$section_val" "[ OK ] " "$msg"
|
||||
}
|
||||
|
||||
print_msg_failed()
|
||||
{
|
||||
local section_name="$1"
|
||||
local section_val="$2"
|
||||
local msg="$3"
|
||||
printf "$section_name :\t%-${status_tab}.${status_tab}s %s %s\n" "$section_val" "[ FAILED ]" "$msg"
|
||||
}
|
||||
|
||||
if [ ! -z "$input_node" ]; then
|
||||
expected_devname=$input_node
|
||||
elif [ ! -z "$wifi_phy" ]; then
|
||||
expected_devname=$wifi_phy
|
||||
fi
|
||||
|
||||
if [ ! -z "$devicename" ]; then
|
||||
if [ ! -z "$expected_devname" ]; then
|
||||
if [ "$devicename" = "$expected_devname" ]; then
|
||||
print_msg_ok "$S_DEV" "$devicename"
|
||||
else
|
||||
print_msg_failed "$S_DEV" "$devicename" "Expected: $expected_devname"
|
||||
fi
|
||||
else
|
||||
if [ "$devicename" = "$manufacturer" ]; then
|
||||
print_msg_failed "$S_DEV" "$devicename" "Redundant: use of vendor name is discouraged"
|
||||
elif [ "$devicename" = "$product" ]; then
|
||||
print_msg_failed "$S_DEV" "$devicename" "Redundant: use of product name is discouraged"
|
||||
else
|
||||
print_msg_failed "$S_DEV" "$devicename" "Unknown devicename - should the script be updated?"
|
||||
fi
|
||||
fi
|
||||
elif [ ! -z "$expected_devname" ]; then
|
||||
print_msg_failed "$S_DEV" "blank" "Expected: $expected_devname"
|
||||
fi
|
||||
|
||||
if [ ! -z "$color" ]; then
|
||||
color_upper=`echo $color | tr [:lower:] [:upper:]`
|
||||
color_id_definition=$(cat $led_defs_path | grep "_$color_upper\s" | awk '{print $2}')
|
||||
if [ ! -z "$color_id_definition" ]; then
|
||||
print_msg_ok "$S_CLR" "$color" "Matching definition: $color_id_definition"
|
||||
else
|
||||
print_msg_failed "$S_CLR" "$color" "Definition not found in $led_defs_path"
|
||||
fi
|
||||
|
||||
fi
|
||||
|
||||
if [ ! -z "$function" ]; then
|
||||
# strip optional enumerator
|
||||
function=`echo $function | sed s'/\(.*\)-[0-9]*$/\1/'`
|
||||
fun_definition=$(cat $led_defs_path | grep "\"$function\"" | awk '{print $2}')
|
||||
if [ ! -z "$fun_definition" ]; then
|
||||
print_msg_ok "$S_FUN" "$function" "Matching definition: $fun_definition"
|
||||
else
|
||||
print_msg_failed "$S_FUN" "$function" "Definition not found in $led_defs_path"
|
||||
fi
|
||||
|
||||
fi
|
||||
Loading…
Reference in New Issue
Block a user