drivers/video/msm: update to new kernel
[sfrench/cifs-2.6.git] / 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