drivers/leds/leds-sm5701.c

   1 /*
   2  * leds-sm5701.c
   3  *
   4  * Copyright (c) 2014 Silicon Mitus Co., Ltd
   5  *
   6  *  This program is free software; you can redistribute  it and/or modify it
   7  *  under  the terms of  the GNU General  Public License as published by the
   8  *  Free Software Foundation;  either version 2 of the  License, or (at your
   9  *  option) any later version.
  10  *
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/moduleparam.h>
  15 #include <linux/delay.h>
  16 #include <linux/i2c.h>
  17 #include <linux/leds.h>
  18 #include <linux/slab.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/fs.h>
  21 #include <linux/workqueue.h>
  22 #include <linux/mfd/sm5701_core.h>
  23
  24 #if defined (CONFIG_OF)
  25 #include <linux/of_device.h>
  26 #include <linux/of.h>
  27 #include <linux/of_gpio.h>
  28 #endif /* CONFIG_OF */
  29
  30 //#include <linux/platform_data/leds-sm5701.h>
  31
  32
  33 enum sm5701_oper_mode {
  34         SUSPEND_MODE = 0,
  35         CHARGING_OFF_MODE,
  36         CHARGING_ON_MODE,
  37         CHARGING_FLASH_BOOST_MODE
  38 };
  39
  40 struct SM5701_leds_data {
  41         struct device *dev;
  42         struct SM5701_dev *iodev;
  43
  44         struct led_classdev cdev_flash;
  45         struct led_classdev cdev_movie;
  46
  47         struct work_struct work_flash;
  48         struct work_struct work_movie;
  49
  50         u8 br_flash; //IFLED Current in Flash Mode
  51         u8 br_movie; //IMLED Current in Movie Mode
  52
  53         unsigned int flashen;
  54         unsigned int flashset;
  55
  56         //struct sm5701_platform_data *pdata;
  57
  58         struct mutex lock;
  59 };
  60
  61 static struct i2c_client * leds_sm5701_client = NULL;
  62
  63 #define ENABSTMR_SHIFT  4
  64 void sm5701_set_enabstmr(int abstmr_enable)
  65 {
  66     struct i2c_client * client;
  67     u8 data = 0;
  68
  69     client = leds_sm5701_client;
  70
  71     if( !client) return;
  72
  73     pr_info("%s abstmr_enable = %d\n",__func__,abstmr_enable);
  74
  75     SM5701_reg_read(client, SM5701_FLEDCNTL1, &data);
  76
  77     data = (data & (~SM5701_FLEDCNTL1_ENABSTMR)) | (abstmr_enable << ENABSTMR_SHIFT);
  78
  79     SM5701_reg_write(client,SM5701_FLEDCNTL1,data);
  80
  81     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL1, data);
  82
  83 }
  84 EXPORT_SYMBOL(sm5701_set_enabstmr);
  85
  86 #define ABSTMR_SHIFT  2
  87 void sm5701_set_abstmr(int abstmr_sec)
  88 {
  89     struct i2c_client * client;
  90     u8 data = 0;
  91
  92     client = leds_sm5701_client;
  93
  94     if( !client) return;
  95
  96     pr_info("%s abstmr_sec = %d\n",__func__,abstmr_sec);
  97
  98     SM5701_reg_read(client, SM5701_FLEDCNTL1, &data);
  99
 100     data = (data & (~SM5701_FLEDCNTL1_ABSTMR)) | (abstmr_sec << ABSTMR_SHIFT);
 101
 102     SM5701_reg_write(client,SM5701_FLEDCNTL1,data);
 103
 104     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL1, data);
 105
 106 }
 107 EXPORT_SYMBOL(sm5701_set_abstmr);
 108
 109 void sm5701_set_fleden(int fled_enable)
 110 {
 111     struct i2c_client * client;
 112     u8 data = 0;
 113
 114     client = leds_sm5701_client;
 115
 116     if( !client) return;
 117
 118     pr_info("%s fled_enable = %d\n",__func__,fled_enable);
 119
 120     SM5701_reg_read(client, SM5701_FLEDCNTL1, &data);
 121
 122     data = (data & (~SM5701_FLEDCNTL1_FLEDEN)) | fled_enable;
 123
 124     SM5701_reg_write(client,SM5701_FLEDCNTL1,data);
 125
 126     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL1, data);
 127
 128 }
 129 EXPORT_SYMBOL(sm5701_set_fleden);
 130
 131 #define nENSAFET_SHIFT  7
 132 void sm5701_set_nensafet(int nensafet_enable)
 133 {
 134     struct i2c_client * client;
 135     u8 data = 0;
 136
 137     client = leds_sm5701_client;
 138
 139     if( !client) return;
 140
 141     pr_info("%s nensafet_enable = %d\n",__func__,nensafet_enable);
 142
 143     SM5701_reg_read(client, SM5701_FLEDCNTL2, &data);
 144
 145     data = (data & (~SM5701_FLEDCNTL2_nENSAFET)) | (nensafet_enable << nENSAFET_SHIFT);
 146
 147     SM5701_reg_write(client,SM5701_FLEDCNTL2,data);
 148
 149     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL2, data);
 150
 151 }
 152 EXPORT_SYMBOL(sm5701_set_nensafet);
 153
 154 #define SAFET_SHIFT  5
 155 void sm5701_set_safet(int safet_us)
 156 {
 157     struct i2c_client * client;
 158     u8 data = 0;
 159
 160     client = leds_sm5701_client;
 161
 162     if( !client) return;
 163
 164     pr_info("%s safet_us = %d\n",__func__,safet_us);
 165
 166     SM5701_reg_read(client, SM5701_FLEDCNTL2, &data);
 167
 168     data = (data & (~SM5701_FLEDCNTL2_SAFET)) | (safet_us << SAFET_SHIFT);
 169
 170     SM5701_reg_write(client,SM5701_FLEDCNTL2,data);
 171
 172     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL2, data);
 173
 174 }
 175 EXPORT_SYMBOL(sm5701_set_safet);
 176
 177 #define nONESHOT_SHIFT  4
 178 void sm5701_set_noneshot(int noneshot_enable)
 179 {
 180     struct i2c_client * client;
 181     u8 data = 0;
 182
 183     client = leds_sm5701_client;
 184
 185     if( !client) return;
 186
 187     pr_info("%s noneshot_enable = %d\n",__func__,noneshot_enable);
 188
 189     SM5701_reg_read(client, SM5701_FLEDCNTL2, &data);
 190
 191     data = (data & (~SM5701_FLEDCNTL2_nONESHOT)) | (noneshot_enable << nONESHOT_SHIFT);
 192
 193     SM5701_reg_write(client,SM5701_FLEDCNTL2,data);
 194
 195     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL2, data);
 196
 197 }
 198 EXPORT_SYMBOL(sm5701_set_noneshot);
 199
 200 void sm5701_set_onetimer(int onetimer_ms)
 201 {
 202     struct i2c_client * client;
 203     u8 data = 0;
 204
 205     client = leds_sm5701_client;
 206
 207     if( !client) return;
 208
 209     pr_info("%s onetimer_ms = %d\n",__func__,onetimer_ms);
 210
 211     SM5701_reg_read(client, SM5701_FLEDCNTL2, &data);
 212
 213     data = (data & (~SM5701_FLEDCNTL2_ONETIMER)) | onetimer_ms;
 214
 215     SM5701_reg_write(client,SM5701_FLEDCNTL2,data);
 216
 217     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL2, data);
 218
 219 }
 220 EXPORT_SYMBOL(sm5701_set_onetimer);
 221
 222 #define IFLED_MAX   0x1F
 223 #define IFLED_MIN   0x0
 224 void sm5701_set_ifled(int ifled_ma)
 225 {
 226     struct i2c_client * client;
 227     u8 data = 0;
 228
 229     client = leds_sm5701_client;
 230
 231     if( !client) return;
 232
 233     pr_info("%s ifled_ma = %d\n",__func__,ifled_ma);
 234
 235     if(ifled_ma < IFLED_MIN)
 236         ifled_ma = IFLED_MIN;
 237     else if (ifled_ma > IFLED_MAX)
 238         ifled_ma = IFLED_MAX;
 239
 240     SM5701_reg_read(client, SM5701_FLEDCNTL3, &data);
 241
 242     data = (data & (~SM5701_FLEDCNTL3_IFLED)) | ifled_ma;
 243
 244     SM5701_reg_write(client,SM5701_FLEDCNTL3,data);
 245
 246     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL3, data);
 247
 248 }
 249 EXPORT_SYMBOL(sm5701_set_ifled);
 250
 251 #define IMLED_MAX   0x1F
 252 #define IMLED_MIN   0x0
 253 void sm5701_set_imled(int imled_ma)
 254 {
 255     struct i2c_client * client;
 256     u8 data = 0;
 257
 258     client = leds_sm5701_client;
 259
 260     if( !client) return;
 261
 262     pr_info("%s imled_ma = %d\n",__func__,imled_ma);
 263
 264     if(imled_ma < IMLED_MIN)
 265         imled_ma = IMLED_MIN;
 266     else if(imled_ma > IMLED_MAX)
 267         imled_ma = IMLED_MAX;
 268
 269     SM5701_reg_read(client, SM5701_FLEDCNTL4, &data);
 270
 271     data = (data & (~SM5701_FLEDCNTL4_IMLED)) | imled_ma;
 272
 273     SM5701_reg_write(client,SM5701_FLEDCNTL4,data);
 274
 275     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL4, data);
 276
 277 }
 278 EXPORT_SYMBOL(sm5701_set_imled);
 279
 280 #define ENLOWBATT_SHIFT  7
 281 void sm5701_set_enlowbatt(int enlowbatt_enable)
 282 {
 283     struct i2c_client * client;
 284     u8 data = 0;
 285
 286     client = leds_sm5701_client;
 287
 288     if( !client) return;
 289
 290     pr_info("%s enlowbatt_enable = %d\n",__func__,enlowbatt_enable);
 291
 292     SM5701_reg_read(client, SM5701_FLEDCNTL5, &data);
 293
 294     data = (data & (~SM5701_FLEDCNTL5_ENLOWBATT)) | (enlowbatt_enable << ENLOWBATT_SHIFT);
 295
 296     SM5701_reg_write(client,SM5701_FLEDCNTL5,data);
 297
 298     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL5, data);
 299
 300 }
 301 EXPORT_SYMBOL(sm5701_set_enlowbatt);
 302
 303 #define LBRSTIMER_SHIFT  5
 304 void sm5701_set_lbrstimer(int lbrstimer_us)
 305 {
 306     struct i2c_client * client;
 307     u8 data = 0;
 308
 309     client = leds_sm5701_client;
 310
 311     if( !client) return;
 312
 313     pr_info("%s lbrstimer_us = %d\n",__func__,lbrstimer_us);
 314
 315     SM5701_reg_read(client, SM5701_FLEDCNTL5, &data);
 316
 317     data = (data & (~SM5701_FLEDCNTL5_LBRSTIMER)) | (lbrstimer_us << LBRSTIMER_SHIFT);
 318
 319     SM5701_reg_write(client,SM5701_FLEDCNTL5,data);
 320
 321     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL5, data);
 322
 323 }
 324 EXPORT_SYMBOL(sm5701_set_lbrstimer);
 325
 326 #define LOWBATT_SHIFT  2
 327 void sm5701_set_lowbatt(int lowbatt_v)
 328 {
 329     struct i2c_client * client;
 330     u8 data = 0;
 331
 332     client = leds_sm5701_client;
 333
 334     if( !client) return;
 335
 336     pr_info("%s lowbatt_v = %d\n",__func__,lowbatt_v);
 337
 338     SM5701_reg_read(client, SM5701_FLEDCNTL5, &data);
 339
 340     data = (data & (~SM5701_FLEDCNTL5_LOWBATT)) | (lowbatt_v << LOWBATT_SHIFT);
 341
 342     SM5701_reg_write(client,SM5701_FLEDCNTL5,data);
 343
 344     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL5, data);
 345
 346 }
 347 EXPORT_SYMBOL(sm5701_set_lowbatt);
 348
 349 void sm5701_set_lbdhys(int lbdhys_mv)
 350 {
 351     struct i2c_client * client;
 352     u8 data = 0;
 353
 354     client = leds_sm5701_client;
 355
 356     if( !client) return;
 357
 358     pr_info("%s lbdhys_mv = %d\n",__func__,lbdhys_mv);
 359
 360     SM5701_reg_read(client, SM5701_FLEDCNTL5, &data);
 361
 362     data = (data & (~SM5701_FLEDCNTL5_LBDHYS))| lbdhys_mv;
 363
 364     SM5701_reg_write(client,SM5701_FLEDCNTL5,data);
 365
 366     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL5, data);
 367
 368 }
 369 EXPORT_SYMBOL(sm5701_set_lbdhys);
 370
 371 void SM5701_set_bstout(int bstout_mv)
 372 {
 373     struct i2c_client * client;
 374     u8 data = 0;
 375
 376     client = leds_sm5701_client;
 377
 378     if( !client) return;
 379
 380     pr_info("%s bstout_mv = %d\n",__func__,bstout_mv);
 381
 382     SM5701_reg_read(client, SM5701_FLEDCNTL6, &data);
 383
 384     data = (data & (~SM5701_FLEDCNTL6_BSTOUT))| bstout_mv;
 385
 386     SM5701_reg_write(client,SM5701_FLEDCNTL6,data);
 387
 388     pr_info("write SM5701 addr : 0x%02x data : 0x%02x\n", SM5701_FLEDCNTL6, data);
 389
 390 }
 391 EXPORT_SYMBOL(SM5701_set_bstout);
 392
 393 /* brightness control */
 394 static int sm5701_brightness_control(struct SM5701_leds_data *chip,
 395                           u8 brightness, enum sm5701_flash_mode flash_mode)
 396 {
 397         switch (flash_mode) {
 398         case NONE_MODE:
 399                 break;
 400
 401         case FLASH_MODE:
 402                 sm5701_set_ifled(brightness);
 403                 break;
 404
 405         case MOVIE_MODE:
 406                 sm5701_set_imled(brightness);
 407                 break;
 408
 409         default:
 410                 break;
 411         }
 412
 413         return flash_mode;
 414 }
 415
 416 /* movie */
 417
 418 /* movie config for sm5701*/
 419 static ssize_t sm5701_movie_store(struct device *dev,
 420                                       struct device_attribute *attr,
 421                                       const char *buf, size_t size)
 422 {
 423         ssize_t ret;
 424         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 425         struct SM5701_leds_data *chip =
 426             container_of(led_cdev, struct SM5701_leds_data, work_movie);
 427         unsigned int state;
 428
 429         ret = kstrtouint(buf, 10, &state);
 430         if (ret)
 431                 goto out_strtoint;
 432
 433         if (state == 0)
 434                 sm5701_set_fleden(SM5701_FLEDEN_DISABLED);
 435         else if (state == 1)
 436                 sm5701_set_fleden(SM5701_FLEDEN_ON_MOVIE);
 437         else
 438                 sm5701_set_fleden(SM5701_FLEDEN_DISABLED);
 439
 440         //sm5701_dump_register();
 441
 442         return size;
 443
 444 out_strtoint:
 445         dev_err(chip->dev, "%s: fail to change str to int\n", __func__);
 446         return ret;
 447 }
 448
 449 static DEVICE_ATTR(movie, S_IWUSR, NULL, sm5701_movie_store);
 450
 451 static void sm5701_deferred_movie_brightness_set(struct work_struct *work)
 452 {
 453     struct SM5701_leds_data *chip =
 454         container_of(work, struct SM5701_leds_data, work_movie);
 455
 456         mutex_lock(&chip->lock);
 457         sm5701_brightness_control(chip, chip->br_movie, MOVIE_MODE);
 458         mutex_unlock(&chip->lock);
 459 }
 460
 461 static void sm5701_movie_brightness_set(struct led_classdev *cdev,
 462                                         enum led_brightness brightness)
 463 {
 464         struct SM5701_leds_data *chip =
 465             container_of(cdev, struct SM5701_leds_data, cdev_movie);
 466
 467         if(brightness >= 0 && brightness <= cdev->max_brightness )
 468         {
 469             chip->br_movie = brightness;
 470             schedule_work(&chip->work_movie);
 471         }
 472 }
 473
 474 /* flash */
 475
 476 /* flash config for sm5701*/
 477 static ssize_t sm5701_flash_store(struct device *dev,
 478                                        struct device_attribute *attr,
 479                                        const char *buf, size_t size)
 480 {
 481         ssize_t ret;
 482         struct led_classdev *led_cdev = dev_get_drvdata(dev);
 483         struct SM5701_leds_data *chip =
 484             container_of(led_cdev, struct SM5701_leds_data, work_flash);
 485         unsigned int state;
 486
 487         ret = kstrtouint(buf, 10, &state);
 488         if (ret)
 489                 goto out_strtoint;
 490
 491         if (state == 0)
 492                 sm5701_set_fleden(SM5701_FLEDEN_DISABLED);
 493         else if (state == 1)
 494                 sm5701_set_fleden(SM5701_FLEDEN_ON_FLASH);
 495         else
 496                 sm5701_set_fleden(SM5701_FLEDEN_DISABLED);
 497
 498         //sm5701_dump_register();
 499
 500         return size;
 501
 502 out_strtoint:
 503         dev_err(chip->dev, "%s: fail to change str to int\n", __func__);
 504         return ret;
 505 }
 506
 507 static DEVICE_ATTR(flash, S_IWUSR, NULL, sm5701_flash_store);
 508
 509 static void sm5701_deferred_flash_brightness_set(struct work_struct *work)
 510 {
 511     struct SM5701_leds_data *chip =
 512         container_of(work, struct SM5701_leds_data, work_flash);
 513
 514         mutex_lock(&chip->lock);
 515         sm5701_brightness_control(chip, chip->br_flash, FLASH_MODE);
 516         mutex_unlock(&chip->lock);
 517 }
 518
 519 static void sm5701_flash_brightness_set(struct led_classdev *cdev,
 520                                          enum led_brightness brightness)
 521 {
 522         struct SM5701_leds_data *chip =
 523             container_of(cdev, struct SM5701_leds_data, cdev_flash);
 524
 525         if(brightness >= 0 && brightness <= cdev->max_brightness )
 526         {
 527             chip->br_flash = brightness;
 528             schedule_work(&chip->work_flash);
 529         }
 530 }
 531
 532 /* chip initialize */
 533 static int sm5701_chip_init(struct SM5701_leds_data *chip)
 534 {
 535         int ret = 0;
 536
 537         chip->br_movie = 0x0E; //150mA
 538         sm5701_set_imled(chip->br_movie);
 539
 540         chip->br_flash = 0x19; //1200mA
 541         sm5701_set_ifled(chip->br_flash);
 542
 543         //sm5701_dump_register();
 544
 545         //disable ABSTMR
 546         sm5701_set_enabstmr(0);
 547
 548         return ret;
 549 }
 550
 551 static int sm5701_leds_parse_dt(struct SM5701_leds_data *chip)
 552 {
 553         struct device_node *np = of_find_node_by_name(NULL, "leds_sm5701");
 554         int ret = 0;
 555
 556         if (np == NULL) {
 557                 pr_err("%s np NULL\n", __func__);
 558                 return -1;
 559         } else {
 560                 chip->flashen = of_get_named_gpio(np, "flashen-gpio", 0);
 561                 chip->flashset = of_get_named_gpio(np, "flashtorch-gpio", 0);
 562
 563                 pr_info("%s: SM5701_parse_dt flashen: %d\n", __func__, chip->flashen);
 564                 pr_info("%s: SM5701_parse_dt flashset: %d\n", __func__, chip->flashset);
 565
 566                 ret = gpio_request(chip->flashen, NULL);
 567                 if (ret < 0)
 568                         printk(KERN_WARNING"[FLASH] FLASHEN request failed.%d\n", ret);
 569                 else
 570                         gpio_direction_output(chip->flashen, 0);
 571
 572                 ret = gpio_request(chip->flashset, NULL);
 573                 if (ret < 0)
 574                         printk(KERN_WARNING"[FLASH] FLASHSET %d\n", ret);
 575                 else
 576                         gpio_direction_output(chip->flashset, 0);
 577         }
 578
 579         return ret;
 580 }
 581
 582 static int leds_sm5701_probe(struct platform_device *pdev)
 583 {
 584         struct SM5701_dev *iodev = dev_get_drvdata(pdev->dev.parent);
 585         struct SM5701_leds_data *chip;
 586
 587         int err;
 588
 589         printk("******* %s *******\n",__func__);
 590
 591         chip = kzalloc(sizeof(struct SM5701_leds_data), GFP_KERNEL);
 592         if (!chip)
 593            return -ENOMEM;
 594
 595         chip->dev = &pdev->dev;
 596         chip->iodev = iodev;
 597         platform_set_drvdata(pdev, chip);
 598
 599 #if 0   //Prevent Issue : 34260
 600         if (!(leds_sm5701_client = kmalloc(sizeof(struct i2c_client), GFP_KERNEL))) {
 601             return -ENOMEM;
 602         }
 603         memset(leds_sm5701_client, 0, sizeof(struct i2c_client));
 604 #endif
 605
 606         leds_sm5701_client = chip->iodev->i2c;
 607
 608         mutex_init(&chip->lock);
 609
 610         /* flash */
 611         INIT_WORK(&chip->work_flash, sm5701_deferred_flash_brightness_set);
 612         chip->cdev_flash.name = "flash";
 613         chip->cdev_flash.max_brightness = 32-1;//0x1f
 614         chip->cdev_flash.brightness_set = sm5701_flash_brightness_set;
 615         chip->cdev_flash.default_trigger = "flash";
 616         err = led_classdev_register((struct device *)
 617                                     chip->dev, &chip->cdev_flash);
 618
 619         if (err < 0) {
 620                 dev_err(chip->dev, "failed to register flash\n");
 621                 goto err_create_flash_file;
 622         }
 623         err = device_create_file(chip->cdev_flash.dev, &dev_attr_flash);
 624         if (err < 0) {
 625                 dev_err(chip->dev, "failed to create flash file\n");
 626                 goto err_create_flash_pin_file;
 627         }
 628
 629         /* movie */
 630         INIT_WORK(&chip->work_movie, sm5701_deferred_movie_brightness_set);
 631         chip->cdev_movie.name = "movie";
 632         chip->cdev_movie.max_brightness = 32-1;//0x1f
 633         chip->cdev_movie.brightness_set = sm5701_movie_brightness_set;
 634         chip->cdev_movie.default_trigger = "movie";
 635         err = led_classdev_register((struct device *)
 636                                     chip->dev, &chip->cdev_movie);
 637         if (err < 0) {
 638                 dev_err(chip->dev, "failed to register movie\n");
 639                 goto err_create_movie_file;
 640         }
 641         err = device_create_file(chip->cdev_movie.dev, &dev_attr_movie);
 642         if (err < 0) {
 643                 dev_err(chip->dev, "failed to create movie file\n");
 644                 goto err_create_movie_pin_file;
 645         }
 646
 647         err = sm5701_chip_init(chip);
 648         if (err < 0)
 649                 goto err_out;
 650
 651         //sm5701_dump_register();
 652
 653         /* To control FLED releated GPIOs */
 654         err = sm5701_leds_parse_dt(chip);
 655         if (err < 0)
 656                 dev_err(chip->dev, "Failed to control GPIOs\n");
 657
 658         dev_info(chip->dev, "LEDs_SM5701 Probe Done\n");
 659
 660         return 0;
 661
 662 err_create_movie_file:
 663         device_remove_file(chip->cdev_movie.dev, &dev_attr_movie);
 664 err_create_movie_pin_file:
 665         led_classdev_unregister(&chip->cdev_movie);
 666 err_create_flash_file:
 667         device_remove_file(chip->cdev_flash.dev, &dev_attr_flash);
 668 err_create_flash_pin_file:
 669         led_classdev_unregister(&chip->cdev_flash);
 670 err_out:
 671         return err;
 672 }
 673
 674 static int leds_sm5701_remove(struct platform_device *pdev)
 675 {
 676         struct SM5701_leds_data *chip = platform_get_drvdata(pdev);
 677
 678         device_remove_file(chip->cdev_movie.dev, &dev_attr_movie);
 679         led_classdev_unregister(&chip->cdev_movie);
 680         flush_work(&chip->work_movie);
 681         device_remove_file(chip->cdev_flash.dev, &dev_attr_flash);
 682         led_classdev_unregister(&chip->cdev_flash);
 683         flush_work(&chip->work_flash);
 684         return 0;
 685 }
 686
 687 static const struct platform_device_id leds_sm5701_id[] = {
 688         {"leds_sm5701", 0},
 689         {}
 690 };
 691
 692 MODULE_DEVICE_TABLE(platform, leds_sm5701_id);
 693
 694 #ifdef CONFIG_OF
 695 static struct of_device_id leds_sm5701_match_table[] = {
 696         { .compatible = "sm,leds_sm5701",},
 697         {},
 698 };
 699 #else
 700 #define SM5701_match_table NULL
 701 #endif
 702
 703 static struct platform_driver leds_sm5701_driver = {
 704         .driver = {
 705                    .name = "leds_sm5701",
 706                    .owner = THIS_MODULE,
 707                    .of_match_table = leds_sm5701_match_table,
 708                    },
 709         .probe = leds_sm5701_probe,
 710         .remove = leds_sm5701_remove,
 711         .id_table = leds_sm5701_id,
 712 };
 713
 714 static int __init leds_sm5701_init(void)
 715 {
 716     printk("******* %s *******\n",__func__);
 717
 718         return platform_driver_register(&leds_sm5701_driver);
 719 }
 720
 721 subsys_initcall(leds_sm5701_init);
 722
 723 static void __exit leds_sm5701_exit(void)
 724 {
 725         platform_driver_unregister(&leds_sm5701_driver);
 726 }
 727 module_exit(leds_sm5701_exit);
 728
 729 /* Module information */
 730 MODULE_DESCRIPTION("SILICONMITUS SM5701 Flash LED Driver");
 731 MODULE_LICENSE("GPL");
 732 MODULE_ALIAS("platform:leds-sm5701");
 733