WAR: gr3d: limit 3d clock when camera is on
[linux-2.6.git] / drivers / media / video / tegra / tegra_camera.c
1 /*
2  * drivers/media/video/tegra/tegra_camera.c
3  *
4  * Copyright (C) 2010 Google, Inc.
5  * Copyright (c) 2010-2012, NVIDIA Corporation.  All rights reserved.
6  *
7  * This software is licensed under the terms of the GNU General Public
8  * License version 2, as published by the Free Software Foundation, and
9  * may be copied, distributed, and modified under those terms.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  */
17
18 #include <linux/miscdevice.h>
19 #include <linux/platform_device.h>
20 #include <linux/ioctl.h>
21 #include <linux/fs.h>
22 #include <linux/device.h>
23 #include <linux/regulator/consumer.h>
24 #include <linux/clk.h>
25 #include <linux/io.h>
26 #include <linux/uaccess.h>
27 #include <linux/delay.h>
28 #include <mach/iomap.h>
29 #include <mach/clk.h>
30 #include <mach/powergate.h>
31
32 #include <media/tegra_camera.h>
33
34 /* Eventually this should handle all clock and reset calls for the isp, vi,
35  * vi_sensor, and csi modules, replacing nvrm and nvos completely for camera
36  */
37 #define TEGRA_CAMERA_NAME "tegra_camera"
38
39 struct tegra_camera_dev {
40         struct device *dev;
41         struct miscdevice misc_dev;
42         struct clk *isp_clk;
43         struct clk *vi_clk;
44         struct clk *vi_sensor_clk;
45         struct clk *csus_clk;
46         struct clk *csi_clk;
47         struct clk *emc_clk;
48         struct regulator *reg;
49         struct tegra_camera_clk_info info;
50         struct mutex tegra_camera_lock;
51         atomic_t in_use;
52         int power_on;
53 };
54
55 struct tegra_camera_block {
56         int (*enable) (struct tegra_camera_dev *dev);
57         int (*disable) (struct tegra_camera_dev *dev);
58         bool is_enabled;
59 };
60
61 /*
62  * Declare and define two static variables to provide hint to
63  * gr3d module
64  */
65 static int tegra_camera_on;
66 static struct tegra_camera_platform_data *pdata;
67
68 int is_tegra_camera_on(void)
69 {
70         if (pdata) {
71                 if (pdata->limit_3d_emc_clk)
72                         return tegra_camera_on;
73                 else
74                         return 0;
75         } else {
76                 return 0;
77         }
78 }
79
80 static int tegra_camera_enable_clk(struct tegra_camera_dev *dev)
81 {
82         clk_enable(dev->vi_clk);
83         clk_enable(dev->vi_sensor_clk);
84         clk_enable(dev->csus_clk);
85
86         tegra_periph_reset_assert(dev->vi_clk);
87         udelay(2);
88         tegra_periph_reset_deassert(dev->vi_clk);
89
90         clk_enable(dev->isp_clk);
91         tegra_periph_reset_assert(dev->isp_clk);
92         udelay(2);
93         tegra_periph_reset_deassert(dev->isp_clk);
94
95         clk_enable(dev->csi_clk);
96         tegra_periph_reset_assert(dev->csi_clk);
97         udelay(2);
98         tegra_periph_reset_deassert(dev->csi_clk);
99         return 0;
100 }
101
102 static int tegra_camera_disable_clk(struct tegra_camera_dev *dev)
103 {
104         clk_disable(dev->csi_clk);
105         tegra_periph_reset_assert(dev->csi_clk);
106         clk_disable(dev->isp_clk);
107         tegra_periph_reset_assert(dev->isp_clk);
108         clk_disable(dev->csus_clk);
109         clk_disable(dev->vi_sensor_clk);
110         clk_disable(dev->vi_clk);
111         tegra_periph_reset_assert(dev->vi_clk);
112
113         return 0;
114 }
115
116 static int tegra_camera_enable_emc(struct tegra_camera_dev *dev)
117 {
118         int ret = tegra_emc_disable_eack();
119         clk_enable(dev->emc_clk);
120 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
121         clk_set_rate(dev->emc_clk, 300000000);
122 #endif
123         return ret;
124 }
125
126 static int tegra_camera_disable_emc(struct tegra_camera_dev *dev)
127 {
128         clk_disable(dev->emc_clk);
129         return tegra_emc_enable_eack();
130 }
131
132 static int tegra_camera_clk_set_rate(struct tegra_camera_dev *dev)
133 {
134         struct clk *clk, *clk_parent;
135         struct tegra_camera_clk_info *info = &dev->info;
136         unsigned long parent_rate, parent_div_rate, parent_div_rate_pre;
137
138         if (!info) {
139                 dev_err(dev->dev,
140                                 "%s: no clock info %d\n",
141                                 __func__, info->id);
142                 return -EINVAL;
143         }
144
145         if (info->id != TEGRA_CAMERA_MODULE_VI &&
146                 info->id != TEGRA_CAMERA_MODULE_EMC) {
147                 dev_err(dev->dev,
148                                 "%s: set rate only aplies to vi module %d\n",
149                                 __func__, info->id);
150                 return -EINVAL;
151         }
152
153         switch (info->clk_id) {
154         case TEGRA_CAMERA_VI_CLK:
155                 clk = dev->vi_clk;
156                 break;
157         case TEGRA_CAMERA_VI_SENSOR_CLK:
158                 clk = dev->vi_sensor_clk;
159                 break;
160         case TEGRA_CAMERA_EMC_CLK:
161                 clk = dev->emc_clk;
162 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
163                 dev_dbg(dev->dev, "%s: emc_clk rate=%lu\n",
164                         __func__, info->rate);
165                 clk_set_rate(dev->emc_clk, info->rate);
166 #endif
167                 goto set_rate_end;
168         default:
169                 dev_err(dev->dev,
170                                 "%s: invalid clk id for set rate %d\n",
171                                 __func__, info->clk_id);
172                 return -EINVAL;
173         }
174
175         clk_parent = clk_get_parent(clk);
176         parent_rate = clk_get_rate(clk_parent);
177         dev_dbg(dev->dev, "%s: clk_id=%d, parent_rate=%lu, clk_rate=%lu\n",
178                         __func__, info->clk_id, parent_rate, info->rate);
179         parent_div_rate = parent_rate;
180         parent_div_rate_pre = parent_rate;
181
182         /*
183          * The requested clock rate from user space should be respected.
184          * This loop is to search the clock rate that is higher than requested
185          * clock.
186          */
187         while (parent_div_rate >= info->rate) {
188                 parent_div_rate_pre = parent_div_rate;
189                 parent_div_rate = clk_round_rate(clk, parent_div_rate-1);
190         }
191
192         dev_dbg(dev->dev, "%s: set_rate=%lu",
193                         __func__, parent_div_rate_pre);
194
195         clk_set_rate(clk, parent_div_rate_pre);
196
197         if (info->clk_id == TEGRA_CAMERA_VI_CLK) {
198                 /*
199                  * bit 25: 0 = pd2vi_Clk, 1 = vi_sensor_clk
200                  * bit 24: 0 = internal clock, 1 = external clock(pd2vi_clk)
201                  */
202                 if (info->flag == TEGRA_CAMERA_ENABLE_PD2VI_CLK)
203                         tegra_clk_cfg_ex(clk, TEGRA_CLK_VI_INP_SEL, 2);
204
205 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
206                 {
207                         u32 val;
208                         void __iomem *apb_misc =
209                                 IO_ADDRESS(TEGRA_APB_MISC_BASE);
210                         val = readl(apb_misc + 0x42c);
211                         writel(val | 0x1, apb_misc + 0x42c);
212                 }
213 #endif
214         }
215
216 set_rate_end:
217         info->rate = clk_get_rate(clk);
218         dev_dbg(dev->dev, "%s: get_rate=%lu",
219                         __func__, info->rate);
220         return 0;
221
222 }
223
224 static int tegra_camera_power_on(struct tegra_camera_dev *dev)
225 {
226         int ret = 0;
227
228         dev_dbg(dev->dev, "%s++\n", __func__);
229
230         /* Enable external power */
231         if (dev->reg) {
232                 ret = regulator_enable(dev->reg);
233                 if (ret) {
234                         dev_err(dev->dev,
235                                 "%s: enable csi regulator failed.\n",
236                                 __func__);
237                         return ret;
238                 }
239         }
240 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
241         /* Unpowergate VE */
242         ret = tegra_unpowergate_partition(TEGRA_POWERGATE_VENC);
243         if (ret)
244                 dev_err(dev->dev,
245                         "%s: unpowergate failed.\n",
246                         __func__);
247 #endif
248         dev->power_on = 1;
249         tegra_camera_on = dev->power_on;
250         return ret;
251 }
252
253 static int tegra_camera_power_off(struct tegra_camera_dev *dev)
254 {
255         int ret = 0;
256
257         dev_dbg(dev->dev, "%s++\n", __func__);
258
259 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
260         /* Powergate VE */
261         ret = tegra_powergate_partition(TEGRA_POWERGATE_VENC);
262         if (ret)
263                 dev_err(dev->dev,
264                         "%s: powergate failed.\n",
265                         __func__);
266 #endif
267         /* Disable external power */
268         if (dev->reg) {
269                 ret = regulator_disable(dev->reg);
270                 if (ret) {
271                         dev_err(dev->dev,
272                                 "%s: disable csi regulator failed.\n",
273                                 __func__);
274                         return ret;
275                 }
276         }
277         dev->power_on = 0;
278         tegra_camera_on = dev->power_on;
279         return ret;
280 }
281
282 static long tegra_camera_ioctl(struct file *file,
283                                unsigned int cmd, unsigned long arg)
284 {
285         uint id;
286         struct tegra_camera_dev *dev = file->private_data;
287
288         /* first element of arg must be u32 with id of module to talk to */
289         if (copy_from_user(&id, (const void __user *)arg, sizeof(uint))) {
290                 dev_err(dev->dev,
291                                 "%s: Failed to copy arg from user", __func__);
292                 return -EFAULT;
293         }
294
295         if (id >= TEGRA_CAMERA_MODULE_MAX) {
296                 dev_err(dev->dev,
297                                 "%s: Invalid id to tegra isp ioctl%d\n",
298                                 __func__, id);
299                 return -EINVAL;
300         }
301
302         switch (cmd) {
303         /*
304          * Clock enable/disable and reset should be handled in kernel.
305          * In order to support legacy code in user space, we don't remove
306          * these IOCTL.
307          */
308         case TEGRA_CAMERA_IOCTL_ENABLE:
309         case TEGRA_CAMERA_IOCTL_DISABLE:
310         case TEGRA_CAMERA_IOCTL_RESET:
311                 return 0;
312         case TEGRA_CAMERA_IOCTL_CLK_SET_RATE:
313         {
314                 int ret;
315
316                 if (copy_from_user(&dev->info, (const void __user *)arg,
317                                    sizeof(struct tegra_camera_clk_info))) {
318                         dev_err(dev->dev,
319                                 "%s: Failed to copy arg from user\n", __func__);
320                         return -EFAULT;
321                 }
322                 ret = tegra_camera_clk_set_rate(dev);
323                 if (ret)
324                         return ret;
325                 if (copy_to_user((void __user *)arg, &dev->info,
326                                  sizeof(struct tegra_camera_clk_info))) {
327                         dev_err(dev->dev,
328                                 "%s: Failed to copy arg to user\n", __func__);
329                         return -EFAULT;
330                 }
331                 return 0;
332         }
333         default:
334                 dev_err(dev->dev,
335                                 "%s: Unknown tegra_camera ioctl.\n", __func__);
336                 return -EINVAL;
337         }
338         return 0;
339 }
340
341 static int tegra_camera_open(struct inode *inode, struct file *file)
342 {
343         struct miscdevice *miscdev = file->private_data;
344         struct tegra_camera_dev *dev = container_of(miscdev,
345                                                 struct tegra_camera_dev,
346                                                 misc_dev);
347         int ret = 0;
348
349         dev_info(dev->dev, "%s\n", __func__);
350
351         if (atomic_xchg(&dev->in_use, 1))
352                 return -EBUSY;
353
354         file->private_data = dev;
355
356         mutex_lock(&dev->tegra_camera_lock);
357         /* turn on CSI regulator */
358         ret = tegra_camera_power_on(dev);
359         if (ret)
360                 goto open_exit;
361         /* set EMC request */
362         ret = tegra_camera_enable_emc(dev);
363         if (ret)
364                 goto open_exit;
365         /* enable camera HW clock */
366         ret = tegra_camera_enable_clk(dev);
367         if (ret)
368                 goto open_exit;
369 open_exit:
370         mutex_unlock(&dev->tegra_camera_lock);
371         return ret;
372 }
373
374 static int tegra_camera_release(struct inode *inode, struct file *file)
375 {
376         int ret = 0;
377         struct tegra_camera_dev *dev = file->private_data;
378
379         dev_info(dev->dev, "%s\n", __func__);
380
381
382         mutex_lock(&dev->tegra_camera_lock);
383         /* disable HW clock */
384         ret = tegra_camera_disable_clk(dev);
385         if (ret)
386                 goto release_exit;
387         /* nullify EMC request */
388         ret = tegra_camera_disable_emc(dev);
389         if (ret)
390                 goto release_exit;
391         /* turn off CSI regulator */
392         tegra_camera_power_off(dev);
393         if (ret)
394                 goto release_exit;
395
396 release_exit:
397         mutex_unlock(&dev->tegra_camera_lock);
398         WARN_ON(!atomic_xchg(&dev->in_use, 0));
399         return 0;
400 }
401
402 static const struct file_operations tegra_camera_fops = {
403         .owner = THIS_MODULE,
404         .open = tegra_camera_open,
405         .unlocked_ioctl = tegra_camera_ioctl,
406         .release = tegra_camera_release,
407 };
408
409 static int tegra_camera_clk_get(struct platform_device *pdev, const char *name,
410                                 struct clk **clk)
411 {
412         *clk = clk_get(&pdev->dev, name);
413         if (IS_ERR_OR_NULL(*clk)) {
414                 dev_err(&pdev->dev, "%s: unable to get clock for %s\n",
415                         __func__, name);
416                 *clk = NULL;
417                 return PTR_ERR(*clk);
418         }
419         return 0;
420 }
421
422 static int tegra_camera_probe(struct platform_device *pdev)
423 {
424         int err;
425         struct tegra_camera_dev *dev;
426
427         dev_info(&pdev->dev, "%s\n", __func__);
428         dev = devm_kzalloc(&pdev->dev, sizeof(struct tegra_camera_dev),
429                         GFP_KERNEL);
430         if (!dev) {
431                 err = -ENOMEM;
432                 dev_err(&pdev->dev, "%s: unable to allocate memory\n",
433                         __func__);
434                 goto alloc_err;
435         }
436
437         mutex_init(&dev->tegra_camera_lock);
438
439         /* Powergate VE when boot */
440         mutex_lock(&dev->tegra_camera_lock);
441 #ifndef CONFIG_ARCH_TEGRA_2x_SOC
442         err = tegra_powergate_partition(TEGRA_POWERGATE_VENC);
443         if (err)
444                 dev_err(&pdev->dev, "%s: powergate failed.\n", __func__);
445 #endif
446         mutex_unlock(&dev->tegra_camera_lock);
447
448         dev->dev = &pdev->dev;
449         pdata = pdev->dev.platform_data;
450
451         /* Get regulator pointer */
452 #ifdef CONFIG_ARCH_TEGRA_2x_SOC
453         dev->reg = regulator_get(&pdev->dev, "vcsi");
454 #else
455         dev->reg = regulator_get(&pdev->dev, "avdd_dsi_csi");
456 #endif
457         if (IS_ERR_OR_NULL(dev->reg)) {
458                 if (dev->reg == ERR_PTR(-ENODEV)) {
459                         dev->reg = NULL;
460                         dev_info(&pdev->dev, "%s: no regulator device, overriding\n",
461                                                         __func__);
462                 } else {
463                         dev_err(&pdev->dev, "%s: couldn't get regulator\n",
464                                                         __func__);
465                         return PTR_ERR(dev->reg);
466                 }
467         }
468
469         dev->misc_dev.minor = MISC_DYNAMIC_MINOR;
470         dev->misc_dev.name = TEGRA_CAMERA_NAME;
471         dev->misc_dev.fops = &tegra_camera_fops;
472         dev->misc_dev.parent = &pdev->dev;
473
474         err = misc_register(&dev->misc_dev);
475         if (err) {
476                 dev_err(&pdev->dev, "%s: Unable to register misc device!\n",
477                        TEGRA_CAMERA_NAME);
478                 goto misc_register_err;
479         }
480
481         err = tegra_camera_clk_get(pdev, "isp", &dev->isp_clk);
482         if (err)
483                 goto misc_register_err;
484         err = tegra_camera_clk_get(pdev, "vi", &dev->vi_clk);
485         if (err)
486                 goto vi_clk_get_err;
487         err = tegra_camera_clk_get(pdev, "vi_sensor", &dev->vi_sensor_clk);
488         if (err)
489                 goto vi_sensor_clk_get_err;
490         err = tegra_camera_clk_get(pdev, "csus", &dev->csus_clk);
491         if (err)
492                 goto csus_clk_get_err;
493         err = tegra_camera_clk_get(pdev, "csi", &dev->csi_clk);
494         if (err)
495                 goto csi_clk_get_err;
496         err = tegra_camera_clk_get(pdev, "emc", &dev->emc_clk);
497         if (err)
498                 goto emc_clk_get_err;
499
500         /* dev is set in order to restore in _remove */
501         platform_set_drvdata(pdev, dev);
502
503         return 0;
504
505 emc_clk_get_err:
506         clk_put(dev->emc_clk);
507 csi_clk_get_err:
508         clk_put(dev->csus_clk);
509 csus_clk_get_err:
510         clk_put(dev->vi_sensor_clk);
511 vi_sensor_clk_get_err:
512         clk_put(dev->vi_clk);
513 vi_clk_get_err:
514         clk_put(dev->isp_clk);
515 misc_register_err:
516         regulator_put(dev->reg);
517 alloc_err:
518         return err;
519 }
520
521 static int tegra_camera_remove(struct platform_device *pdev)
522 {
523         struct tegra_camera_dev *dev = platform_get_drvdata(pdev);
524
525         clk_put(dev->isp_clk);
526         clk_put(dev->vi_clk);
527         clk_put(dev->vi_sensor_clk);
528         clk_put(dev->csus_clk);
529         clk_put(dev->csi_clk);
530
531         misc_deregister(&dev->misc_dev);
532         regulator_put(dev->reg);
533         mutex_destroy(&dev->tegra_camera_lock);
534
535         return 0;
536 }
537
538 static int tegra_camera_suspend(struct platform_device *pdev, pm_message_t state)
539 {
540         struct tegra_camera_dev *dev = platform_get_drvdata(pdev);
541         int ret = 0;
542
543         mutex_lock(&dev->tegra_camera_lock);
544         if (dev->power_on) {
545                 ret = -EBUSY;
546                 dev_err(&pdev->dev,
547                 "tegra_camera cannot suspend, "
548                 "application is holding on to camera. \n");
549         }
550         mutex_unlock(&dev->tegra_camera_lock);
551
552         return ret;
553 }
554
555 static int tegra_camera_resume(struct platform_device *pdev)
556 {
557         return 0;
558 }
559
560 static struct platform_driver tegra_camera_driver = {
561         .probe = tegra_camera_probe,
562         .remove = tegra_camera_remove,
563         .suspend = tegra_camera_suspend,
564         .resume = tegra_camera_resume,
565         .driver = { .name = TEGRA_CAMERA_NAME }
566 };
567
568 static int __init tegra_camera_init(void)
569 {
570         return platform_driver_register(&tegra_camera_driver);
571 }
572
573 static void __exit tegra_camera_exit(void)
574 {
575         platform_driver_unregister(&tegra_camera_driver);
576 }
577
578 module_init(tegra_camera_init);
579 module_exit(tegra_camera_exit);
580