mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git
synced 2024-12-28 00:32:00 +00:00
Merge branch 'for-leds-next' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/leds.git
This commit is contained in:
Stephen Rothwell
commit
e7782a1595
@ -23,6 +23,12 @@ properties:
|
||||
description: I2C slave address of the microcontroller.
|
||||
maxItems: 1
|
||||
|
||||
interrupts:
|
||||
description:
|
||||
Specifier for the global LED brightness changed by front button press
|
||||
interrupt.
|
||||
maxItems: 1
|
||||
|
||||
"#address-cells":
|
||||
const: 1
|
||||
|
||||
@ -56,6 +62,7 @@ additionalProperties: false
|
||||
examples:
|
||||
- |
|
||||
|
||||
#include <dt-bindings/interrupt-controller/irq.h>
|
||||
#include <dt-bindings/leds/common.h>
|
||||
|
||||
i2c {
|
||||
@ -65,6 +72,7 @@ examples:
|
||||
led-controller@2b {
|
||||
compatible = "cznic,turris-omnia-leds";
|
||||
reg = <0x2b>;
|
||||
interrupts-extended = <&mcu 11 IRQ_TYPE_NONE>;
|
||||
#address-cells = <1>;
|
||||
#size-cells = <0>;
|
||||
|
||||
|
||||
@ -27,7 +27,7 @@ properties:
|
||||
description: |
|
||||
For multicolor LED support this property should be defined as either
|
||||
LED_COLOR_ID_RGB or LED_COLOR_ID_MULTI which can be found in
|
||||
include/linux/leds/common.h.
|
||||
include/dt-bindings/leds/common.h.
|
||||
enum: [ 8, 9 ]
|
||||
|
||||
required:
|
||||
|
||||
@ -23,6 +23,7 @@ properties:
|
||||
items:
|
||||
- enum:
|
||||
- qcom,pm6150l-flash-led
|
||||
- qcom,pm660l-flash-led
|
||||
- qcom,pm8150c-flash-led
|
||||
- qcom,pm8150l-flash-led
|
||||
- qcom,pm8350c-flash-led
|
||||
|
||||
@ -185,6 +185,14 @@ W: http://www.adaptec.com/
|
||||
F: Documentation/scsi/aacraid.rst
|
||||
F: drivers/scsi/aacraid/
|
||||
|
||||
AAEON UPBOARD FPGA MFD DRIVER
|
||||
M: Thomas Richard <thomas.richard@bootlin.com>
|
||||
S: Maintained
|
||||
F: drivers/leds/leds-upboard.c
|
||||
F: drivers/mfd/upboard-fpga.c
|
||||
F: drivers/pinctrl/pinctrl-upboard.c
|
||||
F: include/linux/mfd/upboard-fpga.h
|
||||
|
||||
AB8500 BATTERY AND CHARGER DRIVERS
|
||||
M: Linus Walleij <linus.walleij@linaro.org>
|
||||
F: Documentation/devicetree/bindings/power/supply/*ab8500*
|
||||
|
||||
@ -217,6 +217,8 @@ config LEDS_TURRIS_OMNIA
|
||||
depends on I2C
|
||||
depends on MACH_ARMADA_38X || COMPILE_TEST
|
||||
depends on OF
|
||||
depends on TURRIS_OMNIA_MCU
|
||||
depends on TURRIS_OMNIA_MCU_GPIO
|
||||
select LEDS_TRIGGERS
|
||||
help
|
||||
This option enables basic support for the LEDs found on the front
|
||||
@ -826,6 +828,15 @@ config LEDS_SC27XX_BLTC
|
||||
This driver can also be built as a module. If so the module will be
|
||||
called leds-sc27xx-bltc.
|
||||
|
||||
config LEDS_UPBOARD
|
||||
tristate "LED support for the UP board"
|
||||
depends on LEDS_CLASS && MFD_UPBOARD_FPGA
|
||||
help
|
||||
This option enables support for the UP board LEDs.
|
||||
|
||||
This driver can also be built as a module. If so the module will be
|
||||
called leds-upboard.
|
||||
|
||||
comment "LED driver for blink(1) USB RGB LED is under Special HID drivers (HID_THINGM)"
|
||||
|
||||
config LEDS_BLINKM
|
||||
|
||||
@ -90,6 +90,7 @@ obj-$(CONFIG_LEDS_TI_LMU_COMMON) += leds-ti-lmu-common.o
|
||||
obj-$(CONFIG_LEDS_TLC591XX) += leds-tlc591xx.o
|
||||
obj-$(CONFIG_LEDS_TPS6105X) += leds-tps6105x.o
|
||||
obj-$(CONFIG_LEDS_TURRIS_OMNIA) += leds-turris-omnia.o
|
||||
obj-$(CONFIG_LEDS_UPBOARD) += leds-upboard.o
|
||||
obj-$(CONFIG_LEDS_WM831X_STATUS) += leds-wm831x-status.o
|
||||
obj-$(CONFIG_LEDS_WM8350) += leds-wm8350.o
|
||||
obj-$(CONFIG_LEDS_WRAP) += leds-wrap.o
|
||||
|
||||
@ -265,7 +265,7 @@ static int lp8860_init(struct lp8860_led *led)
|
||||
goto out;
|
||||
}
|
||||
|
||||
reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs) / sizeof(lp8860_eeprom_disp_regs[0]);
|
||||
reg_count = ARRAY_SIZE(lp8860_eeprom_disp_regs);
|
||||
for (i = 0; i < reg_count; i++) {
|
||||
ret = regmap_write(led->eeprom_regmap,
|
||||
lp8860_eeprom_disp_regs[i].reg,
|
||||
|
||||
@ -439,6 +439,7 @@ static int netxbig_leds_get_of_pdata(struct device *dev,
|
||||
}
|
||||
gpio_ext_pdev = of_find_device_by_node(gpio_ext_np);
|
||||
if (!gpio_ext_pdev) {
|
||||
of_node_put(gpio_ext_np);
|
||||
dev_err(dev, "Failed to find platform device for gpio-ext\n");
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
@ -2,7 +2,7 @@
|
||||
/*
|
||||
* CZ.NIC's Turris Omnia LEDs driver
|
||||
*
|
||||
* 2020, 2023 by Marek Behún <kabel@kernel.org>
|
||||
* 2020, 2023, 2024 by Marek Behún <kabel@kernel.org>
|
||||
*/
|
||||
|
||||
#include <linux/i2c.h>
|
||||
@ -10,35 +10,23 @@
|
||||
#include <linux/module.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/turris-omnia-mcu-interface.h>
|
||||
|
||||
#define OMNIA_BOARD_LEDS 12
|
||||
#define OMNIA_LED_NUM_CHANNELS 3
|
||||
|
||||
/* MCU controller commands at I2C address 0x2a */
|
||||
#define OMNIA_MCU_I2C_ADDR 0x2a
|
||||
|
||||
#define CMD_GET_STATUS_WORD 0x01
|
||||
#define STS_FEATURES_SUPPORTED BIT(2)
|
||||
|
||||
#define CMD_GET_FEATURES 0x10
|
||||
#define FEAT_LED_GAMMA_CORRECTION BIT(5)
|
||||
|
||||
/* LED controller commands at I2C address 0x2b */
|
||||
#define CMD_LED_MODE 0x03
|
||||
#define CMD_LED_MODE_LED(l) ((l) & 0x0f)
|
||||
#define CMD_LED_MODE_USER 0x10
|
||||
|
||||
#define CMD_LED_STATE 0x04
|
||||
#define CMD_LED_STATE_LED(l) ((l) & 0x0f)
|
||||
#define CMD_LED_STATE_ON 0x10
|
||||
|
||||
#define CMD_LED_COLOR 0x05
|
||||
#define CMD_LED_SET_BRIGHTNESS 0x07
|
||||
#define CMD_LED_GET_BRIGHTNESS 0x08
|
||||
|
||||
#define CMD_SET_GAMMA_CORRECTION 0x30
|
||||
#define CMD_GET_GAMMA_CORRECTION 0x31
|
||||
/* MCU controller I2C address 0x2a, needed for detecting MCU features */
|
||||
#define OMNIA_MCU_I2C_ADDR 0x2a
|
||||
|
||||
/**
|
||||
* struct omnia_led - per-LED part of driver private data structure
|
||||
* @mc_cdev: multi-color LED class device
|
||||
* @subled_info: per-channel information
|
||||
* @cached_channels: cached values of per-channel brightness that was sent to the MCU
|
||||
* @on: whether the LED was set on
|
||||
* @hwtrig: whether the LED blinking was offloaded to the MCU
|
||||
* @reg: LED identifier to the MCU
|
||||
*/
|
||||
struct omnia_led {
|
||||
struct led_classdev_mc mc_cdev;
|
||||
struct mc_subled subled_info[OMNIA_LED_NUM_CHANNELS];
|
||||
@ -49,73 +37,38 @@ struct omnia_led {
|
||||
|
||||
#define to_omnia_led(l) container_of(l, struct omnia_led, mc_cdev)
|
||||
|
||||
/**
|
||||
* struct omnia_leds - driver private data structure
|
||||
* @client: I2C client device
|
||||
* @lock: mutex to protect cached state
|
||||
* @has_gamma_correction: whether the MCU firmware supports gamma correction
|
||||
* @brightness_knode: kernel node of the "brightness" device sysfs attribute (this is the
|
||||
* driver specific global brightness, not the LED classdev brightness)
|
||||
* @leds: flexible array of per-LED data
|
||||
*/
|
||||
struct omnia_leds {
|
||||
struct i2c_client *client;
|
||||
struct mutex lock;
|
||||
bool has_gamma_correction;
|
||||
struct kernfs_node *brightness_knode;
|
||||
struct omnia_led leds[];
|
||||
};
|
||||
|
||||
static int omnia_cmd_write_u8(const struct i2c_client *client, u8 cmd, u8 val)
|
||||
static int omnia_cmd_set_color(const struct i2c_client *client, u8 led, u8 r, u8 g, u8 b)
|
||||
{
|
||||
u8 buf[2] = { cmd, val };
|
||||
int ret;
|
||||
u8 buf[5] = { OMNIA_CMD_LED_COLOR, led, r, g, b };
|
||||
|
||||
ret = i2c_master_send(client, buf, sizeof(buf));
|
||||
|
||||
return ret < 0 ? ret : 0;
|
||||
}
|
||||
|
||||
static int omnia_cmd_read_raw(struct i2c_adapter *adapter, u8 addr, u8 cmd,
|
||||
void *reply, size_t len)
|
||||
{
|
||||
struct i2c_msg msgs[2];
|
||||
int ret;
|
||||
|
||||
msgs[0].addr = addr;
|
||||
msgs[0].flags = 0;
|
||||
msgs[0].len = 1;
|
||||
msgs[0].buf = &cmd;
|
||||
msgs[1].addr = addr;
|
||||
msgs[1].flags = I2C_M_RD;
|
||||
msgs[1].len = len;
|
||||
msgs[1].buf = reply;
|
||||
|
||||
ret = i2c_transfer(adapter, msgs, ARRAY_SIZE(msgs));
|
||||
if (likely(ret == ARRAY_SIZE(msgs)))
|
||||
return 0;
|
||||
else if (ret < 0)
|
||||
return ret;
|
||||
else
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
static int omnia_cmd_read_u8(const struct i2c_client *client, u8 cmd)
|
||||
{
|
||||
u8 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read_raw(client->adapter, client->addr, cmd, &reply, 1);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return reply;
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static int omnia_led_send_color_cmd(const struct i2c_client *client,
|
||||
struct omnia_led *led)
|
||||
{
|
||||
char cmd[5];
|
||||
int ret;
|
||||
|
||||
cmd[0] = CMD_LED_COLOR;
|
||||
cmd[1] = led->reg;
|
||||
cmd[2] = led->subled_info[0].brightness;
|
||||
cmd[3] = led->subled_info[1].brightness;
|
||||
cmd[4] = led->subled_info[2].brightness;
|
||||
|
||||
/* Send the color change command */
|
||||
ret = i2c_master_send(client, cmd, 5);
|
||||
ret = omnia_cmd_set_color(client, led->reg, led->subled_info[0].brightness,
|
||||
led->subled_info[1].brightness, led->subled_info[2].brightness);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
@ -170,12 +123,12 @@ static int omnia_led_brightness_set_blocking(struct led_classdev *cdev,
|
||||
* is not being blinked by HW.
|
||||
*/
|
||||
if (!err && !led->hwtrig && !brightness != !led->on) {
|
||||
u8 state = CMD_LED_STATE_LED(led->reg);
|
||||
u8 state = OMNIA_CMD_LED_STATE_LED(led->reg);
|
||||
|
||||
if (brightness)
|
||||
state |= CMD_LED_STATE_ON;
|
||||
state |= OMNIA_CMD_LED_STATE_ON;
|
||||
|
||||
err = omnia_cmd_write_u8(leds->client, CMD_LED_STATE, state);
|
||||
err = omnia_cmd_write_u8(leds->client, OMNIA_CMD_LED_STATE, state);
|
||||
if (!err)
|
||||
led->on = !!brightness;
|
||||
}
|
||||
@ -210,8 +163,8 @@ static int omnia_hwtrig_activate(struct led_classdev *cdev)
|
||||
|
||||
if (!err) {
|
||||
/* Put the LED into MCU controlled mode */
|
||||
err = omnia_cmd_write_u8(leds->client, CMD_LED_MODE,
|
||||
CMD_LED_MODE_LED(led->reg));
|
||||
err = omnia_cmd_write_u8(leds->client, OMNIA_CMD_LED_MODE,
|
||||
OMNIA_CMD_LED_MODE_LED(led->reg));
|
||||
if (!err)
|
||||
led->hwtrig = true;
|
||||
}
|
||||
@ -232,9 +185,8 @@ static void omnia_hwtrig_deactivate(struct led_classdev *cdev)
|
||||
led->hwtrig = false;
|
||||
|
||||
/* Put the LED into software mode */
|
||||
err = omnia_cmd_write_u8(leds->client, CMD_LED_MODE,
|
||||
CMD_LED_MODE_LED(led->reg) |
|
||||
CMD_LED_MODE_USER);
|
||||
err = omnia_cmd_write_u8(leds->client, OMNIA_CMD_LED_MODE,
|
||||
OMNIA_CMD_LED_MODE_LED(led->reg) | OMNIA_CMD_LED_MODE_USER);
|
||||
|
||||
mutex_unlock(&leds->lock);
|
||||
|
||||
@ -300,38 +252,26 @@ static int omnia_led_register(struct i2c_client *client, struct omnia_led *led,
|
||||
*/
|
||||
cdev->default_trigger = omnia_hw_trigger.name;
|
||||
|
||||
/* put the LED into software mode */
|
||||
ret = omnia_cmd_write_u8(client, CMD_LED_MODE,
|
||||
CMD_LED_MODE_LED(led->reg) |
|
||||
CMD_LED_MODE_USER);
|
||||
if (ret) {
|
||||
dev_err(dev, "Cannot set LED %pOF to software mode: %i\n", np,
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
/* Put the LED into software mode */
|
||||
ret = omnia_cmd_write_u8(client, OMNIA_CMD_LED_MODE, OMNIA_CMD_LED_MODE_LED(led->reg) |
|
||||
OMNIA_CMD_LED_MODE_USER);
|
||||
if (ret)
|
||||
return dev_err_probe(dev, ret, "Cannot set LED %pOF to software mode\n", np);
|
||||
|
||||
/* disable the LED */
|
||||
ret = omnia_cmd_write_u8(client, CMD_LED_STATE,
|
||||
CMD_LED_STATE_LED(led->reg));
|
||||
if (ret) {
|
||||
dev_err(dev, "Cannot set LED %pOF brightness: %i\n", np, ret);
|
||||
return ret;
|
||||
}
|
||||
/* Disable the LED */
|
||||
ret = omnia_cmd_write_u8(client, OMNIA_CMD_LED_STATE, OMNIA_CMD_LED_STATE_LED(led->reg));
|
||||
if (ret)
|
||||
return dev_err_probe(dev, ret, "Cannot set LED %pOF brightness\n", np);
|
||||
|
||||
/* Set initial color and cache it */
|
||||
ret = omnia_led_send_color_cmd(client, led);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "Cannot set LED %pOF initial color: %i\n", np,
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
if (ret < 0)
|
||||
return dev_err_probe(dev, ret, "Cannot set LED %pOF initial color\n", np);
|
||||
|
||||
ret = devm_led_classdev_multicolor_register_ext(dev, &led->mc_cdev,
|
||||
&init_data);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "Cannot register LED %pOF: %i\n", np, ret);
|
||||
return ret;
|
||||
}
|
||||
if (ret < 0)
|
||||
return dev_err_probe(dev, ret, "Cannot register LED %pOF\n", np);
|
||||
|
||||
return 1;
|
||||
}
|
||||
@ -351,14 +291,14 @@ static ssize_t brightness_show(struct device *dev, struct device_attribute *a,
|
||||
char *buf)
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
int ret;
|
||||
u8 reply;
|
||||
int err;
|
||||
|
||||
ret = omnia_cmd_read_u8(client, CMD_LED_GET_BRIGHTNESS);
|
||||
err = omnia_cmd_read_u8(client, OMNIA_CMD_GET_BRIGHTNESS, &reply);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return sysfs_emit(buf, "%d\n", ret);
|
||||
return sysfs_emit(buf, "%d\n", reply);
|
||||
}
|
||||
|
||||
static ssize_t brightness_store(struct device *dev, struct device_attribute *a,
|
||||
@ -374,7 +314,7 @@ static ssize_t brightness_store(struct device *dev, struct device_attribute *a,
|
||||
if (brightness > 100)
|
||||
return -EINVAL;
|
||||
|
||||
err = omnia_cmd_write_u8(client, CMD_LED_SET_BRIGHTNESS, brightness);
|
||||
err = omnia_cmd_write_u8(client, OMNIA_CMD_SET_BRIGHTNESS, brightness);
|
||||
|
||||
return err ?: count;
|
||||
}
|
||||
@ -385,17 +325,16 @@ static ssize_t gamma_correction_show(struct device *dev,
|
||||
{
|
||||
struct i2c_client *client = to_i2c_client(dev);
|
||||
struct omnia_leds *leds = i2c_get_clientdata(client);
|
||||
int ret;
|
||||
u8 reply = 0;
|
||||
int err;
|
||||
|
||||
if (leds->has_gamma_correction) {
|
||||
ret = omnia_cmd_read_u8(client, CMD_GET_GAMMA_CORRECTION);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
} else {
|
||||
ret = 0;
|
||||
err = omnia_cmd_read_u8(client, OMNIA_CMD_GET_GAMMA_CORRECTION, &reply);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
|
||||
return sysfs_emit(buf, "%d\n", !!ret);
|
||||
return sysfs_emit(buf, "%d\n", !!reply);
|
||||
}
|
||||
|
||||
static ssize_t gamma_correction_store(struct device *dev,
|
||||
@ -413,7 +352,7 @@ static ssize_t gamma_correction_store(struct device *dev,
|
||||
if (kstrtobool(buf, &val) < 0)
|
||||
return -EINVAL;
|
||||
|
||||
err = omnia_cmd_write_u8(client, CMD_SET_GAMMA_CORRECTION, val);
|
||||
err = omnia_cmd_write_u8(client, OMNIA_CMD_SET_GAMMA_CORRECTION, val);
|
||||
|
||||
return err ?: count;
|
||||
}
|
||||
@ -426,26 +365,104 @@ static struct attribute *omnia_led_controller_attrs[] = {
|
||||
};
|
||||
ATTRIBUTE_GROUPS(omnia_led_controller);
|
||||
|
||||
static int omnia_mcu_get_features(const struct i2c_client *client)
|
||||
static irqreturn_t omnia_brightness_changed_threaded_fn(int irq, void *data)
|
||||
{
|
||||
struct omnia_leds *leds = data;
|
||||
|
||||
if (unlikely(!leds->brightness_knode)) {
|
||||
/*
|
||||
* Note that sysfs_get_dirent() may sleep. This is okay, because we are in threaded
|
||||
* context.
|
||||
*/
|
||||
leds->brightness_knode = sysfs_get_dirent(leds->client->dev.kobj.sd, "brightness");
|
||||
if (!leds->brightness_knode)
|
||||
return IRQ_NONE;
|
||||
}
|
||||
|
||||
sysfs_notify_dirent(leds->brightness_knode);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static void omnia_brightness_knode_put(void *data)
|
||||
{
|
||||
struct omnia_leds *leds = data;
|
||||
|
||||
if (leds->brightness_knode)
|
||||
sysfs_put(leds->brightness_knode);
|
||||
}
|
||||
|
||||
static int omnia_request_brightness_irq(struct omnia_leds *leds)
|
||||
{
|
||||
struct device *dev = &leds->client->dev;
|
||||
int ret;
|
||||
|
||||
if (!leds->client->irq) {
|
||||
dev_info(dev,
|
||||
"Brightness change interrupt supported by MCU firmware but not described in device-tree\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Registering the brightness_knode destructor before requesting the IRQ ensures that on
|
||||
* removal the brightness_knode sysfs node is put only after the IRQ is freed.
|
||||
* This is needed because the interrupt handler uses the knode.
|
||||
*/
|
||||
ret = devm_add_action(dev, omnia_brightness_knode_put, leds);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
return devm_request_threaded_irq(dev, leds->client->irq, NULL,
|
||||
omnia_brightness_changed_threaded_fn, IRQF_ONESHOT,
|
||||
"leds-turris-omnia", leds);
|
||||
}
|
||||
|
||||
static int omnia_mcu_get_features(const struct i2c_client *mcu_client)
|
||||
{
|
||||
u16 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read_raw(client->adapter, OMNIA_MCU_I2C_ADDR,
|
||||
CMD_GET_STATUS_WORD, &reply, sizeof(reply));
|
||||
err = omnia_cmd_read_u16(mcu_client, OMNIA_CMD_GET_STATUS_WORD, &reply);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Check whether MCU firmware supports the CMD_GET_FEAUTRES command */
|
||||
if (!(le16_to_cpu(reply) & STS_FEATURES_SUPPORTED))
|
||||
/* Check whether MCU firmware supports the OMNIA_CMD_GET_FEAUTRES command */
|
||||
if (!(reply & OMNIA_STS_FEATURES_SUPPORTED))
|
||||
return 0;
|
||||
|
||||
err = omnia_cmd_read_raw(client->adapter, OMNIA_MCU_I2C_ADDR,
|
||||
CMD_GET_FEATURES, &reply, sizeof(reply));
|
||||
err = omnia_cmd_read_u16(mcu_client, OMNIA_CMD_GET_FEATURES, &reply);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return le16_to_cpu(reply);
|
||||
return reply;
|
||||
}
|
||||
|
||||
static int omnia_match_mcu_client(struct device *dev, void *data)
|
||||
{
|
||||
struct i2c_client *client;
|
||||
|
||||
client = i2c_verify_client(dev);
|
||||
if (!client)
|
||||
return 0;
|
||||
|
||||
return client->addr == OMNIA_MCU_I2C_ADDR;
|
||||
}
|
||||
|
||||
static int omnia_find_mcu_and_get_features(struct device *dev)
|
||||
{
|
||||
struct device *mcu_dev;
|
||||
int ret;
|
||||
|
||||
mcu_dev = device_find_child(dev->parent, NULL, omnia_match_mcu_client);
|
||||
if (!mcu_dev)
|
||||
return -ENODEV;
|
||||
|
||||
ret = omnia_mcu_get_features(i2c_verify_client(mcu_dev));
|
||||
|
||||
put_device(mcu_dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int omnia_leds_probe(struct i2c_client *client)
|
||||
@ -457,13 +474,10 @@ static int omnia_leds_probe(struct i2c_client *client)
|
||||
int ret, count;
|
||||
|
||||
count = of_get_available_child_count(np);
|
||||
if (!count) {
|
||||
dev_err(dev, "LEDs are not defined in device tree!\n");
|
||||
return -ENODEV;
|
||||
} else if (count > OMNIA_BOARD_LEDS) {
|
||||
dev_err(dev, "Too many LEDs defined in device tree!\n");
|
||||
return -EINVAL;
|
||||
}
|
||||
if (count == 0)
|
||||
return dev_err_probe(dev, -ENODEV, "LEDs are not defined in device tree!\n");
|
||||
if (count > OMNIA_BOARD_LEDS)
|
||||
return dev_err_probe(dev, -EINVAL, "Too many LEDs defined in device tree!\n");
|
||||
|
||||
leds = devm_kzalloc(dev, struct_size(leds, leds, count), GFP_KERNEL);
|
||||
if (!leds)
|
||||
@ -472,28 +486,23 @@ static int omnia_leds_probe(struct i2c_client *client)
|
||||
leds->client = client;
|
||||
i2c_set_clientdata(client, leds);
|
||||
|
||||
ret = omnia_mcu_get_features(client);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "Cannot determine MCU supported features: %d\n",
|
||||
ret);
|
||||
return ret;
|
||||
}
|
||||
ret = omnia_find_mcu_and_get_features(dev);
|
||||
if (ret < 0)
|
||||
return dev_err_probe(dev, ret, "Cannot determine MCU supported features\n");
|
||||
|
||||
leds->has_gamma_correction = ret & FEAT_LED_GAMMA_CORRECTION;
|
||||
if (!leds->has_gamma_correction) {
|
||||
dev_info(dev,
|
||||
"Your board's MCU firmware does not support the LED gamma correction feature.\n");
|
||||
dev_info(dev,
|
||||
"Consider upgrading MCU firmware with the omnia-mcutool utility.\n");
|
||||
leds->has_gamma_correction = ret & OMNIA_FEAT_LED_GAMMA_CORRECTION;
|
||||
|
||||
if (ret & OMNIA_FEAT_BRIGHTNESS_INT) {
|
||||
ret = omnia_request_brightness_irq(leds);
|
||||
if (ret < 0)
|
||||
return dev_err_probe(dev, ret, "Cannot request brightness IRQ\n");
|
||||
}
|
||||
|
||||
mutex_init(&leds->lock);
|
||||
|
||||
ret = devm_led_trigger_register(dev, &omnia_hw_trigger);
|
||||
if (ret < 0) {
|
||||
dev_err(dev, "Cannot register private LED trigger: %d\n", ret);
|
||||
return ret;
|
||||
}
|
||||
if (ret < 0)
|
||||
return dev_err_probe(dev, ret, "Cannot register private LED trigger\n");
|
||||
|
||||
led = &leds->leds[0];
|
||||
for_each_available_child_of_node_scoped(np, child) {
|
||||
@ -509,20 +518,11 @@ static int omnia_leds_probe(struct i2c_client *client)
|
||||
|
||||
static void omnia_leds_remove(struct i2c_client *client)
|
||||
{
|
||||
u8 buf[5];
|
||||
/* Put all LEDs into default (HW triggered) mode */
|
||||
omnia_cmd_write_u8(client, OMNIA_CMD_LED_MODE, OMNIA_CMD_LED_MODE_LED(OMNIA_BOARD_LEDS));
|
||||
|
||||
/* put all LEDs into default (HW triggered) mode */
|
||||
omnia_cmd_write_u8(client, CMD_LED_MODE,
|
||||
CMD_LED_MODE_LED(OMNIA_BOARD_LEDS));
|
||||
|
||||
/* set all LEDs color to [255, 255, 255] */
|
||||
buf[0] = CMD_LED_COLOR;
|
||||
buf[1] = OMNIA_BOARD_LEDS;
|
||||
buf[2] = 255;
|
||||
buf[3] = 255;
|
||||
buf[4] = 255;
|
||||
|
||||
i2c_master_send(client, buf, 5);
|
||||
/* Set all LEDs color to [255, 255, 255] */
|
||||
omnia_cmd_set_color(client, OMNIA_BOARD_LEDS, 255, 255, 255);
|
||||
}
|
||||
|
||||
static const struct of_device_id of_omnia_leds_match[] = {
|
||||
|
||||
126
drivers/leds/leds-upboard.c
Normal file
126
drivers/leds/leds-upboard.c
Normal file
@ -0,0 +1,126 @@
|
||||
// SPDX-License-Identifier: GPL-2.0-only
|
||||
/*
|
||||
* UP board LED driver.
|
||||
*
|
||||
* Copyright (c) AAEON. All rights reserved.
|
||||
* Copyright (C) 2024 Bootlin
|
||||
*
|
||||
* Author: Gary Wang <garywang@aaeon.com.tw>
|
||||
* Author: Thomas Richard <thomas.richard@bootlin.com>
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/container_of.h>
|
||||
#include <linux/leds.h>
|
||||
#include <linux/mfd/upboard-fpga.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/regmap.h>
|
||||
|
||||
#define led_cdev_to_led_upboard(c) container_of(c, struct upboard_led, cdev)
|
||||
|
||||
struct upboard_led {
|
||||
struct regmap_field *field;
|
||||
struct led_classdev cdev;
|
||||
};
|
||||
|
||||
struct upboard_led_profile {
|
||||
const char *name;
|
||||
unsigned int bit;
|
||||
};
|
||||
|
||||
static struct upboard_led_profile upboard_up_led_profile[] = {
|
||||
{ "upboard:yellow:" LED_FUNCTION_STATUS, 0 },
|
||||
{ "upboard:green:" LED_FUNCTION_STATUS, 1 },
|
||||
{ "upboard:red:" LED_FUNCTION_STATUS, 2 },
|
||||
};
|
||||
|
||||
static struct upboard_led_profile upboard_up2_led_profile[] = {
|
||||
{ "upboard:blue:" LED_FUNCTION_STATUS, 0 },
|
||||
{ "upboard:yellow:" LED_FUNCTION_STATUS, 1 },
|
||||
{ "upboard:green:" LED_FUNCTION_STATUS, 2 },
|
||||
{ "upboard:red:" LED_FUNCTION_STATUS, 3 },
|
||||
};
|
||||
|
||||
static enum led_brightness upboard_led_brightness_get(struct led_classdev *cdev)
|
||||
{
|
||||
struct upboard_led *led = led_cdev_to_led_upboard(cdev);
|
||||
int brightness, ret;
|
||||
|
||||
ret = regmap_field_read(led->field, &brightness);
|
||||
|
||||
return ret ? LED_OFF : brightness;
|
||||
};
|
||||
|
||||
static int upboard_led_brightness_set(struct led_classdev *cdev, enum led_brightness brightness)
|
||||
{
|
||||
struct upboard_led *led = led_cdev_to_led_upboard(cdev);
|
||||
|
||||
return regmap_field_write(led->field, brightness != LED_OFF);
|
||||
};
|
||||
|
||||
static int upboard_led_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
struct upboard_fpga *fpga = dev_get_drvdata(dev->parent);
|
||||
struct upboard_led_profile *led_profile;
|
||||
struct upboard_led *led;
|
||||
int led_instances, ret, i;
|
||||
|
||||
switch (fpga->fpga_data->type) {
|
||||
case UPBOARD_UP_FPGA:
|
||||
led_profile = upboard_up_led_profile;
|
||||
led_instances = ARRAY_SIZE(upboard_up_led_profile);
|
||||
break;
|
||||
case UPBOARD_UP2_FPGA:
|
||||
led_profile = upboard_up2_led_profile;
|
||||
led_instances = ARRAY_SIZE(upboard_up2_led_profile);
|
||||
break;
|
||||
default:
|
||||
return dev_err_probe(dev, -EINVAL, "Unknown device type %d\n",
|
||||
fpga->fpga_data->type);
|
||||
}
|
||||
|
||||
for (i = 0; i < led_instances; i++) {
|
||||
const struct reg_field fldconf = {
|
||||
.reg = UPBOARD_REG_FUNC_EN0,
|
||||
.lsb = led_profile[i].bit,
|
||||
.msb = led_profile[i].bit,
|
||||
};
|
||||
|
||||
led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
|
||||
if (!led)
|
||||
return -ENOMEM;
|
||||
|
||||
led->field = devm_regmap_field_alloc(&pdev->dev, fpga->regmap, fldconf);
|
||||
if (IS_ERR(led->field))
|
||||
return PTR_ERR(led->field);
|
||||
|
||||
led->cdev.brightness_get = upboard_led_brightness_get;
|
||||
led->cdev.brightness_set_blocking = upboard_led_brightness_set;
|
||||
led->cdev.max_brightness = LED_ON;
|
||||
|
||||
led->cdev.name = led_profile[i].name;
|
||||
|
||||
ret = devm_led_classdev_register(dev, &led->cdev);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver upboard_led_driver = {
|
||||
.driver = {
|
||||
.name = "upboard-leds",
|
||||
},
|
||||
.probe = upboard_led_probe,
|
||||
};
|
||||
|
||||
module_platform_driver(upboard_led_driver);
|
||||
|
||||
MODULE_AUTHOR("Gary Wang <garywang@aaeon.com.tw>");
|
||||
MODULE_AUTHOR("Thomas Richard <thomas.richard@bootlin.com>");
|
||||
MODULE_DESCRIPTION("UP Board LED driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
MODULE_ALIAS("platform:upboard-led");
|
||||
@ -50,7 +50,13 @@ static int led_pwm_mc_set(struct led_classdev *cdev,
|
||||
duty = priv->leds[i].state.period - duty;
|
||||
|
||||
priv->leds[i].state.duty_cycle = duty;
|
||||
priv->leds[i].state.enabled = duty > 0;
|
||||
/*
|
||||
* Disabling a PWM doesn't guarantee that it emits the inactive level.
|
||||
* So keep it on. Only for suspending the PWM should be disabled because
|
||||
* otherwise it refuses to suspend. The possible downside is that the
|
||||
* LED might stay (or even go) on.
|
||||
*/
|
||||
priv->leds[i].state.enabled = !(cdev->flags & LED_SUSPENDED);
|
||||
ret = pwm_apply_might_sleep(priv->leds[i].pwm,
|
||||
&priv->leds[i].state);
|
||||
if (ret)
|
||||
|
||||
@ -156,7 +156,7 @@ static ssize_t led_invert_show(struct device *dev,
|
||||
{
|
||||
struct activity_data *activity_data = led_trigger_get_drvdata(dev);
|
||||
|
||||
return sprintf(buf, "%u\n", activity_data->invert);
|
||||
return sprintf(buf, "%d\n", activity_data->invert);
|
||||
}
|
||||
|
||||
static ssize_t led_invert_store(struct device *dev,
|
||||
|
||||
@ -605,6 +605,8 @@ static int netdev_trig_notify(struct notifier_block *nb,
|
||||
trigger_data->net_dev = NULL;
|
||||
break;
|
||||
case NETDEV_UP:
|
||||
trigger_data->hw_control = can_hw_control(trigger_data);
|
||||
fallthrough;
|
||||
case NETDEV_CHANGE:
|
||||
get_device_state(trigger_data);
|
||||
/* Refresh link_speed visibility */
|
||||
|
||||
@ -52,6 +52,7 @@ int omnia_cmd_write_read(const struct i2c_client *client,
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(omnia_cmd_write_read);
|
||||
|
||||
static int omnia_get_version_hash(struct omnia_mcu *mcu, bool bootloader,
|
||||
char version[static OMNIA_FW_VERSION_HEX_LEN])
|
||||
@ -257,6 +258,8 @@ static int omnia_mcu_read_features(struct omnia_mcu *mcu)
|
||||
_DEF_FEAT(NEW_INT_API, "new interrupt API"),
|
||||
_DEF_FEAT(POWEROFF_WAKEUP, "poweroff and wakeup"),
|
||||
_DEF_FEAT(TRNG, "true random number generator"),
|
||||
_DEF_FEAT(BRIGHTNESS_INT, "LED panel brightness change interrupt"),
|
||||
_DEF_FEAT(LED_GAMMA_CORRECTION, "LED gamma correction"),
|
||||
#undef _DEF_FEAT
|
||||
};
|
||||
struct i2c_client *client = mcu->client;
|
||||
|
||||
@ -8,7 +8,6 @@
|
||||
#ifndef __TURRIS_OMNIA_MCU_H
|
||||
#define __TURRIS_OMNIA_MCU_H
|
||||
|
||||
#include <linux/bitops.h>
|
||||
#include <linux/completion.h>
|
||||
#include <linux/gpio/driver.h>
|
||||
#include <linux/hw_random.h>
|
||||
@ -17,8 +16,6 @@
|
||||
#include <linux/types.h>
|
||||
#include <linux/watchdog.h>
|
||||
#include <linux/workqueue.h>
|
||||
#include <asm/byteorder.h>
|
||||
#include <linux/unaligned.h>
|
||||
|
||||
struct i2c_client;
|
||||
struct rtc_device;
|
||||
@ -93,133 +90,6 @@ struct omnia_mcu {
|
||||
#endif
|
||||
};
|
||||
|
||||
int omnia_cmd_write_read(const struct i2c_client *client,
|
||||
void *cmd, unsigned int cmd_len,
|
||||
void *reply, unsigned int reply_len);
|
||||
|
||||
static inline int omnia_cmd_write(const struct i2c_client *client, void *cmd,
|
||||
unsigned int len)
|
||||
{
|
||||
return omnia_cmd_write_read(client, cmd, len, NULL, 0);
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u8(const struct i2c_client *client, u8 cmd,
|
||||
u8 val)
|
||||
{
|
||||
u8 buf[2] = { cmd, val };
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u16(const struct i2c_client *client, u8 cmd,
|
||||
u16 val)
|
||||
{
|
||||
u8 buf[3];
|
||||
|
||||
buf[0] = cmd;
|
||||
put_unaligned_le16(val, &buf[1]);
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u32(const struct i2c_client *client, u8 cmd,
|
||||
u32 val)
|
||||
{
|
||||
u8 buf[5];
|
||||
|
||||
buf[0] = cmd;
|
||||
put_unaligned_le32(val, &buf[1]);
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read(const struct i2c_client *client, u8 cmd,
|
||||
void *reply, unsigned int len)
|
||||
{
|
||||
return omnia_cmd_write_read(client, &cmd, 1, reply, len);
|
||||
}
|
||||
|
||||
static inline unsigned int
|
||||
omnia_compute_reply_length(unsigned long mask, bool interleaved,
|
||||
unsigned int offset)
|
||||
{
|
||||
if (!mask)
|
||||
return 0;
|
||||
|
||||
return ((__fls(mask) >> 3) << interleaved) + 1 + offset;
|
||||
}
|
||||
|
||||
/* Returns 0 on success */
|
||||
static inline int omnia_cmd_read_bits(const struct i2c_client *client, u8 cmd,
|
||||
unsigned long bits, unsigned long *dst)
|
||||
{
|
||||
__le32 reply;
|
||||
int err;
|
||||
|
||||
if (!bits) {
|
||||
*dst = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply,
|
||||
omnia_compute_reply_length(bits, false, 0));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le32_to_cpu(reply) & bits;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_bit(const struct i2c_client *client, u8 cmd,
|
||||
unsigned long bit)
|
||||
{
|
||||
unsigned long reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read_bits(client, cmd, bit, &reply);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return !!reply;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u32(const struct i2c_client *client, u8 cmd,
|
||||
u32 *dst)
|
||||
{
|
||||
__le32 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le32_to_cpu(reply);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u16(const struct i2c_client *client, u8 cmd,
|
||||
u16 *dst)
|
||||
{
|
||||
__le16 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le16_to_cpu(reply);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u8(const struct i2c_client *client, u8 cmd,
|
||||
u8 *reply)
|
||||
{
|
||||
return omnia_cmd_read(client, cmd, reply, sizeof(*reply));
|
||||
}
|
||||
|
||||
#ifdef CONFIG_TURRIS_OMNIA_MCU_GPIO
|
||||
extern const u8 omnia_int_to_gpio_idx[32];
|
||||
extern const struct attribute_group omnia_mcu_gpio_group;
|
||||
|
||||
@ -9,7 +9,10 @@
|
||||
#define __TURRIS_OMNIA_MCU_INTERFACE_H
|
||||
|
||||
#include <linux/bitfield.h>
|
||||
#include <linux/bits.h>
|
||||
#include <linux/bitops.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/unaligned.h>
|
||||
#include <asm/byteorder.h>
|
||||
|
||||
enum omnia_commands_e {
|
||||
OMNIA_CMD_GET_STATUS_WORD = 0x01, /* slave sends status word back */
|
||||
@ -236,6 +239,20 @@ enum omnia_int_e {
|
||||
OMNIA_INT_LAN5_LED1 = BIT(31),
|
||||
};
|
||||
|
||||
enum omnia_cmd_led_mode_e {
|
||||
OMNIA_CMD_LED_MODE_LED_MASK = GENMASK(3, 0),
|
||||
OMNIA_CMD_LED_MODE_USER = BIT(4),
|
||||
};
|
||||
|
||||
#define OMNIA_CMD_LED_MODE_LED(_l) FIELD_PREP(OMNIA_CMD_LED_MODE_LED_MASK, _l)
|
||||
|
||||
enum omnia_cmd_led_state_e {
|
||||
OMNIA_CMD_LED_STATE_LED_MASK = GENMASK(3, 0),
|
||||
OMNIA_CMD_LED_STATE_ON = BIT(4),
|
||||
};
|
||||
|
||||
#define OMNIA_CMD_LED_STATE_LED(_l) FIELD_PREP(OMNIA_CMD_LED_STATE_LED_MASK, _l)
|
||||
|
||||
enum omnia_cmd_poweroff_e {
|
||||
OMNIA_CMD_POWER_OFF_POWERON_BUTTON = BIT(0),
|
||||
OMNIA_CMD_POWER_OFF_MAGIC = 0xdead,
|
||||
@ -246,4 +263,135 @@ enum omnia_cmd_usb_ovc_prot_e {
|
||||
OMNIA_CMD_xET_USB_OVC_PROT_ENABLE = BIT(4),
|
||||
};
|
||||
|
||||
/* Command execution functions */
|
||||
|
||||
struct i2c_client;
|
||||
|
||||
int omnia_cmd_write_read(const struct i2c_client *client,
|
||||
void *cmd, unsigned int cmd_len,
|
||||
void *reply, unsigned int reply_len);
|
||||
|
||||
static inline int omnia_cmd_write(const struct i2c_client *client, void *cmd,
|
||||
unsigned int len)
|
||||
{
|
||||
return omnia_cmd_write_read(client, cmd, len, NULL, 0);
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u8(const struct i2c_client *client, u8 cmd,
|
||||
u8 val)
|
||||
{
|
||||
u8 buf[2] = { cmd, val };
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u16(const struct i2c_client *client, u8 cmd,
|
||||
u16 val)
|
||||
{
|
||||
u8 buf[3];
|
||||
|
||||
buf[0] = cmd;
|
||||
put_unaligned_le16(val, &buf[1]);
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_write_u32(const struct i2c_client *client, u8 cmd,
|
||||
u32 val)
|
||||
{
|
||||
u8 buf[5];
|
||||
|
||||
buf[0] = cmd;
|
||||
put_unaligned_le32(val, &buf[1]);
|
||||
|
||||
return omnia_cmd_write(client, buf, sizeof(buf));
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read(const struct i2c_client *client, u8 cmd,
|
||||
void *reply, unsigned int len)
|
||||
{
|
||||
return omnia_cmd_write_read(client, &cmd, 1, reply, len);
|
||||
}
|
||||
|
||||
static inline unsigned int
|
||||
omnia_compute_reply_length(unsigned long mask, bool interleaved,
|
||||
unsigned int offset)
|
||||
{
|
||||
if (!mask)
|
||||
return 0;
|
||||
|
||||
return ((__fls(mask) >> 3) << interleaved) + 1 + offset;
|
||||
}
|
||||
|
||||
/* Returns 0 on success */
|
||||
static inline int omnia_cmd_read_bits(const struct i2c_client *client, u8 cmd,
|
||||
unsigned long bits, unsigned long *dst)
|
||||
{
|
||||
__le32 reply;
|
||||
int err;
|
||||
|
||||
if (!bits) {
|
||||
*dst = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply,
|
||||
omnia_compute_reply_length(bits, false, 0));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le32_to_cpu(reply) & bits;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_bit(const struct i2c_client *client, u8 cmd,
|
||||
unsigned long bit)
|
||||
{
|
||||
unsigned long reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read_bits(client, cmd, bit, &reply);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return !!reply;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u32(const struct i2c_client *client, u8 cmd,
|
||||
u32 *dst)
|
||||
{
|
||||
__le32 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le32_to_cpu(reply);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u16(const struct i2c_client *client, u8 cmd,
|
||||
u16 *dst)
|
||||
{
|
||||
__le16 reply;
|
||||
int err;
|
||||
|
||||
err = omnia_cmd_read(client, cmd, &reply, sizeof(reply));
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
*dst = le16_to_cpu(reply);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int omnia_cmd_read_u8(const struct i2c_client *client, u8 cmd,
|
||||
u8 *reply)
|
||||
{
|
||||
return omnia_cmd_read(client, cmd, reply, sizeof(*reply));
|
||||
}
|
||||
|
||||
#endif /* __TURRIS_OMNIA_MCU_INTERFACE_H */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user