1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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/gpio.h>
23#include <linux/sched.h>
24#include <linux/slab.h>
25#include <linux/platform_data/video-msm_fb.h>
26
27
28#define LCD_CONTROL_BLOCK_BASE 0x110000
29#define CMN (LCD_CONTROL_BLOCK_BASE|0x10)
30#define INTFLG (LCD_CONTROL_BLOCK_BASE|0x18)
31#define HCYCLE (LCD_CONTROL_BLOCK_BASE|0x34)
32#define HDE_START (LCD_CONTROL_BLOCK_BASE|0x3C)
33#define VPOS (LCD_CONTROL_BLOCK_BASE|0xC0)
34#define MPLFBUF (LCD_CONTROL_BLOCK_BASE|0x20)
35#define WAKEUP (LCD_CONTROL_BLOCK_BASE|0x54)
36#define WSYN_DLY (LCD_CONTROL_BLOCK_BASE|0x58)
37#define REGENB (LCD_CONTROL_BLOCK_BASE|0x5C)
38
39#define BASE5 0x150000
40#define BASE6 0x160000
41#define BASE7 0x170000
42
43#define GPIOIEV (BASE5 + 0x10)
44#define GPIOIE (BASE5 + 0x14)
45#define GPIORIS (BASE5 + 0x18)
46#define GPIOMIS (BASE5 + 0x1C)
47#define GPIOIC (BASE5 + 0x20)
48
49#define INTMASK (BASE6 + 0x0C)
50#define INTMASK_VWAKEOUT (1U << 0)
51#define INTMASK_VWAKEOUT_ACTIVE_LOW (1U << 8)
52#define GPIOSEL (BASE7 + 0x00)
53#define GPIOSEL_VWAKEINT (1U << 0)
54
55static DECLARE_WAIT_QUEUE_HEAD(toshiba_vsync_wait);
56
57struct panel_info {
58 struct msm_mddi_client_data *client_data;
59 struct platform_device pdev;
60 struct msm_panel_data panel_data;
61 struct msmfb_callback *toshiba_callback;
62 int toshiba_got_int;
63};
64
65
66static void toshiba_request_vsync(struct msm_panel_data *panel_data,
67 struct msmfb_callback *callback)
68{
69 struct panel_info *panel = container_of(panel_data, struct panel_info,
70 panel_data);
71 struct msm_mddi_client_data *client_data = panel->client_data;
72
73 panel->toshiba_callback = callback;
74 if (panel->toshiba_got_int) {
75 panel->toshiba_got_int = 0;
76 client_data->activate_link(client_data);
77 }
78}
79
80static void toshiba_clear_vsync(struct msm_panel_data *panel_data)
81{
82 struct panel_info *panel = container_of(panel_data, struct panel_info,
83 panel_data);
84 struct msm_mddi_client_data *client_data = panel->client_data;
85
86 client_data->activate_link(client_data);
87}
88
89static void toshiba_wait_vsync(struct msm_panel_data *panel_data)
90{
91 struct panel_info *panel = container_of(panel_data, struct panel_info,
92 panel_data);
93 struct msm_mddi_client_data *client_data = panel->client_data;
94
95 if (panel->toshiba_got_int) {
96 panel->toshiba_got_int = 0;
97 client_data->activate_link(client_data);
98 }
99 if (wait_event_timeout(toshiba_vsync_wait, panel->toshiba_got_int,
100 HZ/2) == 0)
101 printk(KERN_ERR "timeout waiting for VSYNC\n");
102 panel->toshiba_got_int = 0;
103
104}
105
106static int toshiba_suspend(struct msm_panel_data *panel_data)
107{
108 struct panel_info *panel = container_of(panel_data, struct panel_info,
109 panel_data);
110 struct msm_mddi_client_data *client_data = panel->client_data;
111
112 struct msm_mddi_bridge_platform_data *bridge_data =
113 client_data->private_client_data;
114 int ret;
115
116 ret = bridge_data->uninit(bridge_data, client_data);
117 if (ret) {
118 printk(KERN_INFO "mddi toshiba client: non zero return from "
119 "uninit\n");
120 return ret;
121 }
122 client_data->suspend(client_data);
123 return 0;
124}
125
126static int toshiba_resume(struct msm_panel_data *panel_data)
127{
128 struct panel_info *panel = container_of(panel_data, struct panel_info,
129 panel_data);
130 struct msm_mddi_client_data *client_data = panel->client_data;
131
132 struct msm_mddi_bridge_platform_data *bridge_data =
133 client_data->private_client_data;
134 int ret;
135
136 client_data->resume(client_data);
137 ret = bridge_data->init(bridge_data, client_data);
138 if (ret)
139 return ret;
140 return 0;
141}
142
143static int toshiba_blank(struct msm_panel_data *panel_data)
144{
145 struct panel_info *panel = container_of(panel_data, struct panel_info,
146 panel_data);
147 struct msm_mddi_client_data *client_data = panel->client_data;
148 struct msm_mddi_bridge_platform_data *bridge_data =
149 client_data->private_client_data;
150
151 return bridge_data->blank(bridge_data, client_data);
152}
153
154static int toshiba_unblank(struct msm_panel_data *panel_data)
155{
156 struct panel_info *panel = container_of(panel_data, struct panel_info,
157 panel_data);
158 struct msm_mddi_client_data *client_data = panel->client_data;
159 struct msm_mddi_bridge_platform_data *bridge_data =
160 client_data->private_client_data;
161
162 return bridge_data->unblank(bridge_data, client_data);
163}
164
165irqreturn_t toshiba_vsync_interrupt(int irq, void *data)
166{
167 struct panel_info *panel = data;
168
169 panel->toshiba_got_int = 1;
170 if (panel->toshiba_callback) {
171 panel->toshiba_callback->func(panel->toshiba_callback);
172 panel->toshiba_callback = 0;
173 }
174 wake_up(&toshiba_vsync_wait);
175 return IRQ_HANDLED;
176}
177
178static int setup_vsync(struct panel_info *panel,
179 int init)
180{
181 int ret;
182 int gpio = 97;
183 unsigned int irq;
184
185 if (!init) {
186 ret = 0;
187 goto uninit;
188 }
189 ret = gpio_request_one(gpio, GPIOF_IN, "vsync");
190 if (ret)
191 goto err_request_gpio_failed;
192
193 ret = irq = gpio_to_irq(gpio);
194 if (ret < 0)
195 goto err_get_irq_num_failed;
196
197 ret = request_irq(irq, toshiba_vsync_interrupt, IRQF_TRIGGER_RISING,
198 "vsync", panel);
199 if (ret)
200 goto err_request_irq_failed;
201 printk(KERN_INFO "vsync on gpio %d now %d\n",
202 gpio, gpio_get_value(gpio));
203 return 0;
204
205uninit:
206 free_irq(gpio_to_irq(gpio), panel);
207err_request_irq_failed:
208err_get_irq_num_failed:
209 gpio_free(gpio);
210err_request_gpio_failed:
211 return ret;
212}
213
214static int mddi_toshiba_probe(struct platform_device *pdev)
215{
216 int ret;
217 struct msm_mddi_client_data *client_data = pdev->dev.platform_data;
218 struct msm_mddi_bridge_platform_data *bridge_data =
219 client_data->private_client_data;
220 struct panel_info *panel =
221 kzalloc(sizeof(struct panel_info), GFP_KERNEL);
222 if (!panel)
223 return -ENOMEM;
224 platform_set_drvdata(pdev, panel);
225
226
227 client_data->remote_write(client_data, GPIOSEL_VWAKEINT, GPIOSEL);
228 client_data->remote_write(client_data, INTMASK_VWAKEOUT, INTMASK);
229
230 ret = setup_vsync(panel, 1);
231 if (ret) {
232 dev_err(&pdev->dev, "mddi_bridge_setup_vsync failed\n");
233 return ret;
234 }
235
236 panel->client_data = client_data;
237 panel->panel_data.suspend = toshiba_suspend;
238 panel->panel_data.resume = toshiba_resume;
239 panel->panel_data.wait_vsync = toshiba_wait_vsync;
240 panel->panel_data.request_vsync = toshiba_request_vsync;
241 panel->panel_data.clear_vsync = toshiba_clear_vsync;
242 panel->panel_data.blank = toshiba_blank;
243 panel->panel_data.unblank = toshiba_unblank;
244 panel->panel_data.fb_data = &bridge_data->fb_data;
245 panel->panel_data.caps = MSMFB_CAP_PARTIAL_UPDATES;
246
247 panel->pdev.name = "msm_panel";
248 panel->pdev.id = pdev->id;
249 panel->pdev.resource = client_data->fb_resource;
250 panel->pdev.num_resources = 1;
251 panel->pdev.dev.platform_data = &panel->panel_data;
252 bridge_data->init(bridge_data, client_data);
253 platform_device_register(&panel->pdev);
254
255 return 0;
256}
257
258static int mddi_toshiba_remove(struct platform_device *pdev)
259{
260 struct panel_info *panel = platform_get_drvdata(pdev);
261
262 setup_vsync(panel, 0);
263 kfree(panel);
264 return 0;
265}
266
267static struct platform_driver mddi_client_d263_0000 = {
268 .probe = mddi_toshiba_probe,
269 .remove = mddi_toshiba_remove,
270 .driver = { .name = "mddi_c_d263_0000" },
271};
272
273static int __init mddi_client_toshiba_init(void)
274{
275 platform_driver_register(&mddi_client_d263_0000);
276 return 0;
277}
278
279module_init(mddi_client_toshiba_init);
280
281
