Quelle  leds-bcm63138.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2021 Rafał Miłecki <rafal@milecki.pl>
 */
#include <linux/bits.h>
#include <linux/cleanup.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/spinlock.h>

#define BCM63138_MAX_LEDS    32
#define BCM63138_MAX_BRIGHTNESS    9

#define BCM63138_LED_BITS    4    /* how many bits control a single LED */
#define BCM63138_LED_MASK    ((1 << BCM63138_LED_BITS) - 1) /* 0xf */
#define BCM63138_LEDS_PER_REG    (32 / BCM63138_LED_BITS) /* 8 */

#define BCM63138_GLB_CTRL    0x00
#define  BCM63138_GLB_CTRL_SERIAL_LED_DATA_PPOL  BIT(1)
#define  BCM63138_GLB_CTRL_SERIAL_LED_CLK_POL  BIT(2)
#define  BCM63138_GLB_CTRL_SERIAL_LED_EN_POL  BIT(3)
#define  BCM63138_GLB_CTRL_SERIAL_LED_MSB_FIRST  BIT(4)
#define BCM63138_MASK     0x04
#define BCM63138_HW_LED_EN    0x08
#define BCM63138_SERIAL_LED_SHIFT_SEL   0x0c
#define BCM63138_FLASH_RATE_CTRL1   0x10
#define BCM63138_FLASH_RATE_CTRL2   0x14
#define BCM63138_FLASH_RATE_CTRL3   0x18
#define BCM63138_FLASH_RATE_CTRL4   0x1c
#define BCM63138_BRIGHT_CTRL1    0x20
#define BCM63138_BRIGHT_CTRL2    0x24
#define BCM63138_BRIGHT_CTRL3    0x28
#define BCM63138_BRIGHT_CTRL4    0x2c
#define BCM63138_POWER_LED_CFG    0x30
#define BCM63138_POWER_LUT_BASE0   0x34 /* -> b0 */
#define BCM63138_HW_POLARITY    0xb4
#define BCM63138_SW_DATA    0xb8
#define BCM63138_SW_POLARITY    0xbc
#define BCM63138_PARALLEL_LED_POLARITY   0xc0
#define BCM63138_SERIAL_LED_POLARITY   0xc4
#define BCM63138_HW_LED_STATUS    0xc8
#define BCM63138_FLASH_CTRL_STATUS   0xcc
#define BCM63138_FLASH_BRT_CTRL    0xd0
#define BCM63138_FLASH_P_LED_OUT_STATUS   0xd4
#define BCM63138_FLASH_S_LED_OUT_STATUS   0xd8

struct bcm63138_leds {
 struct device *dev;
 void __iomem *base;
 spinlock_t lock;
};

struct bcm63138_led {
 struct bcm63138_leds *leds;
 struct led_classdev cdev;
 u32 pin;
 bool active_low;
};

/*
 * I/O access
 */

static void bcm63138_leds_write(struct bcm63138_leds *leds, unsigned int reg,
    u32 data)
{
 writel(data, leds->base + reg);
}

static unsigned long bcm63138_leds_read(struct bcm63138_leds *leds,
     unsigned int reg)
{
 return readl(leds->base + reg);
}

static void bcm63138_leds_update_bits(struct bcm63138_leds *leds,
          unsigned int reg, u32 mask, u32 val)
{
 WARN_ON(val & ~mask);

 bcm63138_leds_write(leds, reg, (bcm63138_leds_read(leds, reg) & ~mask) | (val & mask));
}

/*
 * Helpers
 */

static void bcm63138_leds_set_flash_rate(struct bcm63138_leds *leds,
      struct bcm63138_led *led,
      u8 value)
{
 int reg_offset = (led->pin >> fls((BCM63138_LEDS_PER_REG - 1))) * 4;
 int shift = (led->pin & (BCM63138_LEDS_PER_REG - 1)) * BCM63138_LED_BITS;

 bcm63138_leds_update_bits(leds, BCM63138_FLASH_RATE_CTRL1 + reg_offset,
      BCM63138_LED_MASK << shift, value << shift);
}

static void bcm63138_leds_set_bright(struct bcm63138_leds *leds,
         struct bcm63138_led *led,
         u8 value)
{
 int reg_offset = (led->pin >> fls((BCM63138_LEDS_PER_REG - 1))) * 4;
 int shift = (led->pin & (BCM63138_LEDS_PER_REG - 1)) * BCM63138_LED_BITS;

 bcm63138_leds_update_bits(leds, BCM63138_BRIGHT_CTRL1 + reg_offset,
      BCM63138_LED_MASK << shift, value << shift);
}

static void bcm63138_leds_enable_led(struct bcm63138_leds *leds,
         struct bcm63138_led *led,
         enum led_brightness value)
{
 u32 bit = BIT(led->pin);

 bcm63138_leds_update_bits(leds, BCM63138_SW_DATA, bit, value ? bit : 0);
}

/*
 * API callbacks
 */

static void bcm63138_leds_brightness_set(struct led_classdev *led_cdev,
      enum led_brightness value)
{
 struct bcm63138_led *led = container_of(led_cdev, struct bcm63138_led, cdev);
 struct bcm63138_leds *leds = led->leds;

 guard(spinlock_irqsave)(&leds->lock);

 bcm63138_leds_enable_led(leds, led, value);
 if (!value)
  bcm63138_leds_set_flash_rate(leds, led, 0);
 else
  bcm63138_leds_set_bright(leds, led, value);
}

static int bcm63138_leds_blink_set(struct led_classdev *led_cdev,
       unsigned long *delay_on,
       unsigned long *delay_off)
{
 struct bcm63138_led *led = container_of(led_cdev, struct bcm63138_led, cdev);
 struct bcm63138_leds *leds = led->leds;
 u8 value;

 if (!*delay_on && !*delay_off) {
  *delay_on = 640;
  *delay_off = 640;
 }

 if (*delay_on != *delay_off) {
  dev_dbg(led_cdev->dev, "Blinking at unequal delays is not supported\n");
  return -EINVAL;
 }

 switch (*delay_on) {
 case 1152 ... 1408: /* 1280 ms ± 10% */
  value = 0x7;
  break;
 case 576 ... 704: /* 640 ms ± 10% */
  value = 0x6;
  break;
 case 288 ... 352: /* 320 ms ± 10% */
  value = 0x5;
  break;
 case 126 ... 154: /* 140 ms ± 10% */
  value = 0x4;
  break;
 case 59 ... 72: /* 65 ms ± 10% */
  value = 0x3;
  break;
 default:
  dev_dbg(led_cdev->dev, "Blinking delay value %lu is unsupported\n",
   *delay_on);
  return -EINVAL;
 }

 guard(spinlock_irqsave)(&leds->lock);

 bcm63138_leds_enable_led(leds, led, BCM63138_MAX_BRIGHTNESS);
 bcm63138_leds_set_flash_rate(leds, led, value);

 return 0;
}

/*
 * LED driver
 */

static void bcm63138_leds_create_led(struct bcm63138_leds *leds,
         struct device_node *np)
{
 struct led_init_data init_data = {
  .fwnode = of_fwnode_handle(np),
 };
 struct device *dev = leds->dev;
 struct bcm63138_led *led;
 struct pinctrl *pinctrl;
 u32 bit;
 int err;

 led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
 if (!led) {
  dev_err(dev, "Failed to alloc LED\n");
  return;
 }

 led->leds = leds;

 if (of_property_read_u32(np, "reg", &led->pin)) {
  dev_err(dev, "Missing \"reg\" property in %pOF\n", np);
  goto err_free;
 }

 if (led->pin >= BCM63138_MAX_LEDS) {
  dev_err(dev, "Invalid \"reg\" value %d\n", led->pin);
  goto err_free;
 }

 led->active_low = of_property_read_bool(np, "active-low");

 led->cdev.max_brightness = BCM63138_MAX_BRIGHTNESS;
 led->cdev.brightness_set = bcm63138_leds_brightness_set;
 led->cdev.blink_set = bcm63138_leds_blink_set;

 err = devm_led_classdev_register_ext(dev, &led->cdev, &init_data);
 if (err) {
  dev_err(dev, "Failed to register LED %pOF: %d\n", np, err);
  goto err_free;
 }

 pinctrl = devm_pinctrl_get_select_default(led->cdev.dev);
 if (IS_ERR(pinctrl) && PTR_ERR(pinctrl) != -ENODEV) {
  dev_warn(led->cdev.dev, "Failed to select %pOF pinctrl: %ld\n",
    np, PTR_ERR(pinctrl));
 }

 bit = BIT(led->pin);
 bcm63138_leds_update_bits(leds, BCM63138_PARALLEL_LED_POLARITY, bit,
      led->active_low ? 0 : bit);
 bcm63138_leds_update_bits(leds, BCM63138_HW_LED_EN, bit, 0);
 bcm63138_leds_set_flash_rate(leds, led, 0);
 bcm63138_leds_enable_led(leds, led, led->cdev.brightness);

 return;

err_free:
 devm_kfree(dev, led);
}

static int bcm63138_leds_probe(struct platform_device *pdev)
{
 struct device_node *np = dev_of_node(&pdev->dev);
 struct device *dev = &pdev->dev;
 struct bcm63138_leds *leds;
 u32 shift_bits;

 leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL);
 if (!leds)
  return -ENOMEM;

 leds->dev = dev;

 leds->base = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(leds->base))
  return PTR_ERR(leds->base);

 spin_lock_init(&leds->lock);

 /* If this property is not present, we use boot defaults */
 if (!of_property_read_u32(np, "brcm,serial-shift-bits", &shift_bits)) {
  bcm63138_leds_write(leds, BCM63138_SERIAL_LED_SHIFT_SEL,
        GENMASK(shift_bits - 1, 0));
 }

 bcm63138_leds_write(leds, BCM63138_GLB_CTRL,
       BCM63138_GLB_CTRL_SERIAL_LED_DATA_PPOL |
       BCM63138_GLB_CTRL_SERIAL_LED_EN_POL);
 bcm63138_leds_write(leds, BCM63138_HW_LED_EN, 0);
 bcm63138_leds_write(leds, BCM63138_SERIAL_LED_POLARITY, 0);
 bcm63138_leds_write(leds, BCM63138_PARALLEL_LED_POLARITY, 0);

 for_each_available_child_of_node_scoped(np, child) {
  bcm63138_leds_create_led(leds, child);
 }

 return 0;
}

static const struct of_device_id bcm63138_leds_of_match_table[] = {
 { .compatible = "brcm,bcm63138-leds", },
 { },
};

static struct platform_driver bcm63138_leds_driver = {
 .probe = bcm63138_leds_probe,
 .driver = {
  .name = "leds-bcm63xxx",
  .of_match_table = bcm63138_leds_of_match_table,
 },
};

module_platform_driver(bcm63138_leds_driver);

MODULE_AUTHOR("Rafał Miłecki");
MODULE_DESCRIPTION("Broadcom BCM63138 SoC LED driver");
MODULE_LICENSE("GPL");
MODULE_DEVICE_TABLE(of, bcm63138_leds_of_match_table);