backlight: l4f00242t03: use spi_get_drvdata and spi_set_drvdata
[~shefty/rdma-dev.git] / drivers / video / backlight / ld9040.c
1 /*
2  * ld9040 AMOLED LCD panel driver.
3  *
4  * Copyright (c) 2011 Samsung Electronics
5  * Author: Donghwa Lee  <dh09.lee@samsung.com>
6  * Derived from drivers/video/backlight/s6e63m0.c
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the
10  * Free Software Foundation; either version 2 of the License, or (at your
11  * option) any later version.
12  */
13
14 #include <linux/backlight.h>
15 #include <linux/delay.h>
16 #include <linux/fb.h>
17 #include <linux/gpio.h>
18 #include <linux/interrupt.h>
19 #include <linux/irq.h>
20 #include <linux/kernel.h>
21 #include <linux/lcd.h>
22 #include <linux/module.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/spi/spi.h>
25 #include <linux/wait.h>
26
27 #include "ld9040_gamma.h"
28
29 #define SLEEPMSEC               0x1000
30 #define ENDDEF                  0x2000
31 #define DEFMASK                 0xFF00
32 #define COMMAND_ONLY            0xFE
33 #define DATA_ONLY               0xFF
34
35 #define MIN_BRIGHTNESS          0
36 #define MAX_BRIGHTNESS          24
37
38 struct ld9040 {
39         struct device                   *dev;
40         struct spi_device               *spi;
41         unsigned int                    power;
42         unsigned int                    current_brightness;
43
44         struct lcd_device               *ld;
45         struct backlight_device         *bd;
46         struct lcd_platform_data        *lcd_pd;
47
48         struct mutex                    lock;
49         bool  enabled;
50 };
51
52 static struct regulator_bulk_data supplies[] = {
53         { .supply = "vdd3", },
54         { .supply = "vci", },
55 };
56
57 static void ld9040_regulator_enable(struct ld9040 *lcd)
58 {
59         int ret = 0;
60         struct lcd_platform_data *pd = NULL;
61
62         pd = lcd->lcd_pd;
63         mutex_lock(&lcd->lock);
64         if (!lcd->enabled) {
65                 ret = regulator_bulk_enable(ARRAY_SIZE(supplies), supplies);
66                 if (ret)
67                         goto out;
68
69                 lcd->enabled = true;
70         }
71         msleep(pd->power_on_delay);
72 out:
73         mutex_unlock(&lcd->lock);
74 }
75
76 static void ld9040_regulator_disable(struct ld9040 *lcd)
77 {
78         int ret = 0;
79
80         mutex_lock(&lcd->lock);
81         if (lcd->enabled) {
82                 ret = regulator_bulk_disable(ARRAY_SIZE(supplies), supplies);
83                 if (ret)
84                         goto out;
85
86                 lcd->enabled = false;
87         }
88 out:
89         mutex_unlock(&lcd->lock);
90 }
91
92 static const unsigned short seq_swreset[] = {
93         0x01, COMMAND_ONLY,
94         ENDDEF, 0x00
95 };
96
97 static const unsigned short seq_user_setting[] = {
98         0xF0, 0x5A,
99
100         DATA_ONLY, 0x5A,
101         ENDDEF, 0x00
102 };
103
104 static const unsigned short seq_elvss_on[] = {
105         0xB1, 0x0D,
106
107         DATA_ONLY, 0x00,
108         DATA_ONLY, 0x16,
109         ENDDEF, 0x00
110 };
111
112 static const unsigned short seq_gtcon[] = {
113         0xF7, 0x09,
114
115         DATA_ONLY, 0x00,
116         DATA_ONLY, 0x00,
117         ENDDEF, 0x00
118 };
119
120 static const unsigned short seq_panel_condition[] = {
121         0xF8, 0x05,
122
123         DATA_ONLY, 0x65,
124         DATA_ONLY, 0x96,
125         DATA_ONLY, 0x71,
126         DATA_ONLY, 0x7D,
127         DATA_ONLY, 0x19,
128         DATA_ONLY, 0x3B,
129         DATA_ONLY, 0x0D,
130         DATA_ONLY, 0x19,
131         DATA_ONLY, 0x7E,
132         DATA_ONLY, 0x0D,
133         DATA_ONLY, 0xE2,
134         DATA_ONLY, 0x00,
135         DATA_ONLY, 0x00,
136         DATA_ONLY, 0x7E,
137         DATA_ONLY, 0x7D,
138         DATA_ONLY, 0x07,
139         DATA_ONLY, 0x07,
140         DATA_ONLY, 0x20,
141         DATA_ONLY, 0x20,
142         DATA_ONLY, 0x20,
143         DATA_ONLY, 0x02,
144         DATA_ONLY, 0x02,
145         ENDDEF, 0x00
146 };
147
148 static const unsigned short seq_gamma_set1[] = {
149         0xF9, 0x00,
150
151         DATA_ONLY, 0xA7,
152         DATA_ONLY, 0xB4,
153         DATA_ONLY, 0xAE,
154         DATA_ONLY, 0xBF,
155         DATA_ONLY, 0x00,
156         DATA_ONLY, 0x91,
157         DATA_ONLY, 0x00,
158         DATA_ONLY, 0xB2,
159         DATA_ONLY, 0xB4,
160         DATA_ONLY, 0xAA,
161         DATA_ONLY, 0xBB,
162         DATA_ONLY, 0x00,
163         DATA_ONLY, 0xAC,
164         DATA_ONLY, 0x00,
165         DATA_ONLY, 0xB3,
166         DATA_ONLY, 0xB1,
167         DATA_ONLY, 0xAA,
168         DATA_ONLY, 0xBC,
169         DATA_ONLY, 0x00,
170         DATA_ONLY, 0xB3,
171         ENDDEF, 0x00
172 };
173
174 static const unsigned short seq_gamma_ctrl[] = {
175         0xFB, 0x02,
176
177         DATA_ONLY, 0x5A,
178         ENDDEF, 0x00
179 };
180
181 static const unsigned short seq_gamma_start[] = {
182         0xF9, COMMAND_ONLY,
183
184         ENDDEF, 0x00
185 };
186
187 static const unsigned short seq_apon[] = {
188         0xF3, 0x00,
189
190         DATA_ONLY, 0x00,
191         DATA_ONLY, 0x00,
192         DATA_ONLY, 0x0A,
193         DATA_ONLY, 0x02,
194         ENDDEF, 0x00
195 };
196
197 static const unsigned short seq_display_ctrl[] = {
198         0xF2, 0x02,
199
200         DATA_ONLY, 0x08,
201         DATA_ONLY, 0x08,
202         DATA_ONLY, 0x10,
203         DATA_ONLY, 0x10,
204         ENDDEF, 0x00
205 };
206
207 static const unsigned short seq_manual_pwr[] = {
208         0xB0, 0x04,
209         ENDDEF, 0x00
210 };
211
212 static const unsigned short seq_pwr_ctrl[] = {
213         0xF4, 0x0A,
214
215         DATA_ONLY, 0x87,
216         DATA_ONLY, 0x25,
217         DATA_ONLY, 0x6A,
218         DATA_ONLY, 0x44,
219         DATA_ONLY, 0x02,
220         DATA_ONLY, 0x88,
221         ENDDEF, 0x00
222 };
223
224 static const unsigned short seq_sleep_out[] = {
225         0x11, COMMAND_ONLY,
226         ENDDEF, 0x00
227 };
228
229 static const unsigned short seq_sleep_in[] = {
230         0x10, COMMAND_ONLY,
231         ENDDEF, 0x00
232 };
233
234 static const unsigned short seq_display_on[] = {
235         0x29, COMMAND_ONLY,
236         ENDDEF, 0x00
237 };
238
239 static const unsigned short seq_display_off[] = {
240         0x28, COMMAND_ONLY,
241         ENDDEF, 0x00
242 };
243
244 static const unsigned short seq_vci1_1st_en[] = {
245         0xF3, 0x10,
246
247         DATA_ONLY, 0x00,
248         DATA_ONLY, 0x00,
249         DATA_ONLY, 0x00,
250         DATA_ONLY, 0x02,
251         ENDDEF, 0x00
252 };
253
254 static const unsigned short seq_vl1_en[] = {
255         0xF3, 0x11,
256
257         DATA_ONLY, 0x00,
258         DATA_ONLY, 0x00,
259         DATA_ONLY, 0x00,
260         DATA_ONLY, 0x02,
261         ENDDEF, 0x00
262 };
263
264 static const unsigned short seq_vl2_en[] = {
265         0xF3, 0x13,
266
267         DATA_ONLY, 0x00,
268         DATA_ONLY, 0x00,
269         DATA_ONLY, 0x00,
270         DATA_ONLY, 0x02,
271         ENDDEF, 0x00
272 };
273
274 static const unsigned short seq_vci1_2nd_en[] = {
275         0xF3, 0x33,
276
277         DATA_ONLY, 0x00,
278         DATA_ONLY, 0x00,
279         DATA_ONLY, 0x00,
280         DATA_ONLY, 0x02,
281         ENDDEF, 0x00
282 };
283
284 static const unsigned short seq_vl3_en[] = {
285         0xF3, 0x37,
286
287         DATA_ONLY, 0x00,
288         DATA_ONLY, 0x00,
289         DATA_ONLY, 0x00,
290         DATA_ONLY, 0x02,
291         ENDDEF, 0x00
292 };
293
294 static const unsigned short seq_vreg1_amp_en[] = {
295         0xF3, 0x37,
296
297         DATA_ONLY, 0x01,
298         DATA_ONLY, 0x00,
299         DATA_ONLY, 0x00,
300         DATA_ONLY, 0x02,
301         ENDDEF, 0x00
302 };
303
304 static const unsigned short seq_vgh_amp_en[] = {
305         0xF3, 0x37,
306
307         DATA_ONLY, 0x11,
308         DATA_ONLY, 0x00,
309         DATA_ONLY, 0x00,
310         DATA_ONLY, 0x02,
311         ENDDEF, 0x00
312 };
313
314 static const unsigned short seq_vgl_amp_en[] = {
315         0xF3, 0x37,
316
317         DATA_ONLY, 0x31,
318         DATA_ONLY, 0x00,
319         DATA_ONLY, 0x00,
320         DATA_ONLY, 0x02,
321         ENDDEF, 0x00
322 };
323
324 static const unsigned short seq_vmos_amp_en[] = {
325         0xF3, 0x37,
326
327         DATA_ONLY, 0xB1,
328         DATA_ONLY, 0x00,
329         DATA_ONLY, 0x00,
330         DATA_ONLY, 0x03,
331         ENDDEF, 0x00
332 };
333
334 static const unsigned short seq_vint_amp_en[] = {
335         0xF3, 0x37,
336
337         DATA_ONLY, 0xF1,
338         /* DATA_ONLY, 0x71,     VMOS/VBL/VBH not used */
339         DATA_ONLY, 0x00,
340         DATA_ONLY, 0x00,
341         DATA_ONLY, 0x03,
342         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
343         ENDDEF, 0x00
344 };
345
346 static const unsigned short seq_vbh_amp_en[] = {
347         0xF3, 0x37,
348
349         DATA_ONLY, 0xF9,
350         DATA_ONLY, 0x00,
351         DATA_ONLY, 0x00,
352         DATA_ONLY, 0x03,
353         ENDDEF, 0x00
354 };
355
356 static const unsigned short seq_vbl_amp_en[] = {
357         0xF3, 0x37,
358
359         DATA_ONLY, 0xFD,
360         DATA_ONLY, 0x00,
361         DATA_ONLY, 0x00,
362         DATA_ONLY, 0x03,
363         ENDDEF, 0x00
364 };
365
366 static const unsigned short seq_gam_amp_en[] = {
367         0xF3, 0x37,
368
369         DATA_ONLY, 0xFF,
370         /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
371         DATA_ONLY, 0x00,
372         DATA_ONLY, 0x00,
373         DATA_ONLY, 0x03,
374         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
375         ENDDEF, 0x00
376 };
377
378 static const unsigned short seq_sd_amp_en[] = {
379         0xF3, 0x37,
380
381         DATA_ONLY, 0xFF,
382         /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
383         DATA_ONLY, 0x80,
384         DATA_ONLY, 0x00,
385         DATA_ONLY, 0x03,
386         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
387         ENDDEF, 0x00
388 };
389
390 static const unsigned short seq_gls_en[] = {
391         0xF3, 0x37,
392
393         DATA_ONLY, 0xFF,
394         /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
395         DATA_ONLY, 0x81,
396         DATA_ONLY, 0x00,
397         DATA_ONLY, 0x03,
398         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
399         ENDDEF, 0x00
400 };
401
402 static const unsigned short seq_els_en[] = {
403         0xF3, 0x37,
404
405         DATA_ONLY, 0xFF,
406         /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
407         DATA_ONLY, 0x83,
408         DATA_ONLY, 0x00,
409         DATA_ONLY, 0x03,
410         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
411         ENDDEF, 0x00
412 };
413
414 static const unsigned short seq_el_on[] = {
415         0xF3, 0x37,
416
417         DATA_ONLY, 0xFF,
418         /* DATA_ONLY, 0x73,     VMOS/VBL/VBH not used */
419         DATA_ONLY, 0x87,
420         DATA_ONLY, 0x00,
421         DATA_ONLY, 0x03,
422         /* DATA_ONLY, 0x02,     VMOS/VBL/VBH not used */
423         ENDDEF, 0x00
424 };
425
426 static int ld9040_spi_write_byte(struct ld9040 *lcd, int addr, int data)
427 {
428         u16 buf[1];
429         struct spi_message msg;
430
431         struct spi_transfer xfer = {
432                 .len            = 2,
433                 .tx_buf         = buf,
434         };
435
436         buf[0] = (addr << 8) | data;
437
438         spi_message_init(&msg);
439         spi_message_add_tail(&xfer, &msg);
440
441         return spi_sync(lcd->spi, &msg);
442 }
443
444 static int ld9040_spi_write(struct ld9040 *lcd, unsigned char address,
445         unsigned char command)
446 {
447         int ret = 0;
448
449         if (address != DATA_ONLY)
450                 ret = ld9040_spi_write_byte(lcd, 0x0, address);
451         if (command != COMMAND_ONLY)
452                 ret = ld9040_spi_write_byte(lcd, 0x1, command);
453
454         return ret;
455 }
456
457 static int ld9040_panel_send_sequence(struct ld9040 *lcd,
458         const unsigned short *wbuf)
459 {
460         int ret = 0, i = 0;
461
462         while ((wbuf[i] & DEFMASK) != ENDDEF) {
463                 if ((wbuf[i] & DEFMASK) != SLEEPMSEC) {
464                         ret = ld9040_spi_write(lcd, wbuf[i], wbuf[i+1]);
465                         if (ret)
466                                 break;
467                 } else {
468                         msleep(wbuf[i+1]);
469                 }
470                 i += 2;
471         }
472
473         return ret;
474 }
475
476 static int _ld9040_gamma_ctl(struct ld9040 *lcd, const unsigned int *gamma)
477 {
478         unsigned int i = 0;
479         int ret = 0;
480
481         /* start gamma table updating. */
482         ret = ld9040_panel_send_sequence(lcd, seq_gamma_start);
483         if (ret) {
484                 dev_err(lcd->dev, "failed to disable gamma table updating.\n");
485                 goto gamma_err;
486         }
487
488         for (i = 0 ; i < GAMMA_TABLE_COUNT; i++) {
489                 ret = ld9040_spi_write(lcd, DATA_ONLY, gamma[i]);
490                 if (ret) {
491                         dev_err(lcd->dev, "failed to set gamma table.\n");
492                         goto gamma_err;
493                 }
494         }
495
496         /* update gamma table. */
497         ret = ld9040_panel_send_sequence(lcd, seq_gamma_ctrl);
498         if (ret)
499                 dev_err(lcd->dev, "failed to update gamma table.\n");
500
501 gamma_err:
502         return ret;
503 }
504
505 static int ld9040_gamma_ctl(struct ld9040 *lcd, int gamma)
506 {
507         return _ld9040_gamma_ctl(lcd, gamma_table.gamma_22_table[gamma]);
508 }
509
510 static int ld9040_ldi_init(struct ld9040 *lcd)
511 {
512         int ret, i;
513         static const unsigned short *init_seq[] = {
514                 seq_user_setting,
515                 seq_panel_condition,
516                 seq_display_ctrl,
517                 seq_manual_pwr,
518                 seq_elvss_on,
519                 seq_gtcon,
520                 seq_gamma_set1,
521                 seq_gamma_ctrl,
522                 seq_sleep_out,
523         };
524
525         for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
526                 ret = ld9040_panel_send_sequence(lcd, init_seq[i]);
527                 /* workaround: minimum delay time for transferring CMD */
528                 usleep_range(300, 310);
529                 if (ret)
530                         break;
531         }
532
533         return ret;
534 }
535
536 static int ld9040_ldi_enable(struct ld9040 *lcd)
537 {
538         return ld9040_panel_send_sequence(lcd, seq_display_on);
539 }
540
541 static int ld9040_ldi_disable(struct ld9040 *lcd)
542 {
543         int ret;
544
545         ret = ld9040_panel_send_sequence(lcd, seq_display_off);
546         ret = ld9040_panel_send_sequence(lcd, seq_sleep_in);
547
548         return ret;
549 }
550
551 static int ld9040_power_is_on(int power)
552 {
553         return power <= FB_BLANK_NORMAL;
554 }
555
556 static int ld9040_power_on(struct ld9040 *lcd)
557 {
558         int ret = 0;
559         struct lcd_platform_data *pd;
560
561         pd = lcd->lcd_pd;
562
563         /* lcd power on */
564         ld9040_regulator_enable(lcd);
565
566         if (!pd->reset) {
567                 dev_err(lcd->dev, "reset is NULL.\n");
568                 return -EINVAL;
569         } else {
570                 pd->reset(lcd->ld);
571                 msleep(pd->reset_delay);
572         }
573
574         ret = ld9040_ldi_init(lcd);
575         if (ret) {
576                 dev_err(lcd->dev, "failed to initialize ldi.\n");
577                 return ret;
578         }
579
580         ret = ld9040_ldi_enable(lcd);
581         if (ret) {
582                 dev_err(lcd->dev, "failed to enable ldi.\n");
583                 return ret;
584         }
585
586         return 0;
587 }
588
589 static int ld9040_power_off(struct ld9040 *lcd)
590 {
591         int ret;
592         struct lcd_platform_data *pd;
593
594         pd = lcd->lcd_pd;
595
596         ret = ld9040_ldi_disable(lcd);
597         if (ret) {
598                 dev_err(lcd->dev, "lcd setting failed.\n");
599                 return -EIO;
600         }
601
602         msleep(pd->power_off_delay);
603
604         /* lcd power off */
605         ld9040_regulator_disable(lcd);
606
607         return 0;
608 }
609
610 static int ld9040_power(struct ld9040 *lcd, int power)
611 {
612         int ret = 0;
613
614         if (ld9040_power_is_on(power) && !ld9040_power_is_on(lcd->power))
615                 ret = ld9040_power_on(lcd);
616         else if (!ld9040_power_is_on(power) && ld9040_power_is_on(lcd->power))
617                 ret = ld9040_power_off(lcd);
618
619         if (!ret)
620                 lcd->power = power;
621
622         return ret;
623 }
624
625 static int ld9040_set_power(struct lcd_device *ld, int power)
626 {
627         struct ld9040 *lcd = lcd_get_data(ld);
628
629         if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
630                 power != FB_BLANK_NORMAL) {
631                 dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
632                 return -EINVAL;
633         }
634
635         return ld9040_power(lcd, power);
636 }
637
638 static int ld9040_get_power(struct lcd_device *ld)
639 {
640         struct ld9040 *lcd = lcd_get_data(ld);
641
642         return lcd->power;
643 }
644
645 static int ld9040_get_brightness(struct backlight_device *bd)
646 {
647         return bd->props.brightness;
648 }
649
650 static int ld9040_set_brightness(struct backlight_device *bd)
651 {
652         int ret = 0, brightness = bd->props.brightness;
653         struct ld9040 *lcd = bl_get_data(bd);
654
655         if (brightness < MIN_BRIGHTNESS ||
656                 brightness > bd->props.max_brightness) {
657                 dev_err(&bd->dev, "lcd brightness should be %d to %d.\n",
658                         MIN_BRIGHTNESS, MAX_BRIGHTNESS);
659                 return -EINVAL;
660         }
661
662         ret = ld9040_gamma_ctl(lcd, bd->props.brightness);
663         if (ret) {
664                 dev_err(&bd->dev, "lcd brightness setting failed.\n");
665                 return -EIO;
666         }
667
668         return ret;
669 }
670
671 static struct lcd_ops ld9040_lcd_ops = {
672         .set_power = ld9040_set_power,
673         .get_power = ld9040_get_power,
674 };
675
676 static const struct backlight_ops ld9040_backlight_ops  = {
677         .get_brightness = ld9040_get_brightness,
678         .update_status = ld9040_set_brightness,
679 };
680
681 static int ld9040_probe(struct spi_device *spi)
682 {
683         int ret = 0;
684         struct ld9040 *lcd = NULL;
685         struct lcd_device *ld = NULL;
686         struct backlight_device *bd = NULL;
687         struct backlight_properties props;
688
689         lcd = devm_kzalloc(&spi->dev, sizeof(struct ld9040), GFP_KERNEL);
690         if (!lcd)
691                 return -ENOMEM;
692
693         /* ld9040 lcd panel uses 3-wire 9bits SPI Mode. */
694         spi->bits_per_word = 9;
695
696         ret = spi_setup(spi);
697         if (ret < 0) {
698                 dev_err(&spi->dev, "spi setup failed.\n");
699                 return ret;
700         }
701
702         lcd->spi = spi;
703         lcd->dev = &spi->dev;
704
705         lcd->lcd_pd = spi->dev.platform_data;
706         if (!lcd->lcd_pd) {
707                 dev_err(&spi->dev, "platform data is NULL.\n");
708                 return -EINVAL;
709         }
710
711         mutex_init(&lcd->lock);
712
713         ret = regulator_bulk_get(lcd->dev, ARRAY_SIZE(supplies), supplies);
714         if (ret) {
715                 dev_err(lcd->dev, "Failed to get regulators: %d\n", ret);
716                 return ret;
717         }
718
719         ld = lcd_device_register("ld9040", &spi->dev, lcd, &ld9040_lcd_ops);
720         if (IS_ERR(ld)) {
721                 ret = PTR_ERR(ld);
722                 goto out_free_regulator;
723         }
724
725         lcd->ld = ld;
726
727         memset(&props, 0, sizeof(struct backlight_properties));
728         props.type = BACKLIGHT_RAW;
729         props.max_brightness = MAX_BRIGHTNESS;
730
731         bd = backlight_device_register("ld9040-bl", &spi->dev,
732                 lcd, &ld9040_backlight_ops, &props);
733         if (IS_ERR(bd)) {
734                 ret = PTR_ERR(bd);
735                 goto out_unregister_lcd;
736         }
737
738         bd->props.brightness = MAX_BRIGHTNESS;
739         lcd->bd = bd;
740
741         /*
742          * if lcd panel was on from bootloader like u-boot then
743          * do not lcd on.
744          */
745         if (!lcd->lcd_pd->lcd_enabled) {
746                 /*
747                  * if lcd panel was off from bootloader then
748                  * current lcd status is powerdown and then
749                  * it enables lcd panel.
750                  */
751                 lcd->power = FB_BLANK_POWERDOWN;
752
753                 ld9040_power(lcd, FB_BLANK_UNBLANK);
754         } else {
755                 lcd->power = FB_BLANK_UNBLANK;
756         }
757
758         dev_set_drvdata(&spi->dev, lcd);
759
760         dev_info(&spi->dev, "ld9040 panel driver has been probed.\n");
761         return 0;
762
763 out_unregister_lcd:
764         lcd_device_unregister(lcd->ld);
765 out_free_regulator:
766         regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
767
768         return ret;
769 }
770
771 static int ld9040_remove(struct spi_device *spi)
772 {
773         struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
774
775         ld9040_power(lcd, FB_BLANK_POWERDOWN);
776         backlight_device_unregister(lcd->bd);
777         lcd_device_unregister(lcd->ld);
778         regulator_bulk_free(ARRAY_SIZE(supplies), supplies);
779
780         return 0;
781 }
782
783 #if defined(CONFIG_PM)
784 static int ld9040_suspend(struct spi_device *spi, pm_message_t mesg)
785 {
786         struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
787
788         dev_dbg(&spi->dev, "lcd->power = %d\n", lcd->power);
789
790         /*
791          * when lcd panel is suspend, lcd panel becomes off
792          * regardless of status.
793          */
794         return ld9040_power(lcd, FB_BLANK_POWERDOWN);
795 }
796
797 static int ld9040_resume(struct spi_device *spi)
798 {
799         struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
800
801         lcd->power = FB_BLANK_POWERDOWN;
802
803         return ld9040_power(lcd, FB_BLANK_UNBLANK);
804 }
805 #else
806 #define ld9040_suspend          NULL
807 #define ld9040_resume           NULL
808 #endif
809
810 /* Power down all displays on reboot, poweroff or halt. */
811 static void ld9040_shutdown(struct spi_device *spi)
812 {
813         struct ld9040 *lcd = dev_get_drvdata(&spi->dev);
814
815         ld9040_power(lcd, FB_BLANK_POWERDOWN);
816 }
817
818 static struct spi_driver ld9040_driver = {
819         .driver = {
820                 .name   = "ld9040",
821                 .owner  = THIS_MODULE,
822         },
823         .probe          = ld9040_probe,
824         .remove         = ld9040_remove,
825         .shutdown       = ld9040_shutdown,
826         .suspend        = ld9040_suspend,
827         .resume         = ld9040_resume,
828 };
829
830 module_spi_driver(ld9040_driver);
831
832 MODULE_AUTHOR("Donghwa Lee <dh09.lee@samsung.com>");
833 MODULE_DESCRIPTION("ld9040 LCD Driver");
834 MODULE_LICENSE("GPL");