drivers/video/msm/mddi_client_novb9f6_5582.c

   1 /*
   2  * Copyright (C) 2008 HTC Corporation.
   3  *
   4  * This software is licensed under the terms of the GNU General Public
   5  * License version 2, as published by the Free Software Foundation, and
   6  * may be copied, distributed, and modified under those terms.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/delay.h>
  18 #include <linux/interrupt.h>
  19 #include <linux/gpio.h>
  20 #include <linux/wakelock.h>
  21 #include <mach/msm_fb.h>
  22
  23 static DECLARE_WAIT_QUEUE_HEAD(novtec_vsync_wait);
  24
  25 struct panel_info {
  26         struct msm_mddi_client_data *client_data;
  27         struct platform_device pdev;
  28         struct msm_panel_data panel_data;
  29         struct msmfb_callback *novtec_callback;
  30         struct wake_lock idle_lock;
  31         int novtec_got_int;
  32 };
  33
  34 static struct platform_device mddi_nov_cabc = {
  35         .name = "nov_cabc",
  36         .id = 0,
  37 };
  38
  39 static void novtec_request_vsync(struct msm_panel_data *panel_data,
  40                                   struct msmfb_callback *callback)
  41 {
  42         struct panel_info *panel = container_of(panel_data, struct panel_info,
  43                                                 panel_data);
  44         struct msm_mddi_client_data *client_data = panel->client_data;
  45
  46         panel->novtec_callback = callback;
  47         if (panel->novtec_got_int) {
  48                 panel->novtec_got_int = 0;
  49                 client_data->activate_link(client_data);
  50         }
  51 }
  52
  53 static void novtec_clear_vsync(struct msm_panel_data *panel_data)
  54 {
  55         struct panel_info *panel = container_of(panel_data, struct panel_info,
  56                                                 panel_data);
  57         struct msm_mddi_client_data *client_data = panel->client_data;
  58
  59         client_data->activate_link(client_data);
  60 }
  61
  62 static void novtec_wait_vsync(struct msm_panel_data *panel_data)
  63 {
  64         struct panel_info *panel = container_of(panel_data, struct panel_info,
  65                                                 panel_data);
  66         struct msm_mddi_client_data *client_data = panel->client_data;
  67
  68         if (panel->novtec_got_int) {
  69                 panel->novtec_got_int = 0;
  70                 client_data->activate_link(client_data); /* clears interrupt */
  71         }
  72         if (wait_event_timeout(novtec_vsync_wait, panel->novtec_got_int,
  73                                 HZ/2) == 0)
  74                 printk(KERN_ERR "timeout waiting for VSYNC\n");
  75         panel->novtec_got_int = 0;
  76         /* interrupt clears when screen dma starts */
  77 }
  78
  79 static int novtec_suspend(struct msm_panel_data *panel_data)
  80 {
  81         struct panel_info *panel = container_of(panel_data, struct panel_info,
  82                                                 panel_data);
  83         struct msm_mddi_client_data *client_data = panel->client_data;
  84
  85         struct msm_mddi_bridge_platform_data *bridge_data =
  86                 client_data->private_client_data;
  87         int ret;
  88
  89         wake_lock(&panel->idle_lock);
  90         ret = bridge_data->uninit(bridge_data, client_data);
  91         wake_unlock(&panel->idle_lock);
  92         if (ret) {
  93                 printk(KERN_INFO "mddi novtec client: non zero return from "
  94                         "uninit\n");
  95                 return ret;
  96         }
  97         client_data->suspend(client_data);
  98         return 0;
  99 }
 100
 101 static int novtec_resume(struct msm_panel_data *panel_data)
 102 {
 103         struct panel_info *panel = container_of(panel_data, struct panel_info,
 104                                                 panel_data);
 105         struct msm_mddi_client_data *client_data = panel->client_data;
 106
 107         struct msm_mddi_bridge_platform_data *bridge_data =
 108                 client_data->private_client_data;
 109         int ret;
 110
 111         wake_lock(&panel->idle_lock);
 112         client_data->resume(client_data);
 113         wake_unlock(&panel->idle_lock);
 114         ret = bridge_data->init(bridge_data, client_data);
 115         if (ret)
 116                 return ret;
 117         return 0;
 118 }
 119
 120 static int novtec_blank(struct msm_panel_data *panel_data)
 121 {
 122         struct panel_info *panel = container_of(panel_data, struct panel_info,
 123                                                 panel_data);
 124         struct msm_mddi_client_data *client_data = panel->client_data;
 125         struct msm_mddi_bridge_platform_data *bridge_data =
 126                 client_data->private_client_data;
 127
 128         return bridge_data->blank(bridge_data, client_data);
 129 }
 130
 131 static int novtec_unblank(struct msm_panel_data *panel_data)
 132 {
 133         struct panel_info *panel = container_of(panel_data, struct panel_info,
 134                                                 panel_data);
 135         struct msm_mddi_client_data *client_data = panel->client_data;
 136         struct msm_mddi_bridge_platform_data *bridge_data =
 137                 client_data->private_client_data;
 138
 139         return bridge_data->unblank(bridge_data, client_data);
 140 }
 141
 142 static irqreturn_t novtec_vsync_interrupt(int irq, void *data)
 143 {
 144         struct panel_info *panel = data;
 145
 146         panel->novtec_got_int = 1;
 147         if (panel->novtec_callback) {
 148                 mdelay(3);
 149                 panel->novtec_callback->func(panel->novtec_callback);
 150                 panel->novtec_callback = 0;
 151         }
 152         wake_up(&novtec_vsync_wait);
 153         return IRQ_HANDLED;
 154 }
 155
 156 static int setup_vsync(struct panel_info *panel,
 157                        int init)
 158 {
 159         int ret;
 160         int gpio = 98;
 161         unsigned int irq;
 162
 163         if (!init) {
 164                 ret = 0;
 165                 goto uninit;
 166         }
 167         ret = gpio_request(gpio, "vsync");
 168         if (ret)
 169                 goto err_request_gpio_failed;
 170
 171         ret = gpio_direction_input(gpio);
 172         if (ret)
 173                 goto err_gpio_direction_input_failed;
 174
 175         ret = irq = gpio_to_irq(gpio);
 176         if (ret < 0)
 177                 goto err_get_irq_num_failed;
 178
 179         ret = request_irq(irq, novtec_vsync_interrupt, IRQF_TRIGGER_FALLING,
 180                           "vsync", panel);
 181         if (ret)
 182                 goto err_request_irq_failed;
 183         printk(KERN_INFO "vsync on gpio %d now %d\n",
 184                gpio, gpio_get_value(gpio));
 185         return 0;
 186
 187 uninit:
 188         free_irq(gpio_to_irq(gpio), panel);
 189 err_request_irq_failed:
 190 err_get_irq_num_failed:
 191 err_gpio_direction_input_failed:
 192         gpio_free(gpio);
 193 err_request_gpio_failed:
 194         return ret;
 195 }
 196
 197 static int mddi_novtec_probe(struct platform_device *pdev)
 198 {
 199         int ret;
 200         struct msm_mddi_client_data *client_data = pdev->dev.platform_data;
 201         struct msm_mddi_bridge_platform_data *bridge_data =
 202                 client_data->private_client_data;
 203         struct panel_data *panel_data = &bridge_data->panel_conf;
 204         struct panel_info *panel =
 205                 kzalloc(sizeof(struct panel_info), GFP_KERNEL);
 206
 207         if (!panel)
 208                 return -ENOMEM;
 209         platform_set_drvdata(pdev, panel);
 210
 211         printk(KERN_DEBUG "%s\n", __func__);
 212
 213         if (panel_data->caps & MSMFB_CAP_CABC) {
 214                 printk(KERN_INFO "CABC enabled\n");
 215                 mddi_nov_cabc.dev.platform_data = client_data;
 216                 platform_device_register(&mddi_nov_cabc);
 217         }
 218
 219         ret = setup_vsync(panel, 1);
 220         if (ret) {
 221                 dev_err(&pdev->dev, "mddi_bridge_setup_vsync failed\n");
 222                 return ret;
 223         }
 224
 225         panel->client_data = client_data;
 226         panel->panel_data.suspend = novtec_suspend;
 227         panel->panel_data.resume = novtec_resume;
 228         panel->panel_data.wait_vsync = novtec_wait_vsync;
 229         panel->panel_data.request_vsync = novtec_request_vsync;
 230         panel->panel_data.clear_vsync = novtec_clear_vsync;
 231         panel->panel_data.blank = novtec_blank;
 232         panel->panel_data.unblank = novtec_unblank;
 233         panel->panel_data.fb_data =  &bridge_data->fb_data;
 234         panel->panel_data.caps = MSMFB_CAP_PARTIAL_UPDATES;
 235
 236         panel->pdev.name = "msm_panel";
 237         panel->pdev.id = pdev->id;
 238         panel->pdev.resource = client_data->fb_resource;
 239         panel->pdev.num_resources = 1;
 240         panel->pdev.dev.platform_data = &panel->panel_data;
 241         platform_device_register(&panel->pdev);
 242         wake_lock_init(&panel->idle_lock, WAKE_LOCK_IDLE, "nov_idle_lock");
 243
 244         return 0;
 245 }
 246
 247 static int mddi_novtec_remove(struct platform_device *pdev)
 248 {
 249         struct panel_info *panel = platform_get_drvdata(pdev);
 250
 251         setup_vsync(panel, 0);
 252         kfree(panel);
 253         return 0;
 254 }
 255
 256 static struct platform_driver mddi_client_d263_0000 = {
 257         .probe = mddi_novtec_probe,
 258         .remove = mddi_novtec_remove,
 259         .driver = { .name = "mddi_c_b9f6_5582" },
 260 };
 261
 262 static int __init mddi_client_novtec_init(void)
 263 {
 264         platform_driver_register(&mddi_client_d263_0000);
 265         return 0;
 266 }
 267
 268 module_init(mddi_client_novtec_init);
 269