drivers/video/backlight/lm3630a_bl.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3 * Simple driver for Texas Instruments LM3630A Backlight driver chip
   4 * Copyright (C) 2012 Texas Instruments
   5 */
   6 #include <linux/module.h>
   7 #include <linux/slab.h>
   8 #include <linux/i2c.h>
   9 #include <linux/backlight.h>
  10 #include <linux/err.h>
  11 #include <linux/delay.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/regmap.h>
  15 #include <linux/pwm.h>
  16 #include <linux/platform_data/lm3630a_bl.h>
  17
  18 #define REG_CTRL        0x00
  19 #define REG_BOOST       0x02
  20 #define REG_CONFIG      0x01
  21 #define REG_BRT_A       0x03
  22 #define REG_BRT_B       0x04
  23 #define REG_I_A         0x05
  24 #define REG_I_B         0x06
  25 #define REG_INT_STATUS  0x09
  26 #define REG_INT_EN      0x0A
  27 #define REG_FAULT       0x0B
  28 #define REG_PWM_OUTLOW  0x12
  29 #define REG_PWM_OUTHIGH 0x13
  30 #define REG_FILTER_STRENGTH     0x50
  31 #define REG_MAX         0x50
  32
  33 #define INT_DEBOUNCE_MSEC       10
  34
  35 #define LM3630A_BANK_0          0
  36 #define LM3630A_BANK_1          1
  37
  38 #define LM3630A_NUM_SINKS       2
  39 #define LM3630A_SINK_0          0
  40 #define LM3630A_SINK_1          1
  41
  42 struct lm3630a_chip {
  43         struct device *dev;
  44         struct delayed_work work;
  45
  46         int irq;
  47         struct workqueue_struct *irqthread;
  48         struct lm3630a_platform_data *pdata;
  49         struct backlight_device *bleda;
  50         struct backlight_device *bledb;
  51         struct regmap *regmap;
  52         struct pwm_device *pwmd;
  53 };
  54
  55 /* i2c access */
  56 static int lm3630a_read(struct lm3630a_chip *pchip, unsigned int reg)
  57 {
  58         int rval;
  59         unsigned int reg_val;
  60
  61         rval = regmap_read(pchip->regmap, reg, &reg_val);
  62         if (rval < 0)
  63                 return rval;
  64         return reg_val & 0xFF;
  65 }
  66
  67 static int lm3630a_write(struct lm3630a_chip *pchip,
  68                          unsigned int reg, unsigned int data)
  69 {
  70         return regmap_write(pchip->regmap, reg, data);
  71 }
  72
  73 static int lm3630a_update(struct lm3630a_chip *pchip,
  74                           unsigned int reg, unsigned int mask,
  75                           unsigned int data)
  76 {
  77         return regmap_update_bits(pchip->regmap, reg, mask, data);
  78 }
  79
  80 /* initialize chip */
  81 static int lm3630a_chip_init(struct lm3630a_chip *pchip)
  82 {
  83         int rval;
  84         struct lm3630a_platform_data *pdata = pchip->pdata;
  85
  86         usleep_range(1000, 2000);
  87         /* set Filter Strength Register */
  88         rval = lm3630a_write(pchip, REG_FILTER_STRENGTH, 0x03);
  89         /* set Cofig. register */
  90         rval |= lm3630a_update(pchip, REG_CONFIG, 0x07, pdata->pwm_ctrl);
  91         /* set boost control */
  92         rval |= lm3630a_write(pchip, REG_BOOST, 0x38);
  93         /* set current A */
  94         rval |= lm3630a_update(pchip, REG_I_A, 0x1F, 0x1F);
  95         /* set current B */
  96         rval |= lm3630a_write(pchip, REG_I_B, 0x1F);
  97         /* set control */
  98         rval |= lm3630a_update(pchip, REG_CTRL, 0x14, pdata->leda_ctrl);
  99         rval |= lm3630a_update(pchip, REG_CTRL, 0x0B, pdata->ledb_ctrl);
 100         usleep_range(1000, 2000);
 101         /* set brightness A and B */
 102         rval |= lm3630a_write(pchip, REG_BRT_A, pdata->leda_init_brt);
 103         rval |= lm3630a_write(pchip, REG_BRT_B, pdata->ledb_init_brt);
 104
 105         if (rval < 0)
 106                 dev_err(pchip->dev, "i2c failed to access register\n");
 107         return rval;
 108 }
 109
 110 /* interrupt handling */
 111 static void lm3630a_delayed_func(struct work_struct *work)
 112 {
 113         int rval;
 114         struct lm3630a_chip *pchip;
 115
 116         pchip = container_of(work, struct lm3630a_chip, work.work);
 117
 118         rval = lm3630a_read(pchip, REG_INT_STATUS);
 119         if (rval < 0) {
 120                 dev_err(pchip->dev,
 121                         "i2c failed to access REG_INT_STATUS Register\n");
 122                 return;
 123         }
 124
 125         dev_info(pchip->dev, "REG_INT_STATUS Register is 0x%x\n", rval);
 126 }
 127
 128 static irqreturn_t lm3630a_isr_func(int irq, void *chip)
 129 {
 130         int rval;
 131         struct lm3630a_chip *pchip = chip;
 132         unsigned long delay = msecs_to_jiffies(INT_DEBOUNCE_MSEC);
 133
 134         queue_delayed_work(pchip->irqthread, &pchip->work, delay);
 135
 136         rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
 137         if (rval < 0) {
 138                 dev_err(pchip->dev, "i2c failed to access register\n");
 139                 return IRQ_NONE;
 140         }
 141         return IRQ_HANDLED;
 142 }
 143
 144 static int lm3630a_intr_config(struct lm3630a_chip *pchip)
 145 {
 146         int rval;
 147
 148         rval = lm3630a_write(pchip, REG_INT_EN, 0x87);
 149         if (rval < 0)
 150                 return rval;
 151
 152         INIT_DELAYED_WORK(&pchip->work, lm3630a_delayed_func);
 153         pchip->irqthread = create_singlethread_workqueue("lm3630a-irqthd");
 154         if (!pchip->irqthread) {
 155                 dev_err(pchip->dev, "create irq thread fail\n");
 156                 return -ENOMEM;
 157         }
 158         if (request_threaded_irq
 159             (pchip->irq, NULL, lm3630a_isr_func,
 160              IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "lm3630a_irq", pchip)) {
 161                 dev_err(pchip->dev, "request threaded irq fail\n");
 162                 destroy_workqueue(pchip->irqthread);
 163                 return -ENOMEM;
 164         }
 165         return rval;
 166 }
 167
 168 static void lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max)
 169 {
 170         unsigned int period = pchip->pdata->pwm_period;
 171         unsigned int duty = br * period / br_max;
 172
 173         pwm_config(pchip->pwmd, duty, period);
 174         if (duty)
 175                 pwm_enable(pchip->pwmd);
 176         else
 177                 pwm_disable(pchip->pwmd);
 178 }
 179
 180 /* update and get brightness */
 181 static int lm3630a_bank_a_update_status(struct backlight_device *bl)
 182 {
 183         int ret;
 184         struct lm3630a_chip *pchip = bl_get_data(bl);
 185         enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
 186
 187         /* pwm control */
 188         if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) {
 189                 lm3630a_pwm_ctrl(pchip, bl->props.brightness,
 190                                  bl->props.max_brightness);
 191                 return bl->props.brightness;
 192         }
 193
 194         /* disable sleep */
 195         ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
 196         if (ret < 0)
 197                 goto out_i2c_err;
 198         usleep_range(1000, 2000);
 199         /* minimum brightness is 0x04 */
 200         ret = lm3630a_write(pchip, REG_BRT_A, bl->props.brightness);
 201         if (bl->props.brightness < 0x4)
 202                 ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDA_ENABLE, 0);
 203         else
 204                 ret |= lm3630a_update(pchip, REG_CTRL,
 205                                       LM3630A_LEDA_ENABLE, LM3630A_LEDA_ENABLE);
 206         if (ret < 0)
 207                 goto out_i2c_err;
 208         return 0;
 209
 210 out_i2c_err:
 211         dev_err(pchip->dev, "i2c failed to access\n");
 212         return bl->props.brightness;
 213 }
 214
 215 static int lm3630a_bank_a_get_brightness(struct backlight_device *bl)
 216 {
 217         int brightness, rval;
 218         struct lm3630a_chip *pchip = bl_get_data(bl);
 219         enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
 220
 221         if ((pwm_ctrl & LM3630A_PWM_BANK_A) != 0) {
 222                 rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
 223                 if (rval < 0)
 224                         goto out_i2c_err;
 225                 brightness = (rval & 0x01) << 8;
 226                 rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
 227                 if (rval < 0)
 228                         goto out_i2c_err;
 229                 brightness |= rval;
 230                 goto out;
 231         }
 232
 233         /* disable sleep */
 234         rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
 235         if (rval < 0)
 236                 goto out_i2c_err;
 237         usleep_range(1000, 2000);
 238         rval = lm3630a_read(pchip, REG_BRT_A);
 239         if (rval < 0)
 240                 goto out_i2c_err;
 241         brightness = rval;
 242
 243 out:
 244         bl->props.brightness = brightness;
 245         return bl->props.brightness;
 246 out_i2c_err:
 247         dev_err(pchip->dev, "i2c failed to access register\n");
 248         return 0;
 249 }
 250
 251 static const struct backlight_ops lm3630a_bank_a_ops = {
 252         .options = BL_CORE_SUSPENDRESUME,
 253         .update_status = lm3630a_bank_a_update_status,
 254         .get_brightness = lm3630a_bank_a_get_brightness,
 255 };
 256
 257 /* update and get brightness */
 258 static int lm3630a_bank_b_update_status(struct backlight_device *bl)
 259 {
 260         int ret;
 261         struct lm3630a_chip *pchip = bl_get_data(bl);
 262         enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
 263
 264         /* pwm control */
 265         if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) {
 266                 lm3630a_pwm_ctrl(pchip, bl->props.brightness,
 267                                  bl->props.max_brightness);
 268                 return bl->props.brightness;
 269         }
 270
 271         /* disable sleep */
 272         ret = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
 273         if (ret < 0)
 274                 goto out_i2c_err;
 275         usleep_range(1000, 2000);
 276         /* minimum brightness is 0x04 */
 277         ret = lm3630a_write(pchip, REG_BRT_B, bl->props.brightness);
 278         if (bl->props.brightness < 0x4)
 279                 ret |= lm3630a_update(pchip, REG_CTRL, LM3630A_LEDB_ENABLE, 0);
 280         else
 281                 ret |= lm3630a_update(pchip, REG_CTRL,
 282                                       LM3630A_LEDB_ENABLE, LM3630A_LEDB_ENABLE);
 283         if (ret < 0)
 284                 goto out_i2c_err;
 285         return 0;
 286
 287 out_i2c_err:
 288         dev_err(pchip->dev, "i2c failed to access REG_CTRL\n");
 289         return bl->props.brightness;
 290 }
 291
 292 static int lm3630a_bank_b_get_brightness(struct backlight_device *bl)
 293 {
 294         int brightness, rval;
 295         struct lm3630a_chip *pchip = bl_get_data(bl);
 296         enum lm3630a_pwm_ctrl pwm_ctrl = pchip->pdata->pwm_ctrl;
 297
 298         if ((pwm_ctrl & LM3630A_PWM_BANK_B) != 0) {
 299                 rval = lm3630a_read(pchip, REG_PWM_OUTHIGH);
 300                 if (rval < 0)
 301                         goto out_i2c_err;
 302                 brightness = (rval & 0x01) << 8;
 303                 rval = lm3630a_read(pchip, REG_PWM_OUTLOW);
 304                 if (rval < 0)
 305                         goto out_i2c_err;
 306                 brightness |= rval;
 307                 goto out;
 308         }
 309
 310         /* disable sleep */
 311         rval = lm3630a_update(pchip, REG_CTRL, 0x80, 0x00);
 312         if (rval < 0)
 313                 goto out_i2c_err;
 314         usleep_range(1000, 2000);
 315         rval = lm3630a_read(pchip, REG_BRT_B);
 316         if (rval < 0)
 317                 goto out_i2c_err;
 318         brightness = rval;
 319
 320 out:
 321         bl->props.brightness = brightness;
 322         return bl->props.brightness;
 323 out_i2c_err:
 324         dev_err(pchip->dev, "i2c failed to access register\n");
 325         return 0;
 326 }
 327
 328 static const struct backlight_ops lm3630a_bank_b_ops = {
 329         .options = BL_CORE_SUSPENDRESUME,
 330         .update_status = lm3630a_bank_b_update_status,
 331         .get_brightness = lm3630a_bank_b_get_brightness,
 332 };
 333
 334 static int lm3630a_backlight_register(struct lm3630a_chip *pchip)
 335 {
 336         struct lm3630a_platform_data *pdata = pchip->pdata;
 337         struct backlight_properties props;
 338         const char *label;
 339
 340         props.type = BACKLIGHT_RAW;
 341         if (pdata->leda_ctrl != LM3630A_LEDA_DISABLE) {
 342                 props.brightness = pdata->leda_init_brt;
 343                 props.max_brightness = pdata->leda_max_brt;
 344                 label = pdata->leda_label ? pdata->leda_label : "lm3630a_leda";
 345                 pchip->bleda =
 346                     devm_backlight_device_register(pchip->dev, label,
 347                                                    pchip->dev, pchip,
 348                                                    &lm3630a_bank_a_ops, &props);
 349                 if (IS_ERR(pchip->bleda))
 350                         return PTR_ERR(pchip->bleda);
 351         }
 352
 353         if ((pdata->ledb_ctrl != LM3630A_LEDB_DISABLE) &&
 354             (pdata->ledb_ctrl != LM3630A_LEDB_ON_A)) {
 355                 props.brightness = pdata->ledb_init_brt;
 356                 props.max_brightness = pdata->ledb_max_brt;
 357                 label = pdata->ledb_label ? pdata->ledb_label : "lm3630a_ledb";
 358                 pchip->bledb =
 359                     devm_backlight_device_register(pchip->dev, label,
 360                                                    pchip->dev, pchip,
 361                                                    &lm3630a_bank_b_ops, &props);
 362                 if (IS_ERR(pchip->bledb))
 363                         return PTR_ERR(pchip->bledb);
 364         }
 365         return 0;
 366 }
 367
 368 static const struct regmap_config lm3630a_regmap = {
 369         .reg_bits = 8,
 370         .val_bits = 8,
 371         .max_register = REG_MAX,
 372 };
 373
 374 static int lm3630a_parse_led_sources(struct fwnode_handle *node,
 375                                      int default_led_sources)
 376 {
 377         u32 sources[LM3630A_NUM_SINKS];
 378         int ret, num_sources, i;
 379
 380         num_sources = fwnode_property_read_u32_array(node, "led-sources", NULL,
 381                                                      0);
 382         if (num_sources < 0)
 383                 return default_led_sources;
 384         else if (num_sources > ARRAY_SIZE(sources))
 385                 return -EINVAL;
 386
 387         ret = fwnode_property_read_u32_array(node, "led-sources", sources,
 388                                              num_sources);
 389         if (ret)
 390                 return ret;
 391
 392         for (i = 0; i < num_sources; i++) {
 393                 if (sources[i] < LM3630A_SINK_0 || sources[i] > LM3630A_SINK_1)
 394                         return -EINVAL;
 395
 396                 ret |= BIT(sources[i]);
 397         }
 398
 399         return ret;
 400 }
 401
 402 static int lm3630a_parse_bank(struct lm3630a_platform_data *pdata,
 403                               struct fwnode_handle *node, int *seen_led_sources)
 404 {
 405         int led_sources, ret;
 406         const char *label;
 407         u32 bank, val;
 408         bool linear;
 409
 410         ret = fwnode_property_read_u32(node, "reg", &bank);
 411         if (ret)
 412                 return ret;
 413
 414         if (bank < LM3630A_BANK_0 || bank > LM3630A_BANK_1)
 415                 return -EINVAL;
 416
 417         led_sources = lm3630a_parse_led_sources(node, BIT(bank));
 418         if (led_sources < 0)
 419                 return led_sources;
 420
 421         if (*seen_led_sources & led_sources)
 422                 return -EINVAL;
 423
 424         *seen_led_sources |= led_sources;
 425
 426         linear = fwnode_property_read_bool(node,
 427                                            "ti,linear-mapping-mode");
 428         if (bank) {
 429                 if (led_sources & BIT(LM3630A_SINK_0) ||
 430                     !(led_sources & BIT(LM3630A_SINK_1)))
 431                         return -EINVAL;
 432
 433                 pdata->ledb_ctrl = linear ?
 434                         LM3630A_LEDB_ENABLE_LINEAR :
 435                         LM3630A_LEDB_ENABLE;
 436         } else {
 437                 if (!(led_sources & BIT(LM3630A_SINK_0)))
 438                         return -EINVAL;
 439
 440                 pdata->leda_ctrl = linear ?
 441                         LM3630A_LEDA_ENABLE_LINEAR :
 442                         LM3630A_LEDA_ENABLE;
 443
 444                 if (led_sources & BIT(LM3630A_SINK_1))
 445                         pdata->ledb_ctrl = LM3630A_LEDB_ON_A;
 446         }
 447
 448         ret = fwnode_property_read_string(node, "label", &label);
 449         if (!ret) {
 450                 if (bank)
 451                         pdata->ledb_label = label;
 452                 else
 453                         pdata->leda_label = label;
 454         }
 455
 456         ret = fwnode_property_read_u32(node, "default-brightness",
 457                                        &val);
 458         if (!ret) {
 459                 if (bank)
 460                         pdata->ledb_init_brt = val;
 461                 else
 462                         pdata->leda_init_brt = val;
 463         }
 464
 465         ret = fwnode_property_read_u32(node, "max-brightness", &val);
 466         if (!ret) {
 467                 if (bank)
 468                         pdata->ledb_max_brt = val;
 469                 else
 470                         pdata->leda_max_brt = val;
 471         }
 472
 473         return 0;
 474 }
 475
 476 static int lm3630a_parse_node(struct lm3630a_chip *pchip,
 477                               struct lm3630a_platform_data *pdata)
 478 {
 479         int ret = -ENODEV, seen_led_sources = 0;
 480         struct fwnode_handle *node;
 481
 482         device_for_each_child_node(pchip->dev, node) {
 483                 ret = lm3630a_parse_bank(pdata, node, &seen_led_sources);
 484                 if (ret)
 485                         return ret;
 486         }
 487
 488         return ret;
 489 }
 490
 491 static int lm3630a_probe(struct i2c_client *client,
 492                          const struct i2c_device_id *id)
 493 {
 494         struct lm3630a_platform_data *pdata = dev_get_platdata(&client->dev);
 495         struct lm3630a_chip *pchip;
 496         int rval;
 497
 498         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 499                 dev_err(&client->dev, "fail : i2c functionality check\n");
 500                 return -EOPNOTSUPP;
 501         }
 502
 503         pchip = devm_kzalloc(&client->dev, sizeof(struct lm3630a_chip),
 504                              GFP_KERNEL);
 505         if (!pchip)
 506                 return -ENOMEM;
 507         pchip->dev = &client->dev;
 508
 509         pchip->regmap = devm_regmap_init_i2c(client, &lm3630a_regmap);
 510         if (IS_ERR(pchip->regmap)) {
 511                 rval = PTR_ERR(pchip->regmap);
 512                 dev_err(&client->dev, "fail : allocate reg. map: %d\n", rval);
 513                 return rval;
 514         }
 515
 516         i2c_set_clientdata(client, pchip);
 517         if (pdata == NULL) {
 518                 pdata = devm_kzalloc(pchip->dev,
 519                                      sizeof(struct lm3630a_platform_data),
 520                                      GFP_KERNEL);
 521                 if (pdata == NULL)
 522                         return -ENOMEM;
 523
 524                 /* default values */
 525                 pdata->leda_max_brt = LM3630A_MAX_BRIGHTNESS;
 526                 pdata->ledb_max_brt = LM3630A_MAX_BRIGHTNESS;
 527                 pdata->leda_init_brt = LM3630A_MAX_BRIGHTNESS;
 528                 pdata->ledb_init_brt = LM3630A_MAX_BRIGHTNESS;
 529
 530                 rval = lm3630a_parse_node(pchip, pdata);
 531                 if (rval) {
 532                         dev_err(&client->dev, "fail : parse node\n");
 533                         return rval;
 534                 }
 535         }
 536         pchip->pdata = pdata;
 537
 538         /* chip initialize */
 539         rval = lm3630a_chip_init(pchip);
 540         if (rval < 0) {
 541                 dev_err(&client->dev, "fail : init chip\n");
 542                 return rval;
 543         }
 544         /* backlight register */
 545         rval = lm3630a_backlight_register(pchip);
 546         if (rval < 0) {
 547                 dev_err(&client->dev, "fail : backlight register.\n");
 548                 return rval;
 549         }
 550         /* pwm */
 551         if (pdata->pwm_ctrl != LM3630A_PWM_DISABLE) {
 552                 pchip->pwmd = devm_pwm_get(pchip->dev, "lm3630a-pwm");
 553                 if (IS_ERR(pchip->pwmd)) {
 554                         dev_err(&client->dev, "fail : get pwm device\n");
 555                         return PTR_ERR(pchip->pwmd);
 556                 }
 557
 558                 /*
 559                  * FIXME: pwm_apply_args() should be removed when switching to
 560                  * the atomic PWM API.
 561                  */
 562                 pwm_apply_args(pchip->pwmd);
 563         }
 564
 565         /* interrupt enable  : irq 0 is not allowed */
 566         pchip->irq = client->irq;
 567         if (pchip->irq) {
 568                 rval = lm3630a_intr_config(pchip);
 569                 if (rval < 0)
 570                         return rval;
 571         }
 572         dev_info(&client->dev, "LM3630A backlight register OK.\n");
 573         return 0;
 574 }
 575
 576 static int lm3630a_remove(struct i2c_client *client)
 577 {
 578         int rval;
 579         struct lm3630a_chip *pchip = i2c_get_clientdata(client);
 580
 581         rval = lm3630a_write(pchip, REG_BRT_A, 0);
 582         if (rval < 0)
 583                 dev_err(pchip->dev, "i2c failed to access register\n");
 584
 585         rval = lm3630a_write(pchip, REG_BRT_B, 0);
 586         if (rval < 0)
 587                 dev_err(pchip->dev, "i2c failed to access register\n");
 588
 589         if (pchip->irq) {
 590                 free_irq(pchip->irq, pchip);
 591                 flush_workqueue(pchip->irqthread);
 592                 destroy_workqueue(pchip->irqthread);
 593         }
 594         return 0;
 595 }
 596
 597 static const struct i2c_device_id lm3630a_id[] = {
 598         {LM3630A_NAME, 0},
 599         {}
 600 };
 601
 602 static const struct of_device_id lm3630a_match_table[] = {
 603         { .compatible = "ti,lm3630a", },
 604         { },
 605 };
 606
 607 MODULE_DEVICE_TABLE(i2c, lm3630a_id);
 608
 609 static struct i2c_driver lm3630a_i2c_driver = {
 610         .driver = {
 611                    .name = LM3630A_NAME,
 612                    .of_match_table = lm3630a_match_table,
 613                    },
 614         .probe = lm3630a_probe,
 615         .remove = lm3630a_remove,
 616         .id_table = lm3630a_id,
 617 };
 618
 619 module_i2c_driver(lm3630a_i2c_driver);
 620
 621 MODULE_DESCRIPTION("Texas Instruments Backlight driver for LM3630A");
 622 MODULE_AUTHOR("Daniel Jeong <gshark.jeong@gmail.com>");
 623 MODULE_AUTHOR("LDD MLP <ldd-mlp@list.ti.com>");
 624 MODULE_LICENSE("GPL v2");