projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/evalenti/linux...
[deliverable/linux.git] / drivers / staging / tidspbridge / rmgr / dbdcd.c
1 /*
2 * dbdcd.c
3 *
4 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
5 *
6 * This file contains the implementation of the DSP/BIOS Bridge
7 * Configuration Database (DCD).
8 *
9 * Notes:
10 * The fxn dcd_get_objects can apply a callback fxn to each DCD object
11 * that is located in a specified COFF file. At the moment,
12 * dcd_auto_register, dcd_auto_unregister, and NLDR module all use
13 * dcd_get_objects.
14 *
15 * Copyright (C) 2005-2006 Texas Instruments, Inc.
16 *
17 * This package is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License version 2 as
19 * published by the Free Software Foundation.
20 *
21 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
22 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
23 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
24 */
25 #include <linux/types.h>
26
27 /* ----------------------------------- Host OS */
28 #include <dspbridge/host_os.h>
29
30 /* ----------------------------------- DSP/BIOS Bridge */
31 #include <dspbridge/dbdefs.h>
32
33 /* ----------------------------------- Platform Manager */
34 #include <dspbridge/cod.h>
35
36 /* ----------------------------------- Others */
37 #include <dspbridge/uuidutil.h>
38
39 /* ----------------------------------- This */
40 #include <dspbridge/dbdcd.h>
41
42 /* ----------------------------------- Global defines. */
43 #define MAX_INT2CHAR_LENGTH 16 /* Max int2char len of 32 bit int */
44
45 /* Name of section containing dependent libraries */
46 #define DEPLIBSECT ".dspbridge_deplibs"
47
48 /* DCD specific structures. */
49 struct dcd_manager {
50 struct cod_manager *cod_mgr; /* Handle to COD manager object. */
51 };
52
53 /* Pointer to the registry support key */
54 static struct list_head reg_key_list;
55 static DEFINE_SPINLOCK(dbdcd_lock);
56
57 /* Global reference variables. */
58 static u32 refs;
59 static u32 enum_refs;
60
61 /* Helper function prototypes. */
62 static s32 atoi(char *psz_buf);
63 static int get_attrs_from_buf(char *psz_buf, u32 ul_buf_size,
64 enum dsp_dcdobjtype obj_type,
65 struct dcd_genericobj *gen_obj);
66 static void compress_buf(char *psz_buf, u32 ul_buf_size, s32 char_size);
67 static char dsp_char2_gpp_char(char *word, s32 dsp_char_size);
68 static int get_dep_lib_info(struct dcd_manager *hdcd_mgr,
69 struct dsp_uuid *uuid_obj,
70 u16 *num_libs,
71 u16 *num_pers_libs,
72 struct dsp_uuid *dep_lib_uuids,
73 bool *prstnt_dep_libs,
74 enum nldr_phase phase);
75
76 /*
77 * ======== dcd_uuid_from_string ========
78 * Purpose:
79 * Converts an ANSI string to a dsp_uuid.
80 * Parameters:
81 * sz_uuid: Pointer to a string that represents a dsp_uuid object.
82 * uuid_obj: Pointer to a dsp_uuid object.
83 * Returns:
84 * 0: Success.
85 * -EINVAL: Coversion failed
86 * Requires:
87 * uuid_obj & sz_uuid are non-NULL values.
88 * Ensures:
89 * Details:
90 * We assume the string representation of a UUID has the following format:
91 * "12345678_1234_1234_1234_123456789abc".
92 */
93 static int dcd_uuid_from_string(char *sz_uuid, struct dsp_uuid *uuid_obj)
94 {
95 char c;
96 u64 t;
97 struct dsp_uuid uuid_tmp;
98
99 /*
100 * sscanf implementation cannot deal with hh format modifier
101 * if the converted value doesn't fit in u32. So, convert the
102 * last six bytes to u64 and memcpy what is needed
103 */
104 if (sscanf(sz_uuid, "%8x%c%4hx%c%4hx%c%2hhx%2hhx%c%llx",
105 &uuid_tmp.data1, &c, &uuid_tmp.data2, &c,
106 &uuid_tmp.data3, &c, &uuid_tmp.data4,
107 &uuid_tmp.data5, &c, &t) != 10)
108 return -EINVAL;
109
110 t = cpu_to_be64(t);
111 memcpy(&uuid_tmp.data6[0], ((char *)&t) + 2, 6);
112 *uuid_obj = uuid_tmp;
113
114 return 0;
115 }
116
117 /*
118 * ======== dcd_auto_register ========
119 * Purpose:
120 * Parses the supplied image and resigsters with DCD.
121 */
122 int dcd_auto_register(struct dcd_manager *hdcd_mgr,
123 char *sz_coff_path)
124 {
125 int status = 0;
126
127 if (hdcd_mgr)
128 status = dcd_get_objects(hdcd_mgr, sz_coff_path,
129 (dcd_registerfxn) dcd_register_object,
130 (void *)sz_coff_path);
131 else
132 status = -EFAULT;
133
134 return status;
135 }
136
137 /*
138 * ======== dcd_auto_unregister ========
139 * Purpose:
140 * Parses the supplied DSP image and unresiters from DCD.
141 */
142 int dcd_auto_unregister(struct dcd_manager *hdcd_mgr,
143 char *sz_coff_path)
144 {
145 int status = 0;
146
147 if (hdcd_mgr)
148 status = dcd_get_objects(hdcd_mgr, sz_coff_path,
149 (dcd_registerfxn) dcd_register_object,
150 NULL);
151 else
152 status = -EFAULT;
153
154 return status;
155 }
156
157 /*
158 * ======== dcd_create_manager ========
159 * Purpose:
160 * Creates DCD manager.
161 */
162 int dcd_create_manager(char *sz_zl_dll_name,
163 struct dcd_manager **dcd_mgr)
164 {
165 struct cod_manager *cod_mgr; /* COD manager handle */
166 struct dcd_manager *dcd_mgr_obj = NULL; /* DCD Manager pointer */
167 int status = 0;
168
169 status = cod_create(&cod_mgr, sz_zl_dll_name);
170 if (status)
171 goto func_end;
172
173 /* Create a DCD object. */
174 dcd_mgr_obj = kzalloc(sizeof(struct dcd_manager), GFP_KERNEL);
175 if (dcd_mgr_obj != NULL) {
176 /* Fill out the object. */
177 dcd_mgr_obj->cod_mgr = cod_mgr;
178
179 /* Return handle to this DCD interface. */
180 *dcd_mgr = dcd_mgr_obj;
181 } else {
182 status = -ENOMEM;
183
184 /*
185 * If allocation of DcdManager object failed, delete the
186 * COD manager.
187 */
188 cod_delete(cod_mgr);
189 }
190
191 func_end:
192 return status;
193 }
194
195 /*
196 * ======== dcd_destroy_manager ========
197 * Purpose:
198 * Frees DCD Manager object.
199 */
200 int dcd_destroy_manager(struct dcd_manager *hdcd_mgr)
201 {
202 struct dcd_manager *dcd_mgr_obj = hdcd_mgr;
203 int status = -EFAULT;
204
205 if (hdcd_mgr) {
206 /* Delete the COD manager. */
207 cod_delete(dcd_mgr_obj->cod_mgr);
208
209 /* Deallocate a DCD manager object. */
210 kfree(dcd_mgr_obj);
211
212 status = 0;
213 }
214
215 return status;
216 }
217
218 /*
219 * ======== dcd_enumerate_object ========
220 * Purpose:
221 * Enumerates objects in the DCD.
222 */
223 int dcd_enumerate_object(s32 index, enum dsp_dcdobjtype obj_type,
224 struct dsp_uuid *uuid_obj)
225 {
226 int status = 0;
227 char sz_reg_key[DCD_MAXPATHLENGTH];
228 char sz_value[DCD_MAXPATHLENGTH];
229 struct dsp_uuid dsp_uuid_obj;
230 char sz_obj_type[MAX_INT2CHAR_LENGTH]; /* str. rep. of obj_type. */
231 u32 dw_key_len = 0;
232 struct dcd_key_elem *dcd_key;
233 int len;
234
235 if ((index != 0) && (enum_refs == 0)) {
236 /*
237 * If an enumeration is being performed on an index greater
238 * than zero, then the current enum_refs must have been
239 * incremented to greater than zero.
240 */
241 status = -EIDRM;
242 } else {
243 /*
244 * Pre-determine final key length. It's length of DCD_REGKEY +
245 * "_\0" + length of sz_obj_type string + terminating NULL.
246 */
247 dw_key_len = strlen(DCD_REGKEY) + 1 + sizeof(sz_obj_type) + 1;
248
249 /* Create proper REG key; concatenate DCD_REGKEY with
250 * obj_type. */
251 strncpy(sz_reg_key, DCD_REGKEY, strlen(DCD_REGKEY) + 1);
252 if ((strlen(sz_reg_key) + strlen("_\0")) <
253 DCD_MAXPATHLENGTH) {
254 strncat(sz_reg_key, "_\0", 2);
255 } else {
256 status = -EPERM;
257 }
258
259 /* This snprintf is guaranteed not to exceed max size of an
260 * integer. */
261 status = snprintf(sz_obj_type, MAX_INT2CHAR_LENGTH, "%d",
262 obj_type);
263
264 if (status == -1) {
265 status = -EPERM;
266 } else {
267 status = 0;
268 if ((strlen(sz_reg_key) + strlen(sz_obj_type)) <
269 DCD_MAXPATHLENGTH) {
270 strncat(sz_reg_key, sz_obj_type,
271 strlen(sz_obj_type) + 1);
272 } else {
273 status = -EPERM;
274 }
275 }
276
277 if (!status) {
278 len = strlen(sz_reg_key);
279 spin_lock(&dbdcd_lock);
280 list_for_each_entry(dcd_key, &reg_key_list, link) {
281 if (!strncmp(dcd_key->name, sz_reg_key, len)
282 && !index--) {
283 strncpy(sz_value, &dcd_key->name[len],
284 strlen(&dcd_key->name[len]) + 1);
285 break;
286 }
287 }
288 spin_unlock(&dbdcd_lock);
289
290 if (&dcd_key->link == &reg_key_list)
291 status = -ENODATA;
292 }
293
294 if (!status) {
295 /* Create UUID value using string retrieved from
296 * registry. */
297 status = dcd_uuid_from_string(sz_value, &dsp_uuid_obj);
298
299 if (!status) {
300 *uuid_obj = dsp_uuid_obj;
301
302 /* Increment enum_refs to update reference
303 * count. */
304 enum_refs++;
305 }
306 } else if (status == -ENODATA) {
307 /* At the end of enumeration. Reset enum_refs. */
308 enum_refs = 0;
309
310 /*
311 * TODO: Revisit, this is not an error case but code
312 * expects non-zero value.
313 */
314 status = ENODATA;
315 } else {
316 status = -EPERM;
317 }
318 }
319
320 return status;
321 }
322
323 /*
324 * ======== dcd_exit ========
325 * Purpose:
326 * Discontinue usage of the DCD module.
327 */
328 void dcd_exit(void)
329 {
330 struct dcd_key_elem *rv, *rv_tmp;
331
332 refs--;
333 if (refs == 0) {
334 list_for_each_entry_safe(rv, rv_tmp, &reg_key_list, link) {
335 list_del(&rv->link);
336 kfree(rv->path);
337 kfree(rv);
338 }
339 }
340
341 }
342
343 /*
344 * ======== dcd_get_dep_libs ========
345 */
346 int dcd_get_dep_libs(struct dcd_manager *hdcd_mgr,
347 struct dsp_uuid *uuid_obj,
348 u16 num_libs, struct dsp_uuid *dep_lib_uuids,
349 bool *prstnt_dep_libs,
350 enum nldr_phase phase)
351 {
352 int status = 0;
353
354 status =
355 get_dep_lib_info(hdcd_mgr, uuid_obj, &num_libs, NULL, dep_lib_uuids,
356 prstnt_dep_libs, phase);
357
358 return status;
359 }
360
361 /*
362 * ======== dcd_get_num_dep_libs ========
363 */
364 int dcd_get_num_dep_libs(struct dcd_manager *hdcd_mgr,
365 struct dsp_uuid *uuid_obj,
366 u16 *num_libs, u16 *num_pers_libs,
367 enum nldr_phase phase)
368 {
369 int status = 0;
370
371 status = get_dep_lib_info(hdcd_mgr, uuid_obj, num_libs, num_pers_libs,
372 NULL, NULL, phase);
373
374 return status;
375 }
376
377 /*
378 * ======== dcd_get_object_def ========
379 * Purpose:
380 * Retrieves the properties of a node or processor based on the UUID and
381 * object type.
382 */
383 int dcd_get_object_def(struct dcd_manager *hdcd_mgr,
384 struct dsp_uuid *obj_uuid,
385 enum dsp_dcdobjtype obj_type,
386 struct dcd_genericobj *obj_def)
387 {
388 struct dcd_manager *dcd_mgr_obj = hdcd_mgr; /* ptr to DCD mgr */
389 struct cod_libraryobj *lib = NULL;
390 int status = 0;
391 int len;
392 u32 ul_addr = 0; /* Used by cod_get_section */
393 u32 ul_len = 0; /* Used by cod_get_section */
394 u32 dw_buf_size; /* Used by REG functions */
395 char sz_reg_key[DCD_MAXPATHLENGTH];
396 char *sz_uuid; /*[MAXUUIDLEN]; */
397 char *tmp;
398 struct dcd_key_elem *dcd_key = NULL;
399 char sz_sect_name[MAXUUIDLEN + 2]; /* ".[UUID]\0" */
400 char *psz_coff_buf;
401 u32 dw_key_len; /* Len of REG key. */
402 char sz_obj_type[MAX_INT2CHAR_LENGTH]; /* str. rep. of obj_type. */
403
404 sz_uuid = kzalloc(MAXUUIDLEN, GFP_KERNEL);
405 if (!sz_uuid) {
406 status = -ENOMEM;
407 goto func_end;
408 }
409
410 if (!hdcd_mgr) {
411 status = -EFAULT;
412 goto func_end;
413 }
414
415 /* Pre-determine final key length. It's length of DCD_REGKEY +
416 * "_\0" + length of sz_obj_type string + terminating NULL */
417 dw_key_len = strlen(DCD_REGKEY) + 1 + sizeof(sz_obj_type) + 1;
418
419 /* Create proper REG key; concatenate DCD_REGKEY with obj_type. */
420 strncpy(sz_reg_key, DCD_REGKEY, strlen(DCD_REGKEY) + 1);
421
422 if ((strlen(sz_reg_key) + strlen("_\0")) < DCD_MAXPATHLENGTH)
423 strncat(sz_reg_key, "_\0", 2);
424 else
425 status = -EPERM;
426
427 status = snprintf(sz_obj_type, MAX_INT2CHAR_LENGTH, "%d", obj_type);
428 if (status == -1) {
429 status = -EPERM;
430 } else {
431 status = 0;
432
433 if ((strlen(sz_reg_key) + strlen(sz_obj_type)) <
434 DCD_MAXPATHLENGTH) {
435 strncat(sz_reg_key, sz_obj_type,
436 strlen(sz_obj_type) + 1);
437 } else {
438 status = -EPERM;
439 }
440
441 /* Create UUID value to set in registry. */
442 snprintf(sz_uuid, MAXUUIDLEN, "%pUL", obj_uuid);
443
444 if ((strlen(sz_reg_key) + MAXUUIDLEN) < DCD_MAXPATHLENGTH)
445 strncat(sz_reg_key, sz_uuid, MAXUUIDLEN);
446 else
447 status = -EPERM;
448
449 /* Retrieve paths from the registry based on struct dsp_uuid */
450 dw_buf_size = DCD_MAXPATHLENGTH;
451 }
452 if (!status) {
453 spin_lock(&dbdcd_lock);
454 list_for_each_entry(dcd_key, &reg_key_list, link) {
455 if (!strncmp(dcd_key->name, sz_reg_key,
456 strlen(sz_reg_key) + 1))
457 break;
458 }
459 spin_unlock(&dbdcd_lock);
460 if (&dcd_key->link == &reg_key_list) {
461 status = -ENOKEY;
462 goto func_end;
463 }
464 }
465
466
467 /* Open COFF file. */
468 status = cod_open(dcd_mgr_obj->cod_mgr, dcd_key->path,
469 COD_NOLOAD, &lib);
470 if (status) {
471 status = -EACCES;
472 goto func_end;
473 }
474
475 /* Ensure sz_uuid + 1 is not greater than sizeof sz_sect_name. */
476 len = strlen(sz_uuid);
477 if (len + 1 > sizeof(sz_sect_name)) {
478 status = -EPERM;
479 goto func_end;
480 }
481
482 /* Create section name based on node UUID. A period is
483 * pre-pended to the UUID string to form the section name.
484 * I.e. ".24BC8D90_BB45_11d4_B756_006008BDB66F" */
485
486 len -= 4; /* uuid has 4 delimiters '-' */
487 tmp = sz_uuid;
488
489 strncpy(sz_sect_name, ".", 2);
490 do {
491 char *uuid = strsep(&tmp, "-");
492 if (!uuid)
493 break;
494 len -= strlen(uuid);
495 strncat(sz_sect_name, uuid, strlen(uuid) + 1);
496 } while (len && strncat(sz_sect_name, "_", 2));
497
498 /* Get section information. */
499 status = cod_get_section(lib, sz_sect_name, &ul_addr, &ul_len);
500 if (status) {
501 status = -EACCES;
502 goto func_end;
503 }
504
505 /* Allocate zeroed buffer. */
506 psz_coff_buf = kzalloc(ul_len + 4, GFP_KERNEL);
507 if (psz_coff_buf == NULL) {
508 status = -ENOMEM;
509 goto func_end;
510 }
511 #ifdef _DB_TIOMAP
512 if (strstr(dcd_key->path, "iva") == NULL) {
513 /* Locate section by objectID and read its content. */
514 status =
515 cod_read_section(lib, sz_sect_name, psz_coff_buf, ul_len);
516 } else {
517 status =
518 cod_read_section(lib, sz_sect_name, psz_coff_buf, ul_len);
519 dev_dbg(bridge, "%s: Skipped Byte swap for IVA!!\n", __func__);
520 }
521 #else
522 status = cod_read_section(lib, sz_sect_name, psz_coff_buf, ul_len);
523 #endif
524 if (!status) {
525 /* Compress DSP buffer to conform to PC format. */
526 if (strstr(dcd_key->path, "iva") == NULL) {
527 compress_buf(psz_coff_buf, ul_len, DSPWORDSIZE);
528 } else {
529 compress_buf(psz_coff_buf, ul_len, 1);
530 dev_dbg(bridge, "%s: Compressing IVA COFF buffer by 1 "
531 "for IVA!!\n", __func__);
532 }
533
534 /* Parse the content of the COFF buffer. */
535 status =
536 get_attrs_from_buf(psz_coff_buf, ul_len, obj_type, obj_def);
537 if (status)
538 status = -EACCES;
539 } else {
540 status = -EACCES;
541 }
542
543 /* Free the previously allocated dynamic buffer. */
544 kfree(psz_coff_buf);
545 func_end:
546 if (lib)
547 cod_close(lib);
548
549 kfree(sz_uuid);
550
551 return status;
552 }
553
554 /*
555 * ======== dcd_get_objects ========
556 */
557 int dcd_get_objects(struct dcd_manager *hdcd_mgr,
558 char *sz_coff_path, dcd_registerfxn register_fxn,
559 void *handle)
560 {
561 struct dcd_manager *dcd_mgr_obj = hdcd_mgr;
562 int status = 0;
563 char *psz_coff_buf;
564 char *psz_cur;
565 struct cod_libraryobj *lib = NULL;
566 u32 ul_addr = 0; /* Used by cod_get_section */
567 u32 ul_len = 0; /* Used by cod_get_section */
568 char seps[] = ":, ";
569 char *token = NULL;
570 struct dsp_uuid dsp_uuid_obj;
571 s32 object_type;
572
573 if (!hdcd_mgr) {
574 status = -EFAULT;
575 goto func_end;
576 }
577
578 /* Open DSP coff file, don't load symbols. */
579 status = cod_open(dcd_mgr_obj->cod_mgr, sz_coff_path, COD_NOLOAD, &lib);
580 if (status) {
581 status = -EACCES;
582 goto func_cont;
583 }
584
585 /* Get DCD_RESIGER_SECTION section information. */
586 status = cod_get_section(lib, DCD_REGISTER_SECTION, &ul_addr, &ul_len);
587 if (status || !(ul_len > 0)) {
588 status = -EACCES;
589 goto func_cont;
590 }
591
592 /* Allocate zeroed buffer. */
593 psz_coff_buf = kzalloc(ul_len + 4, GFP_KERNEL);
594 if (psz_coff_buf == NULL) {
595 status = -ENOMEM;
596 goto func_cont;
597 }
598 #ifdef _DB_TIOMAP
599 if (strstr(sz_coff_path, "iva") == NULL) {
600 /* Locate section by objectID and read its content. */
601 status = cod_read_section(lib, DCD_REGISTER_SECTION,
602 psz_coff_buf, ul_len);
603 } else {
604 dev_dbg(bridge, "%s: Skipped Byte swap for IVA!!\n", __func__);
605 status = cod_read_section(lib, DCD_REGISTER_SECTION,
606 psz_coff_buf, ul_len);
607 }
608 #else
609 status =
610 cod_read_section(lib, DCD_REGISTER_SECTION, psz_coff_buf, ul_len);
611 #endif
612 if (!status) {
613 /* Compress DSP buffer to conform to PC format. */
614 if (strstr(sz_coff_path, "iva") == NULL) {
615 compress_buf(psz_coff_buf, ul_len, DSPWORDSIZE);
616 } else {
617 compress_buf(psz_coff_buf, ul_len, 1);
618 dev_dbg(bridge, "%s: Compress COFF buffer with 1 word "
619 "for IVA!!\n", __func__);
620 }
621
622 /* Read from buffer and register object in buffer. */
623 psz_cur = psz_coff_buf;
624 while ((token = strsep(&psz_cur, seps)) && *token != '\0') {
625 /* Retrieve UUID string. */
626 status = dcd_uuid_from_string(token, &dsp_uuid_obj);
627
628 if (!status) {
629 /* Retrieve object type */
630 token = strsep(&psz_cur, seps);
631
632 /* Retrieve object type */
633 object_type = atoi(token);
634
635 /*
636 * Apply register_fxn to the found DCD object.
637 * Possible actions include:
638 *
639 * 1) Register found DCD object.
640 * 2) Unregister found DCD object
641 * (when handle == NULL)
642 * 3) Add overlay node.
643 */
644 status =
645 register_fxn(&dsp_uuid_obj, object_type,
646 handle);
647 }
648 if (status) {
649 /* if error occurs, break from while loop. */
650 break;
651 }
652 }
653 } else {
654 status = -EACCES;
655 }
656
657 /* Free the previously allocated dynamic buffer. */
658 kfree(psz_coff_buf);
659 func_cont:
660 if (lib)
661 cod_close(lib);
662
663 func_end:
664 return status;
665 }
666
667 /*
668 * ======== dcd_get_library_name ========
669 * Purpose:
670 * Retrieves the library name for the given UUID.
671 *
672 */
673 int dcd_get_library_name(struct dcd_manager *hdcd_mgr,
674 struct dsp_uuid *uuid_obj,
675 char *str_lib_name,
676 u32 *buff_size,
677 enum nldr_phase phase, bool *phase_split)
678 {
679 char sz_reg_key[DCD_MAXPATHLENGTH];
680 char sz_uuid[MAXUUIDLEN];
681 u32 dw_key_len; /* Len of REG key. */
682 char sz_obj_type[MAX_INT2CHAR_LENGTH]; /* str. rep. of obj_type. */
683 int status = 0;
684 struct dcd_key_elem *dcd_key = NULL;
685
686 dev_dbg(bridge, "%s: hdcd_mgr %p, uuid_obj %p, str_lib_name %p,"
687 " buff_size %p\n", __func__, hdcd_mgr, uuid_obj, str_lib_name,
688 buff_size);
689
690 /*
691 * Pre-determine final key length. It's length of DCD_REGKEY +
692 * "_\0" + length of sz_obj_type string + terminating NULL.
693 */
694 dw_key_len = strlen(DCD_REGKEY) + 1 + sizeof(sz_obj_type) + 1;
695
696 /* Create proper REG key; concatenate DCD_REGKEY with obj_type. */
697 strncpy(sz_reg_key, DCD_REGKEY, strlen(DCD_REGKEY) + 1);
698 if ((strlen(sz_reg_key) + strlen("_\0")) < DCD_MAXPATHLENGTH)
699 strncat(sz_reg_key, "_\0", 2);
700 else
701 status = -EPERM;
702
703 switch (phase) {
704 case NLDR_CREATE:
705 /* create phase type */
706 sprintf(sz_obj_type, "%d", DSP_DCDCREATELIBTYPE);
707 break;
708 case NLDR_EXECUTE:
709 /* execute phase type */
710 sprintf(sz_obj_type, "%d", DSP_DCDEXECUTELIBTYPE);
711 break;
712 case NLDR_DELETE:
713 /* delete phase type */
714 sprintf(sz_obj_type, "%d", DSP_DCDDELETELIBTYPE);
715 break;
716 case NLDR_NOPHASE:
717 /* known to be a dependent library */
718 sprintf(sz_obj_type, "%d", DSP_DCDLIBRARYTYPE);
719 break;
720 default:
721 status = -EINVAL;
722 }
723 if (!status) {
724 if ((strlen(sz_reg_key) + strlen(sz_obj_type)) <
725 DCD_MAXPATHLENGTH) {
726 strncat(sz_reg_key, sz_obj_type,
727 strlen(sz_obj_type) + 1);
728 } else {
729 status = -EPERM;
730 }
731 /* Create UUID value to find match in registry. */
732 snprintf(sz_uuid, MAXUUIDLEN, "%pUL", uuid_obj);
733 if ((strlen(sz_reg_key) + MAXUUIDLEN) < DCD_MAXPATHLENGTH)
734 strncat(sz_reg_key, sz_uuid, MAXUUIDLEN);
735 else
736 status = -EPERM;
737 }
738 if (!status) {
739 spin_lock(&dbdcd_lock);
740 list_for_each_entry(dcd_key, &reg_key_list, link) {
741 /* See if the name matches. */
742 if (!strncmp(dcd_key->name, sz_reg_key,
743 strlen(sz_reg_key) + 1))
744 break;
745 }
746 spin_unlock(&dbdcd_lock);
747 }
748
749 if (&dcd_key->link == &reg_key_list)
750 status = -ENOKEY;
751
752 /* If can't find, phases might be registered as generic LIBRARYTYPE */
753 if (status && phase != NLDR_NOPHASE) {
754 if (phase_split)
755 *phase_split = false;
756
757 strncpy(sz_reg_key, DCD_REGKEY, strlen(DCD_REGKEY) + 1);
758 if ((strlen(sz_reg_key) + strlen("_\0")) <
759 DCD_MAXPATHLENGTH) {
760 strncat(sz_reg_key, "_\0", 2);
761 } else {
762 status = -EPERM;
763 }
764 sprintf(sz_obj_type, "%d", DSP_DCDLIBRARYTYPE);
765 if ((strlen(sz_reg_key) + strlen(sz_obj_type))
766 < DCD_MAXPATHLENGTH) {
767 strncat(sz_reg_key, sz_obj_type,
768 strlen(sz_obj_type) + 1);
769 } else {
770 status = -EPERM;
771 }
772 snprintf(sz_uuid, MAXUUIDLEN, "%pUL", uuid_obj);
773 if ((strlen(sz_reg_key) + MAXUUIDLEN) < DCD_MAXPATHLENGTH)
774 strncat(sz_reg_key, sz_uuid, MAXUUIDLEN);
775 else
776 status = -EPERM;
777
778 spin_lock(&dbdcd_lock);
779 list_for_each_entry(dcd_key, &reg_key_list, link) {
780 /* See if the name matches. */
781 if (!strncmp(dcd_key->name, sz_reg_key,
782 strlen(sz_reg_key) + 1))
783 break;
784 }
785 spin_unlock(&dbdcd_lock);
786
787 status = (&dcd_key->link != &reg_key_list) ?
788 0 : -ENOKEY;
789 }
790
791 if (!status)
792 memcpy(str_lib_name, dcd_key->path, strlen(dcd_key->path) + 1);
793 return status;
794 }
795
796 /*
797 * ======== dcd_init ========
798 * Purpose:
799 * Initialize the DCD module.
800 */
801 bool dcd_init(void)
802 {
803 bool ret = true;
804
805 if (refs == 0)
806 INIT_LIST_HEAD(&reg_key_list);
807
808 if (ret)
809 refs++;
810
811 return ret;
812 }
813
814 /*
815 * ======== dcd_register_object ========
816 * Purpose:
817 * Registers a node or a processor with the DCD.
818 * If psz_path_name == NULL, unregister the specified DCD object.
819 */
820 int dcd_register_object(struct dsp_uuid *uuid_obj,
821 enum dsp_dcdobjtype obj_type,
822 char *psz_path_name)
823 {
824 int status = 0;
825 char sz_reg_key[DCD_MAXPATHLENGTH];
826 char sz_uuid[MAXUUIDLEN + 1];
827 u32 dw_path_size = 0;
828 u32 dw_key_len; /* Len of REG key. */
829 char sz_obj_type[MAX_INT2CHAR_LENGTH]; /* str. rep. of obj_type. */
830 struct dcd_key_elem *dcd_key = NULL;
831
832 dev_dbg(bridge, "%s: object UUID %p, obj_type %d, szPathName %s\n",
833 __func__, uuid_obj, obj_type, psz_path_name);
834
835 /*
836 * Pre-determine final key length. It's length of DCD_REGKEY +
837 * "_\0" + length of sz_obj_type string + terminating NULL.
838 */
839 dw_key_len = strlen(DCD_REGKEY) + 1 + sizeof(sz_obj_type) + 1;
840
841 /* Create proper REG key; concatenate DCD_REGKEY with obj_type. */
842 strncpy(sz_reg_key, DCD_REGKEY, strlen(DCD_REGKEY) + 1);
843 if ((strlen(sz_reg_key) + strlen("_\0")) < DCD_MAXPATHLENGTH)
844 strncat(sz_reg_key, "_\0", 2);
845 else {
846 status = -EPERM;
847 goto func_end;
848 }
849
850 status = snprintf(sz_obj_type, MAX_INT2CHAR_LENGTH, "%d", obj_type);
851 if (status == -1) {
852 status = -EPERM;
853 } else {
854 status = 0;
855 if ((strlen(sz_reg_key) + strlen(sz_obj_type)) <
856 DCD_MAXPATHLENGTH) {
857 strncat(sz_reg_key, sz_obj_type,
858 strlen(sz_obj_type) + 1);
859 } else
860 status = -EPERM;
861
862 /* Create UUID value to set in registry. */
863 snprintf(sz_uuid, MAXUUIDLEN, "%pUL", uuid_obj);
864 if ((strlen(sz_reg_key) + MAXUUIDLEN) < DCD_MAXPATHLENGTH)
865 strncat(sz_reg_key, sz_uuid, MAXUUIDLEN);
866 else
867 status = -EPERM;
868 }
869
870 if (status)
871 goto func_end;
872
873 /*
874 * If psz_path_name != NULL, perform registration, otherwise,
875 * perform unregistration.
876 */
877
878 if (psz_path_name) {
879 dw_path_size = strlen(psz_path_name) + 1;
880 spin_lock(&dbdcd_lock);
881 list_for_each_entry(dcd_key, &reg_key_list, link) {
882 /* See if the name matches. */
883 if (!strncmp(dcd_key->name, sz_reg_key,
884 strlen(sz_reg_key) + 1))
885 break;
886 }
887 spin_unlock(&dbdcd_lock);
888 if (&dcd_key->link == &reg_key_list) {
889 /*
890 * Add new reg value (UUID+obj_type)
891 * with COFF path info
892 */
893
894 dcd_key = kmalloc(sizeof(struct dcd_key_elem),
895 GFP_KERNEL);
896 if (!dcd_key) {
897 status = -ENOMEM;
898 goto func_end;
899 }
900
901 dcd_key->path = kmalloc(dw_path_size, GFP_KERNEL);
902
903 if (!dcd_key->path) {
904 kfree(dcd_key);
905 status = -ENOMEM;
906 goto func_end;
907 }
908
909 strncpy(dcd_key->name, sz_reg_key,
910 strlen(sz_reg_key) + 1);
911 strncpy(dcd_key->path, psz_path_name ,
912 dw_path_size);
913 spin_lock(&dbdcd_lock);
914 list_add_tail(&dcd_key->link, &reg_key_list);
915 spin_unlock(&dbdcd_lock);
916 } else {
917 /* Make sure the new data is the same. */
918 if (strncmp(dcd_key->path, psz_path_name,
919 dw_path_size)) {
920 /* The caller needs a different data size! */
921 kfree(dcd_key->path);
922 dcd_key->path = kmalloc(dw_path_size,
923 GFP_KERNEL);
924 if (dcd_key->path == NULL) {
925 status = -ENOMEM;
926 goto func_end;
927 }
928 }
929
930 /* We have a match! Copy out the data. */
931 memcpy(dcd_key->path, psz_path_name, dw_path_size);
932 }
933 dev_dbg(bridge, "%s: psz_path_name=%s, dw_path_size=%d\n",
934 __func__, psz_path_name, dw_path_size);
935 } else {
936 /* Deregister an existing object */
937 spin_lock(&dbdcd_lock);
938 list_for_each_entry(dcd_key, &reg_key_list, link) {
939 if (!strncmp(dcd_key->name, sz_reg_key,
940 strlen(sz_reg_key) + 1)) {
941 list_del(&dcd_key->link);
942 kfree(dcd_key->path);
943 kfree(dcd_key);
944 break;
945 }
946 }
947 spin_unlock(&dbdcd_lock);
948 if (&dcd_key->link == &reg_key_list)
949 status = -EPERM;
950 }
951
952 if (!status) {
953 /*
954 * Because the node database has been updated through a
955 * successful object registration/de-registration operation,
956 * we need to reset the object enumeration counter to allow
957 * current enumerations to reflect this update in the node
958 * database.
959 */
960 enum_refs = 0;
961 }
962 func_end:
963 return status;
964 }
965
966 /*
967 * ======== dcd_unregister_object ========
968 * Call DCD_Register object with psz_path_name set to NULL to
969 * perform actual object de-registration.
970 */
971 int dcd_unregister_object(struct dsp_uuid *uuid_obj,
972 enum dsp_dcdobjtype obj_type)
973 {
974 int status = 0;
975
976 /*
977 * When dcd_register_object is called with NULL as pathname,
978 * it indicates an unregister object operation.
979 */
980 status = dcd_register_object(uuid_obj, obj_type, NULL);
981
982 return status;
983 }
984
985 /*
986 **********************************************************************
987 * DCD Helper Functions
988 **********************************************************************
989 */
990
991 /*
992 * ======== atoi ========
993 * Purpose:
994 * This function converts strings in decimal or hex format to integers.
995 */
996 static s32 atoi(char *psz_buf)
997 {
998 char *pch = psz_buf;
999 s32 base = 0;
1000
1001 while (isspace(*pch))
1002 pch++;
1003
1004 if (*pch == '-' || *pch == '+') {
1005 base = 10;
1006 pch++;
1007 } else if (*pch && tolower(pch[strlen(pch) - 1]) == 'h') {
1008 base = 16;
1009 }
1010
1011 return simple_strtoul(pch, NULL, base);
1012 }
1013
1014 /*
1015 * ======== get_attrs_from_buf ========
1016 * Purpose:
1017 * Parse the content of a buffer filled with DSP-side data and
1018 * retrieve an object's attributes from it. IMPORTANT: Assume the
1019 * buffer has been converted from DSP format to GPP format.
1020 */
1021 static int get_attrs_from_buf(char *psz_buf, u32 ul_buf_size,
1022 enum dsp_dcdobjtype obj_type,
1023 struct dcd_genericobj *gen_obj)
1024 {
1025 int status = 0;
1026 char seps[] = ", ";
1027 char *psz_cur;
1028 char *token;
1029 s32 token_len = 0;
1030 u32 i = 0;
1031 #ifdef _DB_TIOMAP
1032 s32 entry_id;
1033 #endif
1034
1035 switch (obj_type) {
1036 case DSP_DCDNODETYPE:
1037 /*
1038 * Parse COFF sect buffer to retrieve individual tokens used
1039 * to fill in object attrs.
1040 */
1041 psz_cur = psz_buf;
1042 token = strsep(&psz_cur, seps);
1043
1044 /* u32 cb_struct */
1045 gen_obj->obj_data.node_obj.ndb_props.cb_struct =
1046 (u32) atoi(token);
1047 token = strsep(&psz_cur, seps);
1048
1049 /* dsp_uuid ui_node_id */
1050 status = dcd_uuid_from_string(token,
1051 &gen_obj->obj_data.node_obj.
1052 ndb_props.ui_node_id);
1053 if (status)
1054 break;
1055
1056 token = strsep(&psz_cur, seps);
1057
1058 /* ac_name */
1059 token_len = strlen(token);
1060 if (token_len > DSP_MAXNAMELEN - 1)
1061 token_len = DSP_MAXNAMELEN - 1;
1062
1063 strncpy(gen_obj->obj_data.node_obj.ndb_props.ac_name,
1064 token, token_len);
1065 gen_obj->obj_data.node_obj.ndb_props.ac_name[token_len] = '\0';
1066 token = strsep(&psz_cur, seps);
1067 /* u32 ntype */
1068 gen_obj->obj_data.node_obj.ndb_props.ntype = atoi(token);
1069 token = strsep(&psz_cur, seps);
1070 /* u32 cache_on_gpp */
1071 gen_obj->obj_data.node_obj.ndb_props.cache_on_gpp = atoi(token);
1072 token = strsep(&psz_cur, seps);
1073 /* dsp_resourcereqmts dsp_resource_reqmts */
1074 gen_obj->obj_data.node_obj.ndb_props.dsp_resource_reqmts.
1075 cb_struct = (u32) atoi(token);
1076 token = strsep(&psz_cur, seps);
1077
1078 gen_obj->obj_data.node_obj.ndb_props.
1079 dsp_resource_reqmts.static_data_size = atoi(token);
1080 token = strsep(&psz_cur, seps);
1081 gen_obj->obj_data.node_obj.ndb_props.
1082 dsp_resource_reqmts.global_data_size = atoi(token);
1083 token = strsep(&psz_cur, seps);
1084 gen_obj->obj_data.node_obj.ndb_props.
1085 dsp_resource_reqmts.program_mem_size = atoi(token);
1086 token = strsep(&psz_cur, seps);
1087 gen_obj->obj_data.node_obj.ndb_props.
1088 dsp_resource_reqmts.wc_execution_time = atoi(token);
1089 token = strsep(&psz_cur, seps);
1090 gen_obj->obj_data.node_obj.ndb_props.
1091 dsp_resource_reqmts.wc_period = atoi(token);
1092 token = strsep(&psz_cur, seps);
1093
1094 gen_obj->obj_data.node_obj.ndb_props.
1095 dsp_resource_reqmts.wc_deadline = atoi(token);
1096 token = strsep(&psz_cur, seps);
1097
1098 gen_obj->obj_data.node_obj.ndb_props.
1099 dsp_resource_reqmts.avg_exection_time = atoi(token);
1100 token = strsep(&psz_cur, seps);
1101
1102 gen_obj->obj_data.node_obj.ndb_props.
1103 dsp_resource_reqmts.minimum_period = atoi(token);
1104 token = strsep(&psz_cur, seps);
1105
1106 /* s32 prio */
1107 gen_obj->obj_data.node_obj.ndb_props.prio = atoi(token);
1108 token = strsep(&psz_cur, seps);
1109
1110 /* u32 stack_size */
1111 gen_obj->obj_data.node_obj.ndb_props.stack_size = atoi(token);
1112 token = strsep(&psz_cur, seps);
1113
1114 /* u32 sys_stack_size */
1115 gen_obj->obj_data.node_obj.ndb_props.sys_stack_size =
1116 atoi(token);
1117 token = strsep(&psz_cur, seps);
1118
1119 /* u32 stack_seg */
1120 gen_obj->obj_data.node_obj.ndb_props.stack_seg = atoi(token);
1121 token = strsep(&psz_cur, seps);
1122
1123 /* u32 message_depth */
1124 gen_obj->obj_data.node_obj.ndb_props.message_depth =
1125 atoi(token);
1126 token = strsep(&psz_cur, seps);
1127
1128 /* u32 num_input_streams */
1129 gen_obj->obj_data.node_obj.ndb_props.num_input_streams =
1130 atoi(token);
1131 token = strsep(&psz_cur, seps);
1132
1133 /* u32 num_output_streams */
1134 gen_obj->obj_data.node_obj.ndb_props.num_output_streams =
1135 atoi(token);
1136 token = strsep(&psz_cur, seps);
1137
1138 /* u32 timeout */
1139 gen_obj->obj_data.node_obj.ndb_props.timeout = atoi(token);
1140 token = strsep(&psz_cur, seps);
1141
1142 /* char *str_create_phase_fxn */
1143 token_len = strlen(token);
1144 gen_obj->obj_data.node_obj.str_create_phase_fxn =
1145 kzalloc(token_len + 1, GFP_KERNEL);
1146 strncpy(gen_obj->obj_data.node_obj.str_create_phase_fxn,
1147 token, token_len);
1148 gen_obj->obj_data.node_obj.str_create_phase_fxn[token_len] =
1149 '\0';
1150 token = strsep(&psz_cur, seps);
1151
1152 /* char *str_execute_phase_fxn */
1153 token_len = strlen(token);
1154 gen_obj->obj_data.node_obj.str_execute_phase_fxn =
1155 kzalloc(token_len + 1, GFP_KERNEL);
1156 strncpy(gen_obj->obj_data.node_obj.str_execute_phase_fxn,
1157 token, token_len);
1158 gen_obj->obj_data.node_obj.str_execute_phase_fxn[token_len] =
1159 '\0';
1160 token = strsep(&psz_cur, seps);
1161
1162 /* char *str_delete_phase_fxn */
1163 token_len = strlen(token);
1164 gen_obj->obj_data.node_obj.str_delete_phase_fxn =
1165 kzalloc(token_len + 1, GFP_KERNEL);
1166 strncpy(gen_obj->obj_data.node_obj.str_delete_phase_fxn,
1167 token, token_len);
1168 gen_obj->obj_data.node_obj.str_delete_phase_fxn[token_len] =
1169 '\0';
1170 token = strsep(&psz_cur, seps);
1171
1172 /* Segment id for message buffers */
1173 gen_obj->obj_data.node_obj.msg_segid = atoi(token);
1174 token = strsep(&psz_cur, seps);
1175
1176 /* Message notification type */
1177 gen_obj->obj_data.node_obj.msg_notify_type = atoi(token);
1178 token = strsep(&psz_cur, seps);
1179
1180 /* char *str_i_alg_name */
1181 if (token) {
1182 token_len = strlen(token);
1183 gen_obj->obj_data.node_obj.str_i_alg_name =
1184 kzalloc(token_len + 1, GFP_KERNEL);
1185 strncpy(gen_obj->obj_data.node_obj.str_i_alg_name,
1186 token, token_len);
1187 gen_obj->obj_data.node_obj.str_i_alg_name[token_len] =
1188 '\0';
1189 token = strsep(&psz_cur, seps);
1190 }
1191
1192 /* Load type (static, dynamic, or overlay) */
1193 if (token) {
1194 gen_obj->obj_data.node_obj.load_type = atoi(token);
1195 token = strsep(&psz_cur, seps);
1196 }
1197
1198 /* Dynamic load data requirements */
1199 if (token) {
1200 gen_obj->obj_data.node_obj.data_mem_seg_mask =
1201 atoi(token);
1202 token = strsep(&psz_cur, seps);
1203 }
1204
1205 /* Dynamic load code requirements */
1206 if (token) {
1207 gen_obj->obj_data.node_obj.code_mem_seg_mask =
1208 atoi(token);
1209 token = strsep(&psz_cur, seps);
1210 }
1211
1212 /* Extract node profiles into node properties */
1213 if (token) {
1214
1215 gen_obj->obj_data.node_obj.ndb_props.count_profiles =
1216 atoi(token);
1217 for (i = 0;
1218 i <
1219 gen_obj->obj_data.node_obj.
1220 ndb_props.count_profiles; i++) {
1221 token = strsep(&psz_cur, seps);
1222 if (token) {
1223 /* Heap Size for the node */
1224 gen_obj->obj_data.node_obj.
1225 ndb_props.node_profiles[i].
1226 heap_size = atoi(token);
1227 }
1228 }
1229 }
1230 token = strsep(&psz_cur, seps);
1231 if (token) {
1232 gen_obj->obj_data.node_obj.ndb_props.stack_seg_name =
1233 (u32) (token);
1234 }
1235
1236 break;
1237
1238 case DSP_DCDPROCESSORTYPE:
1239 /*
1240 * Parse COFF sect buffer to retrieve individual tokens used
1241 * to fill in object attrs.
1242 */
1243 psz_cur = psz_buf;
1244 token = strsep(&psz_cur, seps);
1245
1246 gen_obj->obj_data.proc_info.cb_struct = atoi(token);
1247 token = strsep(&psz_cur, seps);
1248
1249 gen_obj->obj_data.proc_info.processor_family = atoi(token);
1250 token = strsep(&psz_cur, seps);
1251
1252 gen_obj->obj_data.proc_info.processor_type = atoi(token);
1253 token = strsep(&psz_cur, seps);
1254
1255 gen_obj->obj_data.proc_info.clock_rate = atoi(token);
1256 token = strsep(&psz_cur, seps);
1257
1258 gen_obj->obj_data.proc_info.internal_mem_size = atoi(token);
1259 token = strsep(&psz_cur, seps);
1260
1261 gen_obj->obj_data.proc_info.external_mem_size = atoi(token);
1262 token = strsep(&psz_cur, seps);
1263
1264 gen_obj->obj_data.proc_info.processor_id = atoi(token);
1265 token = strsep(&psz_cur, seps);
1266
1267 gen_obj->obj_data.proc_info.ty_running_rtos = atoi(token);
1268 token = strsep(&psz_cur, seps);
1269
1270 gen_obj->obj_data.proc_info.node_min_priority = atoi(token);
1271 token = strsep(&psz_cur, seps);
1272
1273 gen_obj->obj_data.proc_info.node_max_priority = atoi(token);
1274
1275 #ifdef _DB_TIOMAP
1276 /* Proc object may contain additional(extended) attributes. */
1277 /* attr must match proc.hxx */
1278 for (entry_id = 0; entry_id < 7; entry_id++) {
1279 token = strsep(&psz_cur, seps);
1280 gen_obj->obj_data.ext_proc_obj.ty_tlb[entry_id].
1281 gpp_phys = atoi(token);
1282
1283 token = strsep(&psz_cur, seps);
1284 gen_obj->obj_data.ext_proc_obj.ty_tlb[entry_id].
1285 dsp_virt = atoi(token);
1286 }
1287 #endif
1288
1289 break;
1290
1291 default:
1292 status = -EPERM;
1293 break;
1294 }
1295
1296 return status;
1297 }
1298
1299 /*
1300 * ======== CompressBuffer ========
1301 * Purpose:
1302 * Compress the DSP buffer, if necessary, to conform to PC format.
1303 */
1304 static void compress_buf(char *psz_buf, u32 ul_buf_size, s32 char_size)
1305 {
1306 char *p;
1307 char ch;
1308 char *q;
1309
1310 p = psz_buf;
1311 if (p == NULL)
1312 return;
1313
1314 for (q = psz_buf; q < (psz_buf + ul_buf_size);) {
1315 ch = dsp_char2_gpp_char(q, char_size);
1316 if (ch == '\\') {
1317 q += char_size;
1318 ch = dsp_char2_gpp_char(q, char_size);
1319 switch (ch) {
1320 case 't':
1321 *p = '\t';
1322 break;
1323
1324 case 'n':
1325 *p = '\n';
1326 break;
1327
1328 case 'r':
1329 *p = '\r';
1330 break;
1331
1332 case '0':
1333 *p = '\0';
1334 break;
1335
1336 default:
1337 *p = ch;
1338 break;
1339 }
1340 } else {
1341 *p = ch;
1342 }
1343 p++;
1344 q += char_size;
1345 }
1346
1347 /* NULL out remainder of buffer. */
1348 while (p < q)
1349 *p++ = '\0';
1350 }
1351
1352 /*
1353 * ======== dsp_char2_gpp_char ========
1354 * Purpose:
1355 * Convert DSP char to host GPP char in a portable manner
1356 */
1357 static char dsp_char2_gpp_char(char *word, s32 dsp_char_size)
1358 {
1359 char ch = '\0';
1360 char *ch_src;
1361 s32 i;
1362
1363 for (ch_src = word, i = dsp_char_size; i > 0; i--)
1364 ch |= *ch_src++;
1365
1366 return ch;
1367 }
1368
1369 /*
1370 * ======== get_dep_lib_info ========
1371 */
1372 static int get_dep_lib_info(struct dcd_manager *hdcd_mgr,
1373 struct dsp_uuid *uuid_obj,
1374 u16 *num_libs,
1375 u16 *num_pers_libs,
1376 struct dsp_uuid *dep_lib_uuids,
1377 bool *prstnt_dep_libs,
1378 enum nldr_phase phase)
1379 {
1380 struct dcd_manager *dcd_mgr_obj = hdcd_mgr;
1381 char *psz_coff_buf = NULL;
1382 char *psz_cur;
1383 char *psz_file_name = NULL;
1384 struct cod_libraryobj *lib = NULL;
1385 u32 ul_addr = 0; /* Used by cod_get_section */
1386 u32 ul_len = 0; /* Used by cod_get_section */
1387 u32 dw_data_size = COD_MAXPATHLENGTH;
1388 char seps[] = ", ";
1389 char *token = NULL;
1390 bool get_uuids = (dep_lib_uuids != NULL);
1391 u16 dep_libs = 0;
1392 int status = 0;
1393
1394 /* Initialize to 0 dependent libraries, if only counting number of
1395 * dependent libraries */
1396 if (!get_uuids) {
1397 *num_libs = 0;
1398 *num_pers_libs = 0;
1399 }
1400
1401 /* Allocate a buffer for file name */
1402 psz_file_name = kzalloc(dw_data_size, GFP_KERNEL);
1403 if (psz_file_name == NULL) {
1404 status = -ENOMEM;
1405 } else {
1406 /* Get the name of the library */
1407 status = dcd_get_library_name(hdcd_mgr, uuid_obj, psz_file_name,
1408 &dw_data_size, phase, NULL);
1409 }
1410
1411 /* Open the library */
1412 if (!status) {
1413 status = cod_open(dcd_mgr_obj->cod_mgr, psz_file_name,
1414 COD_NOLOAD, &lib);
1415 }
1416 if (!status) {
1417 /* Get dependent library section information. */
1418 status = cod_get_section(lib, DEPLIBSECT, &ul_addr, &ul_len);
1419
1420 if (status) {
1421 /* Ok, no dependent libraries */
1422 ul_len = 0;
1423 status = 0;
1424 }
1425 }
1426
1427 if (status || !(ul_len > 0))
1428 goto func_cont;
1429
1430 /* Allocate zeroed buffer. */
1431 psz_coff_buf = kzalloc(ul_len + 4, GFP_KERNEL);
1432 if (psz_coff_buf == NULL)
1433 status = -ENOMEM;
1434
1435 /* Read section contents. */
1436 status = cod_read_section(lib, DEPLIBSECT, psz_coff_buf, ul_len);
1437 if (status)
1438 goto func_cont;
1439
1440 /* Compress and format DSP buffer to conform to PC format. */
1441 compress_buf(psz_coff_buf, ul_len, DSPWORDSIZE);
1442
1443 /* Read from buffer */
1444 psz_cur = psz_coff_buf;
1445 while ((token = strsep(&psz_cur, seps)) && *token != '\0') {
1446 if (get_uuids) {
1447 if (dep_libs >= *num_libs) {
1448 /* Gone beyond the limit */
1449 break;
1450 } else {
1451 /* Retrieve UUID string. */
1452 status = dcd_uuid_from_string(token,
1453 &(dep_lib_uuids
1454 [dep_libs]));
1455 if (status)
1456 break;
1457
1458 /* Is this library persistent? */
1459 token = strsep(&psz_cur, seps);
1460 prstnt_dep_libs[dep_libs] = atoi(token);
1461 dep_libs++;
1462 }
1463 } else {
1464 /* Advanc to next token */
1465 token = strsep(&psz_cur, seps);
1466 if (atoi(token))
1467 (*num_pers_libs)++;
1468
1469 /* Just counting number of dependent libraries */
1470 (*num_libs)++;
1471 }
1472 }
1473 func_cont:
1474 if (lib)
1475 cod_close(lib);
1476
1477 /* Free previously allocated dynamic buffers. */
1478 kfree(psz_file_name);
1479
1480 kfree(psz_coff_buf);
1481
1482 return status;
1483 }
Linux kernel - Deliverables
This page took 0.061927 seconds and 6 git commands to generate.