drivers/led/led_cortina.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2
   3 /*
   4  * Copyright (C) 2020 Cortina-Access
   5  * Author: Jway Lin <jway.lin@cortina-access.com>
   6  *
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <errno.h>
  12 #include <led.h>
  13 #include <log.h>
  14 #include <asm/io.h>
  15 #include <dm/lists.h>
  16 #include <linux/bitops.h>
  17
  18 #define LED_MAX_HW_BLINK                127
  19 #define LED_MAX_COUNT                   16
  20
  21 /* LED_CONTROL fields */
  22 #define LED_BLINK_RATE1_SHIFT   0
  23 #define LED_BLINK_RATE1_MASK    0xff
  24 #define LED_BLINK_RATE2_SHIFT   8
  25 #define LED_BLINK_RATE2_MASK    0xff
  26 #define LED_CLK_TEST                    BIT(16)
  27 #define LED_CLK_POLARITY                BIT(17)
  28 #define LED_CLK_TEST_MODE               BIT(16)
  29 #define LED_CLK_TEST_RX_TEST    BIT(30)
  30 #define LED_CLK_TEST_TX_TEST    BIT(31)
  31
  32 /* LED_CONFIG fields */
  33 #define LED_EVENT_ON_SHIFT              0
  34 #define LED_EVENT_ON_MASK               0x7
  35 #define LED_EVENT_BLINK_SHIFT   3
  36 #define LED_EVENT_BLINK_MASK    0x7
  37 #define LED_EVENT_OFF_SHIFT     6
  38 #define LED_EVENT_OFF_MASK              0x7
  39 #define LED_OFF_ON_SHIFT                9
  40 #define LED_OFF_ON_MASK                 0x3
  41 #define LED_PORT_SHIFT                  11
  42 #define LED_PORT_MASK                   0x7
  43 #define LED_OFF_VAL                             BIT(14)
  44 #define LED_SW_EVENT                    BIT(15)
  45 #define LED_BLINK_SEL                   BIT(16)
  46
  47 /* LED_CONFIG structures */
  48 struct cortina_led_cfg {
  49         void __iomem *regs;
  50         u32 pin;                        /* LED pin nubmer */
  51         bool active_low;        /*Active-High or Active-Low*/
  52         u32 off_event;          /* set led off event (RX,TX,SW)*/
  53         u32 blink_event;        /* set led blink event (RX,TX,SW)*/
  54         u32 on_event;   /* set led on event (RX,TX,SW)*/
  55         u32 port;               /* corresponding ethernet port */
  56         int blink_sel;          /* select blink-rate1 or blink-rate2  */
  57 };
  58
  59 /* LED_control structures */
  60 struct cortina_led_plat {
  61         void __iomem *ctrl_regs;
  62         u16 rate1;      /* blink rate setting 0 */
  63         u16 rate2;      /* blink rate setting 1 */
  64 };
  65
  66 enum ca_led_state_t {
  67         CA_EVENT_MODE = 0,
  68         CA_LED_ON = 1,
  69         CA_LED_OFF,
  70 };
  71
  72 static void cortina_led_write(void __iomem *reg, unsigned long data)
  73 {
  74         writel(data, reg);
  75 }
  76
  77 static unsigned long cortina_led_read(void __iomem *reg)
  78 {
  79         return readl(reg);
  80 }
  81
  82 static enum led_state_t cortina_led_get_state(struct udevice *dev)
  83 {
  84         struct cortina_led_cfg *priv = dev_get_priv(dev);
  85         enum led_state_t state = LEDST_OFF;
  86         u32 val;
  87
  88         val = readl(priv->regs);
  89
  90         if (val & LED_SW_EVENT)
  91                 state = LEDST_ON;
  92
  93         return state;
  94 }
  95
  96 static int cortina_led_set_state(struct udevice *dev, enum led_state_t state)
  97 {
  98         u32 val;
  99         struct cortina_led_cfg *priv = dev_get_priv(dev);
 100
 101         val = readl(priv->regs);
 102         val &= ~(LED_OFF_ON_MASK << LED_OFF_ON_SHIFT);
 103
 104         switch (state) {
 105         case LEDST_OFF:
 106                 val &= ~LED_SW_EVENT;
 107                 val |= CA_LED_OFF << LED_OFF_ON_SHIFT;
 108                 cortina_led_write(priv->regs, val);
 109                 break;
 110         case LEDST_ON:
 111                 val |= LED_SW_EVENT;
 112                 val |= CA_LED_ON << LED_OFF_ON_SHIFT;
 113                 cortina_led_write(priv->regs, val);
 114                 break;
 115         case LEDST_TOGGLE:
 116                 if (cortina_led_get_state(dev) == LEDST_OFF)
 117                         return cortina_led_set_state(dev, LEDST_ON);
 118                 else
 119                         return cortina_led_set_state(dev, LEDST_OFF);
 120                 break;
 121         default:
 122                 return -EINVAL;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static const struct led_ops cortina_led_ops = {
 129         .get_state = cortina_led_get_state,
 130         .set_state = cortina_led_set_state,
 131 };
 132
 133 static int ca_led_of_to_plat(struct udevice *dev)
 134 {
 135         struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
 136
 137         /* Top-level LED node */
 138         if (!uc_plat->label) {
 139                 struct cortina_led_plat *plt = dev_get_plat(dev);
 140
 141                 plt->rate1 =
 142                         dev_read_u32_default(dev, "Cortina,blink-rate1", 256);
 143                 plt->rate2 =
 144                         dev_read_u32_default(dev, "Cortina,blink-rate2", 512);
 145                 plt->ctrl_regs = dev_remap_addr(dev);
 146         } else {
 147                 struct cortina_led_cfg *priv = dev_get_priv(dev);
 148
 149                 priv->regs = dev_remap_addr(dev_get_parent(dev));
 150                 priv->pin = dev_read_u32_default(dev, "pin", LED_MAX_COUNT);
 151                 priv->blink_sel = dev_read_u32_default(dev, "blink-sel", 0);
 152                 priv->off_event = dev_read_u32_default(dev, "off-event", 0);
 153                 priv->blink_event = dev_read_u32_default(dev, "blink-event", 0);
 154                 priv->on_event = dev_read_u32_default(dev, "on-event", 0);
 155                 priv->port = dev_read_u32_default(dev, "port", 0);
 156
 157                 if (dev_read_bool(dev, "active-low"))
 158                         priv->active_low = true;
 159                 else
 160                         priv->active_low = false;
 161         }
 162
 163         return 0;
 164 }
 165
 166 static int cortina_led_probe(struct udevice *dev)
 167 {
 168         struct led_uc_plat *uc_plat = dev_get_uclass_plat(dev);
 169
 170         /* Top-level LED node */
 171         if (!uc_plat->label) {
 172                 struct cortina_led_plat *plat = dev_get_plat(dev);
 173                 u32 reg_value, val;
 174                 u16 rate1, rate2;
 175
 176                 if (!plat->ctrl_regs)
 177                         return -EINVAL;
 178
 179                 reg_value = 0;
 180                 reg_value |= LED_CLK_POLARITY;
 181
 182                 rate1 = plat->rate1;
 183                 rate2 = plat->rate2;
 184
 185                 val = rate1 / 16 - 1;
 186                 rate1 = val > LED_MAX_HW_BLINK ?
 187                                         LED_MAX_HW_BLINK : val;
 188                 reg_value |= (rate1 & LED_BLINK_RATE1_MASK) <<
 189                                         LED_BLINK_RATE1_SHIFT;
 190
 191                 val = rate2 / 16 - 1;
 192                 rate2 = val > LED_MAX_HW_BLINK ?
 193                                         LED_MAX_HW_BLINK : val;
 194                 reg_value |= (rate2 & LED_BLINK_RATE2_MASK) <<
 195                                         LED_BLINK_RATE2_SHIFT;
 196
 197                 cortina_led_write(plat->ctrl_regs, reg_value);
 198
 199         } else {
 200                 struct cortina_led_cfg *priv = dev_get_priv(dev);
 201                 void __iomem *regs;
 202                 u32 val, port, off_event, blink_event, on_event;
 203
 204                 regs = priv->regs;
 205                 if (!regs)
 206                         return -EINVAL;
 207
 208                 if (priv->pin >= LED_MAX_COUNT)
 209                         return -EINVAL;
 210
 211                 priv->regs = regs + 4 + priv->pin * 4;
 212
 213                 val = cortina_led_read(priv->regs);
 214
 215                 if (priv->active_low)
 216                         val |= LED_OFF_VAL;
 217                 else
 218                         val &= ~LED_OFF_VAL;
 219
 220                 if (priv->blink_sel == 0)
 221                         val &= ~LED_BLINK_SEL;
 222                 else if (priv->blink_sel == 1)
 223                         val |= LED_BLINK_SEL;
 224
 225                 off_event = priv->off_event;
 226                 val &= ~(LED_EVENT_OFF_MASK << LED_EVENT_OFF_SHIFT);
 227                 if (off_event != 0)
 228                         val |= BIT(off_event) << LED_EVENT_OFF_SHIFT;
 229
 230                 blink_event =  priv->blink_event;
 231                 val &= ~(LED_EVENT_BLINK_MASK << LED_EVENT_BLINK_SHIFT);
 232                 if (blink_event != 0)
 233                         val |= BIT(blink_event) << LED_EVENT_BLINK_SHIFT;
 234
 235                 on_event = priv->on_event;
 236                 val &= ~(LED_EVENT_ON_MASK << LED_EVENT_ON_SHIFT);
 237                 if (on_event != 0)
 238                         val |= BIT(on_event) << LED_EVENT_ON_SHIFT;
 239
 240                 port = priv->port;
 241                 val &= ~(LED_PORT_MASK << LED_PORT_SHIFT);
 242                 val |= port << LED_PORT_SHIFT;
 243
 244                 /* force off */
 245                 val &= ~(LED_OFF_ON_MASK << LED_OFF_ON_SHIFT);
 246                 val |= CA_LED_OFF << LED_OFF_ON_SHIFT;
 247
 248                 cortina_led_write(priv->regs, val);
 249         }
 250
 251         return 0;
 252 }
 253
 254 static int cortina_led_bind(struct udevice *parent)
 255 {
 256         ofnode node;
 257
 258         dev_for_each_subnode(node, parent) {
 259                 struct udevice *dev;
 260                 int ret;
 261
 262                 ret = device_bind_driver_to_node(parent, "ca-leds",
 263                                                  ofnode_get_name(node),
 264                                                  node, &dev);
 265                 if (ret)
 266                         return ret;
 267         }
 268
 269         return 0;
 270 }
 271
 272 static const struct udevice_id ca_led_ids[] = {
 273         { .compatible = "cortina,ca-leds" },
 274         { /* sentinel */ }
 275 };
 276
 277 U_BOOT_DRIVER(cortina_led) = {
 278         .name = "ca-leds",
 279         .id = UCLASS_LED,
 280         .of_match = ca_led_ids,
 281         .of_to_plat = ca_led_of_to_plat,
 282         .bind = cortina_led_bind,
 283         .probe = cortina_led_probe,
 284         .plat_auto      = sizeof(struct cortina_led_plat),
 285         .priv_auto      = sizeof(struct cortina_led_cfg),
 286         .ops = &cortina_led_ops,
 287 };