target/linux/mediatek/patches-4.9/0087-pmic-led2.patch

   1 From patchwork Mon Mar 20 06:47:26 2017
   2 Content-Type: text/plain; charset="utf-8"
   3 MIME-Version: 1.0
   4 Content-Transfer-Encoding: 7bit
   5 Subject: [v6,3/4] leds: Add LED support for MT6323 PMIC
   6 From: sean.wang@mediatek.com
   7 X-Patchwork-Id: 9633081
   8 Message-Id: <1489992447-13007-4-git-send-email-sean.wang@mediatek.com>
   9 To: <rpurdie@rpsys.net>, <jacek.anaszewski@gmail.com>, <lee.jones@linaro.org>,
  10  <matthias.bgg@gmail.com>, <pavel@ucw.cz>, <robh+dt@kernel.org>,
  11  <mark.rutland@arm.com>
  12 Cc: devicetree@vger.kernel.org, keyhaede@gmail.com,
  13  Sean Wang <sean.wang@mediatek.com>, linux-kernel@vger.kernel.org,
  14  linux-mediatek@lists.infradead.org, linux-leds@vger.kernel.org,
  15  linux-arm-kernel@lists.infradead.org
  16 Date: Mon, 20 Mar 2017 14:47:26 +0800
  17
  18 From: Sean Wang <sean.wang@mediatek.com>
  19
  20 MT6323 PMIC is a multi-function device that includes LED function.
  21 It allows attaching up to 4 LEDs which can either be on, off or dimmed
  22 and/or blinked with the controller.
  23
  24 Signed-off-by: Sean Wang <sean.wang@mediatek.com>
  25 Reviewed-by: Jacek Anaszewski <jacek.anaszewski@gmail.com>
  26 ---
  27  drivers/leds/Kconfig       |   8 +
  28  drivers/leds/Makefile      |   1 +
  29  drivers/leds/leds-mt6323.c | 502 +++++++++++++++++++++++++++++++++++++++++++++
  30  3 files changed, 511 insertions(+)
  31  create mode 100644 drivers/leds/leds-mt6323.c
  32
  33 Index: linux-4.9.17/drivers/leds/Kconfig
  34 ===================================================================
  35 --- linux-4.9.17.orig/drivers/leds/Kconfig
  36 +++ linux-4.9.17/drivers/leds/Kconfig
  37 @@ -117,6 +117,14 @@ config LEDS_MIKROTIK_RB532
  38           This option enables support for the so called "User LED" of
  39           Mikrotik's Routerboard 532.
  40
  41 +config LEDS_MT6323
  42 +       tristate "LED Support for Mediatek MT6323 PMIC"
  43 +       depends on LEDS_CLASS
  44 +       depends on MFD_MT6397
  45 +       help
  46 +         This option enables support for on-chip LED drivers found on
  47 +         Mediatek MT6323 PMIC.
  48 +
  49  config LEDS_S3C24XX
  50         tristate "LED Support for Samsung S3C24XX GPIO LEDs"
  51         depends on LEDS_CLASS
  52 Index: linux-4.9.17/drivers/leds/leds-mt6323.c
  53 ===================================================================
  54 --- /dev/null
  55 +++ linux-4.9.17/drivers/leds/leds-mt6323.c
  56 @@ -0,0 +1,502 @@
  57 +/*
  58 + * LED driver for Mediatek MT6323 PMIC
  59 + *
  60 + * Copyright (C) 2017 Sean Wang <sean.wang@mediatek.com>
  61 + *
  62 + * This program is free software; you can redistribute it and/or
  63 + * modify it under the terms of the GNU General Public License as
  64 + * published by the Free Software Foundation; either version 2 of
  65 + * the License, or (at your option) any later version.
  66 + *
  67 + * This program is distributed in the hope that it will be useful,
  68 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  69 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  70 + * GNU General Public License for more details.
  71 + */
  72 +#include <linux/kernel.h>
  73 +#include <linux/leds.h>
  74 +#include <linux/mfd/mt6323/registers.h>
  75 +#include <linux/mfd/mt6397/core.h>
  76 +#include <linux/module.h>
  77 +#include <linux/of.h>
  78 +#include <linux/platform_device.h>
  79 +#include <linux/regmap.h>
  80 +
  81 +/*
  82 + * Register field for MT6323_TOP_CKPDN0 to enable
  83 + * 32K clock common for LED device.
  84 + */
  85 +#define MT6323_RG_DRV_32K_CK_PDN       BIT(11)
  86 +#define MT6323_RG_DRV_32K_CK_PDN_MASK  BIT(11)
  87 +
  88 +/*
  89 + * Register field for MT6323_TOP_CKPDN2 to enable
  90 + * individual clock for LED device.
  91 + */
  92 +#define MT6323_RG_ISINK_CK_PDN(i)      BIT(i)
  93 +#define MT6323_RG_ISINK_CK_PDN_MASK(i) BIT(i)
  94 +
  95 +/*
  96 + * Register field for MT6323_TOP_CKCON1 to select
  97 + * clock source.
  98 + */
  99 +#define MT6323_RG_ISINK_CK_SEL_MASK(i) (BIT(10) << (i))
 100 +
 101 +/*
 102 + * Register for MT6323_ISINK_CON0 to setup the
 103 + * duty cycle of the blink.
 104 + */
 105 +#define MT6323_ISINK_CON0(i)           (MT6323_ISINK0_CON0 + 0x8 * (i))
 106 +#define MT6323_ISINK_DIM_DUTY_MASK     (0x1f << 8)
 107 +#define MT6323_ISINK_DIM_DUTY(i)       (((i) << 8) & \
 108 +                                       MT6323_ISINK_DIM_DUTY_MASK)
 109 +
 110 +/* Register to setup the period of the blink. */
 111 +#define MT6323_ISINK_CON1(i)           (MT6323_ISINK0_CON1 + 0x8 * (i))
 112 +#define MT6323_ISINK_DIM_FSEL_MASK     (0xffff)
 113 +#define MT6323_ISINK_DIM_FSEL(i)       ((i) & MT6323_ISINK_DIM_FSEL_MASK)
 114 +
 115 +/* Register to control the brightness. */
 116 +#define MT6323_ISINK_CON2(i)           (MT6323_ISINK0_CON2 + 0x8 * (i))
 117 +#define MT6323_ISINK_CH_STEP_SHIFT     12
 118 +#define MT6323_ISINK_CH_STEP_MASK      (0x7 << 12)
 119 +#define MT6323_ISINK_CH_STEP(i)                (((i) << 12) & \
 120 +                                       MT6323_ISINK_CH_STEP_MASK)
 121 +#define MT6323_ISINK_SFSTR0_TC_MASK    (0x3 << 1)
 122 +#define MT6323_ISINK_SFSTR0_TC(i)      (((i) << 1) & \
 123 +                                       MT6323_ISINK_SFSTR0_TC_MASK)
 124 +#define MT6323_ISINK_SFSTR0_EN_MASK    BIT(0)
 125 +#define MT6323_ISINK_SFSTR0_EN         BIT(0)
 126 +
 127 +/* Register to LED channel enablement. */
 128 +#define MT6323_ISINK_CH_EN_MASK(i)     BIT(i)
 129 +#define MT6323_ISINK_CH_EN(i)          BIT(i)
 130 +
 131 +#define MT6323_MAX_PERIOD              10000
 132 +#define MT6323_MAX_LEDS                        4
 133 +#define MT6323_MAX_BRIGHTNESS          6
 134 +#define MT6323_UNIT_DUTY               3125
 135 +#define MT6323_CAL_HW_DUTY(o, p)       DIV_ROUND_CLOSEST((o) * 100000ul,\
 136 +                                       (p) * MT6323_UNIT_DUTY)
 137 +
 138 +struct mt6323_leds;
 139 +
 140 +/**
 141 + * struct mt6323_led - state container for the LED device
 142 + * @id:                        the identifier in MT6323 LED device
 143 + * @parent:            the pointer to MT6323 LED controller
 144 + * @cdev:              LED class device for this LED device
 145 + * @current_brightness: current state of the LED device
 146 + */
 147 +struct mt6323_led {
 148 +       int                     id;
 149 +       struct mt6323_leds      *parent;
 150 +       struct led_classdev     cdev;
 151 +       enum led_brightness     current_brightness;
 152 +};
 153 +
 154 +/**
 155 + * struct mt6323_leds -        state container for holding LED controller
 156 + *                     of the driver
 157 + * @dev:               the device pointer
 158 + * @hw:                        the underlying hardware providing shared
 159 + *                     bus for the register operations
 160 + * @lock:              the lock among process context
 161 + * @led:               the array that contains the state of individual
 162 + *                     LED device
 163 + */
 164 +struct mt6323_leds {
 165 +       struct device           *dev;
 166 +       struct mt6397_chip      *hw;
 167 +       /* protect among process context */
 168 +       struct mutex            lock;
 169 +       struct mt6323_led       *led[MT6323_MAX_LEDS];
 170 +};
 171 +
 172 +static int mt6323_led_hw_brightness(struct led_classdev *cdev,
 173 +                                   enum led_brightness brightness)
 174 +{
 175 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 176 +       struct mt6323_leds *leds = led->parent;
 177 +       struct regmap *regmap = leds->hw->regmap;
 178 +       u32 con2_mask = 0, con2_val = 0;
 179 +       int ret;
 180 +
 181 +       /*
 182 +        * Setup current output for the corresponding
 183 +        * brightness level.
 184 +        */
 185 +       con2_mask |= MT6323_ISINK_CH_STEP_MASK |
 186 +                    MT6323_ISINK_SFSTR0_TC_MASK |
 187 +                    MT6323_ISINK_SFSTR0_EN_MASK;
 188 +       con2_val |=  MT6323_ISINK_CH_STEP(brightness - 1) |
 189 +                    MT6323_ISINK_SFSTR0_TC(2) |
 190 +                    MT6323_ISINK_SFSTR0_EN;
 191 +
 192 +       ret = regmap_update_bits(regmap, MT6323_ISINK_CON2(led->id),
 193 +                                con2_mask, con2_val);
 194 +       return ret;
 195 +}
 196 +
 197 +static int mt6323_led_hw_off(struct led_classdev *cdev)
 198 +{
 199 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 200 +       struct mt6323_leds *leds = led->parent;
 201 +       struct regmap *regmap = leds->hw->regmap;
 202 +       unsigned int status;
 203 +       int ret;
 204 +
 205 +       status = MT6323_ISINK_CH_EN(led->id);
 206 +       ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
 207 +                                MT6323_ISINK_CH_EN_MASK(led->id), ~status);
 208 +       if (ret < 0)
 209 +               return ret;
 210 +
 211 +       usleep_range(100, 300);
 212 +       ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
 213 +                                MT6323_RG_ISINK_CK_PDN_MASK(led->id),
 214 +                                MT6323_RG_ISINK_CK_PDN(led->id));
 215 +       if (ret < 0)
 216 +               return ret;
 217 +
 218 +       return 0;
 219 +}
 220 +
 221 +static enum led_brightness
 222 +mt6323_get_led_hw_brightness(struct led_classdev *cdev)
 223 +{
 224 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 225 +       struct mt6323_leds *leds = led->parent;
 226 +       struct regmap *regmap = leds->hw->regmap;
 227 +       unsigned int status;
 228 +       int ret;
 229 +
 230 +       ret = regmap_read(regmap, MT6323_TOP_CKPDN2, &status);
 231 +       if (ret < 0)
 232 +               return ret;
 233 +
 234 +       if (status & MT6323_RG_ISINK_CK_PDN_MASK(led->id))
 235 +               return 0;
 236 +
 237 +       ret = regmap_read(regmap, MT6323_ISINK_EN_CTRL, &status);
 238 +       if (ret < 0)
 239 +               return ret;
 240 +
 241 +       if (!(status & MT6323_ISINK_CH_EN(led->id)))
 242 +               return 0;
 243 +
 244 +       ret = regmap_read(regmap, MT6323_ISINK_CON2(led->id), &status);
 245 +       if (ret < 0)
 246 +               return ret;
 247 +
 248 +       return  ((status & MT6323_ISINK_CH_STEP_MASK)
 249 +                 >> MT6323_ISINK_CH_STEP_SHIFT) + 1;
 250 +}
 251 +
 252 +static int mt6323_led_hw_on(struct led_classdev *cdev,
 253 +                           enum led_brightness brightness)
 254 +{
 255 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 256 +       struct mt6323_leds *leds = led->parent;
 257 +       struct regmap *regmap = leds->hw->regmap;
 258 +       unsigned int status;
 259 +       int ret;
 260 +
 261 +       /*
 262 +        * Setup required clock source, enable the corresponding
 263 +        * clock and channel and let work with continuous blink as
 264 +        * the default.
 265 +        */
 266 +       ret = regmap_update_bits(regmap, MT6323_TOP_CKCON1,
 267 +                                MT6323_RG_ISINK_CK_SEL_MASK(led->id), 0);
 268 +       if (ret < 0)
 269 +               return ret;
 270 +
 271 +       status = MT6323_RG_ISINK_CK_PDN(led->id);
 272 +       ret = regmap_update_bits(regmap, MT6323_TOP_CKPDN2,
 273 +                                MT6323_RG_ISINK_CK_PDN_MASK(led->id),
 274 +                                ~status);
 275 +       if (ret < 0)
 276 +               return ret;
 277 +
 278 +       usleep_range(100, 300);
 279 +
 280 +       ret = regmap_update_bits(regmap, MT6323_ISINK_EN_CTRL,
 281 +                                MT6323_ISINK_CH_EN_MASK(led->id),
 282 +                                MT6323_ISINK_CH_EN(led->id));
 283 +       if (ret < 0)
 284 +               return ret;
 285 +
 286 +       ret = mt6323_led_hw_brightness(cdev, brightness);
 287 +       if (ret < 0)
 288 +               return ret;
 289 +
 290 +       ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
 291 +                                MT6323_ISINK_DIM_DUTY_MASK,
 292 +                                MT6323_ISINK_DIM_DUTY(31));
 293 +       if (ret < 0)
 294 +               return ret;
 295 +
 296 +       ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
 297 +                                MT6323_ISINK_DIM_FSEL_MASK,
 298 +                                MT6323_ISINK_DIM_FSEL(1000));
 299 +       if (ret < 0)
 300 +               return ret;
 301 +
 302 +       return 0;
 303 +}
 304 +
 305 +static int mt6323_led_set_blink(struct led_classdev *cdev,
 306 +                               unsigned long *delay_on,
 307 +                               unsigned long *delay_off)
 308 +{
 309 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 310 +       struct mt6323_leds *leds = led->parent;
 311 +       struct regmap *regmap = leds->hw->regmap;
 312 +       unsigned long period;
 313 +       u8 duty_hw;
 314 +       int ret;
 315 +
 316 +       /*
 317 +        * Units are in ms, if over the hardware able
 318 +        * to support, fallback into software blink
 319 +        */
 320 +       period = *delay_on + *delay_off;
 321 +
 322 +       if (period > MT6323_MAX_PERIOD)
 323 +               return -EINVAL;
 324 +
 325 +       /*
 326 +        * LED subsystem requires a default user
 327 +        * friendly blink pattern for the LED so using
 328 +        * 1Hz duty cycle 50% here if without specific
 329 +        * value delay_on and delay off being assigned.
 330 +        */
 331 +       if (!*delay_on && !*delay_off) {
 332 +               *delay_on = 500;
 333 +               *delay_off = 500;
 334 +       }
 335 +
 336 +       /*
 337 +        * Calculate duty_hw based on the percentage of period during
 338 +        * which the led is ON.
 339 +        */
 340 +       duty_hw = MT6323_CAL_HW_DUTY(*delay_on, period);
 341 +
 342 +       /* hardware doesn't support zero duty cycle. */
 343 +       if (!duty_hw)
 344 +               return -EINVAL;
 345 +
 346 +       mutex_lock(&leds->lock);
 347 +       /*
 348 +        * Set max_brightness as the software blink behavior
 349 +        * when no blink brightness.
 350 +        */
 351 +       if (!led->current_brightness) {
 352 +               ret = mt6323_led_hw_on(cdev, cdev->max_brightness);
 353 +               if (ret < 0)
 354 +                       goto out;
 355 +               led->current_brightness = cdev->max_brightness;
 356 +       }
 357 +
 358 +       ret = regmap_update_bits(regmap, MT6323_ISINK_CON0(led->id),
 359 +                                MT6323_ISINK_DIM_DUTY_MASK,
 360 +                                MT6323_ISINK_DIM_DUTY(duty_hw - 1));
 361 +       if (ret < 0)
 362 +               goto out;
 363 +
 364 +       ret = regmap_update_bits(regmap, MT6323_ISINK_CON1(led->id),
 365 +                                MT6323_ISINK_DIM_FSEL_MASK,
 366 +                                MT6323_ISINK_DIM_FSEL(period - 1));
 367 +out:
 368 +       mutex_unlock(&leds->lock);
 369 +
 370 +       return ret;
 371 +}
 372 +
 373 +static int mt6323_led_set_brightness(struct led_classdev *cdev,
 374 +                                    enum led_brightness brightness)
 375 +{
 376 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 377 +       struct mt6323_leds *leds = led->parent;
 378 +       int ret;
 379 +
 380 +       mutex_lock(&leds->lock);
 381 +
 382 +       if (!led->current_brightness && brightness) {
 383 +               ret = mt6323_led_hw_on(cdev, brightness);
 384 +               if (ret < 0)
 385 +                       goto out;
 386 +       } else if (brightness) {
 387 +               ret = mt6323_led_hw_brightness(cdev, brightness);
 388 +               if (ret < 0)
 389 +                       goto out;
 390 +       } else {
 391 +               ret = mt6323_led_hw_off(cdev);
 392 +               if (ret < 0)
 393 +                       goto out;
 394 +       }
 395 +
 396 +       led->current_brightness = brightness;
 397 +out:
 398 +       mutex_unlock(&leds->lock);
 399 +
 400 +       return ret;
 401 +}
 402 +
 403 +static int mt6323_led_set_dt_default(struct led_classdev *cdev,
 404 +                                    struct device_node *np)
 405 +{
 406 +       struct mt6323_led *led = container_of(cdev, struct mt6323_led, cdev);
 407 +       const char *state;
 408 +       int ret = 0;
 409 +
 410 +       led->cdev.name = of_get_property(np, "label", NULL) ? : np->name;
 411 +       led->cdev.default_trigger = of_get_property(np,
 412 +                                                   "linux,default-trigger",
 413 +                                                   NULL);
 414 +
 415 +       state = of_get_property(np, "default-state", NULL);
 416 +       if (state) {
 417 +               if (!strcmp(state, "keep")) {
 418 +                       ret = mt6323_get_led_hw_brightness(cdev);
 419 +                       if (ret < 0)
 420 +                               return ret;
 421 +                       led->current_brightness = ret;
 422 +                       ret = 0;
 423 +               } else if (!strcmp(state, "on")) {
 424 +                       ret =
 425 +                       mt6323_led_set_brightness(cdev, cdev->max_brightness);
 426 +               } else  {
 427 +                       ret = mt6323_led_set_brightness(cdev, LED_OFF);
 428 +               }
 429 +       }
 430 +
 431 +       return ret;
 432 +}
 433 +
 434 +static int mt6323_led_probe(struct platform_device *pdev)
 435 +{
 436 +       struct device *dev = &pdev->dev;
 437 +       struct device_node *np = pdev->dev.of_node;
 438 +       struct device_node *child;
 439 +       struct mt6397_chip *hw = dev_get_drvdata(pdev->dev.parent);
 440 +       struct mt6323_leds *leds;
 441 +       struct mt6323_led *led;
 442 +       int ret;
 443 +       unsigned int status;
 444 +       u32 reg;
 445 +
 446 +       leds = devm_kzalloc(dev, sizeof(*leds), GFP_KERNEL);
 447 +       if (!leds)
 448 +               return -ENOMEM;
 449 +
 450 +       platform_set_drvdata(pdev, leds);
 451 +       leds->dev = dev;
 452 +
 453 +       /*
 454 +        * leds->hw points to the underlying bus for the register
 455 +        * controlled.
 456 +        */
 457 +       leds->hw = hw;
 458 +       mutex_init(&leds->lock);
 459 +
 460 +       status = MT6323_RG_DRV_32K_CK_PDN;
 461 +       ret = regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
 462 +                                MT6323_RG_DRV_32K_CK_PDN_MASK, ~status);
 463 +       if (ret < 0) {
 464 +               dev_err(leds->dev,
 465 +                       "Failed to update MT6323_TOP_CKPDN0 Register\n");
 466 +               return ret;
 467 +       }
 468 +
 469 +       for_each_available_child_of_node(np, child) {
 470 +               ret = of_property_read_u32(child, "reg", &reg);
 471 +               if (ret) {
 472 +                       dev_err(dev, "Failed to read led 'reg' property\n");
 473 +                       goto put_child_node;
 474 +               }
 475 +
 476 +               if (reg < 0 || reg > MT6323_MAX_LEDS || leds->led[reg]) {
 477 +                       dev_err(dev, "Invalid led reg %u\n", reg);
 478 +                       ret = -EINVAL;
 479 +                       goto put_child_node;
 480 +               }
 481 +
 482 +               led = devm_kzalloc(dev, sizeof(*led), GFP_KERNEL);
 483 +               if (!led) {
 484 +                       ret = -ENOMEM;
 485 +                       goto put_child_node;
 486 +               }
 487 +
 488 +               leds->led[reg] = led;
 489 +               leds->led[reg]->id = reg;
 490 +               leds->led[reg]->cdev.max_brightness = MT6323_MAX_BRIGHTNESS;
 491 +               leds->led[reg]->cdev.brightness_set_blocking =
 492 +                                       mt6323_led_set_brightness;
 493 +               leds->led[reg]->cdev.blink_set = mt6323_led_set_blink;
 494 +               leds->led[reg]->cdev.brightness_get =
 495 +                                       mt6323_get_led_hw_brightness;
 496 +               leds->led[reg]->parent = leds;
 497 +
 498 +               ret = mt6323_led_set_dt_default(&leds->led[reg]->cdev, child);
 499 +               if (ret < 0) {
 500 +                       dev_err(leds->dev,
 501 +                               "Failed to LED set default from devicetree\n");
 502 +                       goto put_child_node;
 503 +               }
 504 +
 505 +               ret = devm_led_classdev_register(dev, &leds->led[reg]->cdev);
 506 +               if (ret) {
 507 +                       dev_err(&pdev->dev, "Failed to register LED: %d\n",
 508 +                               ret);
 509 +                       goto put_child_node;
 510 +               }
 511 +               leds->led[reg]->cdev.dev->of_node = child;
 512 +       }
 513 +
 514 +       return 0;
 515 +
 516 +put_child_node:
 517 +       of_node_put(child);
 518 +       return ret;
 519 +}
 520 +
 521 +static int mt6323_led_remove(struct platform_device *pdev)
 522 +{
 523 +       struct mt6323_leds *leds = platform_get_drvdata(pdev);
 524 +       int i;
 525 +
 526 +       /* Turn the LEDs off on driver removal. */
 527 +       for (i = 0 ; leds->led[i] ; i++)
 528 +               mt6323_led_hw_off(&leds->led[i]->cdev);
 529 +
 530 +       regmap_update_bits(leds->hw->regmap, MT6323_TOP_CKPDN0,
 531 +                          MT6323_RG_DRV_32K_CK_PDN_MASK,
 532 +                          MT6323_RG_DRV_32K_CK_PDN);
 533 +
 534 +       mutex_destroy(&leds->lock);
 535 +
 536 +       return 0;
 537 +}
 538 +
 539 +static const struct of_device_id mt6323_led_dt_match[] = {
 540 +       { .compatible = "mediatek,mt6323-led" },
 541 +       {},
 542 +};
 543 +MODULE_DEVICE_TABLE(of, mt6323_led_dt_match);
 544 +
 545 +static struct platform_driver mt6323_led_driver = {
 546 +       .probe          = mt6323_led_probe,
 547 +       .remove         = mt6323_led_remove,
 548 +       .driver         = {
 549 +               .name   = "mt6323-led",
 550 +               .of_match_table = mt6323_led_dt_match,
 551 +       },
 552 +};
 553 +
 554 +module_platform_driver(mt6323_led_driver);
 555 +
 556 +MODULE_DESCRIPTION("LED driver for Mediatek MT6323 PMIC");
 557 +MODULE_AUTHOR("Sean Wang <sean.wang@mediatek.com>");
 558 +MODULE_LICENSE("GPL");