drivers/video/omap2/displays/panel-lgphilips-lb035q02.c

   1 /*
   2  * LCD panel driver for LG.Philips LB035Q02
   3  *
   4  * Author: Steve Sakoman <steve@sakoman.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 as published by
   8  * the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  13  * more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/delay.h>
  21 #include <linux/spi/spi.h>
  22 #include <linux/mutex.h>
  23 #include <linux/gpio.h>
  24
  25 #include <video/omapdss.h>
  26 #include <video/omap-panel-data.h>
  27
  28 struct lb035q02_data {
  29         struct mutex lock;
  30 };
  31
  32 static struct omap_video_timings lb035q02_timings = {
  33         .x_res = 320,
  34         .y_res = 240,
  35
  36         .pixel_clock    = 6500,
  37
  38         .hsw            = 2,
  39         .hfp            = 20,
  40         .hbp            = 68,
  41
  42         .vsw            = 2,
  43         .vfp            = 4,
  44         .vbp            = 18,
  45
  46         .vsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
  47         .hsync_level    = OMAPDSS_SIG_ACTIVE_LOW,
  48         .data_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE,
  49         .de_level       = OMAPDSS_SIG_ACTIVE_HIGH,
  50         .sync_pclk_edge = OMAPDSS_DRIVE_SIG_OPPOSITE_EDGES,
  51 };
  52
  53 static inline struct panel_generic_dpi_data
  54 *get_panel_data(const struct omap_dss_device *dssdev)
  55 {
  56         return (struct panel_generic_dpi_data *) dssdev->data;
  57 }
  58
  59 static int lb035q02_panel_power_on(struct omap_dss_device *dssdev)
  60 {
  61         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  62         int r, i;
  63
  64         if (dssdev->state == OMAP_DSS_DISPLAY_ACTIVE)
  65                 return 0;
  66
  67         omapdss_dpi_set_timings(dssdev, &dssdev->panel.timings);
  68         omapdss_dpi_set_data_lines(dssdev, dssdev->phy.dpi.data_lines);
  69
  70         r = omapdss_dpi_display_enable(dssdev);
  71         if (r)
  72                 goto err0;
  73
  74         for (i = 0; i < panel_data->num_gpios; ++i) {
  75                 gpio_set_value_cansleep(panel_data->gpios[i],
  76                                 panel_data->gpio_invert[i] ? 0 : 1);
  77         }
  78
  79         return 0;
  80
  81 err0:
  82         return r;
  83 }
  84
  85 static void lb035q02_panel_power_off(struct omap_dss_device *dssdev)
  86 {
  87         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
  88         int i;
  89
  90         if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE)
  91                 return;
  92
  93         for (i = panel_data->num_gpios - 1; i >= 0; --i) {
  94                 gpio_set_value_cansleep(panel_data->gpios[i],
  95                                 panel_data->gpio_invert[i] ? 1 : 0);
  96         }
  97
  98         omapdss_dpi_display_disable(dssdev);
  99 }
 100
 101 static int lb035q02_panel_probe(struct omap_dss_device *dssdev)
 102 {
 103         struct panel_generic_dpi_data *panel_data = get_panel_data(dssdev);
 104         struct lb035q02_data *ld;
 105         int r, i;
 106
 107         if (!panel_data)
 108                 return -EINVAL;
 109
 110         dssdev->panel.timings = lb035q02_timings;
 111
 112         ld = devm_kzalloc(dssdev->dev, sizeof(*ld), GFP_KERNEL);
 113         if (!ld)
 114                 return -ENOMEM;
 115
 116         for (i = 0; i < panel_data->num_gpios; ++i) {
 117                 r = devm_gpio_request_one(dssdev->dev, panel_data->gpios[i],
 118                                 panel_data->gpio_invert[i] ?
 119                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW,
 120                                 "panel gpio");
 121                 if (r)
 122                         return r;
 123         }
 124
 125         mutex_init(&ld->lock);
 126         dev_set_drvdata(dssdev->dev, ld);
 127
 128         return 0;
 129 }
 130
 131 static void lb035q02_panel_remove(struct omap_dss_device *dssdev)
 132 {
 133 }
 134
 135 static int lb035q02_panel_enable(struct omap_dss_device *dssdev)
 136 {
 137         struct lb035q02_data *ld = dev_get_drvdata(dssdev->dev);
 138         int r;
 139
 140         mutex_lock(&ld->lock);
 141
 142         r = lb035q02_panel_power_on(dssdev);
 143         if (r)
 144                 goto err;
 145         dssdev->state = OMAP_DSS_DISPLAY_ACTIVE;
 146
 147         mutex_unlock(&ld->lock);
 148         return 0;
 149 err:
 150         mutex_unlock(&ld->lock);
 151         return r;
 152 }
 153
 154 static void lb035q02_panel_disable(struct omap_dss_device *dssdev)
 155 {
 156         struct lb035q02_data *ld = dev_get_drvdata(dssdev->dev);
 157
 158         mutex_lock(&ld->lock);
 159
 160         lb035q02_panel_power_off(dssdev);
 161         dssdev->state = OMAP_DSS_DISPLAY_DISABLED;
 162
 163         mutex_unlock(&ld->lock);
 164 }
 165
 166 static struct omap_dss_driver lb035q02_driver = {
 167         .probe          = lb035q02_panel_probe,
 168         .remove         = lb035q02_panel_remove,
 169
 170         .enable         = lb035q02_panel_enable,
 171         .disable        = lb035q02_panel_disable,
 172
 173         .driver         = {
 174                 .name   = "lgphilips_lb035q02_panel",
 175                 .owner  = THIS_MODULE,
 176         },
 177 };
 178
 179 static int lb035q02_write_reg(struct spi_device *spi, u8 reg, u16 val)
 180 {
 181         struct spi_message msg;
 182         struct spi_transfer index_xfer = {
 183                 .len            = 3,
 184                 .cs_change      = 1,
 185         };
 186         struct spi_transfer value_xfer = {
 187                 .len            = 3,
 188         };
 189         u8      buffer[16];
 190
 191         spi_message_init(&msg);
 192
 193         /* register index */
 194         buffer[0] = 0x70;
 195         buffer[1] = 0x00;
 196         buffer[2] = reg & 0x7f;
 197         index_xfer.tx_buf = buffer;
 198         spi_message_add_tail(&index_xfer, &msg);
 199
 200         /* register value */
 201         buffer[4] = 0x72;
 202         buffer[5] = val >> 8;
 203         buffer[6] = val;
 204         value_xfer.tx_buf = buffer + 4;
 205         spi_message_add_tail(&value_xfer, &msg);
 206
 207         return spi_sync(spi, &msg);
 208 }
 209
 210 static void init_lb035q02_panel(struct spi_device *spi)
 211 {
 212         /* Init sequence from page 28 of the lb035q02 spec */
 213         lb035q02_write_reg(spi, 0x01, 0x6300);
 214         lb035q02_write_reg(spi, 0x02, 0x0200);
 215         lb035q02_write_reg(spi, 0x03, 0x0177);
 216         lb035q02_write_reg(spi, 0x04, 0x04c7);
 217         lb035q02_write_reg(spi, 0x05, 0xffc0);
 218         lb035q02_write_reg(spi, 0x06, 0xe806);
 219         lb035q02_write_reg(spi, 0x0a, 0x4008);
 220         lb035q02_write_reg(spi, 0x0b, 0x0000);
 221         lb035q02_write_reg(spi, 0x0d, 0x0030);
 222         lb035q02_write_reg(spi, 0x0e, 0x2800);
 223         lb035q02_write_reg(spi, 0x0f, 0x0000);
 224         lb035q02_write_reg(spi, 0x16, 0x9f80);
 225         lb035q02_write_reg(spi, 0x17, 0x0a0f);
 226         lb035q02_write_reg(spi, 0x1e, 0x00c1);
 227         lb035q02_write_reg(spi, 0x30, 0x0300);
 228         lb035q02_write_reg(spi, 0x31, 0x0007);
 229         lb035q02_write_reg(spi, 0x32, 0x0000);
 230         lb035q02_write_reg(spi, 0x33, 0x0000);
 231         lb035q02_write_reg(spi, 0x34, 0x0707);
 232         lb035q02_write_reg(spi, 0x35, 0x0004);
 233         lb035q02_write_reg(spi, 0x36, 0x0302);
 234         lb035q02_write_reg(spi, 0x37, 0x0202);
 235         lb035q02_write_reg(spi, 0x3a, 0x0a0d);
 236         lb035q02_write_reg(spi, 0x3b, 0x0806);
 237 }
 238
 239 static int lb035q02_panel_spi_probe(struct spi_device *spi)
 240 {
 241         init_lb035q02_panel(spi);
 242         return omap_dss_register_driver(&lb035q02_driver);
 243 }
 244
 245 static int lb035q02_panel_spi_remove(struct spi_device *spi)
 246 {
 247         omap_dss_unregister_driver(&lb035q02_driver);
 248         return 0;
 249 }
 250
 251 static struct spi_driver lb035q02_spi_driver = {
 252         .driver         = {
 253                 .name   = "lgphilips_lb035q02_panel-spi",
 254                 .owner  = THIS_MODULE,
 255         },
 256         .probe          = lb035q02_panel_spi_probe,
 257         .remove         = lb035q02_panel_spi_remove,
 258 };
 259
 260 module_spi_driver(lb035q02_spi_driver);
 261
 262 MODULE_LICENSE("GPL");