?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / staging / tidspbridge / rmgr / node.c
blob6e9441e21265c343fa23847849cafac6a8e3ca04
1 /*
2 * node.c
3 *
4 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
5 *
6 * DSP/BIOS Bridge Node Manager.
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 <dspbridge/host_os.h>
22
23 /* ----------------------------------- DSP/BIOS Bridge */
24 #include <dspbridge/dbdefs.h>
25
26 /* ----------------------------------- Trace & Debug */
27 #include <dspbridge/dbc.h>
28
29 /* ----------------------------------- OS Adaptation Layer */
30 #include <dspbridge/cfg.h>
31 #include <dspbridge/list.h>
32 #include <dspbridge/memdefs.h>
33 #include <dspbridge/proc.h>
34 #include <dspbridge/strm.h>
35 #include <dspbridge/sync.h>
36 #include <dspbridge/ntfy.h>
37
38 /* ----------------------------------- Platform Manager */
39 #include <dspbridge/cmm.h>
40 #include <dspbridge/cod.h>
41 #include <dspbridge/dev.h>
42 #include <dspbridge/msg.h>
43
44 /* ----------------------------------- Resource Manager */
45 #include <dspbridge/dbdcd.h>
46 #include <dspbridge/disp.h>
47 #include <dspbridge/rms_sh.h>
48
49 /* ----------------------------------- Link Driver */
50 #include <dspbridge/dspdefs.h>
51 #include <dspbridge/dspioctl.h>
52
53 /* ----------------------------------- Others */
54 #include <dspbridge/gb.h>
55 #include <dspbridge/uuidutil.h>
56
57 /* ----------------------------------- This */
58 #include <dspbridge/nodepriv.h>
59 #include <dspbridge/node.h>
60 #include <dspbridge/dmm.h>
61
62 /* Static/Dynamic Loader includes */
63 #include <dspbridge/dbll.h>
64 #include <dspbridge/nldr.h>
65
66 #include <dspbridge/drv.h>
67 #include <dspbridge/drvdefs.h>
68 #include <dspbridge/resourcecleanup.h>
69 #include <_tiomap.h>
70
71 #include <dspbridge/dspdeh.h>
72
73 #define HOSTPREFIX "/host"
74 #define PIPEPREFIX "/dbpipe"
75
76 #define MAX_INPUTS(h) \
77 ((h)->dcd_props.obj_data.node_obj.ndb_props.num_input_streams)
78 #define MAX_OUTPUTS(h) \
79 ((h)->dcd_props.obj_data.node_obj.ndb_props.num_output_streams)
80
81 #define NODE_GET_PRIORITY(h) ((h)->prio)
82 #define NODE_SET_PRIORITY(hnode, prio) ((hnode)->prio = prio)
83 #define NODE_SET_STATE(hnode, state) ((hnode)->node_state = state)
84
85 #define MAXPIPES 100 /* Max # of /pipe connections (CSL limit) */
86 #define MAXDEVSUFFIXLEN 2 /* Max(Log base 10 of MAXPIPES, MAXSTREAMS) */
87
88 #define PIPENAMELEN (sizeof(PIPEPREFIX) + MAXDEVSUFFIXLEN)
89 #define HOSTNAMELEN (sizeof(HOSTPREFIX) + MAXDEVSUFFIXLEN)
90
91 #define MAXDEVNAMELEN 32 /* dsp_ndbprops.ac_name size */
92 #define CREATEPHASE 1
93 #define EXECUTEPHASE 2
94 #define DELETEPHASE 3
95
96 /* Define default STRM parameters */
97 /*
98 * TBD: Put in header file, make global DSP_STRMATTRS with defaults,
99 * or make defaults configurable.
100 */
101 #define DEFAULTBUFSIZE 32
102 #define DEFAULTNBUFS 2
103 #define DEFAULTSEGID 0
104 #define DEFAULTALIGNMENT 0
105 #define DEFAULTTIMEOUT 10000
106
107 #define RMSQUERYSERVER 0
108 #define RMSCONFIGURESERVER 1
109 #define RMSCREATENODE 2
110 #define RMSEXECUTENODE 3
111 #define RMSDELETENODE 4
112 #define RMSCHANGENODEPRIORITY 5
113 #define RMSREADMEMORY 6
114 #define RMSWRITEMEMORY 7
115 #define RMSCOPY 8
116 #define MAXTIMEOUT 2000
117
118 #define NUMRMSFXNS 9
119
120 #define PWR_TIMEOUT 500 /* default PWR timeout in msec */
121
122 #define STACKSEGLABEL "L1DSRAM_HEAP" /* Label for DSP Stack Segment Addr */
123
124 /*
125 * ======== node_mgr ========
126 */
127 struct node_mgr {
128 struct dev_object *hdev_obj; /* Device object */
129 /* Function interface to Bridge driver */
130 struct bridge_drv_interface *intf_fxns;
131 struct dcd_manager *hdcd_mgr; /* Proc/Node data manager */
132 struct disp_object *disp_obj; /* Node dispatcher */
133 struct lst_list *node_list; /* List of all allocated nodes */
134 u32 num_nodes; /* Number of nodes in node_list */
135 u32 num_created; /* Number of nodes *created* on DSP */
136 struct gb_t_map *pipe_map; /* Pipe connection bit map */
137 struct gb_t_map *pipe_done_map; /* Pipes that are half free */
138 struct gb_t_map *chnl_map; /* Channel allocation bit map */
139 struct gb_t_map *dma_chnl_map; /* DMA Channel allocation bit map */
140 struct gb_t_map *zc_chnl_map; /* Zero-Copy Channel alloc bit map */
141 struct ntfy_object *ntfy_obj; /* Manages registered notifications */
142 struct mutex node_mgr_lock; /* For critical sections */
143 u32 ul_fxn_addrs[NUMRMSFXNS]; /* RMS function addresses */
144 struct msg_mgr *msg_mgr_obj;
145
146 /* Processor properties needed by Node Dispatcher */
147 u32 ul_num_chnls; /* Total number of channels */
148 u32 ul_chnl_offset; /* Offset of chnl ids rsvd for RMS */
149 u32 ul_chnl_buf_size; /* Buffer size for data to RMS */
150 int proc_family; /* eg, 5000 */
151 int proc_type; /* eg, 5510 */
152 u32 udsp_word_size; /* Size of DSP word on host bytes */
153 u32 udsp_data_mau_size; /* Size of DSP data MAU */
154 u32 udsp_mau_size; /* Size of MAU */
155 s32 min_pri; /* Minimum runtime priority for node */
156 s32 max_pri; /* Maximum runtime priority for node */
157
158 struct strm_mgr *strm_mgr_obj; /* STRM manager */
159
160 /* Loader properties */
161 struct nldr_object *nldr_obj; /* Handle to loader */
162 struct node_ldr_fxns nldr_fxns; /* Handle to loader functions */
163 bool loader_init; /* Loader Init function succeeded? */
164 };
165
166 /*
167 * ======== connecttype ========
168 */
169 enum connecttype {
170 NOTCONNECTED = 0,
171 NODECONNECT,
172 HOSTCONNECT,
173 DEVICECONNECT,
174 };
175
176 /*
177 * ======== stream_chnl ========
178 */
179 struct stream_chnl {
180 enum connecttype type; /* Type of stream connection */
181 u32 dev_id; /* pipe or channel id */
182 };
183
184 /*
185 * ======== node_object ========
186 */
187 struct node_object {
188 struct list_head list_elem;
189 struct node_mgr *hnode_mgr; /* The manager of this node */
190 struct proc_object *hprocessor; /* Back pointer to processor */
191 struct dsp_uuid node_uuid; /* Node's ID */
192 s32 prio; /* Node's current priority */
193 u32 utimeout; /* Timeout for blocking NODE calls */
194 u32 heap_size; /* Heap Size */
195 u32 udsp_heap_virt_addr; /* Heap Size */
196 u32 ugpp_heap_virt_addr; /* Heap Size */
197 enum node_type ntype; /* Type of node: message, task, etc */
198 enum node_state node_state; /* NODE_ALLOCATED, NODE_CREATED, ... */
199 u32 num_inputs; /* Current number of inputs */
200 u32 num_outputs; /* Current number of outputs */
201 u32 max_input_index; /* Current max input stream index */
202 u32 max_output_index; /* Current max output stream index */
203 struct stream_chnl *inputs; /* Node's input streams */
204 struct stream_chnl *outputs; /* Node's output streams */
205 struct node_createargs create_args; /* Args for node create func */
206 nodeenv node_env; /* Environment returned by RMS */
207 struct dcd_genericobj dcd_props; /* Node properties from DCD */
208 struct dsp_cbdata *pargs; /* Optional args to pass to node */
209 struct ntfy_object *ntfy_obj; /* Manages registered notifications */
210 char *pstr_dev_name; /* device name, if device node */
211 struct sync_object *sync_done; /* Synchronize node_terminate */
212 s32 exit_status; /* execute function return status */
213
214 /* Information needed for node_get_attr() */
215 void *device_owner; /* If dev node, task that owns it */
216 u32 num_gpp_inputs; /* Current # of from GPP streams */
217 u32 num_gpp_outputs; /* Current # of to GPP streams */
218 /* Current stream connections */
219 struct dsp_streamconnect *stream_connect;
220
221 /* Message queue */
222 struct msg_queue *msg_queue_obj;
223
224 /* These fields used for SM messaging */
225 struct cmm_xlatorobject *xlator; /* Node's SM addr translator */
226
227 /* Handle to pass to dynamic loader */
228 struct nldr_nodeobject *nldr_node_obj;
229 bool loaded; /* Code is (dynamically) loaded */
230 bool phase_split; /* Phases split in many libs or ovly */
231
232 };
233
234 /* Default buffer attributes */
235 static struct dsp_bufferattr node_dfltbufattrs = {
236 0, /* cb_struct */
237 1, /* segment_id */
238 0, /* buf_alignment */
239 };
240
241 static void delete_node(struct node_object *hnode,
242 struct process_context *pr_ctxt);
243 static void delete_node_mgr(struct node_mgr *hnode_mgr);
244 static void fill_stream_connect(struct node_object *node1,
245 struct node_object *node2, u32 stream1,
246 u32 stream2);
247 static void fill_stream_def(struct node_object *hnode,
248 struct node_strmdef *pstrm_def,
249 struct dsp_strmattr *pattrs);
250 static void free_stream(struct node_mgr *hnode_mgr, struct stream_chnl stream);
251 static int get_fxn_address(struct node_object *hnode, u32 * fxn_addr,
252 u32 phase);
253 static int get_node_props(struct dcd_manager *hdcd_mgr,
254 struct node_object *hnode,
255 const struct dsp_uuid *node_uuid,
256 struct dcd_genericobj *dcd_prop);
257 static int get_proc_props(struct node_mgr *hnode_mgr,
258 struct dev_object *hdev_obj);
259 static int get_rms_fxns(struct node_mgr *hnode_mgr);
260 static u32 ovly(void *priv_ref, u32 dsp_run_addr, u32 dsp_load_addr,
261 u32 ul_num_bytes, u32 mem_space);
262 static u32 mem_write(void *priv_ref, u32 dsp_add, void *pbuf,
263 u32 ul_num_bytes, u32 mem_space);
264
265 static u32 refs; /* module reference count */
266
267 /* Dynamic loader functions. */
268 static struct node_ldr_fxns nldr_fxns = {
269 nldr_allocate,
270 nldr_create,
271 nldr_delete,
272 nldr_exit,
273 nldr_get_fxn_addr,
274 nldr_init,
275 nldr_load,
276 nldr_unload,
277 };
278
279 enum node_state node_get_state(void *hnode)
280 {
281 struct node_object *pnode = (struct node_object *)hnode;
282 if (!pnode)
283 return -1;
284 else
285 return pnode->node_state;
286 }
287
288 /*
289 * ======== node_allocate ========
290 * Purpose:
291 * Allocate GPP resources to manage a node on the DSP.
292 */
293 int node_allocate(struct proc_object *hprocessor,
294 const struct dsp_uuid *node_uuid,
295 const struct dsp_cbdata *pargs,
296 const struct dsp_nodeattrin *attr_in,
297 struct node_res_object **noderes,
298 struct process_context *pr_ctxt)
299 {
300 struct node_mgr *hnode_mgr;
301 struct dev_object *hdev_obj;
302 struct node_object *pnode = NULL;
303 enum node_type node_type = NODE_TASK;
304 struct node_msgargs *pmsg_args;
305 struct node_taskargs *ptask_args;
306 u32 num_streams;
307 struct bridge_drv_interface *intf_fxns;
308 int status = 0;
309 struct cmm_object *hcmm_mgr = NULL; /* Shared memory manager hndl */
310 u32 proc_id;
311 u32 pul_value;
312 u32 dynext_base;
313 u32 off_set = 0;
314 u32 ul_stack_seg_addr, ul_stack_seg_val;
315 u32 ul_gpp_mem_base;
316 struct cfg_hostres *host_res;
317 struct bridge_dev_context *pbridge_context;
318 u32 mapped_addr = 0;
319 u32 map_attrs = 0x0;
320 struct dsp_processorstate proc_state;
321 #ifdef DSP_DMM_DEBUG
322 struct dmm_object *dmm_mgr;
323 struct proc_object *p_proc_object = (struct proc_object *)hprocessor;
324 #endif
325
326 void *node_res;
327
328 DBC_REQUIRE(refs > 0);
329 DBC_REQUIRE(hprocessor != NULL);
330 DBC_REQUIRE(noderes != NULL);
331 DBC_REQUIRE(node_uuid != NULL);
332
333 *noderes = NULL;
334
335 status = proc_get_processor_id(hprocessor, &proc_id);
336
337 if (proc_id != DSP_UNIT)
338 goto func_end;
339
340 status = proc_get_dev_object(hprocessor, &hdev_obj);
341 if (!status) {
342 status = dev_get_node_manager(hdev_obj, &hnode_mgr);
343 if (hnode_mgr == NULL)
344 status = -EPERM;
345
346 }
347
348 if (status)
349 goto func_end;
350
351 status = dev_get_bridge_context(hdev_obj, &pbridge_context);
352 if (!pbridge_context) {
353 status = -EFAULT;
354 goto func_end;
355 }
356
357 status = proc_get_state(hprocessor, &proc_state,
358 sizeof(struct dsp_processorstate));
359 if (status)
360 goto func_end;
361 /* If processor is in error state then don't attempt
362 to send the message */
363 if (proc_state.proc_state == PROC_ERROR) {
364 status = -EPERM;
365 goto func_end;
366 }
367
368 /* Assuming that 0 is not a valid function address */
369 if (hnode_mgr->ul_fxn_addrs[0] == 0) {
370 /* No RMS on target - we currently can't handle this */
371 pr_err("%s: Failed, no RMS in base image\n", __func__);
372 status = -EPERM;
373 } else {
374 /* Validate attr_in fields, if non-NULL */
375 if (attr_in) {
376 /* Check if attr_in->prio is within range */
377 if (attr_in->prio < hnode_mgr->min_pri ||
378 attr_in->prio > hnode_mgr->max_pri)
379 status = -EDOM;
380 }
381 }
382 /* Allocate node object and fill in */
383 if (status)
384 goto func_end;
385
386 pnode = kzalloc(sizeof(struct node_object), GFP_KERNEL);
387 if (pnode == NULL) {
388 status = -ENOMEM;
389 goto func_end;
390 }
391 pnode->hnode_mgr = hnode_mgr;
392 /* This critical section protects get_node_props */
393 mutex_lock(&hnode_mgr->node_mgr_lock);
394
395 /* Get dsp_ndbprops from node database */
396 status = get_node_props(hnode_mgr->hdcd_mgr, pnode, node_uuid,
397 &(pnode->dcd_props));
398 if (status)
399 goto func_cont;
400
401 pnode->node_uuid = *node_uuid;
402 pnode->hprocessor = hprocessor;
403 pnode->ntype = pnode->dcd_props.obj_data.node_obj.ndb_props.ntype;
404 pnode->utimeout = pnode->dcd_props.obj_data.node_obj.ndb_props.utimeout;
405 pnode->prio = pnode->dcd_props.obj_data.node_obj.ndb_props.prio;
406
407 /* Currently only C64 DSP builds support Node Dynamic * heaps */
408 /* Allocate memory for node heap */
409 pnode->create_args.asa.task_arg_obj.heap_size = 0;
410 pnode->create_args.asa.task_arg_obj.udsp_heap_addr = 0;
411 pnode->create_args.asa.task_arg_obj.udsp_heap_res_addr = 0;
412 pnode->create_args.asa.task_arg_obj.ugpp_heap_addr = 0;
413 if (!attr_in)
414 goto func_cont;
415
416 /* Check if we have a user allocated node heap */
417 if (!(attr_in->pgpp_virt_addr))
418 goto func_cont;
419
420 /* check for page aligned Heap size */
421 if (((attr_in->heap_size) & (PG_SIZE4K - 1))) {
422 pr_err("%s: node heap size not aligned to 4K, size = 0x%x \n",
423 __func__, attr_in->heap_size);
424 status = -EINVAL;
425 } else {
426 pnode->create_args.asa.task_arg_obj.heap_size =
427 attr_in->heap_size;
428 pnode->create_args.asa.task_arg_obj.ugpp_heap_addr =
429 (u32) attr_in->pgpp_virt_addr;
430 }
431 if (status)
432 goto func_cont;
433
434 status = proc_reserve_memory(hprocessor,
435 pnode->create_args.asa.task_arg_obj.
436 heap_size + PAGE_SIZE,
437 (void **)&(pnode->create_args.asa.
438 task_arg_obj.udsp_heap_res_addr),
439 pr_ctxt);
440 if (status) {
441 pr_err("%s: Failed to reserve memory for heap: 0x%x\n",
442 __func__, status);
443 goto func_cont;
444 }
445 #ifdef DSP_DMM_DEBUG
446 status = dmm_get_handle(p_proc_object, &dmm_mgr);
447 if (!dmm_mgr) {
448 status = DSP_EHANDLE;
449 goto func_cont;
450 }
451
452 dmm_mem_map_dump(dmm_mgr);
453 #endif
454
455 map_attrs |= DSP_MAPLITTLEENDIAN;
456 map_attrs |= DSP_MAPELEMSIZE32;
457 map_attrs |= DSP_MAPVIRTUALADDR;
458 status = proc_map(hprocessor, (void *)attr_in->pgpp_virt_addr,
459 pnode->create_args.asa.task_arg_obj.heap_size,
460 (void *)pnode->create_args.asa.task_arg_obj.
461 udsp_heap_res_addr, (void **)&mapped_addr, map_attrs,
462 pr_ctxt);
463 if (status)
464 pr_err("%s: Failed to map memory for Heap: 0x%x\n",
465 __func__, status);
466 else
467 pnode->create_args.asa.task_arg_obj.udsp_heap_addr =
468 (u32) mapped_addr;
469
470 func_cont:
471 mutex_unlock(&hnode_mgr->node_mgr_lock);
472 if (attr_in != NULL) {
473 /* Overrides of NBD properties */
474 pnode->utimeout = attr_in->utimeout;
475 pnode->prio = attr_in->prio;
476 }
477 /* Create object to manage notifications */
478 if (!status) {
479 pnode->ntfy_obj = kmalloc(sizeof(struct ntfy_object),
480 GFP_KERNEL);
481 if (pnode->ntfy_obj)
482 ntfy_init(pnode->ntfy_obj);
483 else
484 status = -ENOMEM;
485 }
486
487 if (!status) {
488 node_type = node_get_type(pnode);
489 /* Allocate dsp_streamconnect array for device, task, and
490 * dais socket nodes. */
491 if (node_type != NODE_MESSAGE) {
492 num_streams = MAX_INPUTS(pnode) + MAX_OUTPUTS(pnode);
493 pnode->stream_connect = kzalloc(num_streams *
494 sizeof(struct dsp_streamconnect),
495 GFP_KERNEL);
496 if (num_streams > 0 && pnode->stream_connect == NULL)
497 status = -ENOMEM;
498
499 }
500 if (!status && (node_type == NODE_TASK ||
501 node_type == NODE_DAISSOCKET)) {
502 /* Allocate arrays for maintainig stream connections */
503 pnode->inputs = kzalloc(MAX_INPUTS(pnode) *
504 sizeof(struct stream_chnl), GFP_KERNEL);
505 pnode->outputs = kzalloc(MAX_OUTPUTS(pnode) *
506 sizeof(struct stream_chnl), GFP_KERNEL);
507 ptask_args = &(pnode->create_args.asa.task_arg_obj);
508 ptask_args->strm_in_def = kzalloc(MAX_INPUTS(pnode) *
509 sizeof(struct node_strmdef),
510 GFP_KERNEL);
511 ptask_args->strm_out_def = kzalloc(MAX_OUTPUTS(pnode) *
512 sizeof(struct node_strmdef),
513 GFP_KERNEL);
514 if ((MAX_INPUTS(pnode) > 0 && (pnode->inputs == NULL ||
515 ptask_args->strm_in_def
516 == NULL))
517 || (MAX_OUTPUTS(pnode) > 0
518 && (pnode->outputs == NULL
519 || ptask_args->strm_out_def == NULL)))
520 status = -ENOMEM;
521 }
522 }
523 if (!status && (node_type != NODE_DEVICE)) {
524 /* Create an event that will be posted when RMS_EXIT is
525 * received. */
526 pnode->sync_done = kzalloc(sizeof(struct sync_object),
527 GFP_KERNEL);
528 if (pnode->sync_done)
529 sync_init_event(pnode->sync_done);
530 else
531 status = -ENOMEM;
532
533 if (!status) {
534 /*Get the shared mem mgr for this nodes dev object */
535 status = cmm_get_handle(hprocessor, &hcmm_mgr);
536 if (!status) {
537 /* Allocate a SM addr translator for this node
538 * w/ deflt attr */
539 status = cmm_xlator_create(&pnode->xlator,
540 hcmm_mgr, NULL);
541 }
542 }
543 if (!status) {
544 /* Fill in message args */
545 if ((pargs != NULL) && (pargs->cb_data > 0)) {
546 pmsg_args =
547 &(pnode->create_args.asa.node_msg_args);
548 pmsg_args->pdata = kzalloc(pargs->cb_data,
549 GFP_KERNEL);
550 if (pmsg_args->pdata == NULL) {
551 status = -ENOMEM;
552 } else {
553 pmsg_args->arg_length = pargs->cb_data;
554 memcpy(pmsg_args->pdata,
555 pargs->node_data,
556 pargs->cb_data);
557 }
558 }
559 }
560 }
561
562 if (!status && node_type != NODE_DEVICE) {
563 /* Create a message queue for this node */
564 intf_fxns = hnode_mgr->intf_fxns;
565 status =
566 (*intf_fxns->pfn_msg_create_queue) (hnode_mgr->msg_mgr_obj,
567 &pnode->msg_queue_obj,
568 0,
569 pnode->create_args.asa.
570 node_msg_args.max_msgs,
571 pnode);
572 }
573
574 if (!status) {
575 /* Create object for dynamic loading */
576
577 status = hnode_mgr->nldr_fxns.pfn_allocate(hnode_mgr->nldr_obj,
578 (void *)pnode,
579 &pnode->dcd_props.
580 obj_data.node_obj,
581 &pnode->
582 nldr_node_obj,
583 &pnode->phase_split);
584 }
585
586 /* Compare value read from Node Properties and check if it is same as
587 * STACKSEGLABEL, if yes read the Address of STACKSEGLABEL, calculate
588 * GPP Address, Read the value in that address and override the
589 * stack_seg value in task args */
590 if (!status &&
591 (char *)pnode->dcd_props.obj_data.node_obj.ndb_props.
592 stack_seg_name != NULL) {
593 if (strcmp((char *)
594 pnode->dcd_props.obj_data.node_obj.ndb_props.
595 stack_seg_name, STACKSEGLABEL) == 0) {
596 status =
597 hnode_mgr->nldr_fxns.
598 pfn_get_fxn_addr(pnode->nldr_node_obj, "DYNEXT_BEG",
599 &dynext_base);
600 if (status)
601 pr_err("%s: Failed to get addr for DYNEXT_BEG"
602 " status = 0x%x\n", __func__, status);
603
604 status =
605 hnode_mgr->nldr_fxns.
606 pfn_get_fxn_addr(pnode->nldr_node_obj,
607 "L1DSRAM_HEAP", &pul_value);
608
609 if (status)
610 pr_err("%s: Failed to get addr for L1DSRAM_HEAP"
611 " status = 0x%x\n", __func__, status);
612
613 host_res = pbridge_context->resources;
614 if (!host_res)
615 status = -EPERM;
616
617 if (status) {
618 pr_err("%s: Failed to get host resource, status"
619 " = 0x%x\n", __func__, status);
620 goto func_end;
621 }
622
623 ul_gpp_mem_base = (u32) host_res->dw_mem_base[1];
624 off_set = pul_value - dynext_base;
625 ul_stack_seg_addr = ul_gpp_mem_base + off_set;
626 ul_stack_seg_val = readl(ul_stack_seg_addr);
627
628 dev_dbg(bridge, "%s: StackSegVal = 0x%x, StackSegAddr ="
629 " 0x%x\n", __func__, ul_stack_seg_val,
630 ul_stack_seg_addr);
631
632 pnode->create_args.asa.task_arg_obj.stack_seg =
633 ul_stack_seg_val;
634
635 }
636 }
637
638 if (!status) {
639 /* Add the node to the node manager's list of allocated
640 * nodes. */
641 lst_init_elem((struct list_head *)pnode);
642 NODE_SET_STATE(pnode, NODE_ALLOCATED);
643
644 mutex_lock(&hnode_mgr->node_mgr_lock);
645
646 lst_put_tail(hnode_mgr->node_list, (struct list_head *) pnode);
647 ++(hnode_mgr->num_nodes);
648
649 /* Exit critical section */
650 mutex_unlock(&hnode_mgr->node_mgr_lock);
651
652 /* Preset this to assume phases are split
653 * (for overlay and dll) */
654 pnode->phase_split = true;
655
656 /* Notify all clients registered for DSP_NODESTATECHANGE. */
657 proc_notify_all_clients(hprocessor, DSP_NODESTATECHANGE);
658 } else {
659 /* Cleanup */
660 if (pnode)
661 delete_node(pnode, pr_ctxt);
662
663 }
664
665 if (!status) {
666 status = drv_insert_node_res_element(pnode, &node_res, pr_ctxt);
667 if (status) {
668 delete_node(pnode, pr_ctxt);
669 goto func_end;
670 }
671
672 *noderes = (struct node_res_object *)node_res;
673 drv_proc_node_update_heap_status(node_res, true);
674 drv_proc_node_update_status(node_res, true);
675 }
676 DBC_ENSURE((status && *noderes == NULL) || (!status && *noderes));
677 func_end:
678 dev_dbg(bridge, "%s: hprocessor: %p pNodeId: %p pargs: %p attr_in: %p "
679 "node_res: %p status: 0x%x\n", __func__, hprocessor,
680 node_uuid, pargs, attr_in, noderes, status);
681 return status;
682 }
683
684 /*
685 * ======== node_alloc_msg_buf ========
686 * Purpose:
687 * Allocates buffer for zero copy messaging.
688 */
689 DBAPI node_alloc_msg_buf(struct node_object *hnode, u32 usize,
690 struct dsp_bufferattr *pattr,
691 u8 **pbuffer)
692 {
693 struct node_object *pnode = (struct node_object *)hnode;
694 int status = 0;
695 bool va_flag = false;
696 bool set_info;
697 u32 proc_id;
698
699 DBC_REQUIRE(refs > 0);
700 DBC_REQUIRE(pbuffer != NULL);
701
702 DBC_REQUIRE(usize > 0);
703
704 if (!pnode)
705 status = -EFAULT;
706 else if (node_get_type(pnode) == NODE_DEVICE)
707 status = -EPERM;
708
709 if (status)
710 goto func_end;
711
712 if (pattr == NULL)
713 pattr = &node_dfltbufattrs; /* set defaults */
714
715 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
716 if (proc_id != DSP_UNIT) {
717 DBC_ASSERT(NULL);
718 goto func_end;
719 }
720 /* If segment ID includes MEM_SETVIRTUALSEGID then pbuffer is a
721 * virt address, so set this info in this node's translator
722 * object for future ref. If MEM_GETVIRTUALSEGID then retrieve
723 * virtual address from node's translator. */
724 if ((pattr->segment_id & MEM_SETVIRTUALSEGID) ||
725 (pattr->segment_id & MEM_GETVIRTUALSEGID)) {
726 va_flag = true;
727 set_info = (pattr->segment_id & MEM_SETVIRTUALSEGID) ?
728 true : false;
729 /* Clear mask bits */
730 pattr->segment_id &= ~MEM_MASKVIRTUALSEGID;
731 /* Set/get this node's translators virtual address base/size */
732 status = cmm_xlator_info(pnode->xlator, pbuffer, usize,
733 pattr->segment_id, set_info);
734 }
735 if (!status && (!va_flag)) {
736 if (pattr->segment_id != 1) {
737 /* Node supports single SM segment only. */
738 status = -EBADR;
739 }
740 /* Arbitrary SM buffer alignment not supported for host side
741 * allocs, but guaranteed for the following alignment
742 * values. */
743 switch (pattr->buf_alignment) {
744 case 0:
745 case 1:
746 case 2:
747 case 4:
748 break;
749 default:
750 /* alignment value not suportted */
751 status = -EPERM;
752 break;
753 }
754 if (!status) {
755 /* allocate physical buffer from seg_id in node's
756 * translator */
757 (void)cmm_xlator_alloc_buf(pnode->xlator, pbuffer,
758 usize);
759 if (*pbuffer == NULL) {
760 pr_err("%s: error - Out of shared memory\n",
761 __func__);
762 status = -ENOMEM;
763 }
764 }
765 }
766 func_end:
767 return status;
768 }
769
770 /*
771 * ======== node_change_priority ========
772 * Purpose:
773 * Change the priority of a node in the allocated state, or that is
774 * currently running or paused on the target.
775 */
776 int node_change_priority(struct node_object *hnode, s32 prio)
777 {
778 struct node_object *pnode = (struct node_object *)hnode;
779 struct node_mgr *hnode_mgr = NULL;
780 enum node_type node_type;
781 enum node_state state;
782 int status = 0;
783 u32 proc_id;
784
785 DBC_REQUIRE(refs > 0);
786
787 if (!hnode || !hnode->hnode_mgr) {
788 status = -EFAULT;
789 } else {
790 hnode_mgr = hnode->hnode_mgr;
791 node_type = node_get_type(hnode);
792 if (node_type != NODE_TASK && node_type != NODE_DAISSOCKET)
793 status = -EPERM;
794 else if (prio < hnode_mgr->min_pri || prio > hnode_mgr->max_pri)
795 status = -EDOM;
796 }
797 if (status)
798 goto func_end;
799
800 /* Enter critical section */
801 mutex_lock(&hnode_mgr->node_mgr_lock);
802
803 state = node_get_state(hnode);
804 if (state == NODE_ALLOCATED || state == NODE_PAUSED) {
805 NODE_SET_PRIORITY(hnode, prio);
806 } else {
807 if (state != NODE_RUNNING) {
808 status = -EBADR;
809 goto func_cont;
810 }
811 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
812 if (proc_id == DSP_UNIT) {
813 status =
814 disp_node_change_priority(hnode_mgr->disp_obj,
815 hnode,
816 hnode_mgr->ul_fxn_addrs
817 [RMSCHANGENODEPRIORITY],
818 hnode->node_env, prio);
819 }
820 if (status >= 0)
821 NODE_SET_PRIORITY(hnode, prio);
822
823 }
824 func_cont:
825 /* Leave critical section */
826 mutex_unlock(&hnode_mgr->node_mgr_lock);
827 func_end:
828 return status;
829 }
830
831 /*
832 * ======== node_connect ========
833 * Purpose:
834 * Connect two nodes on the DSP, or a node on the DSP to the GPP.
835 */
836 int node_connect(struct node_object *node1, u32 stream1,
837 struct node_object *node2,
838 u32 stream2, struct dsp_strmattr *pattrs,
839 struct dsp_cbdata *conn_param)
840 {
841 struct node_mgr *hnode_mgr;
842 char *pstr_dev_name = NULL;
843 enum node_type node1_type = NODE_TASK;
844 enum node_type node2_type = NODE_TASK;
845 struct node_strmdef *pstrm_def;
846 struct node_strmdef *input = NULL;
847 struct node_strmdef *output = NULL;
848 struct node_object *dev_node_obj;
849 struct node_object *hnode;
850 struct stream_chnl *pstream;
851 u32 pipe_id = GB_NOBITS;
852 u32 chnl_id = GB_NOBITS;
853 s8 chnl_mode;
854 u32 dw_length;
855 int status = 0;
856 DBC_REQUIRE(refs > 0);
857
858 if ((node1 != (struct node_object *)DSP_HGPPNODE && !node1) ||
859 (node2 != (struct node_object *)DSP_HGPPNODE && !node2))
860 status = -EFAULT;
861
862 if (!status) {
863 /* The two nodes must be on the same processor */
864 if (node1 != (struct node_object *)DSP_HGPPNODE &&
865 node2 != (struct node_object *)DSP_HGPPNODE &&
866 node1->hnode_mgr != node2->hnode_mgr)
867 status = -EPERM;
868 /* Cannot connect a node to itself */
869 if (node1 == node2)
870 status = -EPERM;
871
872 }
873 if (!status) {
874 /* node_get_type() will return NODE_GPP if hnode =
875 * DSP_HGPPNODE. */
876 node1_type = node_get_type(node1);
877 node2_type = node_get_type(node2);
878 /* Check stream indices ranges */
879 if ((node1_type != NODE_GPP && node1_type != NODE_DEVICE &&
880 stream1 >= MAX_OUTPUTS(node1)) || (node2_type != NODE_GPP
881 && node2_type !=
882 NODE_DEVICE
883 && stream2 >=
884 MAX_INPUTS(node2)))
885 status = -EINVAL;
886 }
887 if (!status) {
888 /*
889 * Only the following types of connections are allowed:
890 * task/dais socket < == > task/dais socket
891 * task/dais socket < == > device
892 * task/dais socket < == > GPP
893 *
894 * ie, no message nodes, and at least one task or dais
895 * socket node.
896 */
897 if (node1_type == NODE_MESSAGE || node2_type == NODE_MESSAGE ||
898 (node1_type != NODE_TASK && node1_type != NODE_DAISSOCKET &&
899 node2_type != NODE_TASK && node2_type != NODE_DAISSOCKET))
900 status = -EPERM;
901 }
902 /*
903 * Check stream mode. Default is STRMMODE_PROCCOPY.
904 */
905 if (!status && pattrs) {
906 if (pattrs->strm_mode != STRMMODE_PROCCOPY)
907 status = -EPERM; /* illegal stream mode */
908
909 }
910 if (status)
911 goto func_end;
912
913 if (node1_type != NODE_GPP) {
914 hnode_mgr = node1->hnode_mgr;
915 } else {
916 DBC_ASSERT(node2 != (struct node_object *)DSP_HGPPNODE);
917 hnode_mgr = node2->hnode_mgr;
918 }
919 /* Enter critical section */
920 mutex_lock(&hnode_mgr->node_mgr_lock);
921
922 /* Nodes must be in the allocated state */
923 if (node1_type != NODE_GPP && node_get_state(node1) != NODE_ALLOCATED)
924 status = -EBADR;
925
926 if (node2_type != NODE_GPP && node_get_state(node2) != NODE_ALLOCATED)
927 status = -EBADR;
928
929 if (!status) {
930 /* Check that stream indices for task and dais socket nodes
931 * are not already be used. (Device nodes checked later) */
932 if (node1_type == NODE_TASK || node1_type == NODE_DAISSOCKET) {
933 output =
934 &(node1->create_args.asa.
935 task_arg_obj.strm_out_def[stream1]);
936 if (output->sz_device != NULL)
937 status = -EISCONN;
938
939 }
940 if (node2_type == NODE_TASK || node2_type == NODE_DAISSOCKET) {
941 input =
942 &(node2->create_args.asa.
943 task_arg_obj.strm_in_def[stream2]);
944 if (input->sz_device != NULL)
945 status = -EISCONN;
946
947 }
948 }
949 /* Connecting two task nodes? */
950 if (!status && ((node1_type == NODE_TASK ||
951 node1_type == NODE_DAISSOCKET)
952 && (node2_type == NODE_TASK
953 || node2_type == NODE_DAISSOCKET))) {
954 /* Find available pipe */
955 pipe_id = gb_findandset(hnode_mgr->pipe_map);
956 if (pipe_id == GB_NOBITS) {
957 status = -ECONNREFUSED;
958 } else {
959 node1->outputs[stream1].type = NODECONNECT;
960 node2->inputs[stream2].type = NODECONNECT;
961 node1->outputs[stream1].dev_id = pipe_id;
962 node2->inputs[stream2].dev_id = pipe_id;
963 output->sz_device = kzalloc(PIPENAMELEN + 1,
964 GFP_KERNEL);
965 input->sz_device = kzalloc(PIPENAMELEN + 1, GFP_KERNEL);
966 if (output->sz_device == NULL ||
967 input->sz_device == NULL) {
968 /* Undo the connection */
969 kfree(output->sz_device);
970
971 kfree(input->sz_device);
972
973 output->sz_device = NULL;
974 input->sz_device = NULL;
975 gb_clear(hnode_mgr->pipe_map, pipe_id);
976 status = -ENOMEM;
977 } else {
978 /* Copy "/dbpipe<pipId>" name to device names */
979 sprintf(output->sz_device, "%s%d",
980 PIPEPREFIX, pipe_id);
981 strcpy(input->sz_device, output->sz_device);
982 }
983 }
984 }
985 /* Connecting task node to host? */
986 if (!status && (node1_type == NODE_GPP ||
987 node2_type == NODE_GPP)) {
988 if (node1_type == NODE_GPP) {
989 chnl_mode = CHNL_MODETODSP;
990 } else {
991 DBC_ASSERT(node2_type == NODE_GPP);
992 chnl_mode = CHNL_MODEFROMDSP;
993 }
994 /* Reserve a channel id. We need to put the name "/host<id>"
995 * in the node's create_args, but the host
996 * side channel will not be opened until DSPStream_Open is
997 * called for this node. */
998 if (pattrs) {
999 if (pattrs->strm_mode == STRMMODE_RDMA) {
1000 chnl_id =
1001 gb_findandset(hnode_mgr->dma_chnl_map);
1002 /* dma chans are 2nd transport chnl set
1003 * ids(e.g. 16-31) */
1004 (chnl_id != GB_NOBITS) ?
1005 (chnl_id =
1006 chnl_id +
1007 hnode_mgr->ul_num_chnls) : chnl_id;
1008 } else if (pattrs->strm_mode == STRMMODE_ZEROCOPY) {
1009 chnl_id = gb_findandset(hnode_mgr->zc_chnl_map);
1010 /* zero-copy chans are 3nd transport set
1011 * (e.g. 32-47) */
1012 (chnl_id != GB_NOBITS) ? (chnl_id = chnl_id +
1013 (2 *
1014 hnode_mgr->
1015 ul_num_chnls))
1016 : chnl_id;
1017 } else { /* must be PROCCOPY */
1018 DBC_ASSERT(pattrs->strm_mode ==
1019 STRMMODE_PROCCOPY);
1020 chnl_id = gb_findandset(hnode_mgr->chnl_map);
1021 /* e.g. 0-15 */
1022 }
1023 } else {
1024 /* default to PROCCOPY */
1025 chnl_id = gb_findandset(hnode_mgr->chnl_map);
1026 }
1027 if (chnl_id == GB_NOBITS) {
1028 status = -ECONNREFUSED;
1029 goto func_cont2;
1030 }
1031 pstr_dev_name = kzalloc(HOSTNAMELEN + 1, GFP_KERNEL);
1032 if (pstr_dev_name != NULL)
1033 goto func_cont2;
1034
1035 if (pattrs) {
1036 if (pattrs->strm_mode == STRMMODE_RDMA) {
1037 gb_clear(hnode_mgr->dma_chnl_map, chnl_id -
1038 hnode_mgr->ul_num_chnls);
1039 } else if (pattrs->strm_mode == STRMMODE_ZEROCOPY) {
1040 gb_clear(hnode_mgr->zc_chnl_map, chnl_id -
1041 (2 * hnode_mgr->ul_num_chnls));
1042 } else {
1043 DBC_ASSERT(pattrs->strm_mode ==
1044 STRMMODE_PROCCOPY);
1045 gb_clear(hnode_mgr->chnl_map, chnl_id);
1046 }
1047 } else {
1048 gb_clear(hnode_mgr->chnl_map, chnl_id);
1049 }
1050 status = -ENOMEM;
1051 func_cont2:
1052 if (!status) {
1053 if (node1 == (struct node_object *)DSP_HGPPNODE) {
1054 node2->inputs[stream2].type = HOSTCONNECT;
1055 node2->inputs[stream2].dev_id = chnl_id;
1056 input->sz_device = pstr_dev_name;
1057 } else {
1058 node1->outputs[stream1].type = HOSTCONNECT;
1059 node1->outputs[stream1].dev_id = chnl_id;
1060 output->sz_device = pstr_dev_name;
1061 }
1062 sprintf(pstr_dev_name, "%s%d", HOSTPREFIX, chnl_id);
1063 }
1064 }
1065 /* Connecting task node to device node? */
1066 if (!status && ((node1_type == NODE_DEVICE) ||
1067 (node2_type == NODE_DEVICE))) {
1068 if (node2_type == NODE_DEVICE) {
1069 /* node1 == > device */
1070 dev_node_obj = node2;
1071 hnode = node1;
1072 pstream = &(node1->outputs[stream1]);
1073 pstrm_def = output;
1074 } else {
1075 /* device == > node2 */
1076 dev_node_obj = node1;
1077 hnode = node2;
1078 pstream = &(node2->inputs[stream2]);
1079 pstrm_def = input;
1080 }
1081 /* Set up create args */
1082 pstream->type = DEVICECONNECT;
1083 dw_length = strlen(dev_node_obj->pstr_dev_name);
1084 if (conn_param != NULL) {
1085 pstrm_def->sz_device = kzalloc(dw_length + 1 +
1086 conn_param->cb_data,
1087 GFP_KERNEL);
1088 } else {
1089 pstrm_def->sz_device = kzalloc(dw_length + 1,
1090 GFP_KERNEL);
1091 }
1092 if (pstrm_def->sz_device == NULL) {
1093 status = -ENOMEM;
1094 } else {
1095 /* Copy device name */
1096 strncpy(pstrm_def->sz_device,
1097 dev_node_obj->pstr_dev_name, dw_length);
1098 if (conn_param != NULL) {
1099 strncat(pstrm_def->sz_device,
1100 (char *)conn_param->node_data,
1101 (u32) conn_param->cb_data);
1102 }
1103 dev_node_obj->device_owner = hnode;
1104 }
1105 }
1106 if (!status) {
1107 /* Fill in create args */
1108 if (node1_type == NODE_TASK || node1_type == NODE_DAISSOCKET) {
1109 node1->create_args.asa.task_arg_obj.num_outputs++;
1110 fill_stream_def(node1, output, pattrs);
1111 }
1112 if (node2_type == NODE_TASK || node2_type == NODE_DAISSOCKET) {
1113 node2->create_args.asa.task_arg_obj.num_inputs++;
1114 fill_stream_def(node2, input, pattrs);
1115 }
1116 /* Update node1 and node2 stream_connect */
1117 if (node1_type != NODE_GPP && node1_type != NODE_DEVICE) {
1118 node1->num_outputs++;
1119 if (stream1 > node1->max_output_index)
1120 node1->max_output_index = stream1;
1121
1122 }
1123 if (node2_type != NODE_GPP && node2_type != NODE_DEVICE) {
1124 node2->num_inputs++;
1125 if (stream2 > node2->max_input_index)
1126 node2->max_input_index = stream2;
1127
1128 }
1129 fill_stream_connect(node1, node2, stream1, stream2);
1130 }
1131 /* end of sync_enter_cs */
1132 /* Exit critical section */
1133 mutex_unlock(&hnode_mgr->node_mgr_lock);
1134 func_end:
1135 dev_dbg(bridge, "%s: node1: %p stream1: %d node2: %p stream2: %d"
1136 "pattrs: %p status: 0x%x\n", __func__, node1,
1137 stream1, node2, stream2, pattrs, status);
1138 return status;
1139 }
1140
1141 /*
1142 * ======== node_create ========
1143 * Purpose:
1144 * Create a node on the DSP by remotely calling the node's create function.
1145 */
1146 int node_create(struct node_object *hnode)
1147 {
1148 struct node_object *pnode = (struct node_object *)hnode;
1149 struct node_mgr *hnode_mgr;
1150 struct bridge_drv_interface *intf_fxns;
1151 u32 ul_create_fxn;
1152 enum node_type node_type;
1153 int status = 0;
1154 int status1 = 0;
1155 struct dsp_cbdata cb_data;
1156 u32 proc_id = 255;
1157 struct dsp_processorstate proc_state;
1158 struct proc_object *hprocessor;
1159 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1160 struct dspbridge_platform_data *pdata =
1161 omap_dspbridge_dev->dev.platform_data;
1162 #endif
1163
1164 DBC_REQUIRE(refs > 0);
1165 if (!pnode) {
1166 status = -EFAULT;
1167 goto func_end;
1168 }
1169 hprocessor = hnode->hprocessor;
1170 status = proc_get_state(hprocessor, &proc_state,
1171 sizeof(struct dsp_processorstate));
1172 if (status)
1173 goto func_end;
1174 /* If processor is in error state then don't attempt to create
1175 new node */
1176 if (proc_state.proc_state == PROC_ERROR) {
1177 status = -EPERM;
1178 goto func_end;
1179 }
1180 /* create struct dsp_cbdata struct for PWR calls */
1181 cb_data.cb_data = PWR_TIMEOUT;
1182 node_type = node_get_type(hnode);
1183 hnode_mgr = hnode->hnode_mgr;
1184 intf_fxns = hnode_mgr->intf_fxns;
1185 /* Get access to node dispatcher */
1186 mutex_lock(&hnode_mgr->node_mgr_lock);
1187
1188 /* Check node state */
1189 if (node_get_state(hnode) != NODE_ALLOCATED)
1190 status = -EBADR;
1191
1192 if (!status)
1193 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
1194
1195 if (status)
1196 goto func_cont2;
1197
1198 if (proc_id != DSP_UNIT)
1199 goto func_cont2;
1200
1201 /* Make sure streams are properly connected */
1202 if ((hnode->num_inputs && hnode->max_input_index >
1203 hnode->num_inputs - 1) ||
1204 (hnode->num_outputs && hnode->max_output_index >
1205 hnode->num_outputs - 1))
1206 status = -ENOTCONN;
1207
1208 if (!status) {
1209 /* If node's create function is not loaded, load it */
1210 /* Boost the OPP level to max level that DSP can be requested */
1211 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1212 if (pdata->cpu_set_freq)
1213 (*pdata->cpu_set_freq) (pdata->mpu_speed[VDD1_OPP3]);
1214 #endif
1215 status = hnode_mgr->nldr_fxns.pfn_load(hnode->nldr_node_obj,
1216 NLDR_CREATE);
1217 /* Get address of node's create function */
1218 if (!status) {
1219 hnode->loaded = true;
1220 if (node_type != NODE_DEVICE) {
1221 status = get_fxn_address(hnode, &ul_create_fxn,
1222 CREATEPHASE);
1223 }
1224 } else {
1225 pr_err("%s: failed to load create code: 0x%x\n",
1226 __func__, status);
1227 }
1228 /* Request the lowest OPP level */
1229 #if defined(CONFIG_TIDSPBRIDGE_DVFS) && !defined(CONFIG_CPU_FREQ)
1230 if (pdata->cpu_set_freq)
1231 (*pdata->cpu_set_freq) (pdata->mpu_speed[VDD1_OPP1]);
1232 #endif
1233 /* Get address of iAlg functions, if socket node */
1234 if (!status) {
1235 if (node_type == NODE_DAISSOCKET) {
1236 status = hnode_mgr->nldr_fxns.pfn_get_fxn_addr
1237 (hnode->nldr_node_obj,
1238 hnode->dcd_props.obj_data.node_obj.
1239 pstr_i_alg_name,
1240 &hnode->create_args.asa.
1241 task_arg_obj.ul_dais_arg);
1242 }
1243 }
1244 }
1245 if (!status) {
1246 if (node_type != NODE_DEVICE) {
1247 status = disp_node_create(hnode_mgr->disp_obj, hnode,
1248 hnode_mgr->ul_fxn_addrs
1249 [RMSCREATENODE],
1250 ul_create_fxn,
1251 &(hnode->create_args),
1252 &(hnode->node_env));
1253 if (status >= 0) {
1254 /* Set the message queue id to the node env
1255 * pointer */
1256 intf_fxns = hnode_mgr->intf_fxns;
1257 (*intf_fxns->pfn_msg_set_queue_id) (hnode->
1258 msg_queue_obj,
1259 hnode->node_env);
1260 }
1261 }
1262 }
1263 /* Phase II/Overlays: Create, execute, delete phases possibly in
1264 * different files/sections. */
1265 if (hnode->loaded && hnode->phase_split) {
1266 /* If create code was dynamically loaded, we can now unload
1267 * it. */
1268 status1 = hnode_mgr->nldr_fxns.pfn_unload(hnode->nldr_node_obj,
1269 NLDR_CREATE);
1270 hnode->loaded = false;
1271 }
1272 if (status1)
1273 pr_err("%s: Failed to unload create code: 0x%x\n",
1274 __func__, status1);
1275 func_cont2:
1276 /* Update node state and node manager state */
1277 if (status >= 0) {
1278 NODE_SET_STATE(hnode, NODE_CREATED);
1279 hnode_mgr->num_created++;
1280 goto func_cont;
1281 }
1282 if (status != -EBADR) {
1283 /* Put back in NODE_ALLOCATED state if error occurred */
1284 NODE_SET_STATE(hnode, NODE_ALLOCATED);
1285 }
1286 func_cont:
1287 /* Free access to node dispatcher */
1288 mutex_unlock(&hnode_mgr->node_mgr_lock);
1289 func_end:
1290 if (status >= 0) {
1291 proc_notify_clients(hnode->hprocessor, DSP_NODESTATECHANGE);
1292 ntfy_notify(hnode->ntfy_obj, DSP_NODESTATECHANGE);
1293 }
1294
1295 dev_dbg(bridge, "%s: hnode: %p status: 0x%x\n", __func__,
1296 hnode, status);
1297 return status;
1298 }
1299
1300 /*
1301 * ======== node_create_mgr ========
1302 * Purpose:
1303 * Create a NODE Manager object.
1304 */
1305 int node_create_mgr(struct node_mgr **node_man,
1306 struct dev_object *hdev_obj)
1307 {
1308 u32 i;
1309 struct node_mgr *node_mgr_obj = NULL;
1310 struct disp_attr disp_attr_obj;
1311 char *sz_zl_file = "";
1312 struct nldr_attrs nldr_attrs_obj;
1313 int status = 0;
1314 u8 dev_type;
1315 DBC_REQUIRE(refs > 0);
1316 DBC_REQUIRE(node_man != NULL);
1317 DBC_REQUIRE(hdev_obj != NULL);
1318
1319 *node_man = NULL;
1320 /* Allocate Node manager object */
1321 node_mgr_obj = kzalloc(sizeof(struct node_mgr), GFP_KERNEL);
1322 if (node_mgr_obj) {
1323 node_mgr_obj->hdev_obj = hdev_obj;
1324 node_mgr_obj->node_list = kzalloc(sizeof(struct lst_list),
1325 GFP_KERNEL);
1326 node_mgr_obj->pipe_map = gb_create(MAXPIPES);
1327 node_mgr_obj->pipe_done_map = gb_create(MAXPIPES);
1328 if (node_mgr_obj->node_list == NULL
1329 || node_mgr_obj->pipe_map == NULL
1330 || node_mgr_obj->pipe_done_map == NULL) {
1331 status = -ENOMEM;
1332 } else {
1333 INIT_LIST_HEAD(&node_mgr_obj->node_list->head);
1334 node_mgr_obj->ntfy_obj = kmalloc(
1335 sizeof(struct ntfy_object), GFP_KERNEL);
1336 if (node_mgr_obj->ntfy_obj)
1337 ntfy_init(node_mgr_obj->ntfy_obj);
1338 else
1339 status = -ENOMEM;
1340 }
1341 node_mgr_obj->num_created = 0;
1342 } else {
1343 status = -ENOMEM;
1344 }
1345 /* get devNodeType */
1346 if (!status)
1347 status = dev_get_dev_type(hdev_obj, &dev_type);
1348
1349 /* Create the DCD Manager */
1350 if (!status) {
1351 status =
1352 dcd_create_manager(sz_zl_file, &node_mgr_obj->hdcd_mgr);
1353 if (!status)
1354 status = get_proc_props(node_mgr_obj, hdev_obj);
1355
1356 }
1357 /* Create NODE Dispatcher */
1358 if (!status) {
1359 disp_attr_obj.ul_chnl_offset = node_mgr_obj->ul_chnl_offset;
1360 disp_attr_obj.ul_chnl_buf_size = node_mgr_obj->ul_chnl_buf_size;
1361 disp_attr_obj.proc_family = node_mgr_obj->proc_family;
1362 disp_attr_obj.proc_type = node_mgr_obj->proc_type;
1363 status =
1364 disp_create(&node_mgr_obj->disp_obj, hdev_obj,
1365 &disp_attr_obj);
1366 }
1367 /* Create a STRM Manager */
1368 if (!status)
1369 status = strm_create(&node_mgr_obj->strm_mgr_obj, hdev_obj);
1370
1371 if (!status) {
1372 dev_get_intf_fxns(hdev_obj, &node_mgr_obj->intf_fxns);
1373 /* Get msg_ctrl queue manager */
1374 dev_get_msg_mgr(hdev_obj, &node_mgr_obj->msg_mgr_obj);
1375 mutex_init(&node_mgr_obj->node_mgr_lock);
1376 node_mgr_obj->chnl_map = gb_create(node_mgr_obj->ul_num_chnls);
1377 /* dma chnl map. ul_num_chnls is # per transport */
1378 node_mgr_obj->dma_chnl_map =
1379 gb_create(node_mgr_obj->ul_num_chnls);
1380 node_mgr_obj->zc_chnl_map =
1381 gb_create(node_mgr_obj->ul_num_chnls);
1382 if ((node_mgr_obj->chnl_map == NULL)
1383 || (node_mgr_obj->dma_chnl_map == NULL)
1384 || (node_mgr_obj->zc_chnl_map == NULL)) {
1385 status = -ENOMEM;
1386 } else {
1387 /* Block out reserved channels */
1388 for (i = 0; i < node_mgr_obj->ul_chnl_offset; i++)
1389 gb_set(node_mgr_obj->chnl_map, i);
1390
1391 /* Block out channels reserved for RMS */
1392 gb_set(node_mgr_obj->chnl_map,
1393 node_mgr_obj->ul_chnl_offset);
1394 gb_set(node_mgr_obj->chnl_map,
1395 node_mgr_obj->ul_chnl_offset + 1);
1396 }
1397 }
1398 if (!status) {
1399 /* NO RM Server on the IVA */
1400 if (dev_type != IVA_UNIT) {
1401 /* Get addresses of any RMS functions loaded */
1402 status = get_rms_fxns(node_mgr_obj);
1403 }
1404 }
1405
1406 /* Get loader functions and create loader */
1407 if (!status)
1408 node_mgr_obj->nldr_fxns = nldr_fxns; /* Dyn loader funcs */
1409
1410 if (!status) {
1411 nldr_attrs_obj.pfn_ovly = ovly;
1412 nldr_attrs_obj.pfn_write = mem_write;
1413 nldr_attrs_obj.us_dsp_word_size = node_mgr_obj->udsp_word_size;
1414 nldr_attrs_obj.us_dsp_mau_size = node_mgr_obj->udsp_mau_size;
1415 node_mgr_obj->loader_init = node_mgr_obj->nldr_fxns.pfn_init();
1416 status =
1417 node_mgr_obj->nldr_fxns.pfn_create(&node_mgr_obj->nldr_obj,
1418 hdev_obj,
1419 &nldr_attrs_obj);
1420 }
1421 if (!status)
1422 *node_man = node_mgr_obj;
1423 else
1424 delete_node_mgr(node_mgr_obj);
1425
1426 DBC_ENSURE((status && *node_man == NULL) || (!status && *node_man));
1427
1428 return status;
1429 }
1430
1431 /*
1432 * ======== node_delete ========
1433 * Purpose:
1434 * Delete a node on the DSP by remotely calling the node's delete function.
1435 * Loads the node's delete function if necessary. Free GPP side resources
1436 * after node's delete function returns.
1437 */
1438 int node_delete(struct node_res_object *noderes,
1439 struct process_context *pr_ctxt)
1440 {
1441 struct node_object *pnode = noderes->hnode;
1442 struct node_mgr *hnode_mgr;
1443 struct proc_object *hprocessor;
1444 struct disp_object *disp_obj;
1445 u32 ul_delete_fxn;
1446 enum node_type node_type;
1447 enum node_state state;
1448 int status = 0;
1449 int status1 = 0;
1450 struct dsp_cbdata cb_data;
1451 u32 proc_id;
1452 struct bridge_drv_interface *intf_fxns;
1453
1454 void *node_res = noderes;
1455
1456 struct dsp_processorstate proc_state;
1457 DBC_REQUIRE(refs > 0);
1458
1459 if (!pnode) {
1460 status = -EFAULT;
1461 goto func_end;
1462 }
1463 /* create struct dsp_cbdata struct for PWR call */
1464 cb_data.cb_data = PWR_TIMEOUT;
1465 hnode_mgr = pnode->hnode_mgr;
1466 hprocessor = pnode->hprocessor;
1467 disp_obj = hnode_mgr->disp_obj;
1468 node_type = node_get_type(pnode);
1469 intf_fxns = hnode_mgr->intf_fxns;
1470 /* Enter critical section */
1471 mutex_lock(&hnode_mgr->node_mgr_lock);
1472
1473 state = node_get_state(pnode);
1474 /* Execute delete phase code for non-device node in all cases
1475 * except when the node was only allocated. Delete phase must be
1476 * executed even if create phase was executed, but failed.
1477 * If the node environment pointer is non-NULL, the delete phase
1478 * code must be executed. */
1479 if (!(state == NODE_ALLOCATED && pnode->node_env == (u32) NULL) &&
1480 node_type != NODE_DEVICE) {
1481 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
1482 if (status)
1483 goto func_cont1;
1484
1485 if (proc_id == DSP_UNIT || proc_id == IVA_UNIT) {
1486 /* If node has terminated, execute phase code will
1487 * have already been unloaded in node_on_exit(). If the
1488 * node is PAUSED, the execute phase is loaded, and it
1489 * is now ok to unload it. If the node is running, we
1490 * will unload the execute phase only after deleting
1491 * the node. */
1492 if (state == NODE_PAUSED && pnode->loaded &&
1493 pnode->phase_split) {
1494 /* Ok to unload execute code as long as node
1495 * is not * running */
1496 status1 =
1497 hnode_mgr->nldr_fxns.
1498 pfn_unload(pnode->nldr_node_obj,
1499 NLDR_EXECUTE);
1500 pnode->loaded = false;
1501 NODE_SET_STATE(pnode, NODE_DONE);
1502 }
1503 /* Load delete phase code if not loaded or if haven't
1504 * * unloaded EXECUTE phase */
1505 if ((!(pnode->loaded) || (state == NODE_RUNNING)) &&
1506 pnode->phase_split) {
1507 status =
1508 hnode_mgr->nldr_fxns.
1509 pfn_load(pnode->nldr_node_obj, NLDR_DELETE);
1510 if (!status)
1511 pnode->loaded = true;
1512 else
1513 pr_err("%s: fail - load delete code:"
1514 " 0x%x\n", __func__, status);
1515 }
1516 }
1517 func_cont1:
1518 if (!status) {
1519 /* Unblock a thread trying to terminate the node */
1520 (void)sync_set_event(pnode->sync_done);
1521 if (proc_id == DSP_UNIT) {
1522 /* ul_delete_fxn = address of node's delete
1523 * function */
1524 status = get_fxn_address(pnode, &ul_delete_fxn,
1525 DELETEPHASE);
1526 } else if (proc_id == IVA_UNIT)
1527 ul_delete_fxn = (u32) pnode->node_env;
1528 if (!status) {
1529 status = proc_get_state(hprocessor,
1530 &proc_state,
1531 sizeof(struct
1532 dsp_processorstate));
1533 if (proc_state.proc_state != PROC_ERROR) {
1534 status =
1535 disp_node_delete(disp_obj, pnode,
1536 hnode_mgr->
1537 ul_fxn_addrs
1538 [RMSDELETENODE],
1539 ul_delete_fxn,
1540 pnode->node_env);
1541 } else
1542 NODE_SET_STATE(pnode, NODE_DONE);
1543
1544 /* Unload execute, if not unloaded, and delete
1545 * function */
1546 if (state == NODE_RUNNING &&
1547 pnode->phase_split) {
1548 status1 =
1549 hnode_mgr->nldr_fxns.
1550 pfn_unload(pnode->nldr_node_obj,
1551 NLDR_EXECUTE);
1552 }
1553 if (status1)
1554 pr_err("%s: fail - unload execute code:"
1555 " 0x%x\n", __func__, status1);
1556
1557 status1 =
1558 hnode_mgr->nldr_fxns.pfn_unload(pnode->
1559 nldr_node_obj,
1560 NLDR_DELETE);
1561 pnode->loaded = false;
1562 if (status1)
1563 pr_err("%s: fail - unload delete code: "
1564 "0x%x\n", __func__, status1);
1565 }
1566 }
1567 }
1568 /* Free host side resources even if a failure occurred */
1569 /* Remove node from hnode_mgr->node_list */
1570 lst_remove_elem(hnode_mgr->node_list, (struct list_head *)pnode);
1571 hnode_mgr->num_nodes--;
1572 /* Decrement count of nodes created on DSP */
1573 if ((state != NODE_ALLOCATED) || ((state == NODE_ALLOCATED) &&
1574 (pnode->node_env != (u32) NULL)))
1575 hnode_mgr->num_created--;
1576 /* Free host-side resources allocated by node_create()
1577 * delete_node() fails if SM buffers not freed by client! */
1578 drv_proc_node_update_status(node_res, false);
1579 delete_node(pnode, pr_ctxt);
1580
1581 /*
1582 * Release all Node resources and its context
1583 */
1584 idr_remove(pr_ctxt->node_id, ((struct node_res_object *)node_res)->id);
1585 kfree(node_res);
1586
1587 /* Exit critical section */
1588 mutex_unlock(&hnode_mgr->node_mgr_lock);
1589 proc_notify_clients(hprocessor, DSP_NODESTATECHANGE);
1590 func_end:
1591 dev_dbg(bridge, "%s: pnode: %p status 0x%x\n", __func__, pnode, status);
1592 return status;
1593 }
1594
1595 /*
1596 * ======== node_delete_mgr ========
1597 * Purpose:
1598 * Delete the NODE Manager.
1599 */
1600 int node_delete_mgr(struct node_mgr *hnode_mgr)
1601 {
1602 int status = 0;
1603
1604 DBC_REQUIRE(refs > 0);
1605
1606 if (hnode_mgr)
1607 delete_node_mgr(hnode_mgr);
1608 else
1609 status = -EFAULT;
1610
1611 return status;
1612 }
1613
1614 /*
1615 * ======== node_enum_nodes ========
1616 * Purpose:
1617 * Enumerate currently allocated nodes.
1618 */
1619 int node_enum_nodes(struct node_mgr *hnode_mgr, void **node_tab,
1620 u32 node_tab_size, u32 *pu_num_nodes,
1621 u32 *pu_allocated)
1622 {
1623 struct node_object *hnode;
1624 u32 i;
1625 int status = 0;
1626 DBC_REQUIRE(refs > 0);
1627 DBC_REQUIRE(node_tab != NULL || node_tab_size == 0);
1628 DBC_REQUIRE(pu_num_nodes != NULL);
1629 DBC_REQUIRE(pu_allocated != NULL);
1630
1631 if (!hnode_mgr) {
1632 status = -EFAULT;
1633 goto func_end;
1634 }
1635 /* Enter critical section */
1636 mutex_lock(&hnode_mgr->node_mgr_lock);
1637
1638 if (hnode_mgr->num_nodes > node_tab_size) {
1639 *pu_allocated = hnode_mgr->num_nodes;
1640 *pu_num_nodes = 0;
1641 status = -EINVAL;
1642 } else {
1643 hnode = (struct node_object *)lst_first(hnode_mgr->
1644 node_list);
1645 for (i = 0; i < hnode_mgr->num_nodes; i++) {
1646 DBC_ASSERT(hnode);
1647 node_tab[i] = hnode;
1648 hnode = (struct node_object *)lst_next
1649 (hnode_mgr->node_list,
1650 (struct list_head *)hnode);
1651 }
1652 *pu_allocated = *pu_num_nodes = hnode_mgr->num_nodes;
1653 }
1654 /* end of sync_enter_cs */
1655 /* Exit critical section */
1656 mutex_unlock(&hnode_mgr->node_mgr_lock);
1657 func_end:
1658 return status;
1659 }
1660
1661 /*
1662 * ======== node_exit ========
1663 * Purpose:
1664 * Discontinue usage of NODE module.
1665 */
1666 void node_exit(void)
1667 {
1668 DBC_REQUIRE(refs > 0);
1669
1670 refs--;
1671
1672 DBC_ENSURE(refs >= 0);
1673 }
1674
1675 /*
1676 * ======== node_free_msg_buf ========
1677 * Purpose:
1678 * Frees the message buffer.
1679 */
1680 int node_free_msg_buf(struct node_object *hnode, u8 * pbuffer,
1681 struct dsp_bufferattr *pattr)
1682 {
1683 struct node_object *pnode = (struct node_object *)hnode;
1684 int status = 0;
1685 u32 proc_id;
1686 DBC_REQUIRE(refs > 0);
1687 DBC_REQUIRE(pbuffer != NULL);
1688 DBC_REQUIRE(pnode != NULL);
1689 DBC_REQUIRE(pnode->xlator != NULL);
1690
1691 if (!hnode) {
1692 status = -EFAULT;
1693 goto func_end;
1694 }
1695 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
1696 if (proc_id == DSP_UNIT) {
1697 if (!status) {
1698 if (pattr == NULL) {
1699 /* set defaults */
1700 pattr = &node_dfltbufattrs;
1701 }
1702 /* Node supports single SM segment only */
1703 if (pattr->segment_id != 1)
1704 status = -EBADR;
1705
1706 /* pbuffer is clients Va. */
1707 status = cmm_xlator_free_buf(pnode->xlator, pbuffer);
1708 }
1709 } else {
1710 DBC_ASSERT(NULL); /* BUG */
1711 }
1712 func_end:
1713 return status;
1714 }
1715
1716 /*
1717 * ======== node_get_attr ========
1718 * Purpose:
1719 * Copy the current attributes of the specified node into a dsp_nodeattr
1720 * structure.
1721 */
1722 int node_get_attr(struct node_object *hnode,
1723 struct dsp_nodeattr *pattr, u32 attr_size)
1724 {
1725 struct node_mgr *hnode_mgr;
1726 int status = 0;
1727 DBC_REQUIRE(refs > 0);
1728 DBC_REQUIRE(pattr != NULL);
1729 DBC_REQUIRE(attr_size >= sizeof(struct dsp_nodeattr));
1730
1731 if (!hnode) {
1732 status = -EFAULT;
1733 } else {
1734 hnode_mgr = hnode->hnode_mgr;
1735 /* Enter hnode_mgr critical section (since we're accessing
1736 * data that could be changed by node_change_priority() and
1737 * node_connect(). */
1738 mutex_lock(&hnode_mgr->node_mgr_lock);
1739 pattr->cb_struct = sizeof(struct dsp_nodeattr);
1740 /* dsp_nodeattrin */
1741 pattr->in_node_attr_in.cb_struct =
1742 sizeof(struct dsp_nodeattrin);
1743 pattr->in_node_attr_in.prio = hnode->prio;
1744 pattr->in_node_attr_in.utimeout = hnode->utimeout;
1745 pattr->in_node_attr_in.heap_size =
1746 hnode->create_args.asa.task_arg_obj.heap_size;
1747 pattr->in_node_attr_in.pgpp_virt_addr = (void *)
1748 hnode->create_args.asa.task_arg_obj.ugpp_heap_addr;
1749 pattr->node_attr_inputs = hnode->num_gpp_inputs;
1750 pattr->node_attr_outputs = hnode->num_gpp_outputs;
1751 /* dsp_nodeinfo */
1752 get_node_info(hnode, &(pattr->node_info));
1753 /* end of sync_enter_cs */
1754 /* Exit critical section */
1755 mutex_unlock(&hnode_mgr->node_mgr_lock);
1756 }
1757 return status;
1758 }
1759
1760 /*
1761 * ======== node_get_channel_id ========
1762 * Purpose:
1763 * Get the channel index reserved for a stream connection between the
1764 * host and a node.
1765 */
1766 int node_get_channel_id(struct node_object *hnode, u32 dir, u32 index,
1767 u32 *chan_id)
1768 {
1769 enum node_type node_type;
1770 int status = -EINVAL;
1771 DBC_REQUIRE(refs > 0);
1772 DBC_REQUIRE(dir == DSP_TONODE || dir == DSP_FROMNODE);
1773 DBC_REQUIRE(chan_id != NULL);
1774
1775 if (!hnode) {
1776 status = -EFAULT;
1777 return status;
1778 }
1779 node_type = node_get_type(hnode);
1780 if (node_type != NODE_TASK && node_type != NODE_DAISSOCKET) {
1781 status = -EPERM;
1782 return status;
1783 }
1784 if (dir == DSP_TONODE) {
1785 if (index < MAX_INPUTS(hnode)) {
1786 if (hnode->inputs[index].type == HOSTCONNECT) {
1787 *chan_id = hnode->inputs[index].dev_id;
1788 status = 0;
1789 }
1790 }
1791 } else {
1792 DBC_ASSERT(dir == DSP_FROMNODE);
1793 if (index < MAX_OUTPUTS(hnode)) {
1794 if (hnode->outputs[index].type == HOSTCONNECT) {
1795 *chan_id = hnode->outputs[index].dev_id;
1796 status = 0;
1797 }
1798 }
1799 }
1800 return status;
1801 }
1802
1803 /*
1804 * ======== node_get_message ========
1805 * Purpose:
1806 * Retrieve a message from a node on the DSP.
1807 */
1808 int node_get_message(struct node_object *hnode,
1809 struct dsp_msg *message, u32 utimeout)
1810 {
1811 struct node_mgr *hnode_mgr;
1812 enum node_type node_type;
1813 struct bridge_drv_interface *intf_fxns;
1814 int status = 0;
1815 void *tmp_buf;
1816 struct dsp_processorstate proc_state;
1817 struct proc_object *hprocessor;
1818
1819 DBC_REQUIRE(refs > 0);
1820 DBC_REQUIRE(message != NULL);
1821
1822 if (!hnode) {
1823 status = -EFAULT;
1824 goto func_end;
1825 }
1826 hprocessor = hnode->hprocessor;
1827 status = proc_get_state(hprocessor, &proc_state,
1828 sizeof(struct dsp_processorstate));
1829 if (status)
1830 goto func_end;
1831 /* If processor is in error state then don't attempt to get the
1832 message */
1833 if (proc_state.proc_state == PROC_ERROR) {
1834 status = -EPERM;
1835 goto func_end;
1836 }
1837 hnode_mgr = hnode->hnode_mgr;
1838 node_type = node_get_type(hnode);
1839 if (node_type != NODE_MESSAGE && node_type != NODE_TASK &&
1840 node_type != NODE_DAISSOCKET) {
1841 status = -EPERM;
1842 goto func_end;
1843 }
1844 /* This function will block unless a message is available. Since
1845 * DSPNode_RegisterNotify() allows notification when a message
1846 * is available, the system can be designed so that
1847 * DSPNode_GetMessage() is only called when a message is
1848 * available. */
1849 intf_fxns = hnode_mgr->intf_fxns;
1850 status =
1851 (*intf_fxns->pfn_msg_get) (hnode->msg_queue_obj, message, utimeout);
1852 /* Check if message contains SM descriptor */
1853 if (status || !(message->dw_cmd & DSP_RMSBUFDESC))
1854 goto func_end;
1855
1856 /* Translate DSP byte addr to GPP Va. */
1857 tmp_buf = cmm_xlator_translate(hnode->xlator,
1858 (void *)(message->dw_arg1 *
1859 hnode->hnode_mgr->
1860 udsp_word_size), CMM_DSPPA2PA);
1861 if (tmp_buf != NULL) {
1862 /* now convert this GPP Pa to Va */
1863 tmp_buf = cmm_xlator_translate(hnode->xlator, tmp_buf,
1864 CMM_PA2VA);
1865 if (tmp_buf != NULL) {
1866 /* Adjust SM size in msg */
1867 message->dw_arg1 = (u32) tmp_buf;
1868 message->dw_arg2 *= hnode->hnode_mgr->udsp_word_size;
1869 } else {
1870 status = -ESRCH;
1871 }
1872 } else {
1873 status = -ESRCH;
1874 }
1875 func_end:
1876 dev_dbg(bridge, "%s: hnode: %p message: %p utimeout: 0x%x\n", __func__,
1877 hnode, message, utimeout);
1878 return status;
1879 }
1880
1881 /*
1882 * ======== node_get_nldr_obj ========
1883 */
1884 int node_get_nldr_obj(struct node_mgr *hnode_mgr,
1885 struct nldr_object **nldr_ovlyobj)
1886 {
1887 int status = 0;
1888 struct node_mgr *node_mgr_obj = hnode_mgr;
1889 DBC_REQUIRE(nldr_ovlyobj != NULL);
1890
1891 if (!hnode_mgr)
1892 status = -EFAULT;
1893 else
1894 *nldr_ovlyobj = node_mgr_obj->nldr_obj;
1895
1896 DBC_ENSURE(!status || (nldr_ovlyobj != NULL && *nldr_ovlyobj == NULL));
1897 return status;
1898 }
1899
1900 /*
1901 * ======== node_get_strm_mgr ========
1902 * Purpose:
1903 * Returns the Stream manager.
1904 */
1905 int node_get_strm_mgr(struct node_object *hnode,
1906 struct strm_mgr **strm_man)
1907 {
1908 int status = 0;
1909
1910 DBC_REQUIRE(refs > 0);
1911
1912 if (!hnode)
1913 status = -EFAULT;
1914 else
1915 *strm_man = hnode->hnode_mgr->strm_mgr_obj;
1916
1917 return status;
1918 }
1919
1920 /*
1921 * ======== node_get_load_type ========
1922 */
1923 enum nldr_loadtype node_get_load_type(struct node_object *hnode)
1924 {
1925 DBC_REQUIRE(refs > 0);
1926 DBC_REQUIRE(hnode);
1927 if (!hnode) {
1928 dev_dbg(bridge, "%s: Failed. hnode: %p\n", __func__, hnode);
1929 return -1;
1930 } else {
1931 return hnode->dcd_props.obj_data.node_obj.us_load_type;
1932 }
1933 }
1934
1935 /*
1936 * ======== node_get_timeout ========
1937 * Purpose:
1938 * Returns the timeout value for this node.
1939 */
1940 u32 node_get_timeout(struct node_object *hnode)
1941 {
1942 DBC_REQUIRE(refs > 0);
1943 DBC_REQUIRE(hnode);
1944 if (!hnode) {
1945 dev_dbg(bridge, "%s: failed. hnode: %p\n", __func__, hnode);
1946 return 0;
1947 } else {
1948 return hnode->utimeout;
1949 }
1950 }
1951
1952 /*
1953 * ======== node_get_type ========
1954 * Purpose:
1955 * Returns the node type.
1956 */
1957 enum node_type node_get_type(struct node_object *hnode)
1958 {
1959 enum node_type node_type;
1960
1961 if (hnode == (struct node_object *)DSP_HGPPNODE)
1962 node_type = NODE_GPP;
1963 else {
1964 if (!hnode)
1965 node_type = -1;
1966 else
1967 node_type = hnode->ntype;
1968 }
1969 return node_type;
1970 }
1971
1972 /*
1973 * ======== node_init ========
1974 * Purpose:
1975 * Initialize the NODE module.
1976 */
1977 bool node_init(void)
1978 {
1979 DBC_REQUIRE(refs >= 0);
1980
1981 refs++;
1982
1983 return true;
1984 }
1985
1986 /*
1987 * ======== node_on_exit ========
1988 * Purpose:
1989 * Gets called when RMS_EXIT is received for a node.
1990 */
1991 void node_on_exit(struct node_object *hnode, s32 node_status)
1992 {
1993 if (!hnode)
1994 return;
1995
1996 /* Set node state to done */
1997 NODE_SET_STATE(hnode, NODE_DONE);
1998 hnode->exit_status = node_status;
1999 if (hnode->loaded && hnode->phase_split) {
2000 (void)hnode->hnode_mgr->nldr_fxns.pfn_unload(hnode->
2001 nldr_node_obj,
2002 NLDR_EXECUTE);
2003 hnode->loaded = false;
2004 }
2005 /* Unblock call to node_terminate */
2006 (void)sync_set_event(hnode->sync_done);
2007 /* Notify clients */
2008 proc_notify_clients(hnode->hprocessor, DSP_NODESTATECHANGE);
2009 ntfy_notify(hnode->ntfy_obj, DSP_NODESTATECHANGE);
2010 }
2011
2012 /*
2013 * ======== node_pause ========
2014 * Purpose:
2015 * Suspend execution of a node currently running on the DSP.
2016 */
2017 int node_pause(struct node_object *hnode)
2018 {
2019 struct node_object *pnode = (struct node_object *)hnode;
2020 enum node_type node_type;
2021 enum node_state state;
2022 struct node_mgr *hnode_mgr;
2023 int status = 0;
2024 u32 proc_id;
2025 struct dsp_processorstate proc_state;
2026 struct proc_object *hprocessor;
2027
2028 DBC_REQUIRE(refs > 0);
2029
2030 if (!hnode) {
2031 status = -EFAULT;
2032 } else {
2033 node_type = node_get_type(hnode);
2034 if (node_type != NODE_TASK && node_type != NODE_DAISSOCKET)
2035 status = -EPERM;
2036 }
2037 if (status)
2038 goto func_end;
2039
2040 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
2041
2042 if (proc_id == IVA_UNIT)
2043 status = -ENOSYS;
2044
2045 if (!status) {
2046 hnode_mgr = hnode->hnode_mgr;
2047
2048 /* Enter critical section */
2049 mutex_lock(&hnode_mgr->node_mgr_lock);
2050 state = node_get_state(hnode);
2051 /* Check node state */
2052 if (state != NODE_RUNNING)
2053 status = -EBADR;
2054
2055 if (status)
2056 goto func_cont;
2057 hprocessor = hnode->hprocessor;
2058 status = proc_get_state(hprocessor, &proc_state,
2059 sizeof(struct dsp_processorstate));
2060 if (status)
2061 goto func_cont;
2062 /* If processor is in error state then don't attempt
2063 to send the message */
2064 if (proc_state.proc_state == PROC_ERROR) {
2065 status = -EPERM;
2066 goto func_cont;
2067 }
2068
2069 status = disp_node_change_priority(hnode_mgr->disp_obj, hnode,
2070 hnode_mgr->ul_fxn_addrs[RMSCHANGENODEPRIORITY],
2071 hnode->node_env, NODE_SUSPENDEDPRI);
2072
2073 /* Update state */
2074 if (status >= 0)
2075 NODE_SET_STATE(hnode, NODE_PAUSED);
2076
2077 func_cont:
2078 /* End of sync_enter_cs */
2079 /* Leave critical section */
2080 mutex_unlock(&hnode_mgr->node_mgr_lock);
2081 if (status >= 0) {
2082 proc_notify_clients(hnode->hprocessor,
2083 DSP_NODESTATECHANGE);
2084 ntfy_notify(hnode->ntfy_obj, DSP_NODESTATECHANGE);
2085 }
2086 }
2087 func_end:
2088 dev_dbg(bridge, "%s: hnode: %p status 0x%x\n", __func__, hnode, status);
2089 return status;
2090 }
2091
2092 /*
2093 * ======== node_put_message ========
2094 * Purpose:
2095 * Send a message to a message node, task node, or XDAIS socket node. This
2096 * function will block until the message stream can accommodate the
2097 * message, or a timeout occurs.
2098 */
2099 int node_put_message(struct node_object *hnode,
2100 const struct dsp_msg *pmsg, u32 utimeout)
2101 {
2102 struct node_mgr *hnode_mgr = NULL;
2103 enum node_type node_type;
2104 struct bridge_drv_interface *intf_fxns;
2105 enum node_state state;
2106 int status = 0;
2107 void *tmp_buf;
2108 struct dsp_msg new_msg;
2109 struct dsp_processorstate proc_state;
2110 struct proc_object *hprocessor;
2111
2112 DBC_REQUIRE(refs > 0);
2113 DBC_REQUIRE(pmsg != NULL);
2114
2115 if (!hnode) {
2116 status = -EFAULT;
2117 goto func_end;
2118 }
2119 hprocessor = hnode->hprocessor;
2120 status = proc_get_state(hprocessor, &proc_state,
2121 sizeof(struct dsp_processorstate));
2122 if (status)
2123 goto func_end;
2124 /* If processor is in bad state then don't attempt sending the
2125 message */
2126 if (proc_state.proc_state == PROC_ERROR) {
2127 status = -EPERM;
2128 goto func_end;
2129 }
2130 hnode_mgr = hnode->hnode_mgr;
2131 node_type = node_get_type(hnode);
2132 if (node_type != NODE_MESSAGE && node_type != NODE_TASK &&
2133 node_type != NODE_DAISSOCKET)
2134 status = -EPERM;
2135
2136 if (!status) {
2137 /* Check node state. Can't send messages to a node after
2138 * we've sent the RMS_EXIT command. There is still the
2139 * possibility that node_terminate can be called after we've
2140 * checked the state. Could add another SYNC object to
2141 * prevent this (can't use node_mgr_lock, since we don't
2142 * want to block other NODE functions). However, the node may
2143 * still exit on its own, before this message is sent. */
2144 mutex_lock(&hnode_mgr->node_mgr_lock);
2145 state = node_get_state(hnode);
2146 if (state == NODE_TERMINATING || state == NODE_DONE)
2147 status = -EBADR;
2148
2149 /* end of sync_enter_cs */
2150 mutex_unlock(&hnode_mgr->node_mgr_lock);
2151 }
2152 if (status)
2153 goto func_end;
2154
2155 /* assign pmsg values to new msg */
2156 new_msg = *pmsg;
2157 /* Now, check if message contains a SM buffer descriptor */
2158 if (pmsg->dw_cmd & DSP_RMSBUFDESC) {
2159 /* Translate GPP Va to DSP physical buf Ptr. */
2160 tmp_buf = cmm_xlator_translate(hnode->xlator,
2161 (void *)new_msg.dw_arg1,
2162 CMM_VA2DSPPA);
2163 if (tmp_buf != NULL) {
2164 /* got translation, convert to MAUs in msg */
2165 if (hnode->hnode_mgr->udsp_word_size != 0) {
2166 new_msg.dw_arg1 =
2167 (u32) tmp_buf /
2168 hnode->hnode_mgr->udsp_word_size;
2169 /* MAUs */
2170 new_msg.dw_arg2 /= hnode->hnode_mgr->
2171 udsp_word_size;
2172 } else {
2173 pr_err("%s: udsp_word_size is zero!\n",
2174 __func__);
2175 status = -EPERM; /* bad DSPWordSize */
2176 }
2177 } else { /* failed to translate buffer address */
2178 status = -ESRCH;
2179 }
2180 }
2181 if (!status) {
2182 intf_fxns = hnode_mgr->intf_fxns;
2183 status = (*intf_fxns->pfn_msg_put) (hnode->msg_queue_obj,
2184 &new_msg, utimeout);
2185 }
2186 func_end:
2187 dev_dbg(bridge, "%s: hnode: %p pmsg: %p utimeout: 0x%x, "
2188 "status 0x%x\n", __func__, hnode, pmsg, utimeout, status);
2189 return status;
2190 }
2191
2192 /*
2193 * ======== node_register_notify ========
2194 * Purpose:
2195 * Register to be notified on specific events for this node.
2196 */
2197 int node_register_notify(struct node_object *hnode, u32 event_mask,
2198 u32 notify_type,
2199 struct dsp_notification *hnotification)
2200 {
2201 struct bridge_drv_interface *intf_fxns;
2202 int status = 0;
2203
2204 DBC_REQUIRE(refs > 0);
2205 DBC_REQUIRE(hnotification != NULL);
2206
2207 if (!hnode) {
2208 status = -EFAULT;
2209 } else {
2210 /* Check if event mask is a valid node related event */
2211 if (event_mask & ~(DSP_NODESTATECHANGE | DSP_NODEMESSAGEREADY))
2212 status = -EINVAL;
2213
2214 /* Check if notify type is valid */
2215 if (notify_type != DSP_SIGNALEVENT)
2216 status = -EINVAL;
2217
2218 /* Only one Notification can be registered at a
2219 * time - Limitation */
2220 if (event_mask == (DSP_NODESTATECHANGE | DSP_NODEMESSAGEREADY))
2221 status = -EINVAL;
2222 }
2223 if (!status) {
2224 if (event_mask == DSP_NODESTATECHANGE) {
2225 status = ntfy_register(hnode->ntfy_obj, hnotification,
2226 event_mask & DSP_NODESTATECHANGE,
2227 notify_type);
2228 } else {
2229 /* Send Message part of event mask to msg_ctrl */
2230 intf_fxns = hnode->hnode_mgr->intf_fxns;
2231 status = (*intf_fxns->pfn_msg_register_notify)
2232 (hnode->msg_queue_obj,
2233 event_mask & DSP_NODEMESSAGEREADY, notify_type,
2234 hnotification);
2235 }
2236
2237 }
2238 dev_dbg(bridge, "%s: hnode: %p event_mask: 0x%x notify_type: 0x%x "
2239 "hnotification: %p status 0x%x\n", __func__, hnode,
2240 event_mask, notify_type, hnotification, status);
2241 return status;
2242 }
2243
2244 /*
2245 * ======== node_run ========
2246 * Purpose:
2247 * Start execution of a node's execute phase, or resume execution of a node
2248 * that has been suspended (via NODE_NodePause()) on the DSP. Load the
2249 * node's execute function if necessary.
2250 */
2251 int node_run(struct node_object *hnode)
2252 {
2253 struct node_object *pnode = (struct node_object *)hnode;
2254 struct node_mgr *hnode_mgr;
2255 enum node_type node_type;
2256 enum node_state state;
2257 u32 ul_execute_fxn;
2258 u32 ul_fxn_addr;
2259 int status = 0;
2260 u32 proc_id;
2261 struct bridge_drv_interface *intf_fxns;
2262 struct dsp_processorstate proc_state;
2263 struct proc_object *hprocessor;
2264
2265 DBC_REQUIRE(refs > 0);
2266
2267 if (!hnode) {
2268 status = -EFAULT;
2269 goto func_end;
2270 }
2271 hprocessor = hnode->hprocessor;
2272 status = proc_get_state(hprocessor, &proc_state,
2273 sizeof(struct dsp_processorstate));
2274 if (status)
2275 goto func_end;
2276 /* If processor is in error state then don't attempt to run the node */
2277 if (proc_state.proc_state == PROC_ERROR) {
2278 status = -EPERM;
2279 goto func_end;
2280 }
2281 node_type = node_get_type(hnode);
2282 if (node_type == NODE_DEVICE)
2283 status = -EPERM;
2284 if (status)
2285 goto func_end;
2286
2287 hnode_mgr = hnode->hnode_mgr;
2288 if (!hnode_mgr) {
2289 status = -EFAULT;
2290 goto func_end;
2291 }
2292 intf_fxns = hnode_mgr->intf_fxns;
2293 /* Enter critical section */
2294 mutex_lock(&hnode_mgr->node_mgr_lock);
2295
2296 state = node_get_state(hnode);
2297 if (state != NODE_CREATED && state != NODE_PAUSED)
2298 status = -EBADR;
2299
2300 if (!status)
2301 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
2302
2303 if (status)
2304 goto func_cont1;
2305
2306 if ((proc_id != DSP_UNIT) && (proc_id != IVA_UNIT))
2307 goto func_cont1;
2308
2309 if (state == NODE_CREATED) {
2310 /* If node's execute function is not loaded, load it */
2311 if (!(hnode->loaded) && hnode->phase_split) {
2312 status =
2313 hnode_mgr->nldr_fxns.pfn_load(hnode->nldr_node_obj,
2314 NLDR_EXECUTE);
2315 if (!status) {
2316 hnode->loaded = true;
2317 } else {
2318 pr_err("%s: fail - load execute code: 0x%x\n",
2319 __func__, status);
2320 }
2321 }
2322 if (!status) {
2323 /* Get address of node's execute function */
2324 if (proc_id == IVA_UNIT)
2325 ul_execute_fxn = (u32) hnode->node_env;
2326 else {
2327 status = get_fxn_address(hnode, &ul_execute_fxn,
2328 EXECUTEPHASE);
2329 }
2330 }
2331 if (!status) {
2332 ul_fxn_addr = hnode_mgr->ul_fxn_addrs[RMSEXECUTENODE];
2333 status =
2334 disp_node_run(hnode_mgr->disp_obj, hnode,
2335 ul_fxn_addr, ul_execute_fxn,
2336 hnode->node_env);
2337 }
2338 } else if (state == NODE_PAUSED) {
2339 ul_fxn_addr = hnode_mgr->ul_fxn_addrs[RMSCHANGENODEPRIORITY];
2340 status = disp_node_change_priority(hnode_mgr->disp_obj, hnode,
2341 ul_fxn_addr, hnode->node_env,
2342 NODE_GET_PRIORITY(hnode));
2343 } else {
2344 /* We should never get here */
2345 DBC_ASSERT(false);
2346 }
2347 func_cont1:
2348 /* Update node state. */
2349 if (status >= 0)
2350 NODE_SET_STATE(hnode, NODE_RUNNING);
2351 else /* Set state back to previous value */
2352 NODE_SET_STATE(hnode, state);
2353 /*End of sync_enter_cs */
2354 /* Exit critical section */
2355 mutex_unlock(&hnode_mgr->node_mgr_lock);
2356 if (status >= 0) {
2357 proc_notify_clients(hnode->hprocessor, DSP_NODESTATECHANGE);
2358 ntfy_notify(hnode->ntfy_obj, DSP_NODESTATECHANGE);
2359 }
2360 func_end:
2361 dev_dbg(bridge, "%s: hnode: %p status 0x%x\n", __func__, hnode, status);
2362 return status;
2363 }
2364
2365 /*
2366 * ======== node_terminate ========
2367 * Purpose:
2368 * Signal a node running on the DSP that it should exit its execute phase
2369 * function.
2370 */
2371 int node_terminate(struct node_object *hnode, int *pstatus)
2372 {
2373 struct node_object *pnode = (struct node_object *)hnode;
2374 struct node_mgr *hnode_mgr = NULL;
2375 enum node_type node_type;
2376 struct bridge_drv_interface *intf_fxns;
2377 enum node_state state;
2378 struct dsp_msg msg, killmsg;
2379 int status = 0;
2380 u32 proc_id, kill_time_out;
2381 struct deh_mgr *hdeh_mgr;
2382 struct dsp_processorstate proc_state;
2383
2384 DBC_REQUIRE(refs > 0);
2385 DBC_REQUIRE(pstatus != NULL);
2386
2387 if (!hnode || !hnode->hnode_mgr) {
2388 status = -EFAULT;
2389 goto func_end;
2390 }
2391 if (pnode->hprocessor == NULL) {
2392 status = -EFAULT;
2393 goto func_end;
2394 }
2395 status = proc_get_processor_id(pnode->hprocessor, &proc_id);
2396
2397 if (!status) {
2398 hnode_mgr = hnode->hnode_mgr;
2399 node_type = node_get_type(hnode);
2400 if (node_type != NODE_TASK && node_type != NODE_DAISSOCKET)
2401 status = -EPERM;
2402 }
2403 if (!status) {
2404 /* Check node state */
2405 mutex_lock(&hnode_mgr->node_mgr_lock);
2406 state = node_get_state(hnode);
2407 if (state != NODE_RUNNING) {
2408 status = -EBADR;
2409 /* Set the exit status if node terminated on
2410 * its own. */
2411 if (state == NODE_DONE)
2412 *pstatus = hnode->exit_status;
2413
2414 } else {
2415 NODE_SET_STATE(hnode, NODE_TERMINATING);
2416 }
2417 /* end of sync_enter_cs */
2418 mutex_unlock(&hnode_mgr->node_mgr_lock);
2419 }
2420 if (!status) {
2421 /*
2422 * Send exit message. Do not change state to NODE_DONE
2423 * here. That will be done in callback.
2424 */
2425 status = proc_get_state(pnode->hprocessor, &proc_state,
2426 sizeof(struct dsp_processorstate));
2427 if (status)
2428 goto func_cont;
2429 /* If processor is in error state then don't attempt to send
2430 * A kill task command */
2431 if (proc_state.proc_state == PROC_ERROR) {
2432 status = -EPERM;
2433 goto func_cont;
2434 }
2435
2436 msg.dw_cmd = RMS_EXIT;
2437 msg.dw_arg1 = hnode->node_env;
2438 killmsg.dw_cmd = RMS_KILLTASK;
2439 killmsg.dw_arg1 = hnode->node_env;
2440 intf_fxns = hnode_mgr->intf_fxns;
2441
2442 if (hnode->utimeout > MAXTIMEOUT)
2443 kill_time_out = MAXTIMEOUT;
2444 else
2445 kill_time_out = (hnode->utimeout) * 2;
2446
2447 status = (*intf_fxns->pfn_msg_put) (hnode->msg_queue_obj, &msg,
2448 hnode->utimeout);
2449 if (status)
2450 goto func_cont;
2451
2452 /*
2453 * Wait on synchronization object that will be
2454 * posted in the callback on receiving RMS_EXIT
2455 * message, or by node_delete. Check for valid hnode,
2456 * in case posted by node_delete().
2457 */
2458 status = sync_wait_on_event(hnode->sync_done,
2459 kill_time_out / 2);
2460 if (status != ETIME)
2461 goto func_cont;
2462
2463 status = (*intf_fxns->pfn_msg_put)(hnode->msg_queue_obj,
2464 &killmsg, hnode->utimeout);
2465 if (status)
2466 goto func_cont;
2467 status = sync_wait_on_event(hnode->sync_done,
2468 kill_time_out / 2);
2469 if (status) {
2470 /*
2471 * Here it goes the part of the simulation of
2472 * the DSP exception.
2473 */
2474 dev_get_deh_mgr(hnode_mgr->hdev_obj, &hdeh_mgr);
2475 if (!hdeh_mgr)
2476 goto func_cont;
2477
2478 bridge_deh_notify(hdeh_mgr, DSP_SYSERROR, DSP_EXCEPTIONABORT);
2479 }
2480 }
2481 func_cont:
2482 if (!status) {
2483 /* Enter CS before getting exit status, in case node was
2484 * deleted. */
2485 mutex_lock(&hnode_mgr->node_mgr_lock);
2486 /* Make sure node wasn't deleted while we blocked */
2487 if (!hnode) {
2488 status = -EPERM;
2489 } else {
2490 *pstatus = hnode->exit_status;
2491 dev_dbg(bridge, "%s: hnode: %p env 0x%x status 0x%x\n",
2492 __func__, hnode, hnode->node_env, status);
2493 }
2494 mutex_unlock(&hnode_mgr->node_mgr_lock);
2495 } /*End of sync_enter_cs */
2496 func_end:
2497 return status;
2498 }
2499
2500 /*
2501 * ======== delete_node ========
2502 * Purpose:
2503 * Free GPP resources allocated in node_allocate() or node_connect().
2504 */
2505 static void delete_node(struct node_object *hnode,
2506 struct process_context *pr_ctxt)
2507 {
2508 struct node_mgr *hnode_mgr;
2509 struct cmm_xlatorobject *xlator;
2510 struct bridge_drv_interface *intf_fxns;
2511 u32 i;
2512 enum node_type node_type;
2513 struct stream_chnl stream;
2514 struct node_msgargs node_msg_args;
2515 struct node_taskargs task_arg_obj;
2516 #ifdef DSP_DMM_DEBUG
2517 struct dmm_object *dmm_mgr;
2518 struct proc_object *p_proc_object =
2519 (struct proc_object *)hnode->hprocessor;
2520 #endif
2521 int status;
2522 if (!hnode)
2523 goto func_end;
2524 hnode_mgr = hnode->hnode_mgr;
2525 if (!hnode_mgr)
2526 goto func_end;
2527 xlator = hnode->xlator;
2528 node_type = node_get_type(hnode);
2529 if (node_type != NODE_DEVICE) {
2530 node_msg_args = hnode->create_args.asa.node_msg_args;
2531 kfree(node_msg_args.pdata);
2532
2533 /* Free msg_ctrl queue */
2534 if (hnode->msg_queue_obj) {
2535 intf_fxns = hnode_mgr->intf_fxns;
2536 (*intf_fxns->pfn_msg_delete_queue) (hnode->
2537 msg_queue_obj);
2538 hnode->msg_queue_obj = NULL;
2539 }
2540
2541 kfree(hnode->sync_done);
2542
2543 /* Free all stream info */
2544 if (hnode->inputs) {
2545 for (i = 0; i < MAX_INPUTS(hnode); i++) {
2546 stream = hnode->inputs[i];
2547 free_stream(hnode_mgr, stream);
2548 }
2549 kfree(hnode->inputs);
2550 hnode->inputs = NULL;
2551 }
2552 if (hnode->outputs) {
2553 for (i = 0; i < MAX_OUTPUTS(hnode); i++) {
2554 stream = hnode->outputs[i];
2555 free_stream(hnode_mgr, stream);
2556 }
2557 kfree(hnode->outputs);
2558 hnode->outputs = NULL;
2559 }
2560 task_arg_obj = hnode->create_args.asa.task_arg_obj;
2561 if (task_arg_obj.strm_in_def) {
2562 for (i = 0; i < MAX_INPUTS(hnode); i++) {
2563 kfree(task_arg_obj.strm_in_def[i].sz_device);
2564 task_arg_obj.strm_in_def[i].sz_device = NULL;
2565 }
2566 kfree(task_arg_obj.strm_in_def);
2567 task_arg_obj.strm_in_def = NULL;
2568 }
2569 if (task_arg_obj.strm_out_def) {
2570 for (i = 0; i < MAX_OUTPUTS(hnode); i++) {
2571 kfree(task_arg_obj.strm_out_def[i].sz_device);
2572 task_arg_obj.strm_out_def[i].sz_device = NULL;
2573 }
2574 kfree(task_arg_obj.strm_out_def);
2575 task_arg_obj.strm_out_def = NULL;
2576 }
2577 if (task_arg_obj.udsp_heap_res_addr) {
2578 status = proc_un_map(hnode->hprocessor, (void *)
2579 task_arg_obj.udsp_heap_addr,
2580 pr_ctxt);
2581
2582 status = proc_un_reserve_memory(hnode->hprocessor,
2583 (void *)
2584 task_arg_obj.
2585 udsp_heap_res_addr,
2586 pr_ctxt);
2587 #ifdef DSP_DMM_DEBUG
2588 status = dmm_get_handle(p_proc_object, &dmm_mgr);
2589 if (dmm_mgr)
2590 dmm_mem_map_dump(dmm_mgr);
2591 else
2592 status = DSP_EHANDLE;
2593 #endif
2594 }
2595 }
2596 if (node_type != NODE_MESSAGE) {
2597 kfree(hnode->stream_connect);
2598 hnode->stream_connect = NULL;
2599 }
2600 kfree(hnode->pstr_dev_name);
2601 hnode->pstr_dev_name = NULL;
2602
2603 if (hnode->ntfy_obj) {
2604 ntfy_delete(hnode->ntfy_obj);
2605 kfree(hnode->ntfy_obj);
2606 hnode->ntfy_obj = NULL;
2607 }
2608
2609 /* These were allocated in dcd_get_object_def (via node_allocate) */
2610 kfree(hnode->dcd_props.obj_data.node_obj.pstr_create_phase_fxn);
2611 hnode->dcd_props.obj_data.node_obj.pstr_create_phase_fxn = NULL;
2612
2613 kfree(hnode->dcd_props.obj_data.node_obj.pstr_execute_phase_fxn);
2614 hnode->dcd_props.obj_data.node_obj.pstr_execute_phase_fxn = NULL;
2615
2616 kfree(hnode->dcd_props.obj_data.node_obj.pstr_delete_phase_fxn);
2617 hnode->dcd_props.obj_data.node_obj.pstr_delete_phase_fxn = NULL;
2618
2619 kfree(hnode->dcd_props.obj_data.node_obj.pstr_i_alg_name);
2620 hnode->dcd_props.obj_data.node_obj.pstr_i_alg_name = NULL;
2621
2622 /* Free all SM address translator resources */
2623 if (xlator) {
2624 (void)cmm_xlator_delete(xlator, true); /* force free */
2625 xlator = NULL;
2626 }
2627
2628 kfree(hnode->nldr_node_obj);
2629 hnode->nldr_node_obj = NULL;
2630 hnode->hnode_mgr = NULL;
2631 kfree(hnode);
2632 hnode = NULL;
2633 func_end:
2634 return;
2635 }
2636
2637 /*
2638 * ======== delete_node_mgr ========
2639 * Purpose:
2640 * Frees the node manager.
2641 */
2642 static void delete_node_mgr(struct node_mgr *hnode_mgr)
2643 {
2644 struct node_object *hnode;
2645
2646 if (hnode_mgr) {
2647 /* Free resources */
2648 if (hnode_mgr->hdcd_mgr)
2649 dcd_destroy_manager(hnode_mgr->hdcd_mgr);
2650
2651 /* Remove any elements remaining in lists */
2652 if (hnode_mgr->node_list) {
2653 while ((hnode = (struct node_object *)
2654 lst_get_head(hnode_mgr->node_list)))
2655 delete_node(hnode, NULL);
2656
2657 DBC_ASSERT(LST_IS_EMPTY(hnode_mgr->node_list));
2658 kfree(hnode_mgr->node_list);
2659 }
2660 mutex_destroy(&hnode_mgr->node_mgr_lock);
2661 if (hnode_mgr->ntfy_obj) {
2662 ntfy_delete(hnode_mgr->ntfy_obj);
2663 kfree(hnode_mgr->ntfy_obj);
2664 }
2665
2666 if (hnode_mgr->pipe_map)
2667 gb_delete(hnode_mgr->pipe_map);
2668
2669 if (hnode_mgr->pipe_done_map)
2670 gb_delete(hnode_mgr->pipe_done_map);
2671
2672 if (hnode_mgr->chnl_map)
2673 gb_delete(hnode_mgr->chnl_map);
2674
2675 if (hnode_mgr->dma_chnl_map)
2676 gb_delete(hnode_mgr->dma_chnl_map);
2677
2678 if (hnode_mgr->zc_chnl_map)
2679 gb_delete(hnode_mgr->zc_chnl_map);
2680
2681 if (hnode_mgr->disp_obj)
2682 disp_delete(hnode_mgr->disp_obj);
2683
2684 if (hnode_mgr->strm_mgr_obj)
2685 strm_delete(hnode_mgr->strm_mgr_obj);
2686
2687 /* Delete the loader */
2688 if (hnode_mgr->nldr_obj)
2689 hnode_mgr->nldr_fxns.pfn_delete(hnode_mgr->nldr_obj);
2690
2691 if (hnode_mgr->loader_init)
2692 hnode_mgr->nldr_fxns.pfn_exit();
2693
2694 kfree(hnode_mgr);
2695 }
2696 }
2697
2698 /*
2699 * ======== fill_stream_connect ========
2700 * Purpose:
2701 * Fills stream information.
2702 */
2703 static void fill_stream_connect(struct node_object *node1,
2704 struct node_object *node2,
2705 u32 stream1, u32 stream2)
2706 {
2707 u32 strm_index;
2708 struct dsp_streamconnect *strm1 = NULL;
2709 struct dsp_streamconnect *strm2 = NULL;
2710 enum node_type node1_type = NODE_TASK;
2711 enum node_type node2_type = NODE_TASK;
2712
2713 node1_type = node_get_type(node1);
2714 node2_type = node_get_type(node2);
2715 if (node1 != (struct node_object *)DSP_HGPPNODE) {
2716
2717 if (node1_type != NODE_DEVICE) {
2718 strm_index = node1->num_inputs +
2719 node1->num_outputs - 1;
2720 strm1 = &(node1->stream_connect[strm_index]);
2721 strm1->cb_struct = sizeof(struct dsp_streamconnect);
2722 strm1->this_node_stream_index = stream1;
2723 }
2724
2725 if (node2 != (struct node_object *)DSP_HGPPNODE) {
2726 /* NODE == > NODE */
2727 if (node1_type != NODE_DEVICE) {
2728 strm1->connected_node = node2;
2729 strm1->ui_connected_node_id = node2->node_uuid;
2730 strm1->connected_node_stream_index = stream2;
2731 strm1->connect_type = CONNECTTYPE_NODEOUTPUT;
2732 }
2733 if (node2_type != NODE_DEVICE) {
2734 strm_index = node2->num_inputs +
2735 node2->num_outputs - 1;
2736 strm2 = &(node2->stream_connect[strm_index]);
2737 strm2->cb_struct =
2738 sizeof(struct dsp_streamconnect);
2739 strm2->this_node_stream_index = stream2;
2740 strm2->connected_node = node1;
2741 strm2->ui_connected_node_id = node1->node_uuid;
2742 strm2->connected_node_stream_index = stream1;
2743 strm2->connect_type = CONNECTTYPE_NODEINPUT;
2744 }
2745 } else if (node1_type != NODE_DEVICE)
2746 strm1->connect_type = CONNECTTYPE_GPPOUTPUT;
2747 } else {
2748 /* GPP == > NODE */
2749 DBC_ASSERT(node2 != (struct node_object *)DSP_HGPPNODE);
2750 strm_index = node2->num_inputs + node2->num_outputs - 1;
2751 strm2 = &(node2->stream_connect[strm_index]);
2752 strm2->cb_struct = sizeof(struct dsp_streamconnect);
2753 strm2->this_node_stream_index = stream2;
2754 strm2->connect_type = CONNECTTYPE_GPPINPUT;
2755 }
2756 }
2757
2758 /*
2759 * ======== fill_stream_def ========
2760 * Purpose:
2761 * Fills Stream attributes.
2762 */
2763 static void fill_stream_def(struct node_object *hnode,
2764 struct node_strmdef *pstrm_def,
2765 struct dsp_strmattr *pattrs)
2766 {
2767 struct node_mgr *hnode_mgr = hnode->hnode_mgr;
2768
2769 if (pattrs != NULL) {
2770 pstrm_def->num_bufs = pattrs->num_bufs;
2771 pstrm_def->buf_size =
2772 pattrs->buf_size / hnode_mgr->udsp_data_mau_size;
2773 pstrm_def->seg_id = pattrs->seg_id;
2774 pstrm_def->buf_alignment = pattrs->buf_alignment;
2775 pstrm_def->utimeout = pattrs->utimeout;
2776 } else {
2777 pstrm_def->num_bufs = DEFAULTNBUFS;
2778 pstrm_def->buf_size =
2779 DEFAULTBUFSIZE / hnode_mgr->udsp_data_mau_size;
2780 pstrm_def->seg_id = DEFAULTSEGID;
2781 pstrm_def->buf_alignment = DEFAULTALIGNMENT;
2782 pstrm_def->utimeout = DEFAULTTIMEOUT;
2783 }
2784 }
2785
2786 /*
2787 * ======== free_stream ========
2788 * Purpose:
2789 * Updates the channel mask and frees the pipe id.
2790 */
2791 static void free_stream(struct node_mgr *hnode_mgr, struct stream_chnl stream)
2792 {
2793 /* Free up the pipe id unless other node has not yet been deleted. */
2794 if (stream.type == NODECONNECT) {
2795 if (gb_test(hnode_mgr->pipe_done_map, stream.dev_id)) {
2796 /* The other node has already been deleted */
2797 gb_clear(hnode_mgr->pipe_done_map, stream.dev_id);
2798 gb_clear(hnode_mgr->pipe_map, stream.dev_id);
2799 } else {
2800 /* The other node has not been deleted yet */
2801 gb_set(hnode_mgr->pipe_done_map, stream.dev_id);
2802 }
2803 } else if (stream.type == HOSTCONNECT) {
2804 if (stream.dev_id < hnode_mgr->ul_num_chnls) {
2805 gb_clear(hnode_mgr->chnl_map, stream.dev_id);
2806 } else if (stream.dev_id < (2 * hnode_mgr->ul_num_chnls)) {
2807 /* dsp-dma */
2808 gb_clear(hnode_mgr->dma_chnl_map, stream.dev_id -
2809 (1 * hnode_mgr->ul_num_chnls));
2810 } else if (stream.dev_id < (3 * hnode_mgr->ul_num_chnls)) {
2811 /* zero-copy */
2812 gb_clear(hnode_mgr->zc_chnl_map, stream.dev_id -
2813 (2 * hnode_mgr->ul_num_chnls));
2814 }
2815 }
2816 }
2817
2818 /*
2819 * ======== get_fxn_address ========
2820 * Purpose:
2821 * Retrieves the address for create, execute or delete phase for a node.
2822 */
2823 static int get_fxn_address(struct node_object *hnode, u32 * fxn_addr,
2824 u32 phase)
2825 {
2826 char *pstr_fxn_name = NULL;
2827 struct node_mgr *hnode_mgr = hnode->hnode_mgr;
2828 int status = 0;
2829 DBC_REQUIRE(node_get_type(hnode) == NODE_TASK ||
2830 node_get_type(hnode) == NODE_DAISSOCKET ||
2831 node_get_type(hnode) == NODE_MESSAGE);
2832
2833 switch (phase) {
2834 case CREATEPHASE:
2835 pstr_fxn_name =
2836 hnode->dcd_props.obj_data.node_obj.pstr_create_phase_fxn;
2837 break;
2838 case EXECUTEPHASE:
2839 pstr_fxn_name =
2840 hnode->dcd_props.obj_data.node_obj.pstr_execute_phase_fxn;
2841 break;
2842 case DELETEPHASE:
2843 pstr_fxn_name =
2844 hnode->dcd_props.obj_data.node_obj.pstr_delete_phase_fxn;
2845 break;
2846 default:
2847 /* Should never get here */
2848 DBC_ASSERT(false);
2849 break;
2850 }
2851
2852 status =
2853 hnode_mgr->nldr_fxns.pfn_get_fxn_addr(hnode->nldr_node_obj,
2854 pstr_fxn_name, fxn_addr);
2855
2856 return status;
2857 }
2858
2859 /*
2860 * ======== get_node_info ========
2861 * Purpose:
2862 * Retrieves the node information.
2863 */
2864 void get_node_info(struct node_object *hnode, struct dsp_nodeinfo *node_info)
2865 {
2866 u32 i;
2867
2868 DBC_REQUIRE(hnode);
2869 DBC_REQUIRE(node_info != NULL);
2870
2871 node_info->cb_struct = sizeof(struct dsp_nodeinfo);
2872 node_info->nb_node_database_props =
2873 hnode->dcd_props.obj_data.node_obj.ndb_props;
2874 node_info->execution_priority = hnode->prio;
2875 node_info->device_owner = hnode->device_owner;
2876 node_info->number_streams = hnode->num_inputs + hnode->num_outputs;
2877 node_info->node_env = hnode->node_env;
2878
2879 node_info->ns_execution_state = node_get_state(hnode);
2880
2881 /* Copy stream connect data */
2882 for (i = 0; i < hnode->num_inputs + hnode->num_outputs; i++)
2883 node_info->sc_stream_connection[i] = hnode->stream_connect[i];
2884
2885 }
2886
2887 /*
2888 * ======== get_node_props ========
2889 * Purpose:
2890 * Retrieve node properties.
2891 */
2892 static int get_node_props(struct dcd_manager *hdcd_mgr,
2893 struct node_object *hnode,
2894 const struct dsp_uuid *node_uuid,
2895 struct dcd_genericobj *dcd_prop)
2896 {
2897 u32 len;
2898 struct node_msgargs *pmsg_args;
2899 struct node_taskargs *task_arg_obj;
2900 enum node_type node_type = NODE_TASK;
2901 struct dsp_ndbprops *pndb_props =
2902 &(dcd_prop->obj_data.node_obj.ndb_props);
2903 int status = 0;
2904 char sz_uuid[MAXUUIDLEN];
2905
2906 status = dcd_get_object_def(hdcd_mgr, (struct dsp_uuid *)node_uuid,
2907 DSP_DCDNODETYPE, dcd_prop);
2908
2909 if (!status) {
2910 hnode->ntype = node_type = pndb_props->ntype;
2911
2912 /* Create UUID value to set in registry. */
2913 uuid_uuid_to_string((struct dsp_uuid *)node_uuid, sz_uuid,
2914 MAXUUIDLEN);
2915 dev_dbg(bridge, "(node) UUID: %s\n", sz_uuid);
2916
2917 /* Fill in message args that come from NDB */
2918 if (node_type != NODE_DEVICE) {
2919 pmsg_args = &(hnode->create_args.asa.node_msg_args);
2920 pmsg_args->seg_id =
2921 dcd_prop->obj_data.node_obj.msg_segid;
2922 pmsg_args->notify_type =
2923 dcd_prop->obj_data.node_obj.msg_notify_type;
2924 pmsg_args->max_msgs = pndb_props->message_depth;
2925 dev_dbg(bridge, "(node) Max Number of Messages: 0x%x\n",
2926 pmsg_args->max_msgs);
2927 } else {
2928 /* Copy device name */
2929 DBC_REQUIRE(pndb_props->ac_name);
2930 len = strlen(pndb_props->ac_name);
2931 DBC_ASSERT(len < MAXDEVNAMELEN);
2932 hnode->pstr_dev_name = kzalloc(len + 1, GFP_KERNEL);
2933 if (hnode->pstr_dev_name == NULL) {
2934 status = -ENOMEM;
2935 } else {
2936 strncpy(hnode->pstr_dev_name,
2937 pndb_props->ac_name, len);
2938 }
2939 }
2940 }
2941 if (!status) {
2942 /* Fill in create args that come from NDB */
2943 if (node_type == NODE_TASK || node_type == NODE_DAISSOCKET) {
2944 task_arg_obj = &(hnode->create_args.asa.task_arg_obj);
2945 task_arg_obj->prio = pndb_props->prio;
2946 task_arg_obj->stack_size = pndb_props->stack_size;
2947 task_arg_obj->sys_stack_size =
2948 pndb_props->sys_stack_size;
2949 task_arg_obj->stack_seg = pndb_props->stack_seg;
2950 dev_dbg(bridge, "(node) Priority: 0x%x Stack Size: "
2951 "0x%x words System Stack Size: 0x%x words "
2952 "Stack Segment: 0x%x profile count : 0x%x\n",
2953 task_arg_obj->prio, task_arg_obj->stack_size,
2954 task_arg_obj->sys_stack_size,
2955 task_arg_obj->stack_seg,
2956 pndb_props->count_profiles);
2957 }
2958 }
2959
2960 return status;
2961 }
2962
2963 /*
2964 * ======== get_proc_props ========
2965 * Purpose:
2966 * Retrieve the processor properties.
2967 */
2968 static int get_proc_props(struct node_mgr *hnode_mgr,
2969 struct dev_object *hdev_obj)
2970 {
2971 struct cfg_hostres *host_res;
2972 struct bridge_dev_context *pbridge_context;
2973 int status = 0;
2974
2975 status = dev_get_bridge_context(hdev_obj, &pbridge_context);
2976 if (!pbridge_context)
2977 status = -EFAULT;
2978
2979 if (!status) {
2980 host_res = pbridge_context->resources;
2981 if (!host_res)
2982 return -EPERM;
2983 hnode_mgr->ul_chnl_offset = host_res->dw_chnl_offset;
2984 hnode_mgr->ul_chnl_buf_size = host_res->dw_chnl_buf_size;
2985 hnode_mgr->ul_num_chnls = host_res->dw_num_chnls;
2986
2987 /*
2988 * PROC will add an API to get dsp_processorinfo.
2989 * Fill in default values for now.
2990 */
2991 /* TODO -- Instead of hard coding, take from registry */
2992 hnode_mgr->proc_family = 6000;
2993 hnode_mgr->proc_type = 6410;
2994 hnode_mgr->min_pri = DSP_NODE_MIN_PRIORITY;
2995 hnode_mgr->max_pri = DSP_NODE_MAX_PRIORITY;
2996 hnode_mgr->udsp_word_size = DSPWORDSIZE;
2997 hnode_mgr->udsp_data_mau_size = DSPWORDSIZE;
2998 hnode_mgr->udsp_mau_size = 1;
2999
3000 }
3001 return status;
3002 }
3003
3004 /*
3005 * ======== node_get_uuid_props ========
3006 * Purpose:
3007 * Fetch Node UUID properties from DCD/DOF file.
3008 */
3009 int node_get_uuid_props(void *hprocessor,
3010 const struct dsp_uuid *node_uuid,
3011 struct dsp_ndbprops *node_props)
3012 {
3013 struct node_mgr *hnode_mgr = NULL;
3014 struct dev_object *hdev_obj;
3015 int status = 0;
3016 struct dcd_nodeprops dcd_node_props;
3017 struct dsp_processorstate proc_state;
3018
3019 DBC_REQUIRE(refs > 0);
3020 DBC_REQUIRE(hprocessor != NULL);
3021 DBC_REQUIRE(node_uuid != NULL);
3022
3023 if (hprocessor == NULL || node_uuid == NULL) {
3024 status = -EFAULT;
3025 goto func_end;
3026 }
3027 status = proc_get_state(hprocessor, &proc_state,
3028 sizeof(struct dsp_processorstate));
3029 if (status)
3030 goto func_end;
3031 /* If processor is in error state then don't attempt
3032 to send the message */
3033 if (proc_state.proc_state == PROC_ERROR) {
3034 status = -EPERM;
3035 goto func_end;
3036 }
3037
3038 status = proc_get_dev_object(hprocessor, &hdev_obj);
3039 if (hdev_obj) {
3040 status = dev_get_node_manager(hdev_obj, &hnode_mgr);
3041 if (hnode_mgr == NULL) {
3042 status = -EFAULT;
3043 goto func_end;
3044 }
3045 }
3046
3047 /*
3048 * Enter the critical section. This is needed because
3049 * dcd_get_object_def will ultimately end up calling dbll_open/close,
3050 * which needs to be protected in order to not corrupt the zlib manager
3051 * (COD).
3052 */
3053 mutex_lock(&hnode_mgr->node_mgr_lock);
3054
3055 dcd_node_props.pstr_create_phase_fxn = NULL;
3056 dcd_node_props.pstr_execute_phase_fxn = NULL;
3057 dcd_node_props.pstr_delete_phase_fxn = NULL;
3058 dcd_node_props.pstr_i_alg_name = NULL;
3059
3060 status = dcd_get_object_def(hnode_mgr->hdcd_mgr,
3061 (struct dsp_uuid *)node_uuid, DSP_DCDNODETYPE,
3062 (struct dcd_genericobj *)&dcd_node_props);
3063
3064 if (!status) {
3065 *node_props = dcd_node_props.ndb_props;
3066 kfree(dcd_node_props.pstr_create_phase_fxn);
3067
3068 kfree(dcd_node_props.pstr_execute_phase_fxn);
3069
3070 kfree(dcd_node_props.pstr_delete_phase_fxn);
3071
3072 kfree(dcd_node_props.pstr_i_alg_name);
3073 }
3074 /* Leave the critical section, we're done. */
3075 mutex_unlock(&hnode_mgr->node_mgr_lock);
3076 func_end:
3077 return status;
3078 }
3079
3080 /*
3081 * ======== get_rms_fxns ========
3082 * Purpose:
3083 * Retrieve the RMS functions.
3084 */
3085 static int get_rms_fxns(struct node_mgr *hnode_mgr)
3086 {
3087 s32 i;
3088 struct dev_object *dev_obj = hnode_mgr->hdev_obj;
3089 int status = 0;
3090
3091 static char *psz_fxns[NUMRMSFXNS] = {
3092 "RMS_queryServer", /* RMSQUERYSERVER */
3093 "RMS_configureServer", /* RMSCONFIGURESERVER */
3094 "RMS_createNode", /* RMSCREATENODE */
3095 "RMS_executeNode", /* RMSEXECUTENODE */
3096 "RMS_deleteNode", /* RMSDELETENODE */
3097 "RMS_changeNodePriority", /* RMSCHANGENODEPRIORITY */
3098 "RMS_readMemory", /* RMSREADMEMORY */
3099 "RMS_writeMemory", /* RMSWRITEMEMORY */
3100 "RMS_copy", /* RMSCOPY */
3101 };
3102
3103 for (i = 0; i < NUMRMSFXNS; i++) {
3104 status = dev_get_symbol(dev_obj, psz_fxns[i],
3105 &(hnode_mgr->ul_fxn_addrs[i]));
3106 if (status) {
3107 if (status == -ESPIPE) {
3108 /*
3109 * May be loaded dynamically (in the future),
3110 * but return an error for now.
3111 */
3112 dev_dbg(bridge, "%s: RMS function: %s currently"
3113 " not loaded\n", __func__, psz_fxns[i]);
3114 } else {
3115 dev_dbg(bridge, "%s: Symbol not found: %s "
3116 "status = 0x%x\n", __func__,
3117 psz_fxns[i], status);
3118 break;
3119 }
3120 }
3121 }
3122
3123 return status;
3124 }
3125
3126 /*
3127 * ======== ovly ========
3128 * Purpose:
3129 * Called during overlay.Sends command to RMS to copy a block of data.
3130 */
3131 static u32 ovly(void *priv_ref, u32 dsp_run_addr, u32 dsp_load_addr,
3132 u32 ul_num_bytes, u32 mem_space)
3133 {
3134 struct node_object *hnode = (struct node_object *)priv_ref;
3135 struct node_mgr *hnode_mgr;
3136 u32 ul_bytes = 0;
3137 u32 ul_size;
3138 u32 ul_timeout;
3139 int status = 0;
3140 struct bridge_dev_context *hbridge_context;
3141 /* Function interface to Bridge driver*/
3142 struct bridge_drv_interface *intf_fxns;
3143
3144 DBC_REQUIRE(hnode);
3145
3146 hnode_mgr = hnode->hnode_mgr;
3147
3148 ul_size = ul_num_bytes / hnode_mgr->udsp_word_size;
3149 ul_timeout = hnode->utimeout;
3150
3151 /* Call new MemCopy function */
3152 intf_fxns = hnode_mgr->intf_fxns;
3153 status = dev_get_bridge_context(hnode_mgr->hdev_obj, &hbridge_context);
3154 if (!status) {
3155 status =
3156 (*intf_fxns->pfn_brd_mem_copy) (hbridge_context,
3157 dsp_run_addr, dsp_load_addr,
3158 ul_num_bytes, (u32) mem_space);
3159 if (!status)
3160 ul_bytes = ul_num_bytes;
3161 else
3162 pr_debug("%s: failed to copy brd memory, status 0x%x\n",
3163 __func__, status);
3164 } else {
3165 pr_debug("%s: failed to get Bridge context, status 0x%x\n",
3166 __func__, status);
3167 }
3168
3169 return ul_bytes;
3170 }
3171
3172 /*
3173 * ======== mem_write ========
3174 */
3175 static u32 mem_write(void *priv_ref, u32 dsp_add, void *pbuf,
3176 u32 ul_num_bytes, u32 mem_space)
3177 {
3178 struct node_object *hnode = (struct node_object *)priv_ref;
3179 struct node_mgr *hnode_mgr;
3180 u16 mem_sect_type;
3181 u32 ul_timeout;
3182 int status = 0;
3183 struct bridge_dev_context *hbridge_context;
3184 /* Function interface to Bridge driver */
3185 struct bridge_drv_interface *intf_fxns;
3186
3187 DBC_REQUIRE(hnode);
3188 DBC_REQUIRE(mem_space & DBLL_CODE || mem_space & DBLL_DATA);
3189
3190 hnode_mgr = hnode->hnode_mgr;
3191
3192 ul_timeout = hnode->utimeout;
3193 mem_sect_type = (mem_space & DBLL_CODE) ? RMS_CODE : RMS_DATA;
3194
3195 /* Call new MemWrite function */
3196 intf_fxns = hnode_mgr->intf_fxns;
3197 status = dev_get_bridge_context(hnode_mgr->hdev_obj, &hbridge_context);
3198 status = (*intf_fxns->pfn_brd_mem_write) (hbridge_context, pbuf,
3199 dsp_add, ul_num_bytes, mem_sect_type);
3200
3201 return ul_num_bytes;
3202 }
3203
3204 #ifdef CONFIG_TIDSPBRIDGE_BACKTRACE
3205 /*
3206 * ======== node_find_addr ========
3207 */
3208 int node_find_addr(struct node_mgr *node_mgr, u32 sym_addr,
3209 u32 offset_range, void *sym_addr_output, char *sym_name)
3210 {
3211 struct node_object *node_obj;
3212 int status = -ENOENT;
3213 u32 n;
3214
3215 pr_debug("%s(0x%x, 0x%x, 0x%x, 0x%x, %s)\n", __func__,
3216 (unsigned int) node_mgr,
3217 sym_addr, offset_range,
3218 (unsigned int) sym_addr_output, sym_name);
3219
3220 node_obj = (struct node_object *)(node_mgr->node_list->head.next);
3221
3222 for (n = 0; n < node_mgr->num_nodes; n++) {
3223 status = nldr_find_addr(node_obj->nldr_node_obj, sym_addr,
3224 offset_range, sym_addr_output, sym_name);
3225
3226 if (!status)
3227 break;
3228
3229 node_obj = (struct node_object *) (node_obj->list_elem.next);
3230 }
3231
3232 return status;
3233 }
3234 #endif
Tomato firmware and modifications.