mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2025-04-12 06:49:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
linux/drivers/net/dsa/mv88e6xxx/leds.c
Linus Walleij 94a2a84f5e net: dsa: mv88e6xxx: Support LED control 
This adds control over the hardware LEDs in the Marvell
MV88E6xxx DSA switch and enables it for MV88E6352.

This fixes an imminent problem on the Inteno XG6846 which
has a WAN LED that simply do not work with hardware
defaults: driver amendment is necessary.

The patch is modeled after Christian Marangis LED support
code for the QCA8k DSA switch, I got help with the register
definitions from Tim Harvey.

After this patch it is possible to activate hardware link
indication like this (or with a similar script):

  cd /sys/class/leds/Marvell\ 88E6352:05:00:green:wan/
  echo netdev > trigger
  echo 1 > link

This makes the green link indicator come up on any link
speed. It is also possible to be more elaborate, like this:

  cd /sys/class/leds/Marvell\ 88E6352:05:00:green:wan/
  echo netdev > trigger
  echo 1 > link_1000
  cd /sys/class/leds/Marvell\ 88E6352:05:01:amber:wan/
  echo netdev > trigger
  echo 1 > link_100

Making the green LED come on for a gigabit link and the
amber LED come on for a 100 mbit link.

Each port has 2 LED slots (the hardware may use just one or
none) and the hardware triggers are specified in four bits per
LED, and some of the hardware triggers are only available on the
SFP (fiber) uplink. The restrictions are described in the
port.h header file where the registers are described. For
example, selector 1 set for LED 1 on port 5 or 6 will indicate
Fiber 1000 (gigabit) and activity with a blinking LED, but
ONLY for an SFP connection. If port 5/6 is used with something
not SFP, this selector is a noop: something else need to be
selected.

After the previous series rewriting the MV88E6xxx DT
bindings to use YAML a "leds" subnode is already valid
for each port, in my scratch device tree it looks like
this:

   leds {
     #address-cells = <1>;
     #size-cells = <0>;

     led@0 {
       reg = <0>;
       color = <LED_COLOR_ID_GREEN>;
       function = LED_FUNCTION_LAN;
       default-state = "off";
       linux,default-trigger = "netdev";
     };
     led@1 {
       reg = <1>;
       color = <LED_COLOR_ID_AMBER>;
       function = LED_FUNCTION_LAN;
       default-state = "off";
     };
   };

This DT config is not yet configuring everything: when the netdev
default trigger is assigned the hw acceleration callbacks are
not called, and there is no way to set the netdev sub-trigger
type (such as link_1000) from the device tree, such as if you want
a gigabit link indicator. This has to be done from userspace at
this point.

We add LED operations to all switches in the 6352 family:
6172, 6176, 6240 and 6352.

Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Link: https://patch.msgid.link/20241001-mv88e6xxx-leds-v4-1-cc11c4f49b18@linaro.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2024-10-04 15:31:28 -07:00

840 lines
22 KiB
C
Raw Permalink Blame History

// SPDX-License-Identifier: GPL-2.0-or-later
#include <linux/bitfield.h>
#include <linux/leds.h>
#include <linux/property.h>
#include "chip.h"
#include "global2.h"
#include "port.h"
/* Offset 0x16: LED control */
static int mv88e6xxx_port_led_write(struct mv88e6xxx_chip *chip, int port, u16 reg)
{
reg |= MV88E6XXX_PORT_LED_CONTROL_UPDATE;
return mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_LED_CONTROL, reg);
}
static int mv88e6xxx_port_led_read(struct mv88e6xxx_chip *chip, int port,
u16 ptr, u16 *val)
{
int err;
err = mv88e6xxx_port_write(chip, port, MV88E6XXX_PORT_LED_CONTROL, ptr);
if (err)
return err;
err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_LED_CONTROL, val);
*val &= 0x3ff;
return err;
}
static int mv88e6xxx_led_brightness_set(struct mv88e6xxx_port *p, int led,
int brightness)
{
u16 reg;
int err;
err = mv88e6xxx_port_led_read(p->chip, p->port,
MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL,
&reg);
if (err)
return err;
if (led == 1)
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED1_SEL_MASK;
else
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED0_SEL_MASK;
if (brightness) {
/* Selector 0x0f == Force LED ON */
if (led == 1)
reg |= MV88E6XXX_PORT_LED_CONTROL_LED1_SELF;
else
reg |= MV88E6XXX_PORT_LED_CONTROL_LED0_SELF;
} else {
/* Selector 0x0e == Force LED OFF */
if (led == 1)
reg |= MV88E6XXX_PORT_LED_CONTROL_LED1_SELE;
else
reg |= MV88E6XXX_PORT_LED_CONTROL_LED0_SELE;
}
reg |= MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL;
return mv88e6xxx_port_led_write(p->chip, p->port, reg);
}
static int mv88e6xxx_led0_brightness_set_blocking(struct led_classdev *ldev,
enum led_brightness brightness)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_brightness_set(p, 0, brightness);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
static int mv88e6xxx_led1_brightness_set_blocking(struct led_classdev *ldev,
enum led_brightness brightness)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_brightness_set(p, 1, brightness);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
struct mv88e6xxx_led_hwconfig {
int led;
u8 portmask;
unsigned long rules;
bool fiber;
bool blink_activity;
u16 selector;
};
/* The following is a lookup table to check what rules we can support on a
* certain LED given restrictions such as that some rules only work with fiber
* (SFP) connections and some blink on activity by default.
*/
#define MV88E6XXX_PORTS_0_3 (BIT(0) | BIT(1) | BIT(2) | BIT(3))
#define MV88E6XXX_PORTS_4_5 (BIT(4) | BIT(5))
#define MV88E6XXX_PORT_4 BIT(4)
#define MV88E6XXX_PORT_5 BIT(5)
/* Entries are listed in selector order.
*
* These configurations vary across different switch families, list
* different tables per-family here.
*/
static const struct mv88e6xxx_led_hwconfig mv88e6352_led_hwconfigs[] = {
{
.led = 0,
.portmask = MV88E6XXX_PORT_4,
.rules = BIT(TRIGGER_NETDEV_LINK),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL0,
},
{
.led = 1,
.portmask = MV88E6XXX_PORT_5,
.rules = BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL0,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_100) | BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL1,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK_100),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL1,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_4_5,
.rules = BIT(TRIGGER_NETDEV_LINK_100),
.blink_activity = true,
.fiber = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL1,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_4_5,
.rules = BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.fiber = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL1,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL2,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK_100),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL2,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_4_5,
.rules = BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.fiber = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL2,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_4_5,
.rules = BIT(TRIGGER_NETDEV_LINK_100),
.blink_activity = true,
.fiber = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL2,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL3,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_1000),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL3,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_4_5,
.rules = BIT(TRIGGER_NETDEV_LINK),
.fiber = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL3,
},
{
.led = 1,
.portmask = MV88E6XXX_PORT_4,
.rules = BIT(TRIGGER_NETDEV_LINK),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL4,
},
{
.led = 1,
.portmask = MV88E6XXX_PORT_5,
.rules = BIT(TRIGGER_NETDEV_LINK),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL5,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_FULL_DUPLEX),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL6,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL6,
},
{
.led = 0,
.portmask = MV88E6XXX_PORT_4,
.rules = BIT(TRIGGER_NETDEV_FULL_DUPLEX),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL6,
},
{
.led = 1,
.portmask = MV88E6XXX_PORT_5,
.rules = BIT(TRIGGER_NETDEV_FULL_DUPLEX),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL6,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL7,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10) | BIT(TRIGGER_NETDEV_LINK_1000),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL7,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL8,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL8,
},
{
.led = 0,
.portmask = MV88E6XXX_PORT_5,
.rules = BIT(TRIGGER_NETDEV_LINK),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL8,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SEL9,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_100),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SEL9,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_10),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SELA,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_100),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SELA,
},
{
.led = 0,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_100) | BIT(TRIGGER_NETDEV_LINK_1000),
.selector = MV88E6XXX_PORT_LED_CONTROL_LED0_SELB,
},
{
.led = 1,
.portmask = MV88E6XXX_PORTS_0_3,
.rules = BIT(TRIGGER_NETDEV_LINK_100) | BIT(TRIGGER_NETDEV_LINK_1000),
.blink_activity = true,
.selector = MV88E6XXX_PORT_LED_CONTROL_LED1_SELB,
},
};
/* mv88e6xxx_led_match_selector() - look up the appropriate LED mode selector
* @p: port state container
* @led: LED number, 0 or 1
* @blink_activity: blink the LED (usually blink on indicated activity)
* @fiber: the link is connected to fiber such as SFP
* @rules: LED status flags from the LED classdev core
* @selector: fill in the selector in this parameter with an OR operation
*/
static int mv88e6xxx_led_match_selector(struct mv88e6xxx_port *p, int led, bool blink_activity,
bool fiber, unsigned long rules, u16 *selector)
{
const struct mv88e6xxx_led_hwconfig *conf;
int i;
/* No rules means we turn the LED off */
if (!rules) {
if (led == 1)
*selector |= MV88E6XXX_PORT_LED_CONTROL_LED1_SELE;
else
*selector |= MV88E6XXX_PORT_LED_CONTROL_LED0_SELE;
return 0;
}
/* TODO: these rules are for MV88E6352, when adding other families,
* think about making sure you select the table that match the
* specific switch family.
*/
for (i = 0; i < ARRAY_SIZE(mv88e6352_led_hwconfigs); i++) {
conf = &mv88e6352_led_hwconfigs[i];
if (conf->led != led)
continue;
if (!(conf->portmask & BIT(p->port)))
continue;
if (conf->blink_activity != blink_activity)
continue;
if (conf->fiber != fiber)
continue;
if (conf->rules == rules) {
dev_dbg(p->chip->dev, "port%d LED %d set selector %04x for rules %08lx\n",
p->port, led, conf->selector, rules);
*selector |= conf->selector;
return 0;
}
}
return -EOPNOTSUPP;
}
/* mv88e6xxx_led_match_selector() - find Linux netdev rules from a selector value
* @p: port state container
* @selector: the selector value from the LED actity register
* @led: LED number, 0 or 1
* @rules: Linux netdev activity rules found from selector
*/
static int
mv88e6xxx_led_match_rule(struct mv88e6xxx_port *p, u16 selector, int led, unsigned long *rules)
{
const struct mv88e6xxx_led_hwconfig *conf;
int i;
/* Find the selector in the table, we just look for the right selector
* and ignore if the activity has special properties such as blinking
* or is fiber-only.
*/
for (i = 0; i < ARRAY_SIZE(mv88e6352_led_hwconfigs); i++) {
conf = &mv88e6352_led_hwconfigs[i];
if (conf->led != led)
continue;
if (!(conf->portmask & BIT(p->port)))
continue;
if (conf->selector == selector) {
dev_dbg(p->chip->dev, "port%d LED %d has selector %04x, rules %08lx\n",
p->port, led, selector, conf->rules);
*rules = conf->rules;
return 0;
}
}
return -EINVAL;
}
/* mv88e6xxx_led_get_selector() - get the appropriate LED mode selector
* @p: port state container
* @led: LED number, 0 or 1
* @fiber: the link is connected to fiber such as SFP
* @rules: LED status flags from the LED classdev core
* @selector: fill in the selector in this parameter with an OR operation
*/
static int mv88e6xxx_led_get_selector(struct mv88e6xxx_port *p, int led,
bool fiber, unsigned long rules, u16 *selector)
{
int err;
/* What happens here is that we first try to locate a trigger with solid
* indicator (such as LED is on for a 1000 link) else we try a second
* sweep to find something suitable with a trigger that will blink on
* activity.
*/
err = mv88e6xxx_led_match_selector(p, led, false, fiber, rules, selector);
if (err)
return mv88e6xxx_led_match_selector(p, led, true, fiber, rules, selector);
return 0;
}
/* Sets up the hardware blinking period */
static int mv88e6xxx_led_set_blinking_period(struct mv88e6xxx_port *p, int led,
unsigned long delay_on, unsigned long delay_off)
{
unsigned long period;
u16 reg;
period = delay_on + delay_off;
reg = 0;
switch (period) {
case 21:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_21MS;
break;
case 42:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_42MS;
break;
case 84:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_84MS;
break;
case 168:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_168MS;
break;
case 336:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_336MS;
break;
case 672:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_BLINK_RATE_672MS;
break;
default:
/* Fall back to software blinking */
return -EINVAL;
}
/* This is essentially PWM duty cycle: how long time of the period
* will the LED be on. Zero isn't great in most cases.
*/
switch (delay_on) {
case 0:
/* This is usually pretty useless and will make the LED look OFF */
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_NONE;
break;
case 21:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_21MS;
break;
case 42:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_42MS;
break;
case 84:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_84MS;
break;
case 168:
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_168MS;
break;
default:
/* Just use something non-zero */
reg |= MV88E6XXX_PORT_LED_CONTROL_0x06_PULSE_STRETCH_21MS;
break;
}
/* Set up blink rate */
reg |= MV88E6XXX_PORT_LED_CONTROL_POINTER_STRETCH_BLINK;
return mv88e6xxx_port_led_write(p->chip, p->port, reg);
}
static int mv88e6xxx_led_blink_set(struct mv88e6xxx_port *p, int led,
unsigned long *delay_on, unsigned long *delay_off)
{
u16 reg;
int err;
/* Choose a sensible default 336 ms (~3 Hz) */
if ((*delay_on == 0) && (*delay_off == 0)) {
*delay_on = 168;
*delay_off = 168;
}
/* No off delay is just on */
if (*delay_off == 0)
return mv88e6xxx_led_brightness_set(p, led, 1);
err = mv88e6xxx_led_set_blinking_period(p, led, *delay_on, *delay_off);
if (err)
return err;
err = mv88e6xxx_port_led_read(p->chip, p->port,
MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL,
&reg);
if (err)
return err;
if (led == 1)
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED1_SEL_MASK;
else
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED0_SEL_MASK;
/* This will select the forced blinking status */
if (led == 1)
reg |= MV88E6XXX_PORT_LED_CONTROL_LED1_SELD;
else
reg |= MV88E6XXX_PORT_LED_CONTROL_LED0_SELD;
reg |= MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL;
return mv88e6xxx_port_led_write(p->chip, p->port, reg);
}
static int mv88e6xxx_led0_blink_set(struct led_classdev *ldev,
unsigned long *delay_on,
unsigned long *delay_off)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_blink_set(p, 0, delay_on, delay_off);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
static int mv88e6xxx_led1_blink_set(struct led_classdev *ldev,
unsigned long *delay_on,
unsigned long *delay_off)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_blink_set(p, 1, delay_on, delay_off);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
static int
mv88e6xxx_led0_hw_control_is_supported(struct led_classdev *ldev, unsigned long rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
u16 selector = 0;
return mv88e6xxx_led_get_selector(p, 0, p->fiber, rules, &selector);
}
static int
mv88e6xxx_led1_hw_control_is_supported(struct led_classdev *ldev, unsigned long rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
u16 selector = 0;
return mv88e6xxx_led_get_selector(p, 1, p->fiber, rules, &selector);
}
static int mv88e6xxx_led_hw_control_set(struct mv88e6xxx_port *p,
int led, unsigned long rules)
{
u16 reg;
int err;
err = mv88e6xxx_port_led_read(p->chip, p->port,
MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL,
&reg);
if (err)
return err;
if (led == 1)
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED1_SEL_MASK;
else
reg &= ~MV88E6XXX_PORT_LED_CONTROL_LED0_SEL_MASK;
err = mv88e6xxx_led_get_selector(p, led, p->fiber, rules, &reg);
if (err)
return err;
reg |= MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL;
if (led == 0)
dev_dbg(p->chip->dev, "LED 0 hw control on port %d trigger selector 0x%02x\n",
p->port,
(unsigned int)(reg & MV88E6XXX_PORT_LED_CONTROL_LED0_SEL_MASK));
else
dev_dbg(p->chip->dev, "LED 1 hw control on port %d trigger selector 0x%02x\n",
p->port,
(unsigned int)(reg & MV88E6XXX_PORT_LED_CONTROL_LED1_SEL_MASK) >> 4);
return mv88e6xxx_port_led_write(p->chip, p->port, reg);
}
static int
mv88e6xxx_led_hw_control_get(struct mv88e6xxx_port *p, int led, unsigned long *rules)
{
u16 val;
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_port_led_read(p->chip, p->port,
MV88E6XXX_PORT_LED_CONTROL_POINTER_LED01_CTRL, &val);
mv88e6xxx_reg_unlock(p->chip);
if (err)
return err;
/* Mask out the selector bits for this port */
if (led == 1) {
val &= MV88E6XXX_PORT_LED_CONTROL_LED1_SEL_MASK;
/* It's forced blinking/OFF/ON */
if (val == MV88E6XXX_PORT_LED_CONTROL_LED1_SELD ||
val == MV88E6XXX_PORT_LED_CONTROL_LED1_SELE ||
val == MV88E6XXX_PORT_LED_CONTROL_LED1_SELF) {
*rules = 0;
return 0;
}
} else {
val &= MV88E6XXX_PORT_LED_CONTROL_LED0_SEL_MASK;
/* It's forced blinking/OFF/ON */
if (val == MV88E6XXX_PORT_LED_CONTROL_LED0_SELD ||
val == MV88E6XXX_PORT_LED_CONTROL_LED0_SELE ||
val == MV88E6XXX_PORT_LED_CONTROL_LED0_SELF) {
*rules = 0;
return 0;
}
}
err = mv88e6xxx_led_match_rule(p, val, led, rules);
if (!err)
return 0;
dev_dbg(p->chip->dev, "couldn't find matching selector for %04x\n", val);
*rules = 0;
return 0;
}
static int
mv88e6xxx_led0_hw_control_set(struct led_classdev *ldev, unsigned long rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_hw_control_set(p, 0, rules);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
static int
mv88e6xxx_led1_hw_control_set(struct led_classdev *ldev, unsigned long rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
int err;
mv88e6xxx_reg_lock(p->chip);
err = mv88e6xxx_led_hw_control_set(p, 1, rules);
mv88e6xxx_reg_unlock(p->chip);
return err;
}
static int
mv88e6xxx_led0_hw_control_get(struct led_classdev *ldev, unsigned long *rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
return mv88e6xxx_led_hw_control_get(p, 0, rules);
}
static int
mv88e6xxx_led1_hw_control_get(struct led_classdev *ldev, unsigned long *rules)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
return mv88e6xxx_led_hw_control_get(p, 1, rules);
}
static struct device *mv88e6xxx_led_hw_control_get_device(struct mv88e6xxx_port *p)
{
struct dsa_port *dp;
dp = dsa_to_port(p->chip->ds, p->port);
if (!dp)
return NULL;
if (dp->user)
return &dp->user->dev;
return NULL;
}
static struct device *
mv88e6xxx_led0_hw_control_get_device(struct led_classdev *ldev)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led0);
return mv88e6xxx_led_hw_control_get_device(p);
}
static struct device *
mv88e6xxx_led1_hw_control_get_device(struct led_classdev *ldev)
{
struct mv88e6xxx_port *p = container_of(ldev, struct mv88e6xxx_port, led1);
return mv88e6xxx_led_hw_control_get_device(p);
}
int mv88e6xxx_port_setup_leds(struct mv88e6xxx_chip *chip, int port)
{
struct fwnode_handle *led = NULL, *leds = NULL;
struct led_init_data init_data = { };
enum led_default_state state;
struct mv88e6xxx_port *p;
struct led_classdev *l;
struct device *dev;
u32 led_num;
int ret;
/* LEDs are on ports 1,2,3,4, 5 and 6 (index 0..5), no more */
if (port > 5)
return -EOPNOTSUPP;
p = &chip->ports[port];
if (!p->fwnode)
return 0;
dev = chip->dev;
leds = fwnode_get_named_child_node(p->fwnode, "leds");
if (!leds) {
dev_dbg(dev, "No Leds node specified in device tree for port %d!\n",
port);
return 0;
}
fwnode_for_each_child_node(leds, led) {
/* Reg represent the led number of the port, max 2
* LEDs can be connected to each port, in some designs
* only one LED is connected.
*/
if (fwnode_property_read_u32(led, "reg", &led_num))
continue;
if (led_num > 1) {
dev_err(dev, "invalid LED specified port %d\n", port);
return -EINVAL;
}
if (led_num == 0)
l = &p->led0;
else
l = &p->led1;
state = led_init_default_state_get(led);
switch (state) {
case LEDS_DEFSTATE_ON:
l->brightness = 1;
mv88e6xxx_led_brightness_set(p, led_num, 1);
break;
case LEDS_DEFSTATE_KEEP:
break;
default:
l->brightness = 0;
mv88e6xxx_led_brightness_set(p, led_num, 0);
}
l->max_brightness = 1;
if (led_num == 0) {
l->brightness_set_blocking = mv88e6xxx_led0_brightness_set_blocking;
l->blink_set = mv88e6xxx_led0_blink_set;
l->hw_control_is_supported = mv88e6xxx_led0_hw_control_is_supported;
l->hw_control_set = mv88e6xxx_led0_hw_control_set;
l->hw_control_get = mv88e6xxx_led0_hw_control_get;
l->hw_control_get_device = mv88e6xxx_led0_hw_control_get_device;
} else {
l->brightness_set_blocking = mv88e6xxx_led1_brightness_set_blocking;
l->blink_set = mv88e6xxx_led1_blink_set;
l->hw_control_is_supported = mv88e6xxx_led1_hw_control_is_supported;
l->hw_control_set = mv88e6xxx_led1_hw_control_set;
l->hw_control_get = mv88e6xxx_led1_hw_control_get;
l->hw_control_get_device = mv88e6xxx_led1_hw_control_get_device;
}
l->hw_control_trigger = "netdev";
init_data.default_label = ":port";
init_data.fwnode = led;
init_data.devname_mandatory = true;
init_data.devicename = kasprintf(GFP_KERNEL, "%s:0%d:0%d", chip->info->name,
port, led_num);
if (!init_data.devicename)
return -ENOMEM;
ret = devm_led_classdev_register_ext(dev, l, &init_data);
kfree(init_data.devicename);
if (ret) {
dev_err(dev, "Failed to init LED %d for port %d", led_num, port);
return ret;
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink