drivers/video/msm/mddi_client_nt35399.c

   1 /* drivers/video/msm_fb/mddi_client_nt35399.c
   2  *
   3  * Support for Novatek NT35399 MDDI client of Sapphire
   4  *
   5  * Copyright (C) 2008 HTC Incorporated
   6  * Author: Solomon Chiu (solomon_chiu@htc.com)
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17
  18 #include <linux/module.h>
  19 #include <linux/kernel.h>
  20 #include <linux/platform_device.h>
  21 #include <linux/interrupt.h>
  22 #include <linux/sched.h>
  23 #include <linux/gpio.h>
  24 #include <mach/msm_fb.h>
  25
  26 static DECLARE_WAIT_QUEUE_HEAD(nt35399_vsync_wait);
  27
  28 struct panel_info {
  29         struct msm_mddi_client_data *client_data;
  30         struct platform_device pdev;
  31         struct msm_panel_data panel_data;
  32         struct msmfb_callback *fb_callback;
  33         struct work_struct panel_work;
  34         struct workqueue_struct *fb_wq;
  35         int nt35399_got_int;
  36 };
  37
  38 static void
  39 nt35399_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->fb_callback = callback;
  47         if (panel->nt35399_got_int) {
  48                 panel->nt35399_got_int = 0;
  49                 client_data->activate_link(client_data); /* clears interrupt */
  50         }
  51 }
  52
  53 static void nt35399_wait_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         if (panel->nt35399_got_int) {
  60                 panel->nt35399_got_int = 0;
  61                 client_data->activate_link(client_data); /* clears interrupt */
  62         }
  63
  64         if (wait_event_timeout(nt35399_vsync_wait, panel->nt35399_got_int,
  65                                 HZ/2) == 0)
  66                 printk(KERN_ERR "timeout waiting for VSYNC\n");
  67
  68         panel->nt35399_got_int = 0;
  69         /* interrupt clears when screen dma starts */
  70 }
  71
  72 static int nt35399_suspend(struct msm_panel_data *panel_data)
  73 {
  74         struct panel_info *panel = container_of(panel_data, struct panel_info,
  75                                                 panel_data);
  76         struct msm_mddi_client_data *client_data = panel->client_data;
  77
  78         struct msm_mddi_bridge_platform_data *bridge_data =
  79                 client_data->private_client_data;
  80         int ret;
  81
  82         ret = bridge_data->uninit(bridge_data, client_data);
  83         if (ret) {
  84                 printk(KERN_INFO "mddi nt35399 client: non zero return from "
  85                         "uninit\n");
  86                 return ret;
  87         }
  88         client_data->suspend(client_data);
  89         return 0;
  90 }
  91
  92 static int nt35399_resume(struct msm_panel_data *panel_data)
  93 {
  94         struct panel_info *panel = container_of(panel_data, struct panel_info,
  95                                                 panel_data);
  96         struct msm_mddi_client_data *client_data = panel->client_data;
  97
  98         struct msm_mddi_bridge_platform_data *bridge_data =
  99                 client_data->private_client_data;
 100         int ret;
 101
 102         client_data->resume(client_data);
 103         ret = bridge_data->init(bridge_data, client_data);
 104         if (ret)
 105                 return ret;
 106         return 0;
 107 }
 108
 109 static int nt35399_blank(struct msm_panel_data *panel_data)
 110 {
 111         struct panel_info *panel = container_of(panel_data, struct panel_info,
 112                                                 panel_data);
 113         struct msm_mddi_client_data *client_data = panel->client_data;
 114         struct msm_mddi_bridge_platform_data *bridge_data =
 115                 client_data->private_client_data;
 116
 117         return bridge_data->blank(bridge_data, client_data);
 118 }
 119
 120 static int nt35399_unblank(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->unblank(bridge_data, client_data);
 129 }
 130
 131 irqreturn_t nt35399_vsync_interrupt(int irq, void *data)
 132 {
 133         struct panel_info *panel = data;
 134
 135         panel->nt35399_got_int = 1;
 136
 137         if (panel->fb_callback) {
 138                 panel->fb_callback->func(panel->fb_callback);
 139                 panel->fb_callback = NULL;
 140         }
 141
 142         wake_up(&nt35399_vsync_wait);
 143
 144         return IRQ_HANDLED;
 145 }
 146
 147 static int setup_vsync(struct panel_info *panel, int init)
 148 {
 149         int ret;
 150         int gpio = 97;
 151         unsigned int irq;
 152
 153         if (!init) {
 154                 ret = 0;
 155                 goto uninit;
 156         }
 157         ret = gpio_request(gpio, "vsync");
 158         if (ret)
 159                 goto err_request_gpio_failed;
 160
 161         ret = gpio_direction_input(gpio);
 162         if (ret)
 163                 goto err_gpio_direction_input_failed;
 164
 165         ret = irq = gpio_to_irq(gpio);
 166         if (ret < 0)
 167                 goto err_get_irq_num_failed;
 168
 169         ret = request_irq(irq, nt35399_vsync_interrupt, IRQF_TRIGGER_RISING,
 170                           "vsync", panel);
 171         if (ret)
 172                 goto err_request_irq_failed;
 173
 174         printk(KERN_INFO "vsync on gpio %d now %d\n",
 175                gpio, gpio_get_value(gpio));
 176         return 0;
 177
 178 uninit:
 179         free_irq(gpio_to_irq(gpio), panel->client_data);
 180 err_request_irq_failed:
 181 err_get_irq_num_failed:
 182 err_gpio_direction_input_failed:
 183         gpio_free(gpio);
 184 err_request_gpio_failed:
 185         return ret;
 186 }
 187
 188 static int mddi_nt35399_probe(struct platform_device *pdev)
 189 {
 190         struct msm_mddi_client_data *client_data = pdev->dev.platform_data;
 191         struct msm_mddi_bridge_platform_data *bridge_data =
 192                 client_data->private_client_data;
 193
 194         int ret;
 195
 196         struct panel_info *panel = kzalloc(sizeof(struct panel_info),
 197                                            GFP_KERNEL);
 198
 199         printk(KERN_DEBUG "%s: enter.\n", __func__);
 200
 201         if (!panel)
 202                 return -ENOMEM;
 203         platform_set_drvdata(pdev, panel);
 204
 205         ret = setup_vsync(panel, 1);
 206         if (ret) {
 207                 dev_err(&pdev->dev, "mddi_nt35399_setup_vsync failed\n");
 208                 return ret;
 209         }
 210
 211         panel->client_data = client_data;
 212         panel->panel_data.suspend = nt35399_suspend;
 213         panel->panel_data.resume = nt35399_resume;
 214         panel->panel_data.wait_vsync = nt35399_wait_vsync;
 215         panel->panel_data.request_vsync = nt35399_request_vsync;
 216         panel->panel_data.blank = nt35399_blank;
 217         panel->panel_data.unblank = nt35399_unblank;
 218         panel->panel_data.fb_data = &bridge_data->fb_data;
 219         panel->panel_data.caps = 0;
 220
 221         panel->pdev.name = "msm_panel";
 222         panel->pdev.id = pdev->id;
 223         panel->pdev.resource = client_data->fb_resource;
 224         panel->pdev.num_resources = 1;
 225         panel->pdev.dev.platform_data = &panel->panel_data;
 226
 227         if (bridge_data->init)
 228                 bridge_data->init(bridge_data, client_data);
 229
 230         platform_device_register(&panel->pdev);
 231
 232         return 0;
 233 }
 234
 235 static int mddi_nt35399_remove(struct platform_device *pdev)
 236 {
 237         struct panel_info *panel = platform_get_drvdata(pdev);
 238
 239         setup_vsync(panel, 0);
 240         kfree(panel);
 241         return 0;
 242 }
 243
 244 static struct platform_driver mddi_client_0bda_8a47 = {
 245         .probe = mddi_nt35399_probe,
 246         .remove = mddi_nt35399_remove,
 247         .driver = { .name = "mddi_c_0bda_8a47" },
 248 };
 249
 250 static int __init mddi_client_nt35399_init(void)
 251 {
 252         return platform_driver_register(&mddi_client_0bda_8a47);
 253 }
 254
 255 module_init(mddi_client_nt35399_init);
 256