1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <plat/dsp.h>
22
23#include <dspbridge/host_os.h>
24#include <linux/types.h>
25#include <linux/platform_device.h>
26#include <linux/pm.h>
27
28#ifdef MODULE
29#include <linux/module.h>
30#endif
31
32#include <linux/device.h>
33#include <linux/init.h>
34#include <linux/moduleparam.h>
35#include <linux/cdev.h>
36
37
38#include <dspbridge/dbdefs.h>
39
40
41#include <dspbridge/dbc.h>
42
43
44#include <dspbridge/clk.h>
45#include <dspbridge/sync.h>
46
47
48#include <dspbridge/dspapi-ioctl.h>
49#include <dspbridge/dspapi.h>
50#include <dspbridge/dspdrv.h>
51
52
53#include <dspbridge/pwr.h>
54
55
56#include <drv_interface.h>
57
58#include <dspbridge/resourcecleanup.h>
59#include <dspbridge/chnl.h>
60#include <dspbridge/proc.h>
61#include <dspbridge/dev.h>
62#include <dspbridge/drvdefs.h>
63#include <dspbridge/drv.h>
64
65#ifdef CONFIG_TIDSPBRIDGE_DVFS
66#include <mach-omap2/omap3-opp.h>
67#endif
68
69
70#define DRIVER_NAME "DspBridge"
71#define DSPBRIDGE_VERSION "0.3"
72s32 dsp_debug;
73
74struct platform_device *omap_dspbridge_dev;
75struct device *bridge;
76
77
78s32 dsp_test_sleepstate;
79
80static struct cdev bridge_cdev;
81
82static struct class *bridge_class;
83
84static u32 driver_context;
85static s32 driver_major;
86static char *base_img;
87char *iva_img;
88static s32 shm_size = 0x500000;
89static int tc_wordswapon;
90#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
91#define REC_TIMEOUT 5000
92static atomic_t bridge_cref;
93static struct workqueue_struct *bridge_rec_queue;
94static struct work_struct bridge_recovery_work;
95static DECLARE_COMPLETION(bridge_comp);
96static DECLARE_COMPLETION(bridge_open_comp);
97static bool recover;
98#endif
99
100#ifdef CONFIG_PM
101struct omap34_xx_bridge_suspend_data {
102 int suspended;
103 wait_queue_head_t suspend_wq;
104};
105
106static struct omap34_xx_bridge_suspend_data bridge_suspend_data;
107
108static int omap34_xxbridge_suspend_lockout(struct omap34_xx_bridge_suspend_data
109 *s, struct file *f)
110{
111 if ((s)->suspended) {
112 if ((f)->f_flags & O_NONBLOCK)
113 return -EPERM;
114 wait_event_interruptible((s)->suspend_wq, (s)->suspended == 0);
115 }
116 return 0;
117}
118#endif
119
120module_param(dsp_debug, int, 0);
121MODULE_PARM_DESC(dsp_debug, "Wait after loading DSP image. default = false");
122
123module_param(dsp_test_sleepstate, int, 0);
124MODULE_PARM_DESC(dsp_test_sleepstate, "DSP Sleep state = 0");
125
126module_param(base_img, charp, 0);
127MODULE_PARM_DESC(base_img, "DSP base image, default = NULL");
128
129module_param(shm_size, int, 0);
130MODULE_PARM_DESC(shm_size, "shm size, default = 4 MB, minimum = 64 KB");
131
132module_param(tc_wordswapon, int, 0);
133MODULE_PARM_DESC(tc_wordswapon, "TC Word Swap Option. default = 0");
134
135MODULE_AUTHOR("Texas Instruments");
136MODULE_LICENSE("GPL");
137MODULE_VERSION(DSPBRIDGE_VERSION);
138
139static char *driver_name = DRIVER_NAME;
140
141static const struct file_operations bridge_fops = {
142 .open = bridge_open,
143 .release = bridge_release,
144 .unlocked_ioctl = bridge_ioctl,
145 .mmap = bridge_mmap,
146 .llseek = noop_llseek,
147};
148
149#ifdef CONFIG_PM
150static u32 time_out = 1000;
151#ifdef CONFIG_TIDSPBRIDGE_DVFS
152s32 dsp_max_opps = VDD1_OPP5;
153#endif
154
155
156
157#ifdef CONFIG_TIDSPBRIDGE_DVFS
158const struct omap_opp vdd1_rate_table_bridge[] = {
159 {0, 0, 0},
160
161 {S125M, VDD1_OPP1, 0},
162
163 {S250M, VDD1_OPP2, 0},
164
165 {S500M, VDD1_OPP3, 0},
166
167 {S550M, VDD1_OPP4, 0},
168
169 {S600M, VDD1_OPP5, 0},
170};
171#endif
172#endif
173
174struct omap_dsp_platform_data *omap_dspbridge_pdata;
175
176u32 vdd1_dsp_freq[6][4] = {
177 {0, 0, 0, 0},
178
179 {0, 90000, 0, 86000},
180
181 {0, 180000, 80000, 170000},
182
183 {0, 360000, 160000, 340000},
184
185 {0, 396000, 325000, 376000},
186
187 {0, 430000, 355000, 430000},
188};
189
190#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
191static void bridge_recover(struct work_struct *work)
192{
193 struct dev_object *dev;
194 struct cfg_devnode *dev_node;
195 if (atomic_read(&bridge_cref)) {
196 INIT_COMPLETION(bridge_comp);
197 while (!wait_for_completion_timeout(&bridge_comp,
198 msecs_to_jiffies(REC_TIMEOUT)))
199 pr_info("%s:%d handle(s) still opened\n",
200 __func__, atomic_read(&bridge_cref));
201 }
202 dev = dev_get_first();
203 dev_get_dev_node(dev, &dev_node);
204 if (!dev_node || proc_auto_start(dev_node, dev))
205 pr_err("DSP could not be restarted\n");
206 recover = false;
207 complete_all(&bridge_open_comp);
208}
209
210void bridge_recover_schedule(void)
211{
212 INIT_COMPLETION(bridge_open_comp);
213 recover = true;
214 queue_work(bridge_rec_queue, &bridge_recovery_work);
215}
216#endif
217#ifdef CONFIG_TIDSPBRIDGE_DVFS
218static int dspbridge_scale_notification(struct notifier_block *op,
219 unsigned long val, void *ptr)
220{
221 struct omap_dsp_platform_data *pdata =
222 omap_dspbridge_dev->dev.platform_data;
223
224 if (CPUFREQ_POSTCHANGE == val && pdata->dsp_get_opp)
225 pwr_pm_post_scale(PRCM_VDD1, pdata->dsp_get_opp());
226
227 return 0;
228}
229
230static struct notifier_block iva_clk_notifier = {
231 .notifier_call = dspbridge_scale_notification,
232 NULL,
233};
234#endif
235
236
237
238
239
240
241
242
243static int omap3_bridge_startup(struct platform_device *pdev)
244{
245 struct omap_dsp_platform_data *pdata = pdev->dev.platform_data;
246 struct drv_data *drv_datap = NULL;
247 u32 phys_membase, phys_memsize;
248 int err;
249
250#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
251 bridge_rec_queue = create_workqueue("bridge_rec_queue");
252 INIT_WORK(&bridge_recovery_work, bridge_recover);
253 INIT_COMPLETION(bridge_comp);
254#endif
255
256#ifdef CONFIG_PM
257
258 bridge_suspend_data.suspended = 0;
259 init_waitqueue_head(&bridge_suspend_data.suspend_wq);
260
261#ifdef CONFIG_TIDSPBRIDGE_DVFS
262 for (i = 0; i < 6; i++)
263 pdata->mpu_speed[i] = vdd1_rate_table_bridge[i].rate;
264
265 err = cpufreq_register_notifier(&iva_clk_notifier,
266 CPUFREQ_TRANSITION_NOTIFIER);
267 if (err)
268 pr_err("%s: clk_notifier_register failed for iva2_ck\n",
269 __func__);
270#endif
271#endif
272
273 dsp_clk_init();
274
275 drv_datap = kzalloc(sizeof(struct drv_data), GFP_KERNEL);
276 if (!drv_datap) {
277 err = -ENOMEM;
278 goto err1;
279 }
280
281 drv_datap->shm_size = shm_size;
282 drv_datap->tc_wordswapon = tc_wordswapon;
283
284 if (base_img) {
285 drv_datap->base_img = kmalloc(strlen(base_img) + 1, GFP_KERNEL);
286 if (!drv_datap->base_img) {
287 err = -ENOMEM;
288 goto err2;
289 }
290 strncpy(drv_datap->base_img, base_img, strlen(base_img) + 1);
291 }
292
293 dev_set_drvdata(bridge, drv_datap);
294
295 if (shm_size < 0x10000) {
296 err = -EINVAL;
297 pr_err("%s: shm size must be at least 64 KB\n", __func__);
298 goto err3;
299 }
300 dev_dbg(bridge, "%s: requested shm_size = 0x%x\n", __func__, shm_size);
301
302 phys_membase = pdata->phys_mempool_base;
303 phys_memsize = pdata->phys_mempool_size;
304 if (phys_membase > 0 && phys_memsize > 0)
305 mem_ext_phys_pool_init(phys_membase, phys_memsize);
306
307 if (tc_wordswapon)
308 dev_dbg(bridge, "%s: TC Word Swap is enabled\n", __func__);
309
310 driver_context = dsp_init(&err);
311 if (err) {
312 pr_err("DSP Bridge driver initialization failed\n");
313 goto err4;
314 }
315
316 return 0;
317
318err4:
319 mem_ext_phys_pool_release();
320err3:
321 kfree(drv_datap->base_img);
322err2:
323 kfree(drv_datap);
324err1:
325#ifdef CONFIG_TIDSPBRIDGE_DVFS
326 cpufreq_unregister_notifier(&iva_clk_notifier,
327 CPUFREQ_TRANSITION_NOTIFIER);
328#endif
329 dsp_clk_exit();
330
331 return err;
332}
333
334static int __devinit omap34_xx_bridge_probe(struct platform_device *pdev)
335{
336 int err;
337 dev_t dev = 0;
338#ifdef CONFIG_TIDSPBRIDGE_DVFS
339 int i = 0;
340#endif
341
342 omap_dspbridge_dev = pdev;
343
344
345 bridge = &omap_dspbridge_dev->dev;
346
347
348 err = omap3_bridge_startup(pdev);
349 if (err)
350 goto err1;
351
352
353 err = alloc_chrdev_region(&dev, 0, 1, driver_name);
354 if (err) {
355 pr_err("%s: Can't get major %d\n", __func__, driver_major);
356 goto err1;
357 }
358
359 cdev_init(&bridge_cdev, &bridge_fops);
360 bridge_cdev.owner = THIS_MODULE;
361
362 err = cdev_add(&bridge_cdev, dev, 1);
363 if (err) {
364 pr_err("%s: Failed to add bridge device\n", __func__);
365 goto err2;
366 }
367
368
369 bridge_class = class_create(THIS_MODULE, "ti_bridge");
370 if (IS_ERR(bridge_class)) {
371 pr_err("%s: Error creating bridge class\n", __func__);
372 goto err3;
373 }
374
375 driver_major = MAJOR(dev);
376 device_create(bridge_class, NULL, MKDEV(driver_major, 0),
377 NULL, "DspBridge");
378 pr_info("DSP Bridge driver loaded\n");
379
380 return 0;
381
382err3:
383 cdev_del(&bridge_cdev);
384err2:
385 unregister_chrdev_region(dev, 1);
386err1:
387 return err;
388}
389
390static int __devexit omap34_xx_bridge_remove(struct platform_device *pdev)
391{
392 dev_t devno;
393 bool ret;
394 int status = 0;
395 struct drv_data *drv_datap = dev_get_drvdata(bridge);
396
397
398 if (!drv_datap || !drv_datap->drv_object) {
399 status = -ENODATA;
400 pr_err("%s: Failed to retrieve the object handle\n", __func__);
401 goto func_cont;
402 }
403
404#ifdef CONFIG_TIDSPBRIDGE_DVFS
405 if (cpufreq_unregister_notifier(&iva_clk_notifier,
406 CPUFREQ_TRANSITION_NOTIFIER))
407 pr_err("%s: cpufreq_unregister_notifier failed for iva2_ck\n",
408 __func__);
409#endif
410
411 if (driver_context) {
412
413 ret = dsp_deinit(driver_context);
414 driver_context = 0;
415 DBC_ASSERT(ret == true);
416 }
417
418func_cont:
419 mem_ext_phys_pool_release();
420
421 dsp_clk_exit();
422
423 devno = MKDEV(driver_major, 0);
424 cdev_del(&bridge_cdev);
425 unregister_chrdev_region(devno, 1);
426 if (bridge_class) {
427
428 device_destroy(bridge_class, MKDEV(driver_major, 0));
429 class_destroy(bridge_class);
430
431 }
432 return 0;
433}
434
435#ifdef CONFIG_PM
436static int BRIDGE_SUSPEND(struct platform_device *pdev, pm_message_t state)
437{
438 u32 status;
439 u32 command = PWR_EMERGENCYDEEPSLEEP;
440
441 status = pwr_sleep_dsp(command, time_out);
442 if (status)
443 return -1;
444
445 bridge_suspend_data.suspended = 1;
446 return 0;
447}
448
449static int BRIDGE_RESUME(struct platform_device *pdev)
450{
451 u32 status;
452
453 status = pwr_wake_dsp(time_out);
454 if (status)
455 return -1;
456
457 bridge_suspend_data.suspended = 0;
458 wake_up(&bridge_suspend_data.suspend_wq);
459 return 0;
460}
461#else
462#define BRIDGE_SUSPEND NULL
463#define BRIDGE_RESUME NULL
464#endif
465
466static struct platform_driver bridge_driver = {
467 .driver = {
468 .name = "omap-dsp",
469 },
470 .probe = omap34_xx_bridge_probe,
471 .remove = __devexit_p(omap34_xx_bridge_remove),
472 .suspend = BRIDGE_SUSPEND,
473 .resume = BRIDGE_RESUME,
474};
475
476static int __init bridge_init(void)
477{
478 return platform_driver_register(&bridge_driver);
479}
480
481static void __exit bridge_exit(void)
482{
483 platform_driver_unregister(&bridge_driver);
484}
485
486
487
488
489
490static int bridge_open(struct inode *ip, struct file *filp)
491{
492 int status = 0;
493 struct process_context *pr_ctxt = NULL;
494
495
496
497
498
499
500#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
501 if (recover) {
502 if (filp->f_flags & O_NONBLOCK ||
503 wait_for_completion_interruptible(&bridge_open_comp))
504 return -EBUSY;
505 }
506#endif
507 pr_ctxt = kzalloc(sizeof(struct process_context), GFP_KERNEL);
508 if (pr_ctxt) {
509 pr_ctxt->res_state = PROC_RES_ALLOCATED;
510 spin_lock_init(&pr_ctxt->dmm_map_lock);
511 INIT_LIST_HEAD(&pr_ctxt->dmm_map_list);
512 spin_lock_init(&pr_ctxt->dmm_rsv_lock);
513 INIT_LIST_HEAD(&pr_ctxt->dmm_rsv_list);
514
515 pr_ctxt->node_id = kzalloc(sizeof(struct idr), GFP_KERNEL);
516 if (pr_ctxt->node_id) {
517 idr_init(pr_ctxt->node_id);
518 } else {
519 status = -ENOMEM;
520 goto err;
521 }
522
523 pr_ctxt->stream_id = kzalloc(sizeof(struct idr), GFP_KERNEL);
524 if (pr_ctxt->stream_id)
525 idr_init(pr_ctxt->stream_id);
526 else
527 status = -ENOMEM;
528 } else {
529 status = -ENOMEM;
530 }
531err:
532 filp->private_data = pr_ctxt;
533#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
534 if (!status)
535 atomic_inc(&bridge_cref);
536#endif
537 return status;
538}
539
540
541
542
543
544static int bridge_release(struct inode *ip, struct file *filp)
545{
546 int status = 0;
547 struct process_context *pr_ctxt;
548
549 if (!filp->private_data) {
550 status = -EIO;
551 goto err;
552 }
553
554 pr_ctxt = filp->private_data;
555 flush_signals(current);
556 drv_remove_all_resources(pr_ctxt);
557 proc_detach(pr_ctxt);
558 kfree(pr_ctxt);
559
560 filp->private_data = NULL;
561
562err:
563#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
564 if (!atomic_dec_return(&bridge_cref))
565 complete(&bridge_comp);
566#endif
567 return status;
568}
569
570
571static long bridge_ioctl(struct file *filp, unsigned int code,
572 unsigned long args)
573{
574 int status;
575 u32 retval = 0;
576 union trapped_args buf_in;
577
578 DBC_REQUIRE(filp != NULL);
579#ifdef CONFIG_TIDSPBRIDGE_RECOVERY
580 if (recover) {
581 status = -EIO;
582 goto err;
583 }
584#endif
585#ifdef CONFIG_PM
586 status = omap34_xxbridge_suspend_lockout(&bridge_suspend_data, filp);
587 if (status != 0)
588 return status;
589#endif
590
591 if (!filp->private_data) {
592 status = -EIO;
593 goto err;
594 }
595
596 status = copy_from_user(&buf_in, (union trapped_args *)args,
597 sizeof(union trapped_args));
598
599 if (!status) {
600 status = api_call_dev_ioctl(code, &buf_in, &retval,
601 filp->private_data);
602
603 if (!status) {
604 status = retval;
605 } else {
606 dev_dbg(bridge, "%s: IOCTL Failed, code: 0x%x "
607 "status 0x%x\n", __func__, code, status);
608 status = -1;
609 }
610
611 }
612
613err:
614 return status;
615}
616
617
618static int bridge_mmap(struct file *filp, struct vm_area_struct *vma)
619{
620 u32 offset = vma->vm_pgoff << PAGE_SHIFT;
621 u32 status;
622
623 DBC_ASSERT(vma->vm_start < vma->vm_end);
624
625 vma->vm_flags |= VM_RESERVED | VM_IO;
626 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
627
628 dev_dbg(bridge, "%s: vm filp %p offset %x start %lx end %lx page_prot "
629 "%lx flags %lx\n", __func__, filp, offset,
630 vma->vm_start, vma->vm_end, vma->vm_page_prot, vma->vm_flags);
631
632 status = remap_pfn_range(vma, vma->vm_start, vma->vm_pgoff,
633 vma->vm_end - vma->vm_start,
634 vma->vm_page_prot);
635 if (status != 0)
636 status = -EAGAIN;
637
638 return status;
639}
640
641
642
643int drv_remove_all_resources(void *process_ctxt)
644{
645 int status = 0;
646 struct process_context *ctxt = (struct process_context *)process_ctxt;
647 drv_remove_all_strm_res_elements(ctxt);
648 drv_remove_all_node_res_elements(ctxt);
649 drv_remove_all_dmm_res_elements(ctxt);
650 ctxt->res_state = PROC_RES_FREED;
651 return status;
652}
653
654
655module_init(bridge_init);
656module_exit(bridge_exit);
657
