]>
Commit | Line | Data |
---|---|---|
9d200153 SM |
1 | /* Copyright (c) 2008-2009, Code Aurora Forum. All rights reserved. |
2 | * | |
3 | * This program is free software; you can redistribute it and/or modify | |
4 | * it under the terms of the GNU General Public License version 2 and | |
5 | * only version 2 as published by the Free Software Foundation. | |
6 | * | |
7 | * This program is distributed in the hope that it will be useful, | |
8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
10 | * GNU General Public License for more details. | |
11 | * | |
12 | * You should have received a copy of the GNU General Public License | |
13 | * along with this program; if not, write to the Free Software | |
14 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
15 | * 02110-1301, USA. | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/kernel.h> | |
20 | #include <linux/sched.h> | |
21 | #include <linux/time.h> | |
22 | #include <linux/init.h> | |
23 | #include <linux/interrupt.h> | |
24 | #include <linux/spinlock.h> | |
25 | #include <linux/delay.h> | |
26 | #include <mach/hardware.h> | |
27 | #include <asm/io.h> | |
28 | ||
29 | #include <asm/system.h> | |
30 | #include <asm/mach-types.h> | |
31 | #include <linux/semaphore.h> | |
32 | #include <linux/uaccess.h> | |
33 | #include <linux/clk.h> | |
34 | #include <linux/platform_device.h> | |
35 | ||
36 | #include "msm_fb.h" | |
37 | #include "mddihosti.h" | |
38 | #include "mddihost.h" | |
39 | #include <mach/gpio.h> | |
40 | #include <mach/clk.h> | |
41 | ||
42 | static int mddi_probe(struct platform_device *pdev); | |
43 | static int mddi_remove(struct platform_device *pdev); | |
44 | ||
45 | static int mddi_off(struct platform_device *pdev); | |
46 | static int mddi_on(struct platform_device *pdev); | |
47 | ||
48 | static int mddi_suspend(struct platform_device *pdev, pm_message_t state); | |
49 | static int mddi_resume(struct platform_device *pdev); | |
50 | ||
51 | #ifdef CONFIG_HAS_EARLYSUSPEND | |
52 | static void mddi_early_suspend(struct early_suspend *h); | |
53 | static void mddi_early_resume(struct early_suspend *h); | |
54 | #endif | |
55 | ||
56 | static struct platform_device *pdev_list[MSM_FB_MAX_DEV_LIST]; | |
57 | static int pdev_list_cnt; | |
58 | static struct clk *mddi_clk; | |
59 | static struct clk *mddi_pclk; | |
60 | static struct mddi_platform_data *mddi_pdata; | |
61 | ||
62 | static struct platform_driver mddi_driver = { | |
63 | .probe = mddi_probe, | |
64 | .remove = mddi_remove, | |
65 | #ifndef CONFIG_HAS_EARLYSUSPEND | |
66 | #ifdef CONFIG_PM | |
67 | .suspend = mddi_suspend, | |
68 | .resume = mddi_resume, | |
69 | #endif | |
70 | #endif | |
71 | .suspend_late = NULL, | |
72 | .resume_early = NULL, | |
73 | .shutdown = NULL, | |
74 | .driver = { | |
75 | .name = "mddi", | |
76 | }, | |
77 | }; | |
78 | ||
79 | extern int int_mddi_pri_flag; | |
80 | ||
81 | static int mddi_off(struct platform_device *pdev) | |
82 | { | |
83 | int ret = 0; | |
84 | ||
85 | ret = panel_next_off(pdev); | |
86 | ||
87 | if (mddi_pdata && mddi_pdata->mddi_power_save) | |
88 | mddi_pdata->mddi_power_save(0); | |
89 | ||
90 | return ret; | |
91 | } | |
92 | ||
93 | static int mddi_on(struct platform_device *pdev) | |
94 | { | |
95 | int ret = 0; | |
96 | u32 clk_rate; | |
97 | struct msm_fb_data_type *mfd; | |
98 | ||
99 | mfd = platform_get_drvdata(pdev); | |
100 | ||
101 | if (mddi_pdata && mddi_pdata->mddi_power_save) | |
102 | mddi_pdata->mddi_power_save(1); | |
103 | ||
104 | clk_rate = mfd->fbi->var.pixclock; | |
105 | clk_rate = min(clk_rate, mfd->panel_info.clk_max); | |
106 | ||
107 | if (mddi_pdata && | |
108 | mddi_pdata->mddi_sel_clk && | |
109 | mddi_pdata->mddi_sel_clk(&clk_rate)) | |
110 | printk(KERN_ERR | |
111 | "%s: can't select mddi io clk targate rate = %d\n", | |
112 | __func__, clk_rate); | |
113 | ||
114 | if (clk_set_min_rate(mddi_clk, clk_rate) < 0) | |
115 | printk(KERN_ERR "%s: clk_set_min_rate failed\n", | |
116 | __func__); | |
117 | ||
118 | ret = panel_next_on(pdev); | |
119 | ||
120 | return ret; | |
121 | } | |
122 | ||
123 | static int mddi_resource_initialized; | |
124 | ||
125 | static int mddi_probe(struct platform_device *pdev) | |
126 | { | |
127 | struct msm_fb_data_type *mfd; | |
128 | struct platform_device *mdp_dev = NULL; | |
129 | struct msm_fb_panel_data *pdata = NULL; | |
130 | int rc; | |
131 | resource_size_t size ; | |
132 | u32 clk_rate; | |
133 | ||
134 | if ((pdev->id == 0) && (pdev->num_resources >= 0)) { | |
135 | mddi_pdata = pdev->dev.platform_data; | |
136 | ||
137 | size = resource_size(&pdev->resource[0]); | |
138 | msm_pmdh_base = ioremap(pdev->resource[0].start, size); | |
139 | ||
140 | MSM_FB_INFO("primary mddi base phy_addr = 0x%x virt = 0x%x\n", | |
141 | pdev->resource[0].start, (int) msm_pmdh_base); | |
142 | ||
143 | if (unlikely(!msm_pmdh_base)) | |
144 | return -ENOMEM; | |
145 | ||
146 | if (mddi_pdata && mddi_pdata->mddi_power_save) | |
147 | mddi_pdata->mddi_power_save(1); | |
148 | ||
149 | mddi_resource_initialized = 1; | |
150 | return 0; | |
151 | } | |
152 | ||
153 | if (!mddi_resource_initialized) | |
154 | return -EPERM; | |
155 | ||
156 | mfd = platform_get_drvdata(pdev); | |
157 | ||
158 | if (!mfd) | |
159 | return -ENODEV; | |
160 | ||
161 | if (mfd->key != MFD_KEY) | |
162 | return -EINVAL; | |
163 | ||
164 | if (pdev_list_cnt >= MSM_FB_MAX_DEV_LIST) | |
165 | return -ENOMEM; | |
166 | ||
167 | mdp_dev = platform_device_alloc("mdp", pdev->id); | |
168 | if (!mdp_dev) | |
169 | return -ENOMEM; | |
170 | ||
171 | /* | |
172 | * link to the latest pdev | |
173 | */ | |
174 | mfd->pdev = mdp_dev; | |
175 | mfd->dest = DISPLAY_LCD; | |
176 | ||
177 | /* | |
178 | * alloc panel device data | |
179 | */ | |
180 | if (platform_device_add_data | |
181 | (mdp_dev, pdev->dev.platform_data, | |
182 | sizeof(struct msm_fb_panel_data))) { | |
183 | printk(KERN_ERR "mddi_probe: platform_device_add_data failed!\n"); | |
184 | platform_device_put(mdp_dev); | |
185 | return -ENOMEM; | |
186 | } | |
187 | /* | |
188 | * data chain | |
189 | */ | |
190 | pdata = mdp_dev->dev.platform_data; | |
191 | pdata->on = mddi_on; | |
192 | pdata->off = mddi_off; | |
193 | pdata->next = pdev; | |
194 | ||
195 | /* | |
196 | * get/set panel specific fb info | |
197 | */ | |
198 | mfd->panel_info = pdata->panel_info; | |
199 | mfd->fb_imgType = MDP_RGB_565; | |
200 | ||
201 | clk_rate = mfd->panel_info.clk_max; | |
202 | if (mddi_pdata && | |
203 | mddi_pdata->mddi_sel_clk && | |
204 | mddi_pdata->mddi_sel_clk(&clk_rate)) | |
205 | printk(KERN_ERR | |
206 | "%s: can't select mddi io clk targate rate = %d\n", | |
207 | __func__, clk_rate); | |
208 | ||
209 | if (clk_set_max_rate(mddi_clk, clk_rate) < 0) | |
210 | printk(KERN_ERR "%s: clk_set_max_rate failed\n", __func__); | |
211 | mfd->panel_info.clk_rate = mfd->panel_info.clk_min; | |
212 | ||
213 | /* | |
214 | * set driver data | |
215 | */ | |
216 | platform_set_drvdata(mdp_dev, mfd); | |
217 | ||
218 | /* | |
219 | * register in mdp driver | |
220 | */ | |
221 | rc = platform_device_add(mdp_dev); | |
222 | if (rc) | |
223 | goto mddi_probe_err; | |
224 | ||
225 | pdev_list[pdev_list_cnt++] = pdev; | |
226 | ||
227 | #ifdef CONFIG_HAS_EARLYSUSPEND | |
228 | mfd->mddi_early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB; | |
229 | mfd->mddi_early_suspend.suspend = mddi_early_suspend; | |
230 | mfd->mddi_early_suspend.resume = mddi_early_resume; | |
231 | register_early_suspend(&mfd->mddi_early_suspend); | |
232 | #endif | |
233 | ||
234 | return 0; | |
235 | ||
236 | mddi_probe_err: | |
237 | platform_device_put(mdp_dev); | |
238 | return rc; | |
239 | } | |
240 | ||
241 | static int mddi_pad_ctrl; | |
242 | static int mddi_power_locked; | |
243 | static int mddi_is_in_suspend; | |
244 | ||
245 | void mddi_disable(int lock) | |
246 | { | |
247 | mddi_host_type host_idx = MDDI_HOST_PRIM; | |
248 | ||
249 | if (mddi_power_locked) | |
250 | return; | |
251 | ||
252 | if (lock) | |
253 | mddi_power_locked = 1; | |
254 | ||
255 | if (mddi_host_timer.function) | |
256 | del_timer_sync(&mddi_host_timer); | |
257 | ||
258 | mddi_pad_ctrl = mddi_host_reg_in(PAD_CTL); | |
259 | mddi_host_reg_out(PAD_CTL, 0x0); | |
260 | ||
261 | if (clk_set_min_rate(mddi_clk, 0) < 0) | |
262 | printk(KERN_ERR "%s: clk_set_min_rate failed\n", __func__); | |
263 | ||
264 | clk_disable(mddi_clk); | |
265 | if (mddi_pclk) | |
266 | clk_disable(mddi_pclk); | |
267 | disable_irq(INT_MDDI_PRI); | |
268 | ||
269 | if (mddi_pdata && mddi_pdata->mddi_power_save) | |
270 | mddi_pdata->mddi_power_save(0); | |
271 | } | |
272 | ||
273 | static int mddi_suspend(struct platform_device *pdev, pm_message_t state) | |
274 | { | |
275 | if (mddi_is_in_suspend) | |
276 | return 0; | |
277 | ||
278 | mddi_is_in_suspend = 1; | |
279 | mddi_disable(0); | |
280 | return 0; | |
281 | } | |
282 | ||
283 | static int mddi_resume(struct platform_device *pdev) | |
284 | { | |
285 | mddi_host_type host_idx = MDDI_HOST_PRIM; | |
286 | ||
287 | if (!mddi_is_in_suspend) | |
288 | return 0; | |
289 | ||
290 | mddi_is_in_suspend = 0; | |
291 | ||
292 | if (mddi_power_locked) | |
293 | return 0; | |
294 | ||
295 | enable_irq(INT_MDDI_PRI); | |
296 | clk_enable(mddi_clk); | |
297 | if (mddi_pclk) | |
298 | clk_enable(mddi_pclk); | |
299 | mddi_host_reg_out(PAD_CTL, mddi_pad_ctrl); | |
300 | ||
301 | if (mddi_host_timer.function) | |
302 | mddi_host_timer_service(0); | |
303 | ||
304 | return 0; | |
305 | } | |
306 | ||
307 | #ifdef CONFIG_HAS_EARLYSUSPEND | |
308 | static void mddi_early_suspend(struct early_suspend *h) | |
309 | { | |
310 | pm_message_t state; | |
311 | struct msm_fb_data_type *mfd = container_of(h, struct msm_fb_data_type, | |
312 | mddi_early_suspend); | |
313 | ||
314 | state.event = PM_EVENT_SUSPEND; | |
315 | mddi_suspend(mfd->pdev, state); | |
316 | } | |
317 | ||
318 | static void mddi_early_resume(struct early_suspend *h) | |
319 | { | |
320 | struct msm_fb_data_type *mfd = container_of(h, struct msm_fb_data_type, | |
321 | mddi_early_suspend); | |
322 | mddi_resume(mfd->pdev); | |
323 | } | |
324 | #endif | |
325 | ||
326 | static int mddi_remove(struct platform_device *pdev) | |
327 | { | |
328 | if (mddi_host_timer.function) | |
329 | del_timer_sync(&mddi_host_timer); | |
330 | ||
331 | iounmap(msm_pmdh_base); | |
332 | ||
333 | return 0; | |
334 | } | |
335 | ||
336 | static int mddi_register_driver(void) | |
337 | { | |
338 | return platform_driver_register(&mddi_driver); | |
339 | } | |
340 | ||
341 | static int __init mddi_driver_init(void) | |
342 | { | |
343 | int ret; | |
344 | ||
345 | mddi_clk = clk_get(NULL, "mddi_clk"); | |
346 | if (IS_ERR(mddi_clk)) { | |
347 | printk(KERN_ERR "can't find mddi_clk \n"); | |
348 | return PTR_ERR(mddi_clk); | |
349 | } | |
350 | clk_enable(mddi_clk); | |
351 | ||
352 | mddi_pclk = clk_get(NULL, "mddi_pclk"); | |
353 | if (IS_ERR(mddi_pclk)) | |
354 | mddi_pclk = NULL; | |
355 | else | |
356 | clk_enable(mddi_pclk); | |
357 | ||
358 | ret = mddi_register_driver(); | |
359 | if (ret) { | |
360 | clk_disable(mddi_clk); | |
361 | clk_put(mddi_clk); | |
362 | if (mddi_pclk) { | |
363 | clk_disable(mddi_pclk); | |
364 | clk_put(mddi_pclk); | |
365 | } | |
366 | printk(KERN_ERR "mddi_register_driver() failed!\n"); | |
367 | return ret; | |
368 | } | |
369 | ||
370 | mddi_init(); | |
371 | ||
372 | return ret; | |
373 | } | |
374 | ||
375 | module_init(mddi_driver_init); |