91651e7ea5f72ba0da8d01a33225ba2eadc79d4d
[kernel.git] / drivers / video / backlight / jbt6k74.c
1 /* Linux kernel driver for the tpo JBT6K74-AS LCM ASIC
2  *
3  * Copyright (C) 2006-2007 by Openmoko, Inc.
4  * Author: Harald Welte <laforge@openmoko.org>,
5  *         Stefan Schmidt <stefan@openmoko.org>
6  * Copyright (C) 2008 by Harald Welte <laforge@openmoko.org>
7  * Copyright (C) 2009 by Lars-Peter Clausen <lars@metafoo.de>
8  * All rights reserved.
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License as
12  * published by the Free Software Foundation; either version 2 of
13  * the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
23  * MA 02111-1307 USA
24  *
25  */
26
27 #include <linux/kernel.h>
28 #include <linux/types.h>
29 #include <linux/module.h>
30 #include <linux/device.h>
31 #include <linux/platform_device.h>
32 #include <linux/delay.h>
33 #include <linux/workqueue.h>
34 #include <linux/jbt6k74.h>
35 #include <linux/fb.h>
36 #include <linux/lcd.h>
37 #include <linux/time.h>
38 #include <linux/regulator/consumer.h>
39 #include <linux/gpio.h>
40
41 enum jbt_register {
42         JBT_REG_SLEEP_IN                = 0x10,
43         JBT_REG_SLEEP_OUT               = 0x11,
44
45         JBT_REG_DISPLAY_OFF             = 0x28,
46         JBT_REG_DISPLAY_ON              = 0x29,
47
48         JBT_REG_RGB_FORMAT              = 0x3a,
49         JBT_REG_QUAD_RATE               = 0x3b,
50
51         JBT_REG_POWER_ON_OFF            = 0xb0,
52         JBT_REG_BOOSTER_OP              = 0xb1,
53         JBT_REG_BOOSTER_MODE            = 0xb2,
54         JBT_REG_BOOSTER_FREQ            = 0xb3,
55         JBT_REG_OPAMP_SYSCLK            = 0xb4,
56         JBT_REG_VSC_VOLTAGE             = 0xb5,
57         JBT_REG_VCOM_VOLTAGE            = 0xb6,
58         JBT_REG_EXT_DISPL               = 0xb7,
59         JBT_REG_OUTPUT_CONTROL          = 0xb8,
60         JBT_REG_DCCLK_DCEV              = 0xb9,
61         JBT_REG_DISPLAY_MODE1           = 0xba,
62         JBT_REG_DISPLAY_MODE2           = 0xbb,
63         JBT_REG_DISPLAY_MODE            = 0xbc,
64         JBT_REG_ASW_SLEW                = 0xbd,
65         JBT_REG_DUMMY_DISPLAY           = 0xbe,
66         JBT_REG_DRIVE_SYSTEM            = 0xbf,
67
68         JBT_REG_SLEEP_OUT_FR_A          = 0xc0,
69         JBT_REG_SLEEP_OUT_FR_B          = 0xc1,
70         JBT_REG_SLEEP_OUT_FR_C          = 0xc2,
71         JBT_REG_SLEEP_IN_LCCNT_D        = 0xc3,
72         JBT_REG_SLEEP_IN_LCCNT_E        = 0xc4,
73         JBT_REG_SLEEP_IN_LCCNT_F        = 0xc5,
74         JBT_REG_SLEEP_IN_LCCNT_G        = 0xc6,
75
76         JBT_REG_GAMMA1_FINE_1           = 0xc7,
77         JBT_REG_GAMMA1_FINE_2           = 0xc8,
78         JBT_REG_GAMMA1_INCLINATION      = 0xc9,
79         JBT_REG_GAMMA1_BLUE_OFFSET      = 0xca,
80
81         /* VGA */
82         JBT_REG_BLANK_CONTROL           = 0xcf,
83         JBT_REG_BLANK_TH_TV             = 0xd0,
84         JBT_REG_CKV_ON_OFF              = 0xd1,
85         JBT_REG_CKV_1_2                 = 0xd2,
86         JBT_REG_OEV_TIMING              = 0xd3,
87         JBT_REG_ASW_TIMING_1            = 0xd4,
88         JBT_REG_ASW_TIMING_2            = 0xd5,
89
90         /* QVGA */
91         JBT_REG_BLANK_CONTROL_QVGA      = 0xd6,
92         JBT_REG_BLANK_TH_TV_QVGA        = 0xd7,
93         JBT_REG_CKV_ON_OFF_QVGA         = 0xd8,
94         JBT_REG_CKV_1_2_QVGA            = 0xd9,
95         JBT_REG_OEV_TIMING_QVGA         = 0xde,
96         JBT_REG_ASW_TIMING_1_QVGA       = 0xdf,
97         JBT_REG_ASW_TIMING_2_QVGA       = 0xe0,
98
99
100         JBT_REG_HCLOCK_VGA              = 0xec,
101         JBT_REG_HCLOCK_QVGA             = 0xed,
102 };
103
104
105 static const char *jbt_power_mode_names[] = {
106         [JBT_POWER_MODE_OFF]            = "off",
107         [JBT_POWER_MODE_STANDBY]        = "standby",
108         [JBT_POWER_MODE_NORMAL]         = "normal",
109 };
110
111 static const char *jbt_resolution_names[] = {
112         [JBT_RESOLUTION_VGA] = "vga",
113         [JBT_RESOLUTION_QVGA] = "qvga",
114 };
115
116
117 struct jbt_info {
118         struct mutex lock;              /* protects this structure */
119         enum jbt_resolution resolution;
120         enum jbt_power_mode power_mode;
121         enum jbt_power_mode suspend_mode;
122         int suspended;
123
124         struct spi_device *spi;
125         struct lcd_device *lcd_dev;
126
127         unsigned long next_sleep;
128         struct delayed_work blank_work;
129         int blank_mode;
130         struct regulator_bulk_data supplies[2];
131         uint16_t tx_buf[3];
132         uint16_t reg_cache[0xEE];
133 };
134
135 struct jbt_info *jbt_global;
136
137 #define JBT_COMMAND     0x000
138 #define JBT_DATA        0x100
139
140 static int jbt_reg_write_nodata(struct jbt_info *jbt, uint8_t reg)
141 {
142         int ret;
143
144         jbt->tx_buf[0] = JBT_COMMAND | reg;
145         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
146                                         sizeof(uint16_t));
147         if (ret == 0)
148                 jbt->reg_cache[reg] = 0;
149         else
150                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
151
152         mdelay(1);
153
154         return ret;
155 }
156
157
158 static int jbt_reg_write(struct jbt_info *jbt, uint8_t reg, uint8_t data)
159 {
160         int ret;
161
162         jbt->tx_buf[0] = JBT_COMMAND | reg;
163         jbt->tx_buf[1] = JBT_DATA | data;
164         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
165                         2*sizeof(uint16_t));
166         if (ret == 0)
167                 jbt->reg_cache[reg] = data;
168         else
169                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
170
171         mdelay(1);
172
173         return ret;
174 }
175
176 static int jbt_reg_write16(struct jbt_info *jbt, uint8_t reg, uint16_t data)
177 {
178         int ret;
179
180         jbt->tx_buf[0] = JBT_COMMAND | reg;
181         jbt->tx_buf[1] = JBT_DATA | (data >> 8);
182         jbt->tx_buf[2] = JBT_DATA | (data & 0xff);
183
184         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
185                         3*sizeof(uint16_t));
186         if (ret == 0)
187                 jbt->reg_cache[reg] = data;
188         else
189                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
190
191         mdelay(1);
192
193         return ret;
194 }
195
196 static int jbt_init_regs(struct jbt_info *jbt)
197 {
198         int ret;
199
200         dev_dbg(&jbt->spi->dev, "entering %cVGA mode\n",
201                         jbt->resolution == JBT_RESOLUTION_QVGA ? 'Q' : ' ');
202
203         ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE1, 0x01);
204         ret |= jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE2, 0x00);
205         ret |= jbt_reg_write(jbt, JBT_REG_RGB_FORMAT, 0x60);
206         ret |= jbt_reg_write(jbt, JBT_REG_DRIVE_SYSTEM, 0x10);
207         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_OP, 0x56);
208         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_MODE, 0x33);
209         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_FREQ, 0x11);
210         ret |= jbt_reg_write(jbt, JBT_REG_OPAMP_SYSCLK, 0x02);
211         ret |= jbt_reg_write(jbt, JBT_REG_VSC_VOLTAGE, 0x2b);
212         ret |= jbt_reg_write(jbt, JBT_REG_VCOM_VOLTAGE, 0x40);
213         ret |= jbt_reg_write(jbt, JBT_REG_EXT_DISPL, 0x03);
214         ret |= jbt_reg_write(jbt, JBT_REG_DCCLK_DCEV, 0x04);
215         /*
216          * default of 0x02 in JBT_REG_ASW_SLEW responsible for 72Hz requirement
217          * to avoid red / blue flicker
218          */
219         ret |= jbt_reg_write(jbt, JBT_REG_ASW_SLEW, 0x00 | (1 << 5));
220         ret |= jbt_reg_write(jbt, JBT_REG_DUMMY_DISPLAY, 0xff);
221
222         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_A, 0x11);
223         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_B, 0x11);
224         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_C, 0x11);
225         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_D, 0x2040);
226         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_E, 0x60c0);
227         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_F, 0x1020);
228         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_G, 0x60c0);
229
230         ret |= jbt_reg_write16(jbt, JBT_REG_GAMMA1_FINE_1, 0x5533);
231         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_FINE_2, 0x00);
232         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_INCLINATION, 0x00);
233         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_BLUE_OFFSET, 0x00);
234
235         if (jbt->resolution != JBT_RESOLUTION_QVGA) {
236                 ret |= jbt_reg_write16(jbt, JBT_REG_HCLOCK_VGA, 0x1f0);
237                 ret |= jbt_reg_write(jbt, JBT_REG_BLANK_CONTROL, 0x02);
238                 ret |= jbt_reg_write16(jbt, JBT_REG_BLANK_TH_TV, 0x0804);
239
240                 ret |= jbt_reg_write(jbt, JBT_REG_CKV_ON_OFF, 0x01);
241                 ret |= jbt_reg_write16(jbt, JBT_REG_CKV_1_2, 0x0000);
242
243                 ret |= jbt_reg_write16(jbt, JBT_REG_OEV_TIMING, 0x0d0e);
244                 ret |= jbt_reg_write16(jbt, JBT_REG_ASW_TIMING_1, 0x11a4);
245                 ret |= jbt_reg_write(jbt, JBT_REG_ASW_TIMING_2, 0x0e);
246         } else {
247                 ret |= jbt_reg_write16(jbt, JBT_REG_HCLOCK_QVGA, 0x00ff);
248                 ret |= jbt_reg_write(jbt, JBT_REG_BLANK_CONTROL_QVGA, 0x02);
249                 ret |= jbt_reg_write16(jbt, JBT_REG_BLANK_TH_TV_QVGA, 0x0804);
250
251                 ret |= jbt_reg_write(jbt, JBT_REG_CKV_ON_OFF_QVGA, 0x01);
252                 ret |= jbt_reg_write16(jbt, JBT_REG_CKV_1_2_QVGA, 0x0008);
253
254                 ret |= jbt_reg_write16(jbt, JBT_REG_OEV_TIMING_QVGA, 0x050a);
255                 ret |= jbt_reg_write16(jbt, JBT_REG_ASW_TIMING_1_QVGA, 0x0a19);
256                 ret |= jbt_reg_write(jbt, JBT_REG_ASW_TIMING_2_QVGA, 0x0a);
257         }
258
259         return ret ? -EIO : 0;
260 }
261
262
263 static int jbt_off_to_normal(struct jbt_info *jbt)
264 {
265         int ret;
266
267         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
268
269         gpio_set_value_cansleep(pdata->gpio_reset, 1);
270         ret = regulator_bulk_enable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
271
272         mdelay(120);
273
274         /* three times command zero */
275         ret |= jbt_reg_write_nodata(jbt, 0x00);
276         mdelay(1);
277         ret |= jbt_reg_write_nodata(jbt, 0x00);
278         mdelay(1);
279         ret |= jbt_reg_write_nodata(jbt, 0x00);
280         mdelay(1);
281
282         /* deep standby out */
283         ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x11);
284         mdelay(1);
285         ret |= jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
286
287         /* (re)initialize register set */
288         ret |= jbt_init_regs(jbt);
289
290         /* Make sure we are 120 ms after SLEEP_OUT */
291         if (time_before(jiffies, jbt->next_sleep))
292                 mdelay(jiffies_to_msecs(jbt->next_sleep - jiffies));
293
294         if (jbt->resolution == JBT_RESOLUTION_VGA) {
295                 /* RGB I/F on, RAM wirte off, QVGA through, SIGCON enable */
296                 ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x80);
297
298                 /* Quad mode off */
299                 ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x00);
300         } else {
301                 /* RGB I/F on, RAM wirte off, QVGA through, SIGCON enable */
302                 ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x81);
303
304                 /* Quad mode on */
305                 ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x22);
306         }
307
308         /* AVDD on, XVDD on */
309         ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x16);
310
311         /* Output control */
312         ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0xdff9);
313
314         /* Turn on display */
315         ret |= jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_ON);
316
317         /* Sleep mode off */
318         ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_OUT);
319
320         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
321
322         /* Allow the booster and display controller to restart stably */
323         mdelay(5);
324
325         return ret ? -EIO : 0;
326 }
327
328 static int jbt_normal_to_off(struct jbt_info *jbt)
329 {
330         int ret;
331         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
332
333         /* Pull the plug! */
334         ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies),
335                                      jbt->supplies);
336
337         if (!ret)
338                 gpio_set_value_cansleep(pdata->gpio_reset, 0);
339
340         return ret ? -EIO : 0;
341 }
342
343
344 static int jbt_normal_to_standby(struct jbt_info *jbt)
345 {
346         int ret;
347
348         if ( jbt->power_mode != JBT_POWER_MODE_NORMAL ) return 0;
349
350         /* Make sure we are 120 ms after SLEEP_{IN,OUT} */
351         while (time_before(jiffies, jbt->next_sleep)) cpu_relax();
352
353         /* Sleep mode on */
354         ret = jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_OFF);
355         ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0x8000 | 1 << 3);
356
357         ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_IN);
358         jbt->next_sleep = jiffies + msecs_to_jiffies(150);
359
360         jbt->power_mode = JBT_POWER_MODE_STANDBY;
361
362         return ret ? -EIO : 0;
363 }
364
365
366 static int jbt_standby_to_normal(struct jbt_info *jbt)
367 {
368         int ret;
369
370         if ( jbt->power_mode != JBT_POWER_MODE_STANDBY ) return 0;
371
372         /* Make sure we are 120 ms after SLEEP_{IN,OUT} */
373         while (time_before(jiffies, jbt->next_sleep)) cpu_relax();
374
375         ret = jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_OUT);
376         jbt->next_sleep = jiffies + msecs_to_jiffies(150);
377
378         ret |= jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_ON);
379         ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0xdff9);
380
381         jbt->power_mode = JBT_POWER_MODE_NORMAL;
382
383         return ret ? -EIO : 0;
384 }
385
386
387 static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
388                                         enum jbt_power_mode new_mode)
389 {
390         int ret = -EINVAL;
391
392         dev_dbg(&jbt->spi->dev, "entering (old_state=%s, new_state=%s)\n",
393                         jbt_power_mode_names[jbt->power_mode],
394                         jbt_power_mode_names[new_mode]);
395
396         mutex_lock(&jbt->lock);
397
398         switch (jbt->power_mode) {
399         case JBT_POWER_MODE_OFF:
400                 switch (new_mode) {
401                 case JBT_POWER_MODE_OFF:
402                         ret = 0;
403                         break;
404                 case JBT_POWER_MODE_NORMAL:
405                         ret = jbt_off_to_normal(jbt);
406                         break;
407                 case JBT_POWER_MODE_STANDBY:
408                         ret = -EINVAL;
409                         break;
410                 }
411                 break;
412         case JBT_POWER_MODE_NORMAL:
413                 switch (new_mode) {
414                 case JBT_POWER_MODE_NORMAL:
415                         ret = 0;
416                         break;
417                 case JBT_POWER_MODE_OFF:
418                         ret = jbt_normal_to_off(jbt);
419                         break;
420                 case JBT_POWER_MODE_STANDBY:
421                         ret = -EINVAL;
422                         break;
423                 }
424                 break;
425         case JBT_POWER_MODE_STANDBY:
426                 ret = -EINVAL;
427                 break;
428         }
429
430         if (ret == 0) {
431                 jbt->power_mode = new_mode;
432         } else {
433                 dev_err(&jbt->spi->dev, "Failed to enter state '%s': %d\n",
434                                 jbt_power_mode_names[new_mode], ret);
435         }
436
437         mutex_unlock(&jbt->lock);
438
439         return ret;
440 }
441
442 static int jbt6k74_set_resolution(struct jbt_info *jbt,
443                                         enum jbt_resolution new_resolution)
444 {
445         int old_resolution;
446         int ret = 0;
447
448         if ( !jbt ) return -1;
449
450         mutex_lock(&jbt->lock);
451
452         if ( jbt->resolution == new_resolution ) goto out_unlock;
453         if ( jbt->power_mode == JBT_POWER_MODE_OFF ) goto out_unlock;
454
455         old_resolution = jbt->resolution;
456         jbt->resolution = new_resolution;
457
458         if ( jbt->power_mode == JBT_POWER_MODE_NORMAL ) {
459
460                 ret = jbt_normal_to_standby(jbt);
461
462                 mdelay(25);
463
464                 if (jbt->resolution == JBT_RESOLUTION_VGA) {
465                         /* Quad mode off */
466                         ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x00);
467                         ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x80);
468                 } else {
469                         /* Quad mode on */
470                         ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x22);
471                         ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x81);
472                 }
473
474                 mdelay(25);
475
476                 ret |= jbt_standby_to_normal(jbt);
477
478                 if (ret) {
479                         jbt->resolution = old_resolution;
480                         dev_err(&jbt->spi->dev,
481                                 "Failed to set resolution '%s')\n",
482                                 jbt_resolution_names[new_resolution]);
483                 }
484
485         }
486
487 out_unlock:
488         mutex_unlock(&jbt->lock);
489
490         return ret;
491 }
492
493 static ssize_t resolution_read(struct device *dev,
494                                 struct device_attribute *attr, char *buf)
495 {
496         struct jbt_info *jbt = dev_get_drvdata(dev);
497
498         if (jbt->resolution >= ARRAY_SIZE(jbt_resolution_names))
499                 return -EIO;
500
501         return sprintf(buf, "%s\n", jbt_resolution_names[jbt->resolution]);
502 }
503
504 static ssize_t resolution_write(struct device *dev,
505                                 struct device_attribute *attr,
506                                 const char *buf, size_t count)
507 {
508         struct jbt_info *jbt = dev_get_drvdata(dev);
509         int i, ret;
510
511         for (i = 0; i < ARRAY_SIZE(jbt_resolution_names); i++) {
512                 if (!strncmp(buf, jbt_resolution_names[i],
513                         strlen(jbt_resolution_names[i]))) {
514                         ret = jbt6k74_set_resolution(jbt, i);
515                         if (ret)
516                                 return ret;
517                         return count;
518                 }
519         }
520
521         return -EINVAL;
522 }
523
524 static DEVICE_ATTR(resolution, 0644, resolution_read, resolution_write);
525
526 static int reg_by_string(const char *name)
527 {
528         if (!strcmp(name, "gamma_fine1"))
529                 return JBT_REG_GAMMA1_FINE_1;
530         else if (!strcmp(name, "gamma_fine2"))
531                 return JBT_REG_GAMMA1_FINE_2;
532         else if (!strcmp(name, "gamma_inclination"))
533                 return JBT_REG_GAMMA1_INCLINATION;
534         else
535                 return JBT_REG_GAMMA1_BLUE_OFFSET;
536 }
537
538 static ssize_t gamma_read(struct device *dev, struct device_attribute *attr,
539                           char *buf)
540 {
541         struct jbt_info *jbt = dev_get_drvdata(dev);
542         int reg = reg_by_string(attr->attr.name);
543         uint16_t val;
544
545         mutex_lock(&jbt->lock);
546         val = jbt->reg_cache[reg];
547         mutex_unlock(&jbt->lock);
548
549         return sprintf(buf, "0x%04x\n", val);
550 }
551
552 static ssize_t gamma_write(struct device *dev, struct device_attribute *attr,
553                            const char *buf, size_t count)
554 {
555         int ret;
556         struct jbt_info *jbt = dev_get_drvdata(dev);
557         int reg = reg_by_string(attr->attr.name);
558         unsigned long val;
559
560         ret = strict_strtoul(buf, 10, &val);
561         if (ret)
562                 return ret;
563
564         mutex_lock(&jbt->lock);
565         jbt_reg_write(jbt, reg, val & 0xff);
566         mutex_unlock(&jbt->lock);
567
568         return count;
569 }
570
571 static ssize_t reset_write(struct device *dev, struct device_attribute *attr,
572                            const char *buf, size_t count)
573 {
574         int ret;
575         struct jbt_info *jbt = dev_get_drvdata(dev);
576         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
577         enum jbt_power_mode old_power_mode = jbt->power_mode;
578
579         mutex_lock(&jbt->lock);
580
581         if (gpio_is_valid(pdata->gpio_reset)) {
582                 /* hard reset the jbt6k74 */
583                 gpio_set_value_cansleep(pdata->gpio_reset, 0);
584                 mdelay(120);
585                 gpio_set_value_cansleep(pdata->gpio_reset, 1);
586                 mdelay(120);
587         }
588
589         ret = jbt_reg_write_nodata(jbt, 0x01);
590         if (ret < 0)
591                 dev_err(&jbt->spi->dev, "cannot soft reset\n");
592         mdelay(120);
593
594         mutex_unlock(&jbt->lock);
595
596         jbt->power_mode = JBT_POWER_MODE_OFF;
597         jbt6k74_enter_power_mode(jbt, old_power_mode);
598
599         return count;
600 }
601
602 static DEVICE_ATTR(gamma_fine1, 0644, gamma_read, gamma_write);
603 static DEVICE_ATTR(gamma_fine2, 0644, gamma_read, gamma_write);
604 static DEVICE_ATTR(gamma_inclination, 0644, gamma_read, gamma_write);
605 static DEVICE_ATTR(gamma_blue_offset, 0644, gamma_read, gamma_write);
606 static DEVICE_ATTR(reset, 0600, NULL, reset_write);
607
608 static struct attribute *jbt_sysfs_entries[] = {
609         &dev_attr_resolution.attr,
610         &dev_attr_gamma_fine1.attr,
611         &dev_attr_gamma_fine2.attr,
612         &dev_attr_gamma_inclination.attr,
613         &dev_attr_gamma_blue_offset.attr,
614         &dev_attr_reset.attr,
615         NULL,
616 };
617
618 static struct attribute_group jbt_attr_group = {
619         .name   = NULL,
620         .attrs  = jbt_sysfs_entries,
621 };
622
623
624 static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
625 {
626         int ret = -EINVAL;
627         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
628
629         if (m->xres == 240 && m->yres == 320) {
630                 ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_QVGA);
631         } else if (m->xres == 480 && m->yres == 640) {
632                 ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_VGA);
633         } else {
634                 dev_err(&jbt->spi->dev, "Unknown resolution.\n");
635                 jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
636         }
637
638         return ret;
639 }
640
641 static int jbt6k74_set_power(struct lcd_device *ld, int power)
642 {
643         int ret = -EINVAL;
644         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
645
646         jbt->blank_mode = power;
647         cancel_rearming_delayed_work(&jbt->blank_work);
648
649         switch (power) {
650         case FB_BLANK_UNBLANK:
651                 dev_dbg(&jbt->spi->dev, "unblank\n");
652                 mdelay(20);
653                 ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
654                 break;
655         case FB_BLANK_NORMAL:
656                 dev_dbg(&jbt->spi->dev, "blank\n");
657                 ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
658                 break;
659         case FB_BLANK_POWERDOWN:
660                 dev_dbg(&jbt->spi->dev, "powerdown\n");
661                 ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
662                 break;
663         default:
664                 break;
665         }
666
667         return ret;
668 }
669
670 static int jbt6k74_get_power(struct lcd_device *ld)
671 {
672         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
673
674         switch (jbt->power_mode) {
675         case JBT_POWER_MODE_NORMAL:
676                 return FB_BLANK_UNBLANK;
677         case JBT_POWER_MODE_OFF:
678                 return FB_BLANK_NORMAL;
679         default:
680                 return JBT_POWER_MODE_OFF;
681         }
682 }
683
684 struct lcd_ops jbt6k74_lcd_ops = {
685         .set_power = jbt6k74_set_power,
686         .get_power = jbt6k74_get_power,
687         .set_mode  = jbt6k74_set_mode,
688 };
689
690 /* linux device model infrastructure */
691
692 static int __devinit jbt_probe(struct spi_device *spi)
693 {
694         int ret;
695         struct jbt_info *jbt;
696         struct jbt6k74_platform_data *pdata = spi->dev.platform_data;
697
698         /* the controller doesn't have a MISO pin; we can't do detection */
699
700         spi->mode = SPI_CPOL | SPI_CPHA;
701         spi->bits_per_word = 9;
702
703         ret = spi_setup(spi);
704         if (ret < 0) {
705                 dev_err(&spi->dev,
706                         "Failed to setup spi\n");
707                 return ret;
708         }
709
710         jbt = kzalloc(sizeof(*jbt), GFP_KERNEL);
711         if (!jbt)
712                 return -ENOMEM;
713
714         jbt_global = jbt;
715
716         jbt->spi = spi;
717
718         jbt->lcd_dev = lcd_device_register("jbt6k74-lcd", &spi->dev, jbt,
719                                                 &jbt6k74_lcd_ops);
720
721         if (IS_ERR(jbt->lcd_dev)) {
722                 ret = PTR_ERR(jbt->lcd_dev);
723                 goto err_free_drvdata;
724         }
725
726         jbt->resolution = JBT_RESOLUTION_VGA;
727         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
728         jbt->power_mode = JBT_POWER_MODE_OFF;
729         mutex_init(&jbt->lock);
730
731         dev_set_drvdata(&spi->dev, jbt);
732
733         jbt->supplies[0].supply = "VDC";
734         jbt->supplies[1].supply = "VDDIO";
735
736         ret = regulator_bulk_get(&spi->dev, ARRAY_SIZE(jbt->supplies),
737                                         jbt->supplies);
738         if (ret) {
739                 dev_err(&spi->dev, "Failed to power get supplies: %d\n", ret);
740                 goto err_unregister_lcd;
741         }
742
743         if (gpio_is_valid(pdata->gpio_reset)) {
744                 ret = gpio_request(pdata->gpio_reset, "jbt6k74 reset");
745                 if (ret) {
746                         dev_err(&spi->dev, "Failed to request reset gpio: %d\n",
747                                 ret);
748                         goto err_free_supplies;
749                 }
750
751                 ret = gpio_direction_output(pdata->gpio_reset, 1);
752                 if (ret) {
753                         dev_err(&spi->dev, "Failed to set reset gpio direction: %d\n",
754                                 ret);
755                         goto err_gpio_free;
756                 }
757         }
758
759         ret = sysfs_create_group(&spi->dev.kobj, &jbt_attr_group);
760         if (ret < 0) {
761                 dev_err(&spi->dev, "cannot create sysfs group\n");
762                 goto err_gpio_free;
763         }
764
765         mdelay(50);
766         ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
767         if (ret < 0) {
768                 dev_err(&spi->dev, "cannot enter NORMAL state\n");
769                 goto err_sysfs_remove;
770         }
771
772
773         if (pdata->probe_completed)
774                 (pdata->probe_completed)(&spi->dev);
775
776         return 0;
777
778 err_sysfs_remove:
779         sysfs_remove_group(&spi->dev.kobj, &jbt_attr_group);
780 err_gpio_free:
781         gpio_free(pdata->gpio_reset);
782 err_free_supplies:
783         regulator_bulk_free(ARRAY_SIZE(jbt->supplies), jbt->supplies);
784 err_unregister_lcd:
785         lcd_device_unregister(jbt->lcd_dev);
786 err_free_drvdata:
787         dev_set_drvdata(&spi->dev, NULL);
788         kfree(jbt);
789
790         return ret;
791 }
792
793 static int __devexit jbt_remove(struct spi_device *spi)
794 {
795         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
796         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
797
798         /* We don't want to switch off the display in case the user
799          * accidentially unloads the module (whose use count normally is 0) */
800         jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
801
802         sysfs_remove_group(&spi->dev.kobj, &jbt_attr_group);
803
804         if (gpio_is_valid(pdata->gpio_reset))
805                 gpio_free(pdata->gpio_reset);
806
807         lcd_device_unregister(jbt->lcd_dev);
808
809         dev_set_drvdata(&spi->dev, NULL);
810
811         regulator_bulk_free(ARRAY_SIZE(jbt->supplies), jbt->supplies);
812         kfree(jbt);
813
814         return 0;
815 }
816
817 /* Begin horrible layering violations in the interest of making stuff work */
818
819 int jbt6k74_finish_resolutionchange(enum jbt_resolution new_resolution)
820 {
821         if ( !jbt_global ) return 0;
822         return jbt6k74_set_resolution(jbt_global, new_resolution);
823 }
824 EXPORT_SYMBOL_GPL(jbt6k74_finish_resolutionchange);
825
826 void jbt6k74_setpower(enum jbt_power_mode new_power)
827 {
828         if ( !jbt_global ) return;
829         jbt6k74_enter_power_mode(jbt_global, new_power);
830 }
831 EXPORT_SYMBOL_GPL(jbt6k74_setpower);
832
833 /* End horrible layering violations */
834
835 #ifdef CONFIG_PM
836 static int jbt_suspend(struct spi_device *spi, pm_message_t state)
837 {
838         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
839
840         jbt->suspend_mode = jbt->power_mode;
841
842         jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_OFF);
843
844         dev_info(&spi->dev, "suspended\n");
845
846         return 0;
847 }
848
849 int jbt6k74_resume(struct spi_device *spi)
850 {
851         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
852         dev_info(&spi->dev, "starting resume: %d\n", jbt->suspend_mode);
853
854         mdelay(20);
855
856         jbt->suspended = 0;
857         jbt6k74_enter_power_mode(jbt, jbt->suspend_mode);
858
859         dev_info(&spi->dev, "resumed: %d\n", jbt->suspend_mode);
860
861         return 0;
862 }
863 EXPORT_SYMBOL_GPL(jbt6k74_resume);
864
865 #else
866 #define jbt_suspend     NULL
867 #define jbt6k74_resume  NULL
868 #endif
869
870 static struct spi_driver jbt6k74_driver = {
871         .driver = {
872                 .name   = "jbt6k74",
873                 .owner  = THIS_MODULE,
874         },
875
876         .probe   = jbt_probe,
877         .remove  = __devexit_p(jbt_remove),
878         .suspend = jbt_suspend,
879         .resume  = jbt6k74_resume,
880 };
881
882 static int __init jbt_init(void)
883 {
884         return spi_register_driver(&jbt6k74_driver);
885 }
886 module_init(jbt_init);
887
888 static void __exit jbt_exit(void)
889 {
890         spi_unregister_driver(&jbt6k74_driver);
891 }
892 module_exit(jbt_exit);
893
894 MODULE_DESCRIPTION("SPI driver for tpo JBT6K74-AS LCM control interface");
895 MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
896 MODULE_LICENSE("GPL");