8450904d5855b6abfbe020a3f3ba2f92e25157f8
[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 enum jbt_resolution {
105         JBT_RESOLUTION_VGA,
106         JBT_RESOLUTION_QVGA,
107 };
108
109 enum jbt_power_mode {
110         JBT_POWER_MODE_DEEP_STANDBY,
111         JBT_POWER_MODE_SLEEP,
112         JBT_POWER_MODE_NORMAL,
113 };
114
115 static const char *jbt_power_mode_names[] = {
116         [JBT_POWER_MODE_DEEP_STANDBY]   = "deep-standby",
117         [JBT_POWER_MODE_SLEEP]          = "sleep",
118         [JBT_POWER_MODE_NORMAL]         = "normal",
119 };
120
121 static const char *jbt_resolution_names[] = {
122         [JBT_RESOLUTION_VGA] = "vga",
123         [JBT_RESOLUTION_QVGA] = "qvga",
124 };
125
126 struct jbt_info {
127         struct mutex lock;              /* protects this structure */
128         enum jbt_resolution resolution;
129         enum jbt_power_mode power_mode;
130         enum jbt_power_mode suspend_mode;
131         int suspended;
132
133         struct spi_device *spi;
134         struct lcd_device *lcd_dev;
135
136         unsigned long next_sleep;
137         struct delayed_work blank_work;
138         int blank_mode;
139         struct regulator_bulk_data supplies[2];
140         uint16_t tx_buf[3];
141         uint16_t reg_cache[0xEE];
142 };
143
144 #define JBT_COMMAND     0x000
145 #define JBT_DATA        0x100
146
147 static int jbt_reg_write_nodata(struct jbt_info *jbt, uint8_t reg)
148 {
149         int ret;
150
151         jbt->tx_buf[0] = JBT_COMMAND | reg;
152         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
153                                         sizeof(uint16_t));
154         if (ret == 0)
155                 jbt->reg_cache[reg] = 0;
156         else
157                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
158
159         return ret;
160 }
161
162
163 static int jbt_reg_write(struct jbt_info *jbt, uint8_t reg, uint8_t data)
164 {
165         int ret;
166
167         jbt->tx_buf[0] = JBT_COMMAND | reg;
168         jbt->tx_buf[1] = JBT_DATA | data;
169         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
170                         2*sizeof(uint16_t));
171         if (ret == 0)
172                 jbt->reg_cache[reg] = data;
173         else
174                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
175
176         return ret;
177 }
178
179 static int jbt_reg_write16(struct jbt_info *jbt, uint8_t reg, uint16_t data)
180 {
181         int ret;
182
183         jbt->tx_buf[0] = JBT_COMMAND | reg;
184         jbt->tx_buf[1] = JBT_DATA | (data >> 8);
185         jbt->tx_buf[2] = JBT_DATA | (data & 0xff);
186
187         ret = spi_write(jbt->spi, (uint8_t *)jbt->tx_buf,
188                         3*sizeof(uint16_t));
189         if (ret == 0)
190                 jbt->reg_cache[reg] = data;
191         else
192                 dev_err(&jbt->spi->dev, "Write failed: %d\n", ret);
193
194         return ret;
195 }
196
197 static int jbt_init_regs(struct jbt_info *jbt)
198 {
199         int ret;
200
201         dev_dbg(&jbt->spi->dev, "entering %cVGA mode\n",
202                         jbt->resolution == JBT_RESOLUTION_QVGA ? 'Q' : ' ');
203
204         ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE1, 0x01);
205         ret |= jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE2, 0x00);
206         ret |= jbt_reg_write(jbt, JBT_REG_RGB_FORMAT, 0x60);
207         ret |= jbt_reg_write(jbt, JBT_REG_DRIVE_SYSTEM, 0x10);
208         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_OP, 0x56);
209         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_MODE, 0x33);
210         ret |= jbt_reg_write(jbt, JBT_REG_BOOSTER_FREQ, 0x11);
211         ret |= jbt_reg_write(jbt, JBT_REG_OPAMP_SYSCLK, 0x02);
212         ret |= jbt_reg_write(jbt, JBT_REG_VSC_VOLTAGE, 0x2b);
213         ret |= jbt_reg_write(jbt, JBT_REG_VCOM_VOLTAGE, 0x40);
214         ret |= jbt_reg_write(jbt, JBT_REG_EXT_DISPL, 0x03);
215         ret |= jbt_reg_write(jbt, JBT_REG_DCCLK_DCEV, 0x04);
216         /*
217          * default of 0x02 in JBT_REG_ASW_SLEW responsible for 72Hz requirement
218          * to avoid red / blue flicker
219          */
220         ret |= jbt_reg_write(jbt, JBT_REG_ASW_SLEW, 0x00 | (1 << 5));
221         ret |= jbt_reg_write(jbt, JBT_REG_DUMMY_DISPLAY, 0x00);
222
223         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_A, 0x11);
224         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_B, 0x11);
225         ret |= jbt_reg_write(jbt, JBT_REG_SLEEP_OUT_FR_C, 0x11);
226         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_D, 0x2040);
227         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_E, 0x60c0);
228         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_F, 0x1020);
229         ret |= jbt_reg_write16(jbt, JBT_REG_SLEEP_IN_LCCNT_G, 0x60c0);
230
231         ret |= jbt_reg_write16(jbt, JBT_REG_GAMMA1_FINE_1, 0x5533);
232         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_FINE_2, 0x00);
233         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_INCLINATION, 0x00);
234         ret |= jbt_reg_write(jbt, JBT_REG_GAMMA1_BLUE_OFFSET, 0x00);
235
236         if (jbt->resolution != JBT_RESOLUTION_QVGA) {
237                 ret |= jbt_reg_write16(jbt, JBT_REG_HCLOCK_VGA, 0x1f0);
238                 ret |= jbt_reg_write(jbt, JBT_REG_BLANK_CONTROL, 0x02);
239                 ret |= jbt_reg_write16(jbt, JBT_REG_BLANK_TH_TV, 0x0804);
240
241                 ret |= jbt_reg_write(jbt, JBT_REG_CKV_ON_OFF, 0x01);
242                 ret |= jbt_reg_write16(jbt, JBT_REG_CKV_1_2, 0x0000);
243
244                 ret |= jbt_reg_write16(jbt, JBT_REG_OEV_TIMING, 0x0d0e);
245                 ret |= jbt_reg_write16(jbt, JBT_REG_ASW_TIMING_1, 0x11a4);
246                 ret |= jbt_reg_write(jbt, JBT_REG_ASW_TIMING_2, 0x0e);
247         } else {
248                 ret |= jbt_reg_write16(jbt, JBT_REG_HCLOCK_QVGA, 0x00ff);
249                 ret |= jbt_reg_write(jbt, JBT_REG_BLANK_CONTROL_QVGA, 0x02);
250                 ret |= jbt_reg_write16(jbt, JBT_REG_BLANK_TH_TV_QVGA, 0x0804);
251
252                 ret |= jbt_reg_write(jbt, JBT_REG_CKV_ON_OFF_QVGA, 0x01);
253                 ret |= jbt_reg_write16(jbt, JBT_REG_CKV_1_2_QVGA, 0x0008);
254
255                 ret |= jbt_reg_write16(jbt, JBT_REG_OEV_TIMING_QVGA, 0x050a);
256                 ret |= jbt_reg_write16(jbt, JBT_REG_ASW_TIMING_1_QVGA, 0x0a19);
257                 ret |= jbt_reg_write(jbt, JBT_REG_ASW_TIMING_2_QVGA, 0x0a);
258         }
259
260         return ret ? -EIO : 0;
261 }
262
263 static int jbt_standby_to_sleep(struct jbt_info *jbt)
264 {
265         int ret;
266         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
267
268         gpio_set_value_cansleep(pdata->gpio_reset, 1);
269         ret = regulator_bulk_enable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
270
271         /* three times command zero */
272         ret |= jbt_reg_write_nodata(jbt, 0x00);
273         mdelay(1);
274         ret |= jbt_reg_write_nodata(jbt, 0x00);
275         mdelay(1);
276         ret |= jbt_reg_write_nodata(jbt, 0x00);
277         mdelay(1);
278
279         /* deep standby out */
280         ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x11);
281         mdelay(1);
282         ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x28);
283
284         /* (re)initialize register set */
285         ret |= jbt_init_regs(jbt);
286
287         return ret ? -EIO : 0;
288 }
289
290 static int jbt_sleep_to_normal(struct jbt_info *jbt)
291 {
292         int ret;
293
294         /* Make sure we are 120 ms after SLEEP_OUT */
295         if (time_before(jiffies, jbt->next_sleep))
296                 mdelay(jiffies_to_msecs(jbt->next_sleep - jiffies));
297
298         if (jbt->resolution == JBT_RESOLUTION_VGA) {
299                 /* RGB I/F on, RAM wirte off, QVGA through, SIGCON enable */
300                 ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x80);
301
302                 /* Quad mode off */
303                 ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x00);
304         } else {
305                 /* RGB I/F on, RAM wirte off, QVGA through, SIGCON enable */
306                 ret = jbt_reg_write(jbt, JBT_REG_DISPLAY_MODE, 0x81);
307
308                 /* Quad mode on */
309                 ret |= jbt_reg_write(jbt, JBT_REG_QUAD_RATE, 0x22);
310         }
311
312         /* AVDD on, XVDD on */
313         ret |= jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x16);
314
315         /* Output control */
316         ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0xdff9);
317
318         /* Turn on display */
319         ret |= jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_ON);
320
321         /* Sleep mode off */
322         ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_OUT);
323         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
324
325         /* Allow the booster and display controller to restart stably */
326         mdelay(5);
327
328         return ret ? -EIO : 0;
329 }
330
331 static int jbt_normal_to_sleep(struct jbt_info *jbt)
332 {
333         int ret;
334
335         /* Make sure we are 120 ms after SLEEP_OUT */
336         while (time_before(jiffies, jbt->next_sleep))
337                 cpu_relax();
338
339         ret = jbt_reg_write_nodata(jbt, JBT_REG_DISPLAY_OFF);
340         ret |= jbt_reg_write16(jbt, JBT_REG_OUTPUT_CONTROL, 0x8000 | 1 << 3);
341         ret |= jbt_reg_write_nodata(jbt, JBT_REG_SLEEP_IN);
342         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
343
344         /* Allow the internal circuits to stop automatically */
345         mdelay(5);
346
347         return ret ? -EIO : 0;
348 }
349
350 static int jbt_sleep_to_standby(struct jbt_info *jbt)
351 {
352         int ret;
353         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
354
355         ret = jbt_reg_write(jbt, JBT_REG_POWER_ON_OFF, 0x00);
356
357         if (!ret)
358                 ret = regulator_bulk_disable(ARRAY_SIZE(jbt->supplies), jbt->supplies);
359
360         if (!ret)
361                 gpio_set_value_cansleep(pdata->gpio_reset, 0);
362
363         return ret;
364 }
365
366 static int jbt6k74_enter_power_mode(struct jbt_info *jbt,
367                                         enum jbt_power_mode new_mode)
368 {
369         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
370         int ret = -EINVAL;
371
372         dev_dbg(&jbt->spi->dev, "entering (old_state=%s, new_state=%s)\n",
373                         jbt_power_mode_names[jbt->power_mode],
374                         jbt_power_mode_names[new_mode]);
375
376         mutex_lock(&jbt->lock);
377
378         if (jbt->suspended) {
379                 switch (new_mode) {
380                 case JBT_POWER_MODE_DEEP_STANDBY:
381                 case JBT_POWER_MODE_SLEEP:
382                 case JBT_POWER_MODE_NORMAL:
383                         ret = 0;
384                         jbt->suspend_mode = new_mode;
385                         break;
386                 default:
387                         break;
388                 }
389         } else if (new_mode == JBT_POWER_MODE_NORMAL &&
390                         pdata->enable_pixel_clock) {
391                 pdata->enable_pixel_clock(&jbt->spi->dev, 1);
392         }
393
394         switch (jbt->power_mode) {
395         case JBT_POWER_MODE_DEEP_STANDBY:
396                 switch (new_mode) {
397                 case JBT_POWER_MODE_DEEP_STANDBY:
398                         ret = 0;
399                         break;
400                 case JBT_POWER_MODE_SLEEP:
401                         ret = jbt_standby_to_sleep(jbt);
402                         break;
403                 case JBT_POWER_MODE_NORMAL:
404                         /* first transition into sleep */
405                         ret = jbt_standby_to_sleep(jbt);
406                         /* then transition into normal */
407                         ret |= jbt_sleep_to_normal(jbt);
408                         break;
409                 }
410                 break;
411         case JBT_POWER_MODE_SLEEP:
412                 switch (new_mode) {
413                 case JBT_POWER_MODE_SLEEP:
414                         ret = 0;
415                         break;
416                 case JBT_POWER_MODE_DEEP_STANDBY:
417                         ret = jbt_sleep_to_standby(jbt);
418                         break;
419                 case JBT_POWER_MODE_NORMAL:
420                         ret = jbt_sleep_to_normal(jbt);
421                         break;
422                 }
423                 break;
424         case JBT_POWER_MODE_NORMAL:
425                 switch (new_mode) {
426                 case JBT_POWER_MODE_NORMAL:
427                         ret = 0;
428                         break;
429                 case JBT_POWER_MODE_DEEP_STANDBY:
430                         /* first transition into sleep */
431                         ret = jbt_normal_to_sleep(jbt);
432                         /* then transition into deep standby */
433                         ret |= jbt_sleep_to_standby(jbt);
434                         break;
435                 case JBT_POWER_MODE_SLEEP:
436                         ret = jbt_normal_to_sleep(jbt);
437                         break;
438                 }
439         }
440
441         if (ret == 0) {
442                 jbt->power_mode = new_mode;
443                 if (new_mode != JBT_POWER_MODE_NORMAL &&
444                         pdata->enable_pixel_clock)
445                         pdata->enable_pixel_clock(&jbt->spi->dev, 0);
446         } else {
447                 dev_err(&jbt->spi->dev, "Failed enter state '%s': %d\n",
448                                 jbt_power_mode_names[new_mode], ret);
449         }
450
451         mutex_unlock(&jbt->lock);
452
453         return ret;
454 }
455
456 static int jbt6k74_set_resolution(struct jbt_info *jbt,
457                                         enum jbt_resolution new_resolution)
458 {
459         int ret = 0;
460         enum jbt_resolution old_resolution;
461
462         mutex_lock(&jbt->lock);
463
464         if (jbt->resolution == new_resolution)
465                 goto out_unlock;
466
467         old_resolution = jbt->resolution;
468         jbt->resolution = new_resolution;
469
470         if (jbt->power_mode == JBT_POWER_MODE_NORMAL) {
471
472                 /* first transition into sleep */
473                 ret = jbt_normal_to_sleep(jbt);
474                 ret |= jbt_sleep_to_normal(jbt);
475
476                 if (ret) {
477                         jbt->resolution = old_resolution;
478                         dev_err(&jbt->spi->dev, "Failed to set resolution '%s')\n",
479                                 jbt_resolution_names[new_resolution]);
480                 }
481         }
482
483 out_unlock:
484         mutex_unlock(&jbt->lock);
485
486         return ret;
487 }
488
489 static ssize_t resolution_read(struct device *dev,
490                                 struct device_attribute *attr, char *buf)
491 {
492         struct jbt_info *jbt = dev_get_drvdata(dev);
493
494         if (jbt->resolution >= ARRAY_SIZE(jbt_resolution_names))
495                 return -EIO;
496
497         return sprintf(buf, "%s\n", jbt_resolution_names[jbt->resolution]);
498 }
499
500 static ssize_t resolution_write(struct device *dev,
501                                 struct device_attribute *attr,
502                                 const char *buf, size_t count)
503 {
504         struct jbt_info *jbt = dev_get_drvdata(dev);
505         int i, ret;
506
507         for (i = 0; i < ARRAY_SIZE(jbt_resolution_names); i++) {
508                 if (!strncmp(buf, jbt_resolution_names[i],
509                         strlen(jbt_resolution_names[i]))) {
510                         ret = jbt6k74_set_resolution(jbt, i);
511                         if (ret)
512                                 return ret;
513                         return count;
514                 }
515         }
516
517         return -EINVAL;
518 }
519
520 static DEVICE_ATTR(resolution, 0644, resolution_read, resolution_write);
521
522 static int reg_by_string(const char *name)
523 {
524         if (!strcmp(name, "gamma_fine1"))
525                 return JBT_REG_GAMMA1_FINE_1;
526         else if (!strcmp(name, "gamma_fine2"))
527                 return JBT_REG_GAMMA1_FINE_2;
528         else if (!strcmp(name, "gamma_inclination"))
529                 return JBT_REG_GAMMA1_INCLINATION;
530         else
531                 return JBT_REG_GAMMA1_BLUE_OFFSET;
532 }
533
534 static ssize_t gamma_read(struct device *dev, struct device_attribute *attr,
535                           char *buf)
536 {
537         struct jbt_info *jbt = dev_get_drvdata(dev);
538         int reg = reg_by_string(attr->attr.name);
539         uint16_t val;
540
541         mutex_lock(&jbt->lock);
542         val = jbt->reg_cache[reg];
543         mutex_unlock(&jbt->lock);
544
545         return sprintf(buf, "0x%04x\n", val);
546 }
547
548 static ssize_t gamma_write(struct device *dev, struct device_attribute *attr,
549                            const char *buf, size_t count)
550 {
551         int ret;
552         struct jbt_info *jbt = dev_get_drvdata(dev);
553         int reg = reg_by_string(attr->attr.name);
554         unsigned long val;
555
556         ret = strict_strtoul(buf, 10, &val);
557         if (ret)
558                 return ret;
559
560         mutex_lock(&jbt->lock);
561         jbt_reg_write(jbt, reg, val & 0xff);
562         mutex_unlock(&jbt->lock);
563
564         return count;
565 }
566
567 static ssize_t reset_write(struct device *dev, struct device_attribute *attr,
568                            const char *buf, size_t count)
569 {
570         int ret;
571         struct jbt_info *jbt = dev_get_drvdata(dev);
572         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
573         enum jbt_power_mode old_power_mode = jbt->power_mode;
574
575         mutex_lock(&jbt->lock);
576
577         if (gpio_is_valid(pdata->gpio_reset)) {
578                 /* hard reset the jbt6k74 */
579                 gpio_set_value_cansleep(pdata->gpio_reset, 0);
580                 mdelay(120);
581                 gpio_set_value_cansleep(pdata->gpio_reset, 1);
582                 mdelay(120);
583         }
584
585         ret = jbt_reg_write_nodata(jbt, 0x01);
586         if (ret < 0)
587                 dev_err(&jbt->spi->dev, "cannot soft reset\n");
588         mdelay(120);
589
590         mutex_unlock(&jbt->lock);
591
592         jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
593         jbt6k74_enter_power_mode(jbt, old_power_mode);
594
595         return count;
596 }
597
598 static DEVICE_ATTR(gamma_fine1, 0644, gamma_read, gamma_write);
599 static DEVICE_ATTR(gamma_fine2, 0644, gamma_read, gamma_write);
600 static DEVICE_ATTR(gamma_inclination, 0644, gamma_read, gamma_write);
601 static DEVICE_ATTR(gamma_blue_offset, 0644, gamma_read, gamma_write);
602 static DEVICE_ATTR(reset, 0600, NULL, reset_write);
603
604 static struct attribute *jbt_sysfs_entries[] = {
605         &dev_attr_resolution.attr,
606         &dev_attr_gamma_fine1.attr,
607         &dev_attr_gamma_fine2.attr,
608         &dev_attr_gamma_inclination.attr,
609         &dev_attr_gamma_blue_offset.attr,
610         &dev_attr_reset.attr,
611         NULL,
612 };
613
614 static struct attribute_group jbt_attr_group = {
615         .name   = NULL,
616         .attrs  = jbt_sysfs_entries,
617 };
618
619 /* FIXME: This in an ugly hack to delay display blanking.
620   When the jbt is in sleep mode it displays an all white screen and thus one
621   will a see a short flash.
622   By delaying the blanking we will give the backlight a chance to turn off and
623   thus avoid getting the flash */
624 static void jbt_blank_worker(struct work_struct *work)
625 {
626         struct jbt_info *jbt  = container_of(work, struct jbt_info,
627                                                 blank_work.work);
628
629         switch (jbt->blank_mode) {
630         case FB_BLANK_NORMAL:
631                 jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
632                 break;
633         case FB_BLANK_POWERDOWN:
634                 jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
635                 break;
636         default:
637                 break;
638         }
639 }
640
641 static int jbt6k74_set_mode(struct lcd_device *ld, struct fb_videomode *m)
642 {
643         int ret = -EINVAL;
644         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
645
646         if (m->xres == 240 && m->yres == 320) {
647                 ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_QVGA);
648         } else if (m->xres == 480 && m->yres == 640) {
649                 ret = jbt6k74_set_resolution(jbt, JBT_RESOLUTION_VGA);
650         } else {
651                 dev_err(&jbt->spi->dev, "Unknown resolution.\n");
652                 jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_SLEEP);
653         }
654
655         return ret;
656 }
657
658 static int jbt6k74_set_power(struct lcd_device *ld, int power)
659 {
660         int ret = -EINVAL;
661         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
662
663         jbt->blank_mode = power;
664         cancel_rearming_delayed_work(&jbt->blank_work);
665
666         switch (power) {
667         case FB_BLANK_UNBLANK:
668                 dev_dbg(&jbt->spi->dev, "unblank\n");
669                 mdelay(20);
670                 ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
671                 break;
672         case FB_BLANK_NORMAL:
673                 dev_dbg(&jbt->spi->dev, "blank\n");
674                 ret = schedule_delayed_work(&jbt->blank_work, HZ);
675                 break;
676         case FB_BLANK_POWERDOWN:
677                 dev_dbg(&jbt->spi->dev, "powerdown\n");
678                 ret = schedule_delayed_work(&jbt->blank_work, HZ);
679                 break;
680         default:
681                 break;
682         }
683
684         return ret;
685 }
686
687 static int jbt6k74_get_power(struct lcd_device *ld)
688 {
689         struct jbt_info *jbt = dev_get_drvdata(&ld->dev);
690
691         switch (jbt->power_mode) {
692         case JBT_POWER_MODE_NORMAL:
693                 return FB_BLANK_UNBLANK;
694         case JBT_POWER_MODE_SLEEP:
695                 return FB_BLANK_NORMAL;
696         default:
697                 return JBT_POWER_MODE_DEEP_STANDBY;
698         }
699 }
700
701 struct lcd_ops jbt6k74_lcd_ops = {
702         .set_power = jbt6k74_set_power,
703         .get_power = jbt6k74_get_power,
704         .set_mode  = jbt6k74_set_mode,
705 };
706
707 /* linux device model infrastructure */
708
709 static int __devinit jbt_probe(struct spi_device *spi)
710 {
711         int ret;
712         struct jbt_info *jbt;
713         struct jbt6k74_platform_data *pdata = spi->dev.platform_data;
714
715         /* the controller doesn't have a MISO pin; we can't do detection */
716
717         spi->mode = SPI_CPOL | SPI_CPHA;
718         spi->bits_per_word = 9;
719
720         ret = spi_setup(spi);
721         if (ret < 0) {
722                 dev_err(&spi->dev,
723                         "Failed to setup spi\n");
724                 return ret;
725         }
726
727         jbt = kzalloc(sizeof(*jbt), GFP_KERNEL);
728         if (!jbt)
729                 return -ENOMEM;
730
731         jbt->spi = spi;
732
733         jbt->lcd_dev = lcd_device_register("jbt6k74-lcd", &spi->dev, jbt,
734                                                 &jbt6k74_lcd_ops);
735
736         if (IS_ERR(jbt->lcd_dev)) {
737                 ret = PTR_ERR(jbt->lcd_dev);
738                 goto err_free_drvdata;
739         }
740
741         INIT_DELAYED_WORK(&jbt->blank_work, jbt_blank_worker);
742
743         jbt->resolution = JBT_RESOLUTION_VGA;
744         jbt->power_mode = JBT_POWER_MODE_DEEP_STANDBY;
745         jbt->next_sleep = jiffies + msecs_to_jiffies(120);
746         mutex_init(&jbt->lock);
747
748         dev_set_drvdata(&spi->dev, jbt);
749
750         jbt->supplies[0].supply = "VDC";
751         jbt->supplies[1].supply = "VDDIO";
752
753         ret = regulator_bulk_get(&spi->dev, ARRAY_SIZE(jbt->supplies),
754                                         jbt->supplies);
755         if (ret) {
756                 dev_err(&spi->dev, "Failed to power get supplies: %d\n", ret);
757                 goto err_unregister_lcd;
758         }
759
760         if (gpio_is_valid(pdata->gpio_reset)) {
761                 ret = gpio_request(pdata->gpio_reset, "jbt6k74 reset");
762                 if (ret) {
763                         dev_err(&spi->dev, "Failed to request reset gpio: %d\n",
764                                 ret);
765                         goto err_free_supplies;
766                 }
767
768                 ret = gpio_direction_output(pdata->gpio_reset, 1);
769                 if (ret) {
770                         dev_err(&spi->dev, "Failed to set reset gpio direction: %d\n",
771                                 ret);
772                         goto err_gpio_free;
773                 }
774         }
775
776         ret = sysfs_create_group(&spi->dev.kobj, &jbt_attr_group);
777         if (ret < 0) {
778                 dev_err(&spi->dev, "cannot create sysfs group\n");
779                 goto err_gpio_free;
780         }
781
782         mdelay(50);
783         ret = jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
784         if (ret < 0) {
785                 dev_err(&spi->dev, "cannot enter NORMAL state\n");
786                 goto err_sysfs_remove;
787         }
788
789
790         if (pdata->probe_completed)
791                 (pdata->probe_completed)(&spi->dev);
792
793         return 0;
794
795 err_sysfs_remove:
796         sysfs_remove_group(&spi->dev.kobj, &jbt_attr_group);
797 err_gpio_free:
798         gpio_free(pdata->gpio_reset);
799 err_free_supplies:
800         regulator_bulk_free(ARRAY_SIZE(jbt->supplies), jbt->supplies);
801 err_unregister_lcd:
802         lcd_device_unregister(jbt->lcd_dev);
803 err_free_drvdata:
804         dev_set_drvdata(&spi->dev, NULL);
805         kfree(jbt);
806
807         return ret;
808 }
809
810 static int __devexit jbt_remove(struct spi_device *spi)
811 {
812         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
813         struct jbt6k74_platform_data *pdata = jbt->spi->dev.platform_data;
814
815         /* We don't want to switch off the display in case the user
816          * accidentially unloads the module (whose use count normally is 0) */
817         jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_NORMAL);
818
819         sysfs_remove_group(&spi->dev.kobj, &jbt_attr_group);
820
821         if (gpio_is_valid(pdata->gpio_reset))
822                 gpio_free(pdata->gpio_reset);
823
824         lcd_device_unregister(jbt->lcd_dev);
825
826         dev_set_drvdata(&spi->dev, NULL);
827
828         regulator_bulk_free(ARRAY_SIZE(jbt->supplies), jbt->supplies);
829         kfree(jbt);
830
831         return 0;
832 }
833
834 #ifdef CONFIG_PM
835 static int jbt_suspend(struct spi_device *spi, pm_message_t state)
836 {
837         struct jbt_info *jbt = dev_get_drvdata(&spi->dev);
838
839         jbt->suspend_mode = jbt->power_mode;
840
841         jbt6k74_enter_power_mode(jbt, JBT_POWER_MODE_DEEP_STANDBY);
842         jbt->suspended = 1;
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");