← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/staging/tidspbridge/pmgr/cod.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/tidspbridge/pmgr/cod.c
 
1
/*
 
2
 * cod.c
 
3
 *
 
4
 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
 
5
 *
 
6
 * This module implements DSP code management for the DSP/BIOS Bridge
 
7
 * environment. It is mostly a thin wrapper.
 
8
 *
 
9
 * This module provides an interface for loading both static and
 
10
 * dynamic code objects onto DSP systems.
 
11
 *
 
12
 * Copyright (C) 2005-2006 Texas Instruments, Inc.
 
13
 *
 
14
 * This package is free software; you can redistribute it and/or modify
 
15
 * it under the terms of the GNU General Public License version 2 as
 
16
 * published by the Free Software Foundation.
 
17
 *
 
18
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 
19
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
21
 */
 
22
 
 
23
#include <linux/types.h>
 
24
 
 
25
/*  ----------------------------------- Host OS */
 
26
#include <dspbridge/host_os.h>
 
27
#include <linux/fs.h>
 
28
#include <linux/uaccess.h>
 
29
 
 
30
/*  ----------------------------------- DSP/BIOS Bridge */
 
31
#include <dspbridge/dbdefs.h>
 
32
 
 
33
/*  ----------------------------------- Trace & Debug */
 
34
#include <dspbridge/dbc.h>
 
35
 
 
36
/*  ----------------------------------- Platform Manager */
 
37
/* Include appropriate loader header file */
 
38
#include <dspbridge/dbll.h>
 
39
 
 
40
/*  ----------------------------------- This */
 
41
#include <dspbridge/cod.h>
 
42
 
 
43
/*
 
44
 *  ======== cod_manager ========
 
45
 */
 
46
struct cod_manager {
 
47
        struct dbll_tar_obj *target;
 
48
        struct dbll_library_obj *base_lib;
 
49
        bool loaded;            /* Base library loaded? */
 
50
        u32 entry;
 
51
        struct dbll_fxns fxns;
 
52
        struct dbll_attrs attrs;
 
53
        char sz_zl_file[COD_MAXPATHLENGTH];
 
54
};
 
55
 
 
56
/*
 
57
 *  ======== cod_libraryobj ========
 
58
 */
 
59
struct cod_libraryobj {
 
60
        struct dbll_library_obj *dbll_lib;
 
61
        struct cod_manager *cod_mgr;
 
62
};
 
63
 
 
64
static u32 refs = 0L;
 
65
 
 
66
static struct dbll_fxns ldr_fxns = {
 
67
        (dbll_close_fxn) dbll_close,
 
68
        (dbll_create_fxn) dbll_create,
 
69
        (dbll_delete_fxn) dbll_delete,
 
70
        (dbll_exit_fxn) dbll_exit,
 
71
        (dbll_get_attrs_fxn) dbll_get_attrs,
 
72
        (dbll_get_addr_fxn) dbll_get_addr,
 
73
        (dbll_get_c_addr_fxn) dbll_get_c_addr,
 
74
        (dbll_get_sect_fxn) dbll_get_sect,
 
75
        (dbll_init_fxn) dbll_init,
 
76
        (dbll_load_fxn) dbll_load,
 
77
        (dbll_open_fxn) dbll_open,
 
78
        (dbll_read_sect_fxn) dbll_read_sect,
 
79
        (dbll_unload_fxn) dbll_unload,
 
80
};
 
81
 
 
82
static bool no_op(void);
 
83
 
 
84
/*
 
85
 * File operations (originally were under kfile.c)
 
86
 */
 
87
static s32 cod_f_close(struct file *filp)
 
88
{
 
89
        /* Check for valid handle */
 
90
        if (!filp)
 
91
                return -EFAULT;
 
92
 
 
93
        filp_close(filp, NULL);
 
94
 
 
95
        /* we can't use 0 here */
 
96
        return 0;
 
97
}
 
98
 
 
99
static struct file *cod_f_open(const char *psz_file_name, const char *sz_mode)
 
100
{
 
101
        mm_segment_t fs;
 
102
        struct file *filp;
 
103
 
 
104
        fs = get_fs();
 
105
        set_fs(get_ds());
 
106
 
 
107
        /* ignore given mode and open file as read-only */
 
108
        filp = filp_open(psz_file_name, O_RDONLY, 0);
 
109
 
 
110
        if (IS_ERR(filp))
 
111
                filp = NULL;
 
112
 
 
113
        set_fs(fs);
 
114
 
 
115
        return filp;
 
116
}
 
117
 
 
118
static s32 cod_f_read(void __user *pbuffer, s32 size, s32 count,
 
119
                      struct file *filp)
 
120
{
 
121
        /* check for valid file handle */
 
122
        if (!filp)
 
123
                return -EFAULT;
 
124
 
 
125
        if ((size > 0) && (count > 0) && pbuffer) {
 
126
                u32 dw_bytes_read;
 
127
                mm_segment_t fs;
 
128
 
 
129
                /* read from file */
 
130
                fs = get_fs();
 
131
                set_fs(get_ds());
 
132
                dw_bytes_read = filp->f_op->read(filp, pbuffer, size * count,
 
133
                                                 &(filp->f_pos));
 
134
                set_fs(fs);
 
135
 
 
136
                if (!dw_bytes_read)
 
137
                        return -EBADF;
 
138
 
 
139
                return dw_bytes_read / size;
 
140
        }
 
141
 
 
142
        return -EINVAL;
 
143
}
 
144
 
 
145
static s32 cod_f_seek(struct file *filp, s32 offset, s32 origin)
 
146
{
 
147
        loff_t dw_cur_pos;
 
148
 
 
149
        /* check for valid file handle */
 
150
        if (!filp)
 
151
                return -EFAULT;
 
152
 
 
153
        /* based on the origin flag, move the internal pointer */
 
154
        dw_cur_pos = filp->f_op->llseek(filp, offset, origin);
 
155
 
 
156
        if ((s32) dw_cur_pos < 0)
 
157
                return -EPERM;
 
158
 
 
159
        /* we can't use 0 here */
 
160
        return 0;
 
161
}
 
162
 
 
163
static s32 cod_f_tell(struct file *filp)
 
164
{
 
165
        loff_t dw_cur_pos;
 
166
 
 
167
        if (!filp)
 
168
                return -EFAULT;
 
169
 
 
170
        /* Get current position */
 
171
        dw_cur_pos = filp->f_op->llseek(filp, 0, SEEK_CUR);
 
172
 
 
173
        if ((s32) dw_cur_pos < 0)
 
174
                return -EPERM;
 
175
 
 
176
        return dw_cur_pos;
 
177
}
 
178
 
 
179
/*
 
180
 *  ======== cod_close ========
 
181
 */
 
182
void cod_close(struct cod_libraryobj *lib)
 
183
{
 
184
        struct cod_manager *hmgr;
 
185
 
 
186
        DBC_REQUIRE(refs > 0);
 
187
        DBC_REQUIRE(lib != NULL);
 
188
        DBC_REQUIRE(lib->cod_mgr);
 
189
 
 
190
        hmgr = lib->cod_mgr;
 
191
        hmgr->fxns.close_fxn(lib->dbll_lib);
 
192
 
 
193
        kfree(lib);
 
194
}
 
195
 
 
196
/*
 
197
 *  ======== cod_create ========
 
198
 *  Purpose:
 
199
 *      Create an object to manage code on a DSP system.
 
200
 *      This object can be used to load an initial program image with
 
201
 *      arguments that can later be expanded with
 
202
 *      dynamically loaded object files.
 
203
 *
 
204
 */
 
205
int cod_create(struct cod_manager **mgr, char *str_zl_file)
 
206
{
 
207
        struct cod_manager *mgr_new;
 
208
        struct dbll_attrs zl_attrs;
 
209
        int status = 0;
 
210
 
 
211
        DBC_REQUIRE(refs > 0);
 
212
        DBC_REQUIRE(mgr != NULL);
 
213
 
 
214
        /* assume failure */
 
215
        *mgr = NULL;
 
216
 
 
217
        mgr_new = kzalloc(sizeof(struct cod_manager), GFP_KERNEL);
 
218
        if (mgr_new == NULL)
 
219
                return -ENOMEM;
 
220
 
 
221
        /* Set up loader functions */
 
222
        mgr_new->fxns = ldr_fxns;
 
223
 
 
224
        /* initialize the ZL module */
 
225
        mgr_new->fxns.init_fxn();
 
226
 
 
227
        zl_attrs.alloc = (dbll_alloc_fxn) no_op;
 
228
        zl_attrs.free = (dbll_free_fxn) no_op;
 
229
        zl_attrs.fread = (dbll_read_fxn) cod_f_read;
 
230
        zl_attrs.fseek = (dbll_seek_fxn) cod_f_seek;
 
231
        zl_attrs.ftell = (dbll_tell_fxn) cod_f_tell;
 
232
        zl_attrs.fclose = (dbll_f_close_fxn) cod_f_close;
 
233
        zl_attrs.fopen = (dbll_f_open_fxn) cod_f_open;
 
234
        zl_attrs.sym_lookup = NULL;
 
235
        zl_attrs.base_image = true;
 
236
        zl_attrs.log_write = NULL;
 
237
        zl_attrs.log_write_handle = NULL;
 
238
        zl_attrs.write = NULL;
 
239
        zl_attrs.rmm_handle = NULL;
 
240
        zl_attrs.input_params = NULL;
 
241
        zl_attrs.sym_handle = NULL;
 
242
        zl_attrs.sym_arg = NULL;
 
243
 
 
244
        mgr_new->attrs = zl_attrs;
 
245
 
 
246
        status = mgr_new->fxns.create_fxn(&mgr_new->target, &zl_attrs);
 
247
 
 
248
        if (status) {
 
249
                cod_delete(mgr_new);
 
250
                return -ESPIPE;
 
251
        }
 
252
 
 
253
        /* return the new manager */
 
254
        *mgr = mgr_new;
 
255
 
 
256
        return 0;
 
257
}
 
258
 
 
259
/*
 
260
 *  ======== cod_delete ========
 
261
 *  Purpose:
 
262
 *      Delete a code manager object.
 
263
 */
 
264
void cod_delete(struct cod_manager *cod_mgr_obj)
 
265
{
 
266
        DBC_REQUIRE(refs > 0);
 
267
        DBC_REQUIRE(cod_mgr_obj);
 
268
 
 
269
        if (cod_mgr_obj->base_lib) {
 
270
                if (cod_mgr_obj->loaded)
 
271
                        cod_mgr_obj->fxns.unload_fxn(cod_mgr_obj->base_lib,
 
272
                                                        &cod_mgr_obj->attrs);
 
273
 
 
274
                cod_mgr_obj->fxns.close_fxn(cod_mgr_obj->base_lib);
 
275
        }
 
276
        if (cod_mgr_obj->target) {
 
277
                cod_mgr_obj->fxns.delete_fxn(cod_mgr_obj->target);
 
278
                cod_mgr_obj->fxns.exit_fxn();
 
279
        }
 
280
        kfree(cod_mgr_obj);
 
281
}
 
282
 
 
283
/*
 
284
 *  ======== cod_exit ========
 
285
 *  Purpose:
 
286
 *      Discontinue usage of the COD module.
 
287
 *
 
288
 */
 
289
void cod_exit(void)
 
290
{
 
291
        DBC_REQUIRE(refs > 0);
 
292
 
 
293
        refs--;
 
294
 
 
295
        DBC_ENSURE(refs >= 0);
 
296
}
 
297
 
 
298
/*
 
299
 *  ======== cod_get_base_lib ========
 
300
 *  Purpose:
 
301
 *      Get handle to the base image DBL library.
 
302
 */
 
303
int cod_get_base_lib(struct cod_manager *cod_mgr_obj,
 
304
                            struct dbll_library_obj **plib)
 
305
{
 
306
        int status = 0;
 
307
 
 
308
        DBC_REQUIRE(refs > 0);
 
309
        DBC_REQUIRE(cod_mgr_obj);
 
310
        DBC_REQUIRE(plib != NULL);
 
311
 
 
312
        *plib = (struct dbll_library_obj *)cod_mgr_obj->base_lib;
 
313
 
 
314
        return status;
 
315
}
 
316
 
 
317
/*
 
318
 *  ======== cod_get_base_name ========
 
319
 */
 
320
int cod_get_base_name(struct cod_manager *cod_mgr_obj, char *sz_name,
 
321
                             u32 usize)
 
322
{
 
323
        int status = 0;
 
324
 
 
325
        DBC_REQUIRE(refs > 0);
 
326
        DBC_REQUIRE(cod_mgr_obj);
 
327
        DBC_REQUIRE(sz_name != NULL);
 
328
 
 
329
        if (usize <= COD_MAXPATHLENGTH)
 
330
                strncpy(sz_name, cod_mgr_obj->sz_zl_file, usize);
 
331
        else
 
332
                status = -EPERM;
 
333
 
 
334
        return status;
 
335
}
 
336
 
 
337
/*
 
338
 *  ======== cod_get_entry ========
 
339
 *  Purpose:
 
340
 *      Retrieve the entry point of a loaded DSP program image
 
341
 *
 
342
 */
 
343
int cod_get_entry(struct cod_manager *cod_mgr_obj, u32 *entry_pt)
 
344
{
 
345
        DBC_REQUIRE(refs > 0);
 
346
        DBC_REQUIRE(cod_mgr_obj);
 
347
        DBC_REQUIRE(entry_pt != NULL);
 
348
 
 
349
        *entry_pt = cod_mgr_obj->entry;
 
350
 
 
351
        return 0;
 
352
}
 
353
 
 
354
/*
 
355
 *  ======== cod_get_loader ========
 
356
 *  Purpose:
 
357
 *      Get handle to the DBLL loader.
 
358
 */
 
359
int cod_get_loader(struct cod_manager *cod_mgr_obj,
 
360
                          struct dbll_tar_obj **loader)
 
361
{
 
362
        int status = 0;
 
363
 
 
364
        DBC_REQUIRE(refs > 0);
 
365
        DBC_REQUIRE(cod_mgr_obj);
 
366
        DBC_REQUIRE(loader != NULL);
 
367
 
 
368
        *loader = (struct dbll_tar_obj *)cod_mgr_obj->target;
 
369
 
 
370
        return status;
 
371
}
 
372
 
 
373
/*
 
374
 *  ======== cod_get_section ========
 
375
 *  Purpose:
 
376
 *      Retrieve the starting address and length of a section in the COFF file
 
377
 *      given the section name.
 
378
 */
 
379
int cod_get_section(struct cod_libraryobj *lib, char *str_sect,
 
380
                           u32 *addr, u32 *len)
 
381
{
 
382
        struct cod_manager *cod_mgr_obj;
 
383
        int status = 0;
 
384
 
 
385
        DBC_REQUIRE(refs > 0);
 
386
        DBC_REQUIRE(lib != NULL);
 
387
        DBC_REQUIRE(lib->cod_mgr);
 
388
        DBC_REQUIRE(str_sect != NULL);
 
389
        DBC_REQUIRE(addr != NULL);
 
390
        DBC_REQUIRE(len != NULL);
 
391
 
 
392
        *addr = 0;
 
393
        *len = 0;
 
394
        if (lib != NULL) {
 
395
                cod_mgr_obj = lib->cod_mgr;
 
396
                status = cod_mgr_obj->fxns.get_sect_fxn(lib->dbll_lib, str_sect,
 
397
                                                        addr, len);
 
398
        } else {
 
399
                status = -ESPIPE;
 
400
        }
 
401
 
 
402
        DBC_ENSURE(!status || ((*addr == 0) && (*len == 0)));
 
403
 
 
404
        return status;
 
405
}
 
406
 
 
407
/*
 
408
 *  ======== cod_get_sym_value ========
 
409
 *  Purpose:
 
410
 *      Retrieve the value for the specified symbol. The symbol is first
 
411
 *      searched for literally and then, if not found, searched for as a
 
412
 *      C symbol.
 
413
 *
 
414
 */
 
415
int cod_get_sym_value(struct cod_manager *cod_mgr_obj, char *str_sym,
 
416
                             u32 *pul_value)
 
417
{
 
418
        struct dbll_sym_val *dbll_sym;
 
419
 
 
420
        DBC_REQUIRE(refs > 0);
 
421
        DBC_REQUIRE(cod_mgr_obj);
 
422
        DBC_REQUIRE(str_sym != NULL);
 
423
        DBC_REQUIRE(pul_value != NULL);
 
424
 
 
425
        dev_dbg(bridge, "%s: cod_mgr_obj: %p str_sym: %s pul_value: %p\n",
 
426
                __func__, cod_mgr_obj, str_sym, pul_value);
 
427
        if (cod_mgr_obj->base_lib) {
 
428
                if (!cod_mgr_obj->fxns.
 
429
                    get_addr_fxn(cod_mgr_obj->base_lib, str_sym, &dbll_sym)) {
 
430
                        if (!cod_mgr_obj->fxns.
 
431
                            get_c_addr_fxn(cod_mgr_obj->base_lib, str_sym,
 
432
                                                &dbll_sym))
 
433
                                return -ESPIPE;
 
434
                }
 
435
        } else {
 
436
                return -ESPIPE;
 
437
        }
 
438
 
 
439
        *pul_value = dbll_sym->value;
 
440
 
 
441
        return 0;
 
442
}
 
443
 
 
444
/*
 
445
 *  ======== cod_init ========
 
446
 *  Purpose:
 
447
 *      Initialize the COD module's private state.
 
448
 *
 
449
 */
 
450
bool cod_init(void)
 
451
{
 
452
        bool ret = true;
 
453
 
 
454
        DBC_REQUIRE(refs >= 0);
 
455
 
 
456
        if (ret)
 
457
                refs++;
 
458
 
 
459
        DBC_ENSURE((ret && refs > 0) || (!ret && refs >= 0));
 
460
        return ret;
 
461
}
 
462
 
 
463
/*
 
464
 *  ======== cod_load_base ========
 
465
 *  Purpose:
 
466
 *      Load the initial program image, optionally with command-line arguments,
 
467
 *      on the DSP system managed by the supplied handle. The program to be
 
468
 *      loaded must be the first element of the args array and must be a fully
 
469
 *      qualified pathname.
 
470
 *  Details:
 
471
 *      if num_argc doesn't match the number of arguments in the args array, the
 
472
 *      args array is searched for a NULL terminating entry, and argc is
 
473
 *      recalculated to reflect this.  In this way, we can support NULL
 
474
 *      terminating args arrays, if num_argc is very large.
 
475
 */
 
476
int cod_load_base(struct cod_manager *cod_mgr_obj, u32 num_argc, char *args[],
 
477
                         cod_writefxn pfn_write, void *arb, char *envp[])
 
478
{
 
479
        dbll_flags flags;
 
480
        struct dbll_attrs save_attrs;
 
481
        struct dbll_attrs new_attrs;
 
482
        int status;
 
483
        u32 i;
 
484
 
 
485
        DBC_REQUIRE(refs > 0);
 
486
        DBC_REQUIRE(cod_mgr_obj);
 
487
        DBC_REQUIRE(num_argc > 0);
 
488
        DBC_REQUIRE(args != NULL);
 
489
        DBC_REQUIRE(args[0] != NULL);
 
490
        DBC_REQUIRE(pfn_write != NULL);
 
491
        DBC_REQUIRE(cod_mgr_obj->base_lib != NULL);
 
492
 
 
493
        /*
 
494
         *  Make sure every argv[] stated in argc has a value, or change argc to
 
495
         *  reflect true number in NULL terminated argv array.
 
496
         */
 
497
        for (i = 0; i < num_argc; i++) {
 
498
                if (args[i] == NULL) {
 
499
                        num_argc = i;
 
500
                        break;
 
501
                }
 
502
        }
 
503
 
 
504
        /* set the write function for this operation */
 
505
        cod_mgr_obj->fxns.get_attrs_fxn(cod_mgr_obj->target, &save_attrs);
 
506
 
 
507
        new_attrs = save_attrs;
 
508
        new_attrs.write = (dbll_write_fxn) pfn_write;
 
509
        new_attrs.input_params = arb;
 
510
        new_attrs.alloc = (dbll_alloc_fxn) no_op;
 
511
        new_attrs.free = (dbll_free_fxn) no_op;
 
512
        new_attrs.log_write = NULL;
 
513
        new_attrs.log_write_handle = NULL;
 
514
 
 
515
        /* Load the image */
 
516
        flags = DBLL_CODE | DBLL_DATA | DBLL_SYMB;
 
517
        status = cod_mgr_obj->fxns.load_fxn(cod_mgr_obj->base_lib, flags,
 
518
                                            &new_attrs,
 
519
                                            &cod_mgr_obj->entry);
 
520
        if (status)
 
521
                cod_mgr_obj->fxns.close_fxn(cod_mgr_obj->base_lib);
 
522
 
 
523
        if (!status)
 
524
                cod_mgr_obj->loaded = true;
 
525
        else
 
526
                cod_mgr_obj->base_lib = NULL;
 
527
 
 
528
        return status;
 
529
}
 
530
 
 
531
/*
 
532
 *  ======== cod_open ========
 
533
 *      Open library for reading sections.
 
534
 */
 
535
int cod_open(struct cod_manager *hmgr, char *sz_coff_path,
 
536
                    u32 flags, struct cod_libraryobj **lib_obj)
 
537
{
 
538
        int status = 0;
 
539
        struct cod_libraryobj *lib = NULL;
 
540
 
 
541
        DBC_REQUIRE(refs > 0);
 
542
        DBC_REQUIRE(hmgr);
 
543
        DBC_REQUIRE(sz_coff_path != NULL);
 
544
        DBC_REQUIRE(flags == COD_NOLOAD || flags == COD_SYMB);
 
545
        DBC_REQUIRE(lib_obj != NULL);
 
546
 
 
547
        *lib_obj = NULL;
 
548
 
 
549
        lib = kzalloc(sizeof(struct cod_libraryobj), GFP_KERNEL);
 
550
        if (lib == NULL)
 
551
                status = -ENOMEM;
 
552
 
 
553
        if (!status) {
 
554
                lib->cod_mgr = hmgr;
 
555
                status = hmgr->fxns.open_fxn(hmgr->target, sz_coff_path, flags,
 
556
                                             &lib->dbll_lib);
 
557
                if (!status)
 
558
                        *lib_obj = lib;
 
559
        }
 
560
 
 
561
        if (status)
 
562
                pr_err("%s: error status 0x%x, sz_coff_path: %s flags: 0x%x\n",
 
563
                       __func__, status, sz_coff_path, flags);
 
564
        return status;
 
565
}
 
566
 
 
567
/*
 
568
 *  ======== cod_open_base ========
 
569
 *  Purpose:
 
570
 *      Open base image for reading sections.
 
571
 */
 
572
int cod_open_base(struct cod_manager *hmgr, char *sz_coff_path,
 
573
                         dbll_flags flags)
 
574
{
 
575
        int status = 0;
 
576
        struct dbll_library_obj *lib;
 
577
 
 
578
        DBC_REQUIRE(refs > 0);
 
579
        DBC_REQUIRE(hmgr);
 
580
        DBC_REQUIRE(sz_coff_path != NULL);
 
581
 
 
582
        /* if we previously opened a base image, close it now */
 
583
        if (hmgr->base_lib) {
 
584
                if (hmgr->loaded) {
 
585
                        hmgr->fxns.unload_fxn(hmgr->base_lib, &hmgr->attrs);
 
586
                        hmgr->loaded = false;
 
587
                }
 
588
                hmgr->fxns.close_fxn(hmgr->base_lib);
 
589
                hmgr->base_lib = NULL;
 
590
        }
 
591
        status = hmgr->fxns.open_fxn(hmgr->target, sz_coff_path, flags, &lib);
 
592
        if (!status) {
 
593
                /* hang onto the library for subsequent sym table usage */
 
594
                hmgr->base_lib = lib;
 
595
                strncpy(hmgr->sz_zl_file, sz_coff_path, COD_MAXPATHLENGTH - 1);
 
596
                hmgr->sz_zl_file[COD_MAXPATHLENGTH - 1] = '\0';
 
597
        }
 
598
 
 
599
        if (status)
 
600
                pr_err("%s: error status 0x%x sz_coff_path: %s\n", __func__,
 
601
                       status, sz_coff_path);
 
602
        return status;
 
603
}
 
604
 
 
605
/*
 
606
 *  ======== cod_read_section ========
 
607
 *  Purpose:
 
608
 *      Retrieve the content of a code section given the section name.
 
609
 */
 
610
int cod_read_section(struct cod_libraryobj *lib, char *str_sect,
 
611
                            char *str_content, u32 content_size)
 
612
{
 
613
        int status = 0;
 
614
 
 
615
        DBC_REQUIRE(refs > 0);
 
616
        DBC_REQUIRE(lib != NULL);
 
617
        DBC_REQUIRE(lib->cod_mgr);
 
618
        DBC_REQUIRE(str_sect != NULL);
 
619
        DBC_REQUIRE(str_content != NULL);
 
620
 
 
621
        if (lib != NULL)
 
622
                status =
 
623
                    lib->cod_mgr->fxns.read_sect_fxn(lib->dbll_lib, str_sect,
 
624
                                                     str_content, content_size);
 
625
        else
 
626
                status = -ESPIPE;
 
627
 
 
628
        return status;
 
629
}
 
630
 
 
631
/*
 
632
 *  ======== no_op ========
 
633
 *  Purpose:
 
634
 *      No Operation.
 
635
 *
 
636
 */
 
637
static bool no_op(void)
 
638
{
 
639
        return true;
 
640
}