This source file includes following definitions.
- lms501kf03_spi_write_byte
- lms501kf03_spi_write
- lms501kf03_panel_send_sequence
- lms501kf03_ldi_init
- lms501kf03_ldi_enable
- lms501kf03_ldi_disable
- lms501kf03_power_is_on
- lms501kf03_power_on
- lms501kf03_power_off
- lms501kf03_power
- lms501kf03_get_power
- lms501kf03_set_power
- lms501kf03_probe
- lms501kf03_remove
- lms501kf03_suspend
- lms501kf03_resume
- lms501kf03_shutdown
1
2
3
4
5
6
7
8
9 #include <linux/backlight.h>
10 #include <linux/delay.h>
11 #include <linux/fb.h>
12 #include <linux/gpio.h>
13 #include <linux/lcd.h>
14 #include <linux/module.h>
15 #include <linux/spi/spi.h>
16 #include <linux/wait.h>
17
18 #define COMMAND_ONLY 0x00
19 #define DATA_ONLY 0x01
20
21 struct lms501kf03 {
22 struct device *dev;
23 struct spi_device *spi;
24 unsigned int power;
25 struct lcd_device *ld;
26 struct lcd_platform_data *lcd_pd;
27 };
28
29 static const unsigned char seq_password[] = {
30 0xb9, 0xff, 0x83, 0x69,
31 };
32
33 static const unsigned char seq_power[] = {
34 0xb1, 0x01, 0x00, 0x34, 0x06, 0x00, 0x14, 0x14, 0x20, 0x28,
35 0x12, 0x12, 0x17, 0x0a, 0x01, 0xe6, 0xe6, 0xe6, 0xe6, 0xe6,
36 };
37
38 static const unsigned char seq_display[] = {
39 0xb2, 0x00, 0x2b, 0x03, 0x03, 0x70, 0x00, 0xff, 0x00, 0x00,
40 0x00, 0x00, 0x03, 0x03, 0x00, 0x01,
41 };
42
43 static const unsigned char seq_rgb_if[] = {
44 0xb3, 0x09,
45 };
46
47 static const unsigned char seq_display_inv[] = {
48 0xb4, 0x01, 0x08, 0x77, 0x0e, 0x06,
49 };
50
51 static const unsigned char seq_vcom[] = {
52 0xb6, 0x4c, 0x2e,
53 };
54
55 static const unsigned char seq_gate[] = {
56 0xd5, 0x00, 0x05, 0x03, 0x29, 0x01, 0x07, 0x17, 0x68, 0x13,
57 0x37, 0x20, 0x31, 0x8a, 0x46, 0x9b, 0x57, 0x13, 0x02, 0x75,
58 0xb9, 0x64, 0xa8, 0x07, 0x0f, 0x04, 0x07,
59 };
60
61 static const unsigned char seq_panel[] = {
62 0xcc, 0x02,
63 };
64
65 static const unsigned char seq_col_mod[] = {
66 0x3a, 0x77,
67 };
68
69 static const unsigned char seq_w_gamma[] = {
70 0xe0, 0x00, 0x04, 0x09, 0x0f, 0x1f, 0x3f, 0x1f, 0x2f, 0x0a,
71 0x0f, 0x10, 0x16, 0x18, 0x16, 0x17, 0x0d, 0x15, 0x00, 0x04,
72 0x09, 0x0f, 0x38, 0x3f, 0x20, 0x39, 0x0a, 0x0f, 0x10, 0x16,
73 0x18, 0x16, 0x17, 0x0d, 0x15,
74 };
75
76 static const unsigned char seq_rgb_gamma[] = {
77 0xc1, 0x01, 0x03, 0x07, 0x0f, 0x1a, 0x22, 0x2c, 0x33, 0x3c,
78 0x46, 0x4f, 0x58, 0x60, 0x69, 0x71, 0x79, 0x82, 0x89, 0x92,
79 0x9a, 0xa1, 0xa9, 0xb1, 0xb9, 0xc1, 0xc9, 0xcf, 0xd6, 0xde,
80 0xe5, 0xec, 0xf3, 0xf9, 0xff, 0xdd, 0x39, 0x07, 0x1c, 0xcb,
81 0xab, 0x5f, 0x49, 0x80, 0x03, 0x07, 0x0f, 0x19, 0x20, 0x2a,
82 0x31, 0x39, 0x42, 0x4b, 0x53, 0x5b, 0x63, 0x6b, 0x73, 0x7b,
83 0x83, 0x8a, 0x92, 0x9b, 0xa2, 0xaa, 0xb2, 0xba, 0xc2, 0xca,
84 0xd0, 0xd8, 0xe1, 0xe8, 0xf0, 0xf8, 0xff, 0xf7, 0xd8, 0xbe,
85 0xa7, 0x39, 0x40, 0x85, 0x8c, 0xc0, 0x04, 0x07, 0x0c, 0x17,
86 0x1c, 0x23, 0x2b, 0x34, 0x3b, 0x43, 0x4c, 0x54, 0x5b, 0x63,
87 0x6a, 0x73, 0x7a, 0x82, 0x8a, 0x91, 0x98, 0xa1, 0xa8, 0xb0,
88 0xb7, 0xc1, 0xc9, 0xcf, 0xd9, 0xe3, 0xea, 0xf4, 0xff, 0x00,
89 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
90 };
91
92 static const unsigned char seq_up_dn[] = {
93 0x36, 0x10,
94 };
95
96 static const unsigned char seq_sleep_in[] = {
97 0x10,
98 };
99
100 static const unsigned char seq_sleep_out[] = {
101 0x11,
102 };
103
104 static const unsigned char seq_display_on[] = {
105 0x29,
106 };
107
108 static const unsigned char seq_display_off[] = {
109 0x10,
110 };
111
112 static int lms501kf03_spi_write_byte(struct lms501kf03 *lcd, int addr, int data)
113 {
114 u16 buf[1];
115 struct spi_message msg;
116
117 struct spi_transfer xfer = {
118 .len = 2,
119 .tx_buf = buf,
120 };
121
122 buf[0] = (addr << 8) | data;
123
124 spi_message_init(&msg);
125 spi_message_add_tail(&xfer, &msg);
126
127 return spi_sync(lcd->spi, &msg);
128 }
129
130 static int lms501kf03_spi_write(struct lms501kf03 *lcd, unsigned char address,
131 unsigned char command)
132 {
133 return lms501kf03_spi_write_byte(lcd, address, command);
134 }
135
136 static int lms501kf03_panel_send_sequence(struct lms501kf03 *lcd,
137 const unsigned char *wbuf,
138 unsigned int len)
139 {
140 int ret = 0, i = 0;
141
142 while (i < len) {
143 if (i == 0)
144 ret = lms501kf03_spi_write(lcd, COMMAND_ONLY, wbuf[i]);
145 else
146 ret = lms501kf03_spi_write(lcd, DATA_ONLY, wbuf[i]);
147 if (ret)
148 break;
149 i += 1;
150 }
151
152 return ret;
153 }
154
155 static int lms501kf03_ldi_init(struct lms501kf03 *lcd)
156 {
157 int ret, i;
158 static const unsigned char *init_seq[] = {
159 seq_password,
160 seq_power,
161 seq_display,
162 seq_rgb_if,
163 seq_display_inv,
164 seq_vcom,
165 seq_gate,
166 seq_panel,
167 seq_col_mod,
168 seq_w_gamma,
169 seq_rgb_gamma,
170 seq_sleep_out,
171 };
172
173 static const unsigned int size_seq[] = {
174 ARRAY_SIZE(seq_password),
175 ARRAY_SIZE(seq_power),
176 ARRAY_SIZE(seq_display),
177 ARRAY_SIZE(seq_rgb_if),
178 ARRAY_SIZE(seq_display_inv),
179 ARRAY_SIZE(seq_vcom),
180 ARRAY_SIZE(seq_gate),
181 ARRAY_SIZE(seq_panel),
182 ARRAY_SIZE(seq_col_mod),
183 ARRAY_SIZE(seq_w_gamma),
184 ARRAY_SIZE(seq_rgb_gamma),
185 ARRAY_SIZE(seq_sleep_out),
186 };
187
188 for (i = 0; i < ARRAY_SIZE(init_seq); i++) {
189 ret = lms501kf03_panel_send_sequence(lcd, init_seq[i],
190 size_seq[i]);
191 if (ret)
192 break;
193 }
194
195
196
197
198
199 msleep(120);
200
201 return ret;
202 }
203
204 static int lms501kf03_ldi_enable(struct lms501kf03 *lcd)
205 {
206 return lms501kf03_panel_send_sequence(lcd, seq_display_on,
207 ARRAY_SIZE(seq_display_on));
208 }
209
210 static int lms501kf03_ldi_disable(struct lms501kf03 *lcd)
211 {
212 return lms501kf03_panel_send_sequence(lcd, seq_display_off,
213 ARRAY_SIZE(seq_display_off));
214 }
215
216 static int lms501kf03_power_is_on(int power)
217 {
218 return (power) <= FB_BLANK_NORMAL;
219 }
220
221 static int lms501kf03_power_on(struct lms501kf03 *lcd)
222 {
223 int ret = 0;
224 struct lcd_platform_data *pd;
225
226 pd = lcd->lcd_pd;
227
228 if (!pd->power_on) {
229 dev_err(lcd->dev, "power_on is NULL.\n");
230 return -EINVAL;
231 }
232
233 pd->power_on(lcd->ld, 1);
234 msleep(pd->power_on_delay);
235
236 if (!pd->reset) {
237 dev_err(lcd->dev, "reset is NULL.\n");
238 return -EINVAL;
239 }
240
241 pd->reset(lcd->ld);
242 msleep(pd->reset_delay);
243
244 ret = lms501kf03_ldi_init(lcd);
245 if (ret) {
246 dev_err(lcd->dev, "failed to initialize ldi.\n");
247 return ret;
248 }
249
250 ret = lms501kf03_ldi_enable(lcd);
251 if (ret) {
252 dev_err(lcd->dev, "failed to enable ldi.\n");
253 return ret;
254 }
255
256 return 0;
257 }
258
259 static int lms501kf03_power_off(struct lms501kf03 *lcd)
260 {
261 int ret = 0;
262 struct lcd_platform_data *pd;
263
264 pd = lcd->lcd_pd;
265
266 ret = lms501kf03_ldi_disable(lcd);
267 if (ret) {
268 dev_err(lcd->dev, "lcd setting failed.\n");
269 return -EIO;
270 }
271
272 msleep(pd->power_off_delay);
273
274 pd->power_on(lcd->ld, 0);
275
276 return 0;
277 }
278
279 static int lms501kf03_power(struct lms501kf03 *lcd, int power)
280 {
281 int ret = 0;
282
283 if (lms501kf03_power_is_on(power) &&
284 !lms501kf03_power_is_on(lcd->power))
285 ret = lms501kf03_power_on(lcd);
286 else if (!lms501kf03_power_is_on(power) &&
287 lms501kf03_power_is_on(lcd->power))
288 ret = lms501kf03_power_off(lcd);
289
290 if (!ret)
291 lcd->power = power;
292
293 return ret;
294 }
295
296 static int lms501kf03_get_power(struct lcd_device *ld)
297 {
298 struct lms501kf03 *lcd = lcd_get_data(ld);
299
300 return lcd->power;
301 }
302
303 static int lms501kf03_set_power(struct lcd_device *ld, int power)
304 {
305 struct lms501kf03 *lcd = lcd_get_data(ld);
306
307 if (power != FB_BLANK_UNBLANK && power != FB_BLANK_POWERDOWN &&
308 power != FB_BLANK_NORMAL) {
309 dev_err(lcd->dev, "power value should be 0, 1 or 4.\n");
310 return -EINVAL;
311 }
312
313 return lms501kf03_power(lcd, power);
314 }
315
316 static struct lcd_ops lms501kf03_lcd_ops = {
317 .get_power = lms501kf03_get_power,
318 .set_power = lms501kf03_set_power,
319 };
320
321 static int lms501kf03_probe(struct spi_device *spi)
322 {
323 struct lms501kf03 *lcd = NULL;
324 struct lcd_device *ld = NULL;
325 int ret = 0;
326
327 lcd = devm_kzalloc(&spi->dev, sizeof(struct lms501kf03), GFP_KERNEL);
328 if (!lcd)
329 return -ENOMEM;
330
331
332 spi->bits_per_word = 9;
333
334 ret = spi_setup(spi);
335 if (ret < 0) {
336 dev_err(&spi->dev, "spi setup failed.\n");
337 return ret;
338 }
339
340 lcd->spi = spi;
341 lcd->dev = &spi->dev;
342
343 lcd->lcd_pd = dev_get_platdata(&spi->dev);
344 if (!lcd->lcd_pd) {
345 dev_err(&spi->dev, "platform data is NULL\n");
346 return -EINVAL;
347 }
348
349 ld = devm_lcd_device_register(&spi->dev, "lms501kf03", &spi->dev, lcd,
350 &lms501kf03_lcd_ops);
351 if (IS_ERR(ld))
352 return PTR_ERR(ld);
353
354 lcd->ld = ld;
355
356 if (!lcd->lcd_pd->lcd_enabled) {
357
358
359
360
361
362 lcd->power = FB_BLANK_POWERDOWN;
363
364 lms501kf03_power(lcd, FB_BLANK_UNBLANK);
365 } else {
366 lcd->power = FB_BLANK_UNBLANK;
367 }
368
369 spi_set_drvdata(spi, lcd);
370
371 dev_info(&spi->dev, "lms501kf03 panel driver has been probed.\n");
372
373 return 0;
374 }
375
376 static int lms501kf03_remove(struct spi_device *spi)
377 {
378 struct lms501kf03 *lcd = spi_get_drvdata(spi);
379
380 lms501kf03_power(lcd, FB_BLANK_POWERDOWN);
381 return 0;
382 }
383
384 #ifdef CONFIG_PM_SLEEP
385 static int lms501kf03_suspend(struct device *dev)
386 {
387 struct lms501kf03 *lcd = dev_get_drvdata(dev);
388
389 dev_dbg(dev, "lcd->power = %d\n", lcd->power);
390
391
392
393
394
395 return lms501kf03_power(lcd, FB_BLANK_POWERDOWN);
396 }
397
398 static int lms501kf03_resume(struct device *dev)
399 {
400 struct lms501kf03 *lcd = dev_get_drvdata(dev);
401
402 lcd->power = FB_BLANK_POWERDOWN;
403
404 return lms501kf03_power(lcd, FB_BLANK_UNBLANK);
405 }
406 #endif
407
408 static SIMPLE_DEV_PM_OPS(lms501kf03_pm_ops, lms501kf03_suspend,
409 lms501kf03_resume);
410
411 static void lms501kf03_shutdown(struct spi_device *spi)
412 {
413 struct lms501kf03 *lcd = spi_get_drvdata(spi);
414
415 lms501kf03_power(lcd, FB_BLANK_POWERDOWN);
416 }
417
418 static struct spi_driver lms501kf03_driver = {
419 .driver = {
420 .name = "lms501kf03",
421 .pm = &lms501kf03_pm_ops,
422 },
423 .probe = lms501kf03_probe,
424 .remove = lms501kf03_remove,
425 .shutdown = lms501kf03_shutdown,
426 };
427
428 module_spi_driver(lms501kf03_driver);
429
430 MODULE_AUTHOR("Jingoo Han <jg1.han@samsung.com>");
431 MODULE_DESCRIPTION("lms501kf03 LCD Driver");
432 MODULE_LICENSE("GPL");