projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'perf-urgent-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git...
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / staging / tidspbridge / rmgr / proc.c
1 /*
2 * proc.c
3 *
4 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
5 *
6 * Processor interface at the driver level.
7 *
8 * Copyright (C) 2005-2006 Texas Instruments, Inc.
9 *
10 * This package is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
15 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
16 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
17 */
18
19 #include <linux/types.h>
20 /* ------------------------------------ Host OS */
21 #include <linux/dma-mapping.h>
22 #include <linux/scatterlist.h>
23 #include <dspbridge/host_os.h>
24
25 /* ----------------------------------- DSP/BIOS Bridge */
26 #include <dspbridge/dbdefs.h>
27
28 /* ----------------------------------- OS Adaptation Layer */
29 #include <dspbridge/ntfy.h>
30 #include <dspbridge/sync.h>
31 /* ----------------------------------- Bridge Driver */
32 #include <dspbridge/dspdefs.h>
33 #include <dspbridge/dspdeh.h>
34 /* ----------------------------------- Platform Manager */
35 #include <dspbridge/cod.h>
36 #include <dspbridge/dev.h>
37 #include <dspbridge/procpriv.h>
38 #include <dspbridge/dmm.h>
39
40 /* ----------------------------------- Resource Manager */
41 #include <dspbridge/mgr.h>
42 #include <dspbridge/node.h>
43 #include <dspbridge/nldr.h>
44 #include <dspbridge/rmm.h>
45
46 /* ----------------------------------- Others */
47 #include <dspbridge/dbdcd.h>
48 #include <dspbridge/msg.h>
49 #include <dspbridge/dspioctl.h>
50 #include <dspbridge/drv.h>
51
52 /* ----------------------------------- This */
53 #include <dspbridge/proc.h>
54 #include <dspbridge/pwr.h>
55
56 #include <dspbridge/resourcecleanup.h>
57 /* ----------------------------------- Defines, Data Structures, Typedefs */
58 #define MAXCMDLINELEN 255
59 #define PROC_ENVPROCID "PROC_ID=%d"
60 #define MAXPROCIDLEN (8 + 5)
61 #define PROC_DFLT_TIMEOUT 10000 /* Time out in milliseconds */
62 #define PWR_TIMEOUT 500 /* Sleep/wake timout in msec */
63 #define EXTEND "_EXT_END" /* Extmem end addr in DSP binary */
64
65 #define DSP_CACHE_LINE 128
66
67 #define BUFMODE_MASK (3 << 14)
68
69 /* Buffer modes from DSP perspective */
70 #define RBUF 0x4000 /* Input buffer */
71 #define WBUF 0x8000 /* Output Buffer */
72
73 extern struct device *bridge;
74
75 /* ----------------------------------- Globals */
76
77 /* The proc_object structure. */
78 struct proc_object {
79 struct list_head link; /* Link to next proc_object */
80 struct dev_object *dev_obj; /* Device this PROC represents */
81 u32 process; /* Process owning this Processor */
82 struct mgr_object *mgr_obj; /* Manager Object Handle */
83 u32 attach_count; /* Processor attach count */
84 u32 processor_id; /* Processor number */
85 u32 timeout; /* Time out count */
86 enum dsp_procstate proc_state; /* Processor state */
87 u32 unit; /* DDSP unit number */
88 bool is_already_attached; /*
89 * True if the Device below has
90 * GPP Client attached
91 */
92 struct ntfy_object *ntfy_obj; /* Manages notifications */
93 /* Bridge Context Handle */
94 struct bridge_dev_context *bridge_context;
95 /* Function interface to Bridge driver */
96 struct bridge_drv_interface *intf_fxns;
97 char *last_coff;
98 struct list_head proc_list;
99 };
100
101 DEFINE_MUTEX(proc_lock); /* For critical sections */
102
103 /* ----------------------------------- Function Prototypes */
104 static int proc_monitor(struct proc_object *proc_obj);
105 static s32 get_envp_count(char **envp);
106 static char **prepend_envp(char **new_envp, char **envp, s32 envp_elems,
107 s32 cnew_envp, char *sz_var);
108
109 /* remember mapping information */
110 static struct dmm_map_object *add_mapping_info(struct process_context *pr_ctxt,
111 u32 mpu_addr, u32 dsp_addr, u32 size)
112 {
113 struct dmm_map_object *map_obj;
114
115 u32 num_usr_pgs = size / PG_SIZE4K;
116
117 pr_debug("%s: adding map info: mpu_addr 0x%x virt 0x%x size 0x%x\n",
118 __func__, mpu_addr,
119 dsp_addr, size);
120
121 map_obj = kzalloc(sizeof(struct dmm_map_object), GFP_KERNEL);
122 if (!map_obj) {
123 pr_err("%s: kzalloc failed\n", __func__);
124 return NULL;
125 }
126 INIT_LIST_HEAD(&map_obj->link);
127
128 map_obj->pages = kcalloc(num_usr_pgs, sizeof(struct page *),
129 GFP_KERNEL);
130 if (!map_obj->pages) {
131 pr_err("%s: kzalloc failed\n", __func__);
132 kfree(map_obj);
133 return NULL;
134 }
135
136 map_obj->mpu_addr = mpu_addr;
137 map_obj->dsp_addr = dsp_addr;
138 map_obj->size = size;
139 map_obj->num_usr_pgs = num_usr_pgs;
140
141 spin_lock(&pr_ctxt->dmm_map_lock);
142 list_add(&map_obj->link, &pr_ctxt->dmm_map_list);
143 spin_unlock(&pr_ctxt->dmm_map_lock);
144
145 return map_obj;
146 }
147
148 static int match_exact_map_obj(struct dmm_map_object *map_obj,
149 u32 dsp_addr, u32 size)
150 {
151 if (map_obj->dsp_addr == dsp_addr && map_obj->size != size)
152 pr_err("%s: addr match (0x%x), size don't (0x%x != 0x%x)\n",
153 __func__, dsp_addr, map_obj->size, size);
154
155 return map_obj->dsp_addr == dsp_addr &&
156 map_obj->size == size;
157 }
158
159 static void remove_mapping_information(struct process_context *pr_ctxt,
160 u32 dsp_addr, u32 size)
161 {
162 struct dmm_map_object *map_obj;
163
164 pr_debug("%s: looking for virt 0x%x size 0x%x\n", __func__,
165 dsp_addr, size);
166
167 spin_lock(&pr_ctxt->dmm_map_lock);
168 list_for_each_entry(map_obj, &pr_ctxt->dmm_map_list, link) {
169 pr_debug("%s: candidate: mpu_addr 0x%x virt 0x%x size 0x%x\n",
170 __func__,
171 map_obj->mpu_addr,
172 map_obj->dsp_addr,
173 map_obj->size);
174
175 if (match_exact_map_obj(map_obj, dsp_addr, size)) {
176 pr_debug("%s: match, deleting map info\n", __func__);
177 list_del(&map_obj->link);
178 kfree(map_obj->dma_info.sg);
179 kfree(map_obj->pages);
180 kfree(map_obj);
181 goto out;
182 }
183 pr_debug("%s: candidate didn't match\n", __func__);
184 }
185
186 pr_err("%s: failed to find given map info\n", __func__);
187 out:
188 spin_unlock(&pr_ctxt->dmm_map_lock);
189 }
190
191 static int match_containing_map_obj(struct dmm_map_object *map_obj,
192 u32 mpu_addr, u32 size)
193 {
194 u32 map_obj_end = map_obj->mpu_addr + map_obj->size;
195
196 return mpu_addr >= map_obj->mpu_addr &&
197 mpu_addr + size <= map_obj_end;
198 }
199
200 static struct dmm_map_object *find_containing_mapping(
201 struct process_context *pr_ctxt,
202 u32 mpu_addr, u32 size)
203 {
204 struct dmm_map_object *map_obj;
205 pr_debug("%s: looking for mpu_addr 0x%x size 0x%x\n", __func__,
206 mpu_addr, size);
207
208 spin_lock(&pr_ctxt->dmm_map_lock);
209 list_for_each_entry(map_obj, &pr_ctxt->dmm_map_list, link) {
210 pr_debug("%s: candidate: mpu_addr 0x%x virt 0x%x size 0x%x\n",
211 __func__,
212 map_obj->mpu_addr,
213 map_obj->dsp_addr,
214 map_obj->size);
215 if (match_containing_map_obj(map_obj, mpu_addr, size)) {
216 pr_debug("%s: match!\n", __func__);
217 goto out;
218 }
219
220 pr_debug("%s: no match!\n", __func__);
221 }
222
223 map_obj = NULL;
224 out:
225 spin_unlock(&pr_ctxt->dmm_map_lock);
226 return map_obj;
227 }
228
229 static int find_first_page_in_cache(struct dmm_map_object *map_obj,
230 unsigned long mpu_addr)
231 {
232 u32 mapped_base_page = map_obj->mpu_addr >> PAGE_SHIFT;
233 u32 requested_base_page = mpu_addr >> PAGE_SHIFT;
234 int pg_index = requested_base_page - mapped_base_page;
235
236 if (pg_index < 0 || pg_index >= map_obj->num_usr_pgs) {
237 pr_err("%s: failed (got %d)\n", __func__, pg_index);
238 return -1;
239 }
240
241 pr_debug("%s: first page is %d\n", __func__, pg_index);
242 return pg_index;
243 }
244
245 static inline struct page *get_mapping_page(struct dmm_map_object *map_obj,
246 int pg_i)
247 {
248 pr_debug("%s: looking for pg_i %d, num_usr_pgs: %d\n", __func__,
249 pg_i, map_obj->num_usr_pgs);
250
251 if (pg_i < 0 || pg_i >= map_obj->num_usr_pgs) {
252 pr_err("%s: requested pg_i %d is out of mapped range\n",
253 __func__, pg_i);
254 return NULL;
255 }
256
257 return map_obj->pages[pg_i];
258 }
259
260 /*
261 * ======== proc_attach ========
262 * Purpose:
263 * Prepare for communication with a particular DSP processor, and return
264 * a handle to the processor object.
265 */
266 int
267 proc_attach(u32 processor_id,
268 const struct dsp_processorattrin *attr_in,
269 void **ph_processor, struct process_context *pr_ctxt)
270 {
271 int status = 0;
272 struct dev_object *hdev_obj;
273 struct proc_object *p_proc_object = NULL;
274 struct mgr_object *hmgr_obj = NULL;
275 struct drv_object *hdrv_obj = NULL;
276 struct drv_data *drv_datap = dev_get_drvdata(bridge);
277 u8 dev_type;
278
279 if (pr_ctxt->processor) {
280 *ph_processor = pr_ctxt->processor;
281 return status;
282 }
283
284 /* Get the Driver and Manager Object Handles */
285 if (!drv_datap || !drv_datap->drv_object || !drv_datap->mgr_object) {
286 status = -ENODATA;
287 pr_err("%s: Failed to get object handles\n", __func__);
288 } else {
289 hdrv_obj = drv_datap->drv_object;
290 hmgr_obj = drv_datap->mgr_object;
291 }
292
293 if (!status) {
294 /* Get the Device Object */
295 status = drv_get_dev_object(processor_id, hdrv_obj, &hdev_obj);
296 }
297 if (!status)
298 status = dev_get_dev_type(hdev_obj, &dev_type);
299
300 if (status)
301 goto func_end;
302
303 /* If we made it this far, create the Processor object: */
304 p_proc_object = kzalloc(sizeof(struct proc_object), GFP_KERNEL);
305 /* Fill out the Processor Object: */
306 if (p_proc_object == NULL) {
307 status = -ENOMEM;
308 goto func_end;
309 }
310 p_proc_object->dev_obj = hdev_obj;
311 p_proc_object->mgr_obj = hmgr_obj;
312 p_proc_object->processor_id = dev_type;
313 /* Store TGID instead of process handle */
314 p_proc_object->process = current->tgid;
315
316 INIT_LIST_HEAD(&p_proc_object->proc_list);
317
318 if (attr_in)
319 p_proc_object->timeout = attr_in->timeout;
320 else
321 p_proc_object->timeout = PROC_DFLT_TIMEOUT;
322
323 status = dev_get_intf_fxns(hdev_obj, &p_proc_object->intf_fxns);
324 if (!status) {
325 status = dev_get_bridge_context(hdev_obj,
326 &p_proc_object->bridge_context);
327 if (status)
328 kfree(p_proc_object);
329 } else
330 kfree(p_proc_object);
331
332 if (status)
333 goto func_end;
334
335 /* Create the Notification Object */
336 /* This is created with no event mask, no notify mask
337 * and no valid handle to the notification. They all get
338 * filled up when proc_register_notify is called */
339 p_proc_object->ntfy_obj = kmalloc(sizeof(struct ntfy_object),
340 GFP_KERNEL);
341 if (p_proc_object->ntfy_obj)
342 ntfy_init(p_proc_object->ntfy_obj);
343 else
344 status = -ENOMEM;
345
346 if (!status) {
347 /* Insert the Processor Object into the DEV List.
348 * Return handle to this Processor Object:
349 * Find out if the Device is already attached to a
350 * Processor. If so, return AlreadyAttached status */
351 status = dev_insert_proc_object(p_proc_object->dev_obj,
352 (u32) p_proc_object,
353 &p_proc_object->
354 is_already_attached);
355 if (!status) {
356 if (p_proc_object->is_already_attached)
357 status = 0;
358 } else {
359 if (p_proc_object->ntfy_obj) {
360 ntfy_delete(p_proc_object->ntfy_obj);
361 kfree(p_proc_object->ntfy_obj);
362 }
363
364 kfree(p_proc_object);
365 }
366 if (!status) {
367 *ph_processor = (void *)p_proc_object;
368 pr_ctxt->processor = *ph_processor;
369 (void)proc_notify_clients(p_proc_object,
370 DSP_PROCESSORATTACH);
371 }
372 } else {
373 /* Don't leak memory if status is failed */
374 kfree(p_proc_object);
375 }
376 func_end:
377 return status;
378 }
379
380 static int get_exec_file(struct cfg_devnode *dev_node_obj,
381 struct dev_object *hdev_obj,
382 u32 size, char *exec_file)
383 {
384 u8 dev_type;
385 s32 len;
386 struct drv_data *drv_datap = dev_get_drvdata(bridge);
387
388 dev_get_dev_type(hdev_obj, (u8 *) &dev_type);
389
390 if (!exec_file)
391 return -EFAULT;
392
393 if (dev_type == DSP_UNIT) {
394 if (!drv_datap || !drv_datap->base_img)
395 return -EFAULT;
396
397 if (strlen(drv_datap->base_img) > size)
398 return -EINVAL;
399
400 strcpy(exec_file, drv_datap->base_img);
401 } else if (dev_type == IVA_UNIT && iva_img) {
402 len = strlen(iva_img);
403 strncpy(exec_file, iva_img, len + 1);
404 } else {
405 return -ENOENT;
406 }
407
408 return 0;
409 }
410
411 /*
412 * ======== proc_auto_start ======== =
413 * Purpose:
414 * A Particular device gets loaded with the default image
415 * if the AutoStart flag is set.
416 * Parameters:
417 * hdev_obj: Handle to the Device
418 * Returns:
419 * 0: On Successful Loading
420 * -EPERM General Failure
421 * Requires:
422 * hdev_obj != NULL
423 * Ensures:
424 */
425 int proc_auto_start(struct cfg_devnode *dev_node_obj,
426 struct dev_object *hdev_obj)
427 {
428 int status = -EPERM;
429 struct proc_object *p_proc_object;
430 char sz_exec_file[MAXCMDLINELEN];
431 char *argv[2];
432 struct mgr_object *hmgr_obj = NULL;
433 struct drv_data *drv_datap = dev_get_drvdata(bridge);
434 u8 dev_type;
435
436 /* Create a Dummy PROC Object */
437 if (!drv_datap || !drv_datap->mgr_object) {
438 status = -ENODATA;
439 pr_err("%s: Failed to retrieve the object handle\n", __func__);
440 goto func_end;
441 } else {
442 hmgr_obj = drv_datap->mgr_object;
443 }
444
445 p_proc_object = kzalloc(sizeof(struct proc_object), GFP_KERNEL);
446 if (p_proc_object == NULL) {
447 status = -ENOMEM;
448 goto func_end;
449 }
450 p_proc_object->dev_obj = hdev_obj;
451 p_proc_object->mgr_obj = hmgr_obj;
452 status = dev_get_intf_fxns(hdev_obj, &p_proc_object->intf_fxns);
453 if (!status)
454 status = dev_get_bridge_context(hdev_obj,
455 &p_proc_object->bridge_context);
456 if (status)
457 goto func_cont;
458
459 /* Stop the Device, put it into standby mode */
460 status = proc_stop(p_proc_object);
461
462 if (status)
463 goto func_cont;
464
465 /* Get the default executable for this board... */
466 dev_get_dev_type(hdev_obj, (u8 *) &dev_type);
467 p_proc_object->processor_id = dev_type;
468 status = get_exec_file(dev_node_obj, hdev_obj, sizeof(sz_exec_file),
469 sz_exec_file);
470 if (!status) {
471 argv[0] = sz_exec_file;
472 argv[1] = NULL;
473 /* ...and try to load it: */
474 status = proc_load(p_proc_object, 1, (const char **)argv, NULL);
475 if (!status)
476 status = proc_start(p_proc_object);
477 }
478 kfree(p_proc_object->last_coff);
479 p_proc_object->last_coff = NULL;
480 func_cont:
481 kfree(p_proc_object);
482 func_end:
483 return status;
484 }
485
486 /*
487 * ======== proc_ctrl ========
488 * Purpose:
489 * Pass control information to the GPP device driver managing the
490 * DSP processor.
491 *
492 * This will be an OEM-only function, and not part of the DSP/BIOS Bridge
493 * application developer's API.
494 * Call the bridge_dev_ctrl fxn with the Argument. This is a Synchronous
495 * Operation. arg can be null.
496 */
497 int proc_ctrl(void *hprocessor, u32 dw_cmd, struct dsp_cbdata * arg)
498 {
499 int status = 0;
500 struct proc_object *p_proc_object = hprocessor;
501 u32 timeout = 0;
502
503 if (p_proc_object) {
504 /* intercept PWR deep sleep command */
505 if (dw_cmd == BRDIOCTL_DEEPSLEEP) {
506 timeout = arg->cb_data;
507 status = pwr_sleep_dsp(PWR_DEEPSLEEP, timeout);
508 }
509 /* intercept PWR emergency sleep command */
510 else if (dw_cmd == BRDIOCTL_EMERGENCYSLEEP) {
511 timeout = arg->cb_data;
512 status = pwr_sleep_dsp(PWR_EMERGENCYDEEPSLEEP, timeout);
513 } else if (dw_cmd == PWR_DEEPSLEEP) {
514 /* timeout = arg->cb_data; */
515 status = pwr_sleep_dsp(PWR_DEEPSLEEP, timeout);
516 }
517 /* intercept PWR wake commands */
518 else if (dw_cmd == BRDIOCTL_WAKEUP) {
519 timeout = arg->cb_data;
520 status = pwr_wake_dsp(timeout);
521 } else if (dw_cmd == PWR_WAKEUP) {
522 /* timeout = arg->cb_data; */
523 status = pwr_wake_dsp(timeout);
524 } else
525 if (!((*p_proc_object->intf_fxns->dev_cntrl)
526 (p_proc_object->bridge_context, dw_cmd,
527 arg))) {
528 status = 0;
529 } else {
530 status = -EPERM;
531 }
532 } else {
533 status = -EFAULT;
534 }
535
536 return status;
537 }
538
539 /*
540 * ======== proc_detach ========
541 * Purpose:
542 * Destroys the Processor Object. Removes the notification from the Dev
543 * List.
544 */
545 int proc_detach(struct process_context *pr_ctxt)
546 {
547 int status = 0;
548 struct proc_object *p_proc_object = NULL;
549
550 p_proc_object = (struct proc_object *)pr_ctxt->processor;
551
552 if (p_proc_object) {
553 /* Notify the Client */
554 ntfy_notify(p_proc_object->ntfy_obj, DSP_PROCESSORDETACH);
555 /* Remove the notification memory */
556 if (p_proc_object->ntfy_obj) {
557 ntfy_delete(p_proc_object->ntfy_obj);
558 kfree(p_proc_object->ntfy_obj);
559 }
560
561 kfree(p_proc_object->last_coff);
562 p_proc_object->last_coff = NULL;
563 /* Remove the Proc from the DEV List */
564 (void)dev_remove_proc_object(p_proc_object->dev_obj,
565 (u32) p_proc_object);
566 /* Free the Processor Object */
567 kfree(p_proc_object);
568 pr_ctxt->processor = NULL;
569 } else {
570 status = -EFAULT;
571 }
572
573 return status;
574 }
575
576 /*
577 * ======== proc_enum_nodes ========
578 * Purpose:
579 * Enumerate and get configuration information about nodes allocated
580 * on a DSP processor.
581 */
582 int proc_enum_nodes(void *hprocessor, void **node_tab,
583 u32 node_tab_size, u32 *pu_num_nodes,
584 u32 *pu_allocated)
585 {
586 int status = -EPERM;
587 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
588 struct node_mgr *hnode_mgr = NULL;
589
590 if (p_proc_object) {
591 if (!(dev_get_node_manager(p_proc_object->dev_obj,
592 &hnode_mgr))) {
593 if (hnode_mgr) {
594 status = node_enum_nodes(hnode_mgr, node_tab,
595 node_tab_size,
596 pu_num_nodes,
597 pu_allocated);
598 }
599 }
600 } else {
601 status = -EFAULT;
602 }
603
604 return status;
605 }
606
607 /* Cache operation against kernel address instead of users */
608 static int build_dma_sg(struct dmm_map_object *map_obj, unsigned long start,
609 ssize_t len, int pg_i)
610 {
611 struct page *page;
612 unsigned long offset;
613 ssize_t rest;
614 int ret = 0, i = 0;
615 struct scatterlist *sg = map_obj->dma_info.sg;
616
617 while (len) {
618 page = get_mapping_page(map_obj, pg_i);
619 if (!page) {
620 pr_err("%s: no page for %08lx\n", __func__, start);
621 ret = -EINVAL;
622 goto out;
623 } else if (IS_ERR(page)) {
624 pr_err("%s: err page for %08lx(%lu)\n", __func__, start,
625 PTR_ERR(page));
626 ret = PTR_ERR(page);
627 goto out;
628 }
629
630 offset = start & ~PAGE_MASK;
631 rest = min_t(ssize_t, PAGE_SIZE - offset, len);
632
633 sg_set_page(&sg[i], page, rest, offset);
634
635 len -= rest;
636 start += rest;
637 pg_i++, i++;
638 }
639
640 if (i != map_obj->dma_info.num_pages) {
641 pr_err("%s: bad number of sg iterations\n", __func__);
642 ret = -EFAULT;
643 goto out;
644 }
645
646 out:
647 return ret;
648 }
649
650 static int memory_regain_ownership(struct dmm_map_object *map_obj,
651 unsigned long start, ssize_t len, enum dma_data_direction dir)
652 {
653 int ret = 0;
654 unsigned long first_data_page = start >> PAGE_SHIFT;
655 unsigned long last_data_page = ((u32)(start + len - 1) >> PAGE_SHIFT);
656 /* calculating the number of pages this area spans */
657 unsigned long num_pages = last_data_page - first_data_page + 1;
658 struct bridge_dma_map_info *dma_info = &map_obj->dma_info;
659
660 if (!dma_info->sg)
661 goto out;
662
663 if (dma_info->dir != dir || dma_info->num_pages != num_pages) {
664 pr_err("%s: dma info doesn't match given params\n", __func__);
665 return -EINVAL;
666 }
667
668 dma_unmap_sg(bridge, dma_info->sg, num_pages, dma_info->dir);
669
670 pr_debug("%s: dma_map_sg unmapped\n", __func__);
671
672 kfree(dma_info->sg);
673
674 map_obj->dma_info.sg = NULL;
675
676 out:
677 return ret;
678 }
679
680 /* Cache operation against kernel address instead of users */
681 static int memory_give_ownership(struct dmm_map_object *map_obj,
682 unsigned long start, ssize_t len, enum dma_data_direction dir)
683 {
684 int pg_i, ret, sg_num;
685 struct scatterlist *sg;
686 unsigned long first_data_page = start >> PAGE_SHIFT;
687 unsigned long last_data_page = ((u32)(start + len - 1) >> PAGE_SHIFT);
688 /* calculating the number of pages this area spans */
689 unsigned long num_pages = last_data_page - first_data_page + 1;
690
691 pg_i = find_first_page_in_cache(map_obj, start);
692 if (pg_i < 0) {
693 pr_err("%s: failed to find first page in cache\n", __func__);
694 ret = -EINVAL;
695 goto out;
696 }
697
698 sg = kcalloc(num_pages, sizeof(*sg), GFP_KERNEL);
699 if (!sg) {
700 pr_err("%s: kcalloc failed\n", __func__);
701 ret = -ENOMEM;
702 goto out;
703 }
704
705 sg_init_table(sg, num_pages);
706
707 /* cleanup a previous sg allocation */
708 /* this may happen if application doesn't signal for e/o DMA */
709 kfree(map_obj->dma_info.sg);
710
711 map_obj->dma_info.sg = sg;
712 map_obj->dma_info.dir = dir;
713 map_obj->dma_info.num_pages = num_pages;
714
715 ret = build_dma_sg(map_obj, start, len, pg_i);
716 if (ret)
717 goto kfree_sg;
718
719 sg_num = dma_map_sg(bridge, sg, num_pages, dir);
720 if (sg_num < 1) {
721 pr_err("%s: dma_map_sg failed: %d\n", __func__, sg_num);
722 ret = -EFAULT;
723 goto kfree_sg;
724 }
725
726 pr_debug("%s: dma_map_sg mapped %d elements\n", __func__, sg_num);
727 map_obj->dma_info.sg_num = sg_num;
728
729 return 0;
730
731 kfree_sg:
732 kfree(sg);
733 map_obj->dma_info.sg = NULL;
734 out:
735 return ret;
736 }
737
738 int proc_begin_dma(void *hprocessor, void *pmpu_addr, u32 ul_size,
739 enum dma_data_direction dir)
740 {
741 /* Keep STATUS here for future additions to this function */
742 int status = 0;
743 struct process_context *pr_ctxt = (struct process_context *) hprocessor;
744 struct dmm_map_object *map_obj;
745
746 if (!pr_ctxt) {
747 status = -EFAULT;
748 goto err_out;
749 }
750
751 pr_debug("%s: addr 0x%x, size 0x%x, type %d\n", __func__,
752 (u32)pmpu_addr,
753 ul_size, dir);
754
755 mutex_lock(&proc_lock);
756
757 /* find requested memory are in cached mapping information */
758 map_obj = find_containing_mapping(pr_ctxt, (u32) pmpu_addr, ul_size);
759 if (!map_obj) {
760 pr_err("%s: find_containing_mapping failed\n", __func__);
761 status = -EFAULT;
762 goto no_map;
763 }
764
765 if (memory_give_ownership(map_obj, (u32) pmpu_addr, ul_size, dir)) {
766 pr_err("%s: InValid address parameters %p %x\n",
767 __func__, pmpu_addr, ul_size);
768 status = -EFAULT;
769 }
770
771 no_map:
772 mutex_unlock(&proc_lock);
773 err_out:
774
775 return status;
776 }
777
778 int proc_end_dma(void *hprocessor, void *pmpu_addr, u32 ul_size,
779 enum dma_data_direction dir)
780 {
781 /* Keep STATUS here for future additions to this function */
782 int status = 0;
783 struct process_context *pr_ctxt = (struct process_context *) hprocessor;
784 struct dmm_map_object *map_obj;
785
786 if (!pr_ctxt) {
787 status = -EFAULT;
788 goto err_out;
789 }
790
791 pr_debug("%s: addr 0x%x, size 0x%x, type %d\n", __func__,
792 (u32)pmpu_addr,
793 ul_size, dir);
794
795 mutex_lock(&proc_lock);
796
797 /* find requested memory are in cached mapping information */
798 map_obj = find_containing_mapping(pr_ctxt, (u32) pmpu_addr, ul_size);
799 if (!map_obj) {
800 pr_err("%s: find_containing_mapping failed\n", __func__);
801 status = -EFAULT;
802 goto no_map;
803 }
804
805 if (memory_regain_ownership(map_obj, (u32) pmpu_addr, ul_size, dir)) {
806 pr_err("%s: InValid address parameters %p %x\n",
807 __func__, pmpu_addr, ul_size);
808 status = -EFAULT;
809 }
810
811 no_map:
812 mutex_unlock(&proc_lock);
813 err_out:
814 return status;
815 }
816
817 /*
818 * ======== proc_flush_memory ========
819 * Purpose:
820 * Flush cache
821 */
822 int proc_flush_memory(void *hprocessor, void *pmpu_addr,
823 u32 ul_size, u32 ul_flags)
824 {
825 enum dma_data_direction dir = DMA_BIDIRECTIONAL;
826
827 return proc_begin_dma(hprocessor, pmpu_addr, ul_size, dir);
828 }
829
830 /*
831 * ======== proc_invalidate_memory ========
832 * Purpose:
833 * Invalidates the memory specified
834 */
835 int proc_invalidate_memory(void *hprocessor, void *pmpu_addr, u32 size)
836 {
837 enum dma_data_direction dir = DMA_FROM_DEVICE;
838
839 return proc_begin_dma(hprocessor, pmpu_addr, size, dir);
840 }
841
842 /*
843 * ======== proc_get_resource_info ========
844 * Purpose:
845 * Enumerate the resources currently available on a processor.
846 */
847 int proc_get_resource_info(void *hprocessor, u32 resource_type,
848 struct dsp_resourceinfo *resource_info,
849 u32 resource_info_size)
850 {
851 int status = -EPERM;
852 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
853 struct node_mgr *hnode_mgr = NULL;
854 struct nldr_object *nldr_obj = NULL;
855 struct rmm_target_obj *rmm = NULL;
856 struct io_mgr *hio_mgr = NULL; /* IO manager handle */
857
858 if (!p_proc_object) {
859 status = -EFAULT;
860 goto func_end;
861 }
862 switch (resource_type) {
863 case DSP_RESOURCE_DYNDARAM:
864 case DSP_RESOURCE_DYNSARAM:
865 case DSP_RESOURCE_DYNEXTERNAL:
866 case DSP_RESOURCE_DYNSRAM:
867 status = dev_get_node_manager(p_proc_object->dev_obj,
868 &hnode_mgr);
869 if (!hnode_mgr) {
870 status = -EFAULT;
871 goto func_end;
872 }
873
874 status = node_get_nldr_obj(hnode_mgr, &nldr_obj);
875 if (!status) {
876 status = nldr_get_rmm_manager(nldr_obj, &rmm);
877 if (rmm) {
878 if (!rmm_stat(rmm,
879 (enum dsp_memtype)resource_type,
880 (struct dsp_memstat *)
881 &(resource_info->result.
882 mem_stat)))
883 status = -EINVAL;
884 } else {
885 status = -EFAULT;
886 }
887 }
888 break;
889 case DSP_RESOURCE_PROCLOAD:
890 status = dev_get_io_mgr(p_proc_object->dev_obj, &hio_mgr);
891 if (hio_mgr)
892 status =
893 p_proc_object->intf_fxns->
894 io_get_proc_load(hio_mgr,
895 (struct dsp_procloadstat *)
896 &(resource_info->result.
897 proc_load_stat));
898 else
899 status = -EFAULT;
900 break;
901 default:
902 status = -EPERM;
903 break;
904 }
905 func_end:
906 return status;
907 }
908
909 /*
910 * ======== proc_get_dev_object ========
911 * Purpose:
912 * Return the Dev Object handle for a given Processor.
913 *
914 */
915 int proc_get_dev_object(void *hprocessor,
916 struct dev_object **device_obj)
917 {
918 int status = -EPERM;
919 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
920
921 if (p_proc_object) {
922 *device_obj = p_proc_object->dev_obj;
923 status = 0;
924 } else {
925 *device_obj = NULL;
926 status = -EFAULT;
927 }
928
929 return status;
930 }
931
932 /*
933 * ======== proc_get_state ========
934 * Purpose:
935 * Report the state of the specified DSP processor.
936 */
937 int proc_get_state(void *hprocessor,
938 struct dsp_processorstate *proc_state_obj,
939 u32 state_info_size)
940 {
941 int status = 0;
942 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
943 int brd_status;
944
945 if (p_proc_object) {
946 /* First, retrieve BRD state information */
947 status = (*p_proc_object->intf_fxns->brd_status)
948 (p_proc_object->bridge_context, &brd_status);
949 if (!status) {
950 switch (brd_status) {
951 case BRD_STOPPED:
952 proc_state_obj->proc_state = PROC_STOPPED;
953 break;
954 case BRD_SLEEP_TRANSITION:
955 case BRD_DSP_HIBERNATION:
956 /* Fall through */
957 case BRD_RUNNING:
958 proc_state_obj->proc_state = PROC_RUNNING;
959 break;
960 case BRD_LOADED:
961 proc_state_obj->proc_state = PROC_LOADED;
962 break;
963 case BRD_ERROR:
964 proc_state_obj->proc_state = PROC_ERROR;
965 break;
966 default:
967 proc_state_obj->proc_state = 0xFF;
968 status = -EPERM;
969 break;
970 }
971 }
972 } else {
973 status = -EFAULT;
974 }
975 dev_dbg(bridge, "%s, results: status: 0x%x proc_state_obj: 0x%x\n",
976 __func__, status, proc_state_obj->proc_state);
977 return status;
978 }
979
980 /*
981 * ======== proc_get_trace ========
982 * Purpose:
983 * Retrieve the current contents of the trace buffer, located on the
984 * Processor. Predefined symbols for the trace buffer must have been
985 * configured into the DSP executable.
986 * Details:
987 * We support using the symbols SYS_PUTCBEG and SYS_PUTCEND to define a
988 * trace buffer, only. Treat it as an undocumented feature.
989 * This call is destructive, meaning the processor is placed in the monitor
990 * state as a result of this function.
991 */
992 int proc_get_trace(void *hprocessor, u8 * pbuf, u32 max_size)
993 {
994 int status;
995 status = -ENOSYS;
996 return status;
997 }
998
999 /*
1000 * ======== proc_load ========
1001 * Purpose:
1002 * Reset a processor and load a new base program image.
1003 * This will be an OEM-only function, and not part of the DSP/BIOS Bridge
1004 * application developer's API.
1005 */
1006 int proc_load(void *hprocessor, const s32 argc_index,
1007 const char **user_args, const char **user_envp)
1008 {
1009 int status = 0;
1010 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1011 struct io_mgr *hio_mgr; /* IO manager handle */
1012 struct msg_mgr *hmsg_mgr;
1013 struct cod_manager *cod_mgr; /* Code manager handle */
1014 char *pargv0; /* temp argv[0] ptr */
1015 char **new_envp; /* Updated envp[] array. */
1016 char sz_proc_id[MAXPROCIDLEN]; /* Size of "PROC_ID=<n>" */
1017 s32 envp_elems; /* Num elements in envp[]. */
1018 s32 cnew_envp; /* " " in new_envp[] */
1019 s32 nproc_id = 0; /* Anticipate MP version. */
1020 struct dcd_manager *hdcd_handle;
1021 struct dmm_object *dmm_mgr;
1022 u32 dw_ext_end;
1023 u32 proc_id;
1024 int brd_state;
1025 struct drv_data *drv_datap = dev_get_drvdata(bridge);
1026
1027 #ifdef OPT_LOAD_TIME_INSTRUMENTATION
1028 struct timeval tv1;
1029 struct timeval tv2;
1030 #endif
1031
1032 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1033 struct dspbridge_platform_data *pdata =
1034 omap_dspbridge_dev->dev.platform_data;
1035 #endif
1036
1037 #ifdef OPT_LOAD_TIME_INSTRUMENTATION
1038 do_gettimeofday(&tv1);
1039 #endif
1040 if (!p_proc_object) {
1041 status = -EFAULT;
1042 goto func_end;
1043 }
1044 dev_get_cod_mgr(p_proc_object->dev_obj, &cod_mgr);
1045 if (!cod_mgr) {
1046 status = -EPERM;
1047 goto func_end;
1048 }
1049 status = proc_stop(hprocessor);
1050 if (status)
1051 goto func_end;
1052
1053 /* Place the board in the monitor state. */
1054 status = proc_monitor(hprocessor);
1055 if (status)
1056 goto func_end;
1057
1058 /* Save ptr to original argv[0]. */
1059 pargv0 = (char *)user_args[0];
1060 /*Prepend "PROC_ID=<nproc_id>"to envp array for target. */
1061 envp_elems = get_envp_count((char **)user_envp);
1062 cnew_envp = (envp_elems ? (envp_elems + 1) : (envp_elems + 2));
1063 new_envp = kzalloc(cnew_envp * sizeof(char **), GFP_KERNEL);
1064 if (new_envp) {
1065 status = snprintf(sz_proc_id, MAXPROCIDLEN, PROC_ENVPROCID,
1066 nproc_id);
1067 if (status == -1) {
1068 dev_dbg(bridge, "%s: Proc ID string overflow\n",
1069 __func__);
1070 status = -EPERM;
1071 } else {
1072 new_envp =
1073 prepend_envp(new_envp, (char **)user_envp,
1074 envp_elems, cnew_envp, sz_proc_id);
1075 /* Get the DCD Handle */
1076 status = mgr_get_dcd_handle(p_proc_object->mgr_obj,
1077 (u32 *) &hdcd_handle);
1078 if (!status) {
1079 /* Before proceeding with new load,
1080 * check if a previously registered COFF
1081 * exists.
1082 * If yes, unregister nodes in previously
1083 * registered COFF. If any error occurred,
1084 * set previously registered COFF to NULL. */
1085 if (p_proc_object->last_coff != NULL) {
1086 status =
1087 dcd_auto_unregister(hdcd_handle,
1088 p_proc_object->
1089 last_coff);
1090 /* Regardless of auto unregister status,
1091 * free previously allocated
1092 * memory. */
1093 kfree(p_proc_object->last_coff);
1094 p_proc_object->last_coff = NULL;
1095 }
1096 }
1097 /* On success, do cod_open_base() */
1098 status = cod_open_base(cod_mgr, (char *)user_args[0],
1099 COD_SYMB);
1100 }
1101 } else {
1102 status = -ENOMEM;
1103 }
1104 if (!status) {
1105 /* Auto-register data base */
1106 /* Get the DCD Handle */
1107 status = mgr_get_dcd_handle(p_proc_object->mgr_obj,
1108 (u32 *) &hdcd_handle);
1109 if (!status) {
1110 /* Auto register nodes in specified COFF
1111 * file. If registration did not fail,
1112 * (status = 0 or -EACCES)
1113 * save the name of the COFF file for
1114 * de-registration in the future. */
1115 status =
1116 dcd_auto_register(hdcd_handle,
1117 (char *)user_args[0]);
1118 if (status == -EACCES)
1119 status = 0;
1120
1121 if (status) {
1122 status = -EPERM;
1123 } else {
1124 /* Allocate memory for pszLastCoff */
1125 p_proc_object->last_coff =
1126 kzalloc((strlen(user_args[0]) +
1127 1), GFP_KERNEL);
1128 /* If memory allocated, save COFF file name */
1129 if (p_proc_object->last_coff) {
1130 strncpy(p_proc_object->last_coff,
1131 (char *)user_args[0],
1132 (strlen((char *)user_args[0]) +
1133 1));
1134 }
1135 }
1136 }
1137 }
1138 /* Update shared memory address and size */
1139 if (!status) {
1140 /* Create the message manager. This must be done
1141 * before calling the IOOnLoaded function. */
1142 dev_get_msg_mgr(p_proc_object->dev_obj, &hmsg_mgr);
1143 if (!hmsg_mgr) {
1144 status = msg_create(&hmsg_mgr, p_proc_object->dev_obj,
1145 (msg_onexit) node_on_exit);
1146 dev_set_msg_mgr(p_proc_object->dev_obj, hmsg_mgr);
1147 }
1148 }
1149 if (!status) {
1150 /* Set the Device object's message manager */
1151 status = dev_get_io_mgr(p_proc_object->dev_obj, &hio_mgr);
1152 if (hio_mgr)
1153 status = (*p_proc_object->intf_fxns->io_on_loaded)
1154 (hio_mgr);
1155 else
1156 status = -EFAULT;
1157 }
1158 if (!status) {
1159 /* Now, attempt to load an exec: */
1160
1161 /* Boost the OPP level to Maximum level supported by baseport */
1162 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1163 if (pdata->cpu_set_freq)
1164 (*pdata->cpu_set_freq) (pdata->mpu_speed[VDD1_OPP5]);
1165 #endif
1166 status = cod_load_base(cod_mgr, argc_index, (char **)user_args,
1167 dev_brd_write_fxn,
1168 p_proc_object->dev_obj, NULL);
1169 if (status) {
1170 if (status == -EBADF) {
1171 dev_dbg(bridge, "%s: Failure to Load the EXE\n",
1172 __func__);
1173 }
1174 if (status == -ESPIPE) {
1175 pr_err("%s: Couldn't parse the file\n",
1176 __func__);
1177 }
1178 }
1179 /* Requesting the lowest opp supported */
1180 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1181 if (pdata->cpu_set_freq)
1182 (*pdata->cpu_set_freq) (pdata->mpu_speed[VDD1_OPP1]);
1183 #endif
1184
1185 }
1186 if (!status) {
1187 /* Update the Processor status to loaded */
1188 status = (*p_proc_object->intf_fxns->brd_set_state)
1189 (p_proc_object->bridge_context, BRD_LOADED);
1190 if (!status) {
1191 p_proc_object->proc_state = PROC_LOADED;
1192 if (p_proc_object->ntfy_obj)
1193 proc_notify_clients(p_proc_object,
1194 DSP_PROCESSORSTATECHANGE);
1195 }
1196 }
1197 if (!status) {
1198 status = proc_get_processor_id(hprocessor, &proc_id);
1199 if (proc_id == DSP_UNIT) {
1200 /* Use all available DSP address space after EXTMEM
1201 * for DMM */
1202 if (!status)
1203 status = cod_get_sym_value(cod_mgr, EXTEND,
1204 &dw_ext_end);
1205
1206 /* Reset DMM structs and add an initial free chunk */
1207 if (!status) {
1208 status =
1209 dev_get_dmm_mgr(p_proc_object->dev_obj,
1210 &dmm_mgr);
1211 if (dmm_mgr) {
1212 /* Set dw_ext_end to DMM START u8
1213 * address */
1214 dw_ext_end =
1215 (dw_ext_end + 1) * DSPWORDSIZE;
1216 /* DMM memory is from EXT_END */
1217 status = dmm_create_tables(dmm_mgr,
1218 dw_ext_end,
1219 DMMPOOLSIZE);
1220 } else {
1221 status = -EFAULT;
1222 }
1223 }
1224 }
1225 }
1226 /* Restore the original argv[0] */
1227 kfree(new_envp);
1228 user_args[0] = pargv0;
1229 if (!status) {
1230 if (!((*p_proc_object->intf_fxns->brd_status)
1231 (p_proc_object->bridge_context, &brd_state))) {
1232 pr_info("%s: Processor Loaded %s\n", __func__, pargv0);
1233 kfree(drv_datap->base_img);
1234 drv_datap->base_img = kmalloc(strlen(pargv0) + 1,
1235 GFP_KERNEL);
1236 if (drv_datap->base_img)
1237 strncpy(drv_datap->base_img, pargv0,
1238 strlen(pargv0) + 1);
1239 else
1240 status = -ENOMEM;
1241 }
1242 }
1243
1244 func_end:
1245 if (status) {
1246 pr_err("%s: Processor failed to load\n", __func__);
1247 proc_stop(p_proc_object);
1248 }
1249 #ifdef OPT_LOAD_TIME_INSTRUMENTATION
1250 do_gettimeofday(&tv2);
1251 if (tv2.tv_usec < tv1.tv_usec) {
1252 tv2.tv_usec += 1000000;
1253 tv2.tv_sec--;
1254 }
1255 dev_dbg(bridge, "%s: time to load %d sec and %d usec\n", __func__,
1256 tv2.tv_sec - tv1.tv_sec, tv2.tv_usec - tv1.tv_usec);
1257 #endif
1258 return status;
1259 }
1260
1261 /*
1262 * ======== proc_map ========
1263 * Purpose:
1264 * Maps a MPU buffer to DSP address space.
1265 */
1266 int proc_map(void *hprocessor, void *pmpu_addr, u32 ul_size,
1267 void *req_addr, void **pp_map_addr, u32 ul_map_attr,
1268 struct process_context *pr_ctxt)
1269 {
1270 u32 va_align;
1271 u32 pa_align;
1272 struct dmm_object *dmm_mgr;
1273 u32 size_align;
1274 int status = 0;
1275 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1276 struct dmm_map_object *map_obj;
1277 u32 tmp_addr = 0;
1278
1279 #ifdef CONFIG_TIDSPBRIDGE_CACHE_LINE_CHECK
1280 if ((ul_map_attr & BUFMODE_MASK) != RBUF) {
1281 if (!IS_ALIGNED((u32)pmpu_addr, DSP_CACHE_LINE) ||
1282 !IS_ALIGNED(ul_size, DSP_CACHE_LINE)) {
1283 pr_err("%s: not aligned: 0x%x (%d)\n", __func__,
1284 (u32)pmpu_addr, ul_size);
1285 return -EFAULT;
1286 }
1287 }
1288 #endif
1289
1290 /* Calculate the page-aligned PA, VA and size */
1291 va_align = PG_ALIGN_LOW((u32) req_addr, PG_SIZE4K);
1292 pa_align = PG_ALIGN_LOW((u32) pmpu_addr, PG_SIZE4K);
1293 size_align = PG_ALIGN_HIGH(ul_size + (u32) pmpu_addr - pa_align,
1294 PG_SIZE4K);
1295
1296 if (!p_proc_object) {
1297 status = -EFAULT;
1298 goto func_end;
1299 }
1300 /* Critical section */
1301 mutex_lock(&proc_lock);
1302 dmm_get_handle(p_proc_object, &dmm_mgr);
1303 if (dmm_mgr)
1304 status = dmm_map_memory(dmm_mgr, va_align, size_align);
1305 else
1306 status = -EFAULT;
1307
1308 /* Add mapping to the page tables. */
1309 if (!status) {
1310
1311 /* Mapped address = MSB of VA | LSB of PA */
1312 tmp_addr = (va_align | ((u32) pmpu_addr & (PG_SIZE4K - 1)));
1313 /* mapped memory resource tracking */
1314 map_obj = add_mapping_info(pr_ctxt, pa_align, tmp_addr,
1315 size_align);
1316 if (!map_obj)
1317 status = -ENOMEM;
1318 else
1319 status = (*p_proc_object->intf_fxns->brd_mem_map)
1320 (p_proc_object->bridge_context, pa_align, va_align,
1321 size_align, ul_map_attr, map_obj->pages);
1322 }
1323 if (!status) {
1324 /* Mapped address = MSB of VA | LSB of PA */
1325 *pp_map_addr = (void *) tmp_addr;
1326 } else {
1327 remove_mapping_information(pr_ctxt, tmp_addr, size_align);
1328 dmm_un_map_memory(dmm_mgr, va_align, &size_align);
1329 }
1330 mutex_unlock(&proc_lock);
1331
1332 if (status)
1333 goto func_end;
1334
1335 func_end:
1336 dev_dbg(bridge, "%s: hprocessor %p, pmpu_addr %p, ul_size %x, "
1337 "req_addr %p, ul_map_attr %x, pp_map_addr %p, va_align %x, "
1338 "pa_align %x, size_align %x status 0x%x\n", __func__,
1339 hprocessor, pmpu_addr, ul_size, req_addr, ul_map_attr,
1340 pp_map_addr, va_align, pa_align, size_align, status);
1341
1342 return status;
1343 }
1344
1345 /*
1346 * ======== proc_register_notify ========
1347 * Purpose:
1348 * Register to be notified of specific processor events.
1349 */
1350 int proc_register_notify(void *hprocessor, u32 event_mask,
1351 u32 notify_type, struct dsp_notification
1352 * hnotification)
1353 {
1354 int status = 0;
1355 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1356 struct deh_mgr *hdeh_mgr;
1357
1358 /* Check processor handle */
1359 if (!p_proc_object) {
1360 status = -EFAULT;
1361 goto func_end;
1362 }
1363 /* Check if event mask is a valid processor related event */
1364 if (event_mask & ~(DSP_PROCESSORSTATECHANGE | DSP_PROCESSORATTACH |
1365 DSP_PROCESSORDETACH | DSP_PROCESSORRESTART |
1366 DSP_MMUFAULT | DSP_SYSERROR | DSP_PWRERROR |
1367 DSP_WDTOVERFLOW))
1368 status = -EINVAL;
1369
1370 /* Check if notify type is valid */
1371 if (notify_type != DSP_SIGNALEVENT)
1372 status = -EINVAL;
1373
1374 if (!status) {
1375 /* If event mask is not DSP_SYSERROR, DSP_MMUFAULT,
1376 * or DSP_PWRERROR then register event immediately. */
1377 if (event_mask &
1378 ~(DSP_SYSERROR | DSP_MMUFAULT | DSP_PWRERROR |
1379 DSP_WDTOVERFLOW)) {
1380 status = ntfy_register(p_proc_object->ntfy_obj,
1381 hnotification, event_mask,
1382 notify_type);
1383 /* Special case alert, special case alert!
1384 * If we're trying to *deregister* (i.e. event_mask
1385 * is 0), a DSP_SYSERROR or DSP_MMUFAULT notification,
1386 * we have to deregister with the DEH manager.
1387 * There's no way to know, based on event_mask which
1388 * manager the notification event was registered with,
1389 * so if we're trying to deregister and ntfy_register
1390 * failed, we'll give the deh manager a shot.
1391 */
1392 if ((event_mask == 0) && status) {
1393 status =
1394 dev_get_deh_mgr(p_proc_object->dev_obj,
1395 &hdeh_mgr);
1396 status =
1397 bridge_deh_register_notify(hdeh_mgr,
1398 event_mask,
1399 notify_type,
1400 hnotification);
1401 }
1402 } else {
1403 status = dev_get_deh_mgr(p_proc_object->dev_obj,
1404 &hdeh_mgr);
1405 status =
1406 bridge_deh_register_notify(hdeh_mgr,
1407 event_mask,
1408 notify_type,
1409 hnotification);
1410
1411 }
1412 }
1413 func_end:
1414 return status;
1415 }
1416
1417 /*
1418 * ======== proc_reserve_memory ========
1419 * Purpose:
1420 * Reserve a virtually contiguous region of DSP address space.
1421 */
1422 int proc_reserve_memory(void *hprocessor, u32 ul_size,
1423 void **pp_rsv_addr,
1424 struct process_context *pr_ctxt)
1425 {
1426 struct dmm_object *dmm_mgr;
1427 int status = 0;
1428 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1429 struct dmm_rsv_object *rsv_obj;
1430
1431 if (!p_proc_object) {
1432 status = -EFAULT;
1433 goto func_end;
1434 }
1435
1436 status = dmm_get_handle(p_proc_object, &dmm_mgr);
1437 if (!dmm_mgr) {
1438 status = -EFAULT;
1439 goto func_end;
1440 }
1441
1442 status = dmm_reserve_memory(dmm_mgr, ul_size, (u32 *) pp_rsv_addr);
1443 if (status != 0)
1444 goto func_end;
1445
1446 /*
1447 * A successful reserve should be followed by insertion of rsv_obj
1448 * into dmm_rsv_list, so that reserved memory resource tracking
1449 * remains uptodate
1450 */
1451 rsv_obj = kmalloc(sizeof(struct dmm_rsv_object), GFP_KERNEL);
1452 if (rsv_obj) {
1453 rsv_obj->dsp_reserved_addr = (u32) *pp_rsv_addr;
1454 spin_lock(&pr_ctxt->dmm_rsv_lock);
1455 list_add(&rsv_obj->link, &pr_ctxt->dmm_rsv_list);
1456 spin_unlock(&pr_ctxt->dmm_rsv_lock);
1457 }
1458
1459 func_end:
1460 dev_dbg(bridge, "%s: hprocessor: 0x%p ul_size: 0x%x pp_rsv_addr: 0x%p "
1461 "status 0x%x\n", __func__, hprocessor,
1462 ul_size, pp_rsv_addr, status);
1463 return status;
1464 }
1465
1466 /*
1467 * ======== proc_start ========
1468 * Purpose:
1469 * Start a processor running.
1470 */
1471 int proc_start(void *hprocessor)
1472 {
1473 int status = 0;
1474 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1475 struct cod_manager *cod_mgr; /* Code manager handle */
1476 u32 dw_dsp_addr; /* Loaded code's entry point. */
1477 int brd_state;
1478
1479 if (!p_proc_object) {
1480 status = -EFAULT;
1481 goto func_end;
1482 }
1483 /* Call the bridge_brd_start */
1484 if (p_proc_object->proc_state != PROC_LOADED) {
1485 status = -EBADR;
1486 goto func_end;
1487 }
1488 status = dev_get_cod_mgr(p_proc_object->dev_obj, &cod_mgr);
1489 if (!cod_mgr) {
1490 status = -EFAULT;
1491 goto func_cont;
1492 }
1493
1494 status = cod_get_entry(cod_mgr, &dw_dsp_addr);
1495 if (status)
1496 goto func_cont;
1497
1498 status = (*p_proc_object->intf_fxns->brd_start)
1499 (p_proc_object->bridge_context, dw_dsp_addr);
1500 if (status)
1501 goto func_cont;
1502
1503 /* Call dev_create2 */
1504 status = dev_create2(p_proc_object->dev_obj);
1505 if (!status) {
1506 p_proc_object->proc_state = PROC_RUNNING;
1507 /* Deep sleep switces off the peripheral clocks.
1508 * we just put the DSP CPU in idle in the idle loop.
1509 * so there is no need to send a command to DSP */
1510
1511 if (p_proc_object->ntfy_obj) {
1512 proc_notify_clients(p_proc_object,
1513 DSP_PROCESSORSTATECHANGE);
1514 }
1515 } else {
1516 /* Failed to Create Node Manager and DISP Object
1517 * Stop the Processor from running. Put it in STOPPED State */
1518 (void)(*p_proc_object->intf_fxns->
1519 brd_stop) (p_proc_object->bridge_context);
1520 p_proc_object->proc_state = PROC_STOPPED;
1521 }
1522 func_cont:
1523 if (!status) {
1524 if (!((*p_proc_object->intf_fxns->brd_status)
1525 (p_proc_object->bridge_context, &brd_state))) {
1526 pr_info("%s: dsp in running state\n", __func__);
1527 }
1528 } else {
1529 pr_err("%s: Failed to start the dsp\n", __func__);
1530 proc_stop(p_proc_object);
1531 }
1532
1533 func_end:
1534 return status;
1535 }
1536
1537 /*
1538 * ======== proc_stop ========
1539 * Purpose:
1540 * Stop a processor running.
1541 */
1542 int proc_stop(void *hprocessor)
1543 {
1544 int status = 0;
1545 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1546 struct msg_mgr *hmsg_mgr;
1547 struct node_mgr *hnode_mgr;
1548 void *hnode;
1549 u32 node_tab_size = 1;
1550 u32 num_nodes = 0;
1551 u32 nodes_allocated = 0;
1552
1553 if (!p_proc_object) {
1554 status = -EFAULT;
1555 goto func_end;
1556 }
1557 /* check if there are any running nodes */
1558 status = dev_get_node_manager(p_proc_object->dev_obj, &hnode_mgr);
1559 if (!status && hnode_mgr) {
1560 status = node_enum_nodes(hnode_mgr, &hnode, node_tab_size,
1561 &num_nodes, &nodes_allocated);
1562 if ((status == -EINVAL) || (nodes_allocated > 0)) {
1563 pr_err("%s: Can't stop device, active nodes = %d \n",
1564 __func__, nodes_allocated);
1565 return -EBADR;
1566 }
1567 }
1568 /* Call the bridge_brd_stop */
1569 /* It is OK to stop a device that does n't have nodes OR not started */
1570 status =
1571 (*p_proc_object->intf_fxns->
1572 brd_stop) (p_proc_object->bridge_context);
1573 if (!status) {
1574 dev_dbg(bridge, "%s: processor in standby mode\n", __func__);
1575 p_proc_object->proc_state = PROC_STOPPED;
1576 /* Destroy the Node Manager, msg_ctrl Manager */
1577 if (!(dev_destroy2(p_proc_object->dev_obj))) {
1578 /* Destroy the msg_ctrl by calling msg_delete */
1579 dev_get_msg_mgr(p_proc_object->dev_obj, &hmsg_mgr);
1580 if (hmsg_mgr) {
1581 msg_delete(hmsg_mgr);
1582 dev_set_msg_mgr(p_proc_object->dev_obj, NULL);
1583 }
1584 }
1585 } else {
1586 pr_err("%s: Failed to stop the processor\n", __func__);
1587 }
1588 func_end:
1589
1590 return status;
1591 }
1592
1593 /*
1594 * ======== proc_un_map ========
1595 * Purpose:
1596 * Removes a MPU buffer mapping from the DSP address space.
1597 */
1598 int proc_un_map(void *hprocessor, void *map_addr,
1599 struct process_context *pr_ctxt)
1600 {
1601 int status = 0;
1602 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1603 struct dmm_object *dmm_mgr;
1604 u32 va_align;
1605 u32 size_align;
1606
1607 va_align = PG_ALIGN_LOW((u32) map_addr, PG_SIZE4K);
1608 if (!p_proc_object) {
1609 status = -EFAULT;
1610 goto func_end;
1611 }
1612
1613 status = dmm_get_handle(hprocessor, &dmm_mgr);
1614 if (!dmm_mgr) {
1615 status = -EFAULT;
1616 goto func_end;
1617 }
1618
1619 /* Critical section */
1620 mutex_lock(&proc_lock);
1621 /*
1622 * Update DMM structures. Get the size to unmap.
1623 * This function returns error if the VA is not mapped
1624 */
1625 status = dmm_un_map_memory(dmm_mgr, (u32) va_align, &size_align);
1626 /* Remove mapping from the page tables. */
1627 if (!status) {
1628 status = (*p_proc_object->intf_fxns->brd_mem_un_map)
1629 (p_proc_object->bridge_context, va_align, size_align);
1630 }
1631
1632 if (status)
1633 goto unmap_failed;
1634
1635 /*
1636 * A successful unmap should be followed by removal of map_obj
1637 * from dmm_map_list, so that mapped memory resource tracking
1638 * remains uptodate
1639 */
1640 remove_mapping_information(pr_ctxt, (u32) map_addr, size_align);
1641
1642 unmap_failed:
1643 mutex_unlock(&proc_lock);
1644
1645 func_end:
1646 dev_dbg(bridge, "%s: hprocessor: 0x%p map_addr: 0x%p status: 0x%x\n",
1647 __func__, hprocessor, map_addr, status);
1648 return status;
1649 }
1650
1651 /*
1652 * ======== proc_un_reserve_memory ========
1653 * Purpose:
1654 * Frees a previously reserved region of DSP address space.
1655 */
1656 int proc_un_reserve_memory(void *hprocessor, void *prsv_addr,
1657 struct process_context *pr_ctxt)
1658 {
1659 struct dmm_object *dmm_mgr;
1660 int status = 0;
1661 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
1662 struct dmm_rsv_object *rsv_obj;
1663
1664 if (!p_proc_object) {
1665 status = -EFAULT;
1666 goto func_end;
1667 }
1668
1669 status = dmm_get_handle(p_proc_object, &dmm_mgr);
1670 if (!dmm_mgr) {
1671 status = -EFAULT;
1672 goto func_end;
1673 }
1674
1675 status = dmm_un_reserve_memory(dmm_mgr, (u32) prsv_addr);
1676 if (status != 0)
1677 goto func_end;
1678
1679 /*
1680 * A successful unreserve should be followed by removal of rsv_obj
1681 * from dmm_rsv_list, so that reserved memory resource tracking
1682 * remains uptodate
1683 */
1684 spin_lock(&pr_ctxt->dmm_rsv_lock);
1685 list_for_each_entry(rsv_obj, &pr_ctxt->dmm_rsv_list, link) {
1686 if (rsv_obj->dsp_reserved_addr == (u32) prsv_addr) {
1687 list_del(&rsv_obj->link);
1688 kfree(rsv_obj);
1689 break;
1690 }
1691 }
1692 spin_unlock(&pr_ctxt->dmm_rsv_lock);
1693
1694 func_end:
1695 dev_dbg(bridge, "%s: hprocessor: 0x%p prsv_addr: 0x%p status: 0x%x\n",
1696 __func__, hprocessor, prsv_addr, status);
1697 return status;
1698 }
1699
1700 /*
1701 * ======== = proc_monitor ======== ==
1702 * Purpose:
1703 * Place the Processor in Monitor State. This is an internal
1704 * function and a requirement before Processor is loaded.
1705 * This does a bridge_brd_stop, dev_destroy2 and bridge_brd_monitor.
1706 * In dev_destroy2 we delete the node manager.
1707 * Parameters:
1708 * p_proc_object: Pointer to Processor Object
1709 * Returns:
1710 * 0: Processor placed in monitor mode.
1711 * !0: Failed to place processor in monitor mode.
1712 * Requires:
1713 * Valid Processor Handle
1714 * Ensures:
1715 * Success: ProcObject state is PROC_IDLE
1716 */
1717 static int proc_monitor(struct proc_object *proc_obj)
1718 {
1719 int status = -EPERM;
1720 struct msg_mgr *hmsg_mgr;
1721
1722 /* This is needed only when Device is loaded when it is
1723 * already 'ACTIVE' */
1724 /* Destroy the Node Manager, msg_ctrl Manager */
1725 if (!dev_destroy2(proc_obj->dev_obj)) {
1726 /* Destroy the msg_ctrl by calling msg_delete */
1727 dev_get_msg_mgr(proc_obj->dev_obj, &hmsg_mgr);
1728 if (hmsg_mgr) {
1729 msg_delete(hmsg_mgr);
1730 dev_set_msg_mgr(proc_obj->dev_obj, NULL);
1731 }
1732 }
1733 /* Place the Board in the Monitor State */
1734 if (!((*proc_obj->intf_fxns->brd_monitor)
1735 (proc_obj->bridge_context))) {
1736 status = 0;
1737 }
1738
1739 return status;
1740 }
1741
1742 /*
1743 * ======== get_envp_count ========
1744 * Purpose:
1745 * Return the number of elements in the envp array, including the
1746 * terminating NULL element.
1747 */
1748 static s32 get_envp_count(char **envp)
1749 {
1750 s32 ret = 0;
1751 if (envp) {
1752 while (*envp++)
1753 ret++;
1754
1755 ret += 1; /* Include the terminating NULL in the count. */
1756 }
1757
1758 return ret;
1759 }
1760
1761 /*
1762 * ======== prepend_envp ========
1763 * Purpose:
1764 * Prepend an environment variable=value pair to the new envp array, and
1765 * copy in the existing var=value pairs in the old envp array.
1766 */
1767 static char **prepend_envp(char **new_envp, char **envp, s32 envp_elems,
1768 s32 cnew_envp, char *sz_var)
1769 {
1770 char **pp_envp = new_envp;
1771
1772 /* Prepend new environ var=value string */
1773 *new_envp++ = sz_var;
1774
1775 /* Copy user's environment into our own. */
1776 while (envp_elems--)
1777 *new_envp++ = *envp++;
1778
1779 /* Ensure NULL terminates the new environment strings array. */
1780 if (envp_elems == 0)
1781 *new_envp = NULL;
1782
1783 return pp_envp;
1784 }
1785
1786 /*
1787 * ======== proc_notify_clients ========
1788 * Purpose:
1789 * Notify the processor the events.
1790 */
1791 int proc_notify_clients(void *proc, u32 events)
1792 {
1793 int status = 0;
1794 struct proc_object *p_proc_object = (struct proc_object *)proc;
1795
1796 if (!p_proc_object) {
1797 status = -EFAULT;
1798 goto func_end;
1799 }
1800
1801 ntfy_notify(p_proc_object->ntfy_obj, events);
1802 func_end:
1803 return status;
1804 }
1805
1806 /*
1807 * ======== proc_notify_all_clients ========
1808 * Purpose:
1809 * Notify the processor the events. This includes notifying all clients
1810 * attached to a particulat DSP.
1811 */
1812 int proc_notify_all_clients(void *proc, u32 events)
1813 {
1814 int status = 0;
1815 struct proc_object *p_proc_object = (struct proc_object *)proc;
1816
1817 if (!p_proc_object) {
1818 status = -EFAULT;
1819 goto func_end;
1820 }
1821
1822 dev_notify_clients(p_proc_object->dev_obj, events);
1823
1824 func_end:
1825 return status;
1826 }
1827
1828 /*
1829 * ======== proc_get_processor_id ========
1830 * Purpose:
1831 * Retrieves the processor ID.
1832 */
1833 int proc_get_processor_id(void *proc, u32 * proc_id)
1834 {
1835 int status = 0;
1836 struct proc_object *p_proc_object = (struct proc_object *)proc;
1837
1838 if (p_proc_object)
1839 *proc_id = p_proc_object->processor_id;
1840 else
1841 status = -EFAULT;
1842
1843 return status;
1844 }
kernel source for telekom puls (alcatel/mediatek)