mgr.c

Go to the documentation of this file.

/*
 * mgr.c
 *
 * DSP-BIOS Bridge driver support functions for TI OMAP processors.
 *
 * Implementation of Manager interface to the device object at the
 * driver level. This queries the NDB data base and retrieves the
 * data about Node and Processor.
 *
 * Copyright (C) 2005-2006 Texas Instruments, Inc.
 *
 * This package is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

#include <linux/types.h>

/*  ----------------------------------- Host OS */
#include <dspbridge/host_os.h>

/*  ----------------------------------- DSP/BIOS Bridge */
#include <dspbridge/dbdefs.h>

/*  ----------------------------------- OS Adaptation Layer */
#include <dspbridge/sync.h>

/*  ----------------------------------- Others */
#include <dspbridge/dbdcd.h>
#include <dspbridge/drv.h>
#include <dspbridge/dev.h>

/*  ----------------------------------- This */
#include <dspbridge/mgr.h>

/*  ----------------------------------- Defines, Data Structures, Typedefs */
#define ZLDLLNAME               ""

struct mgr_object {
    struct dcd_manager *dcd_mgr;    /* Proc/Node data manager */
};

/*  ----------------------------------- Globals */
static u32 refs;

/*
 *  ========= mgr_create =========
 *  Purpose:
 *      MGR Object gets created only once during driver Loading.
 */
int mgr_create(struct mgr_object **mgr_obj,
              struct cfg_devnode *dev_node_obj)
{
    int status = 0;
    struct mgr_object *pmgr_obj = NULL;
    struct drv_data *drv_datap = dev_get_drvdata(bridge);

    pmgr_obj = kzalloc(sizeof(struct mgr_object), GFP_KERNEL);
    if (pmgr_obj) {
        status = dcd_create_manager(ZLDLLNAME, &pmgr_obj->dcd_mgr);
        if (!status) {
            /* If succeeded store the handle in the MGR Object */
            if (drv_datap) {
                drv_datap->mgr_object = (void *)pmgr_obj;
            } else {
                status = -EPERM;
                pr_err("%s: Failed to store MGR object\n",
                                __func__);
            }

            if (!status) {
                *mgr_obj = pmgr_obj;
            } else {
                dcd_destroy_manager(pmgr_obj->dcd_mgr);
                kfree(pmgr_obj);
            }
        } else {
            /* failed to Create DCD Manager */
            kfree(pmgr_obj);
        }
    } else {
        status = -ENOMEM;
    }

    return status;
}

/*
 *  ========= mgr_destroy =========
 *     This function is invoked during bridge driver unloading.Frees MGR object.
 */
int mgr_destroy(struct mgr_object *hmgr_obj)
{
    int status = 0;
    struct mgr_object *pmgr_obj = (struct mgr_object *)hmgr_obj;
    struct drv_data *drv_datap = dev_get_drvdata(bridge);

    /* Free resources */
    if (hmgr_obj->dcd_mgr)
        dcd_destroy_manager(hmgr_obj->dcd_mgr);

    kfree(pmgr_obj);
    /* Update the driver data with NULL for MGR Object */
    if (drv_datap) {
        drv_datap->mgr_object = NULL;
    } else {
        status = -EPERM;
        pr_err("%s: Failed to store MGR object\n", __func__);
    }

    return status;
}

/*
 *  ======== mgr_enum_node_info ========
 *      Enumerate and get configuration information about nodes configured
 *      in the node database.
 */
int mgr_enum_node_info(u32 node_id, struct dsp_ndbprops *pndb_props,
                  u32 undb_props_size, u32 *pu_num_nodes)
{
    int status = 0;
    struct dsp_uuid node_uuid;
    u32 node_index = 0;
    struct dcd_genericobj gen_obj;
    struct mgr_object *pmgr_obj = NULL;
    struct drv_data *drv_datap = dev_get_drvdata(bridge);

    *pu_num_nodes = 0;
    /* Get the Manager Object from the driver data */
    if (!drv_datap || !drv_datap->mgr_object) {
        pr_err("%s: Failed to retrieve the object handle\n", __func__);
        return -ENODATA;
    }
    pmgr_obj = drv_datap->mgr_object;

    /* Forever loop till we hit failed or no more items in the
     * Enumeration. We will exit the loop other than 0; */
    while (!status) {
        status = dcd_enumerate_object(node_index++, DSP_DCDNODETYPE,
                &node_uuid);
        if (status)
            break;
        *pu_num_nodes = node_index;
        if (node_id == (node_index - 1)) {
            status = dcd_get_object_def(pmgr_obj->dcd_mgr,
                    &node_uuid, DSP_DCDNODETYPE, &gen_obj);
            if (status)
                break;
            /* Get the Obj def */
            *pndb_props = gen_obj.obj_data.node_obj.ndb_props;
        }
    }

    /* the last status is not 0, but neither an error */
    if (status > 0)
        status = 0;

    return status;
}

/*
 *  ======== mgr_enum_processor_info ========
 *      Enumerate and get configuration information about available
 *      DSP processors.
 */
int mgr_enum_processor_info(u32 processor_id,
                   struct dsp_processorinfo *
                   processor_info, u32 processor_info_size,
                   u8 *pu_num_procs)
{
    int status = 0;
    int status1 = 0;
    int status2 = 0;
    struct dsp_uuid temp_uuid;
    u32 temp_index = 0;
    u32 proc_index = 0;
    struct dcd_genericobj gen_obj;
    struct mgr_object *pmgr_obj = NULL;
    struct mgr_processorextinfo *ext_info;
    struct dev_object *hdev_obj;
    struct drv_object *hdrv_obj;
    u8 dev_type;
    struct cfg_devnode *dev_node;
    struct drv_data *drv_datap = dev_get_drvdata(bridge);
    bool proc_detect = false;

    *pu_num_procs = 0;

    /* Retrieve the Object handle from the driver data */
    if (!drv_datap || !drv_datap->drv_object) {
        status = -ENODATA;
        pr_err("%s: Failed to retrieve the object handle\n", __func__);
    } else {
        hdrv_obj = drv_datap->drv_object;
    }

    if (!status) {
        status = drv_get_dev_object(processor_id, hdrv_obj, &hdev_obj);
        if (!status) {
            status = dev_get_dev_type(hdev_obj, (u8 *) &dev_type);
            status = dev_get_dev_node(hdev_obj, &dev_node);
            if (dev_type != DSP_UNIT)
                status = -EPERM;

            if (!status)
                processor_info->processor_type = DSPTYPE64;
        }
    }
    if (status)
        goto func_end;

    /* Get The Manager Object from the driver data */
    if (drv_datap && drv_datap->mgr_object) {
        pmgr_obj = drv_datap->mgr_object;
    } else {
        dev_dbg(bridge, "%s: Failed to get MGR Object\n", __func__);
        goto func_end;
    }
    /* Forever loop till we hit no more items in the
     * Enumeration. We will exit the loop other than 0; */
    while (status1 == 0) {
        status1 = dcd_enumerate_object(temp_index++,
                           DSP_DCDPROCESSORTYPE,
                           &temp_uuid);
        if (status1 != 0)
            break;

        proc_index++;
        /* Get the Object properties to find the Device/Processor
         * Type */
        if (proc_detect != false)
            continue;

        status2 = dcd_get_object_def(pmgr_obj->dcd_mgr,
                         (struct dsp_uuid *)&temp_uuid,
                         DSP_DCDPROCESSORTYPE, &gen_obj);
        if (!status2) {
            /* Get the Obj def */
            if (processor_info_size <
                sizeof(struct mgr_processorextinfo)) {
                *processor_info = gen_obj.obj_data.proc_info;
            } else {
                /* extended info */
                ext_info = (struct mgr_processorextinfo *)
                    processor_info;
                *ext_info = gen_obj.obj_data.ext_proc_obj;
            }
            dev_dbg(bridge, "%s: Got proctype  from DCD %x\n",
                __func__, processor_info->processor_type);
            /* See if we got the needed processor */
            if (dev_type == DSP_UNIT) {
                if (processor_info->processor_type ==
                    DSPPROCTYPE_C64)
                    proc_detect = true;
            } else if (dev_type == IVA_UNIT) {
                if (processor_info->processor_type ==
                    IVAPROCTYPE_ARM7)
                    proc_detect = true;
            }
            /* User applications only check for chip type, so
             * this is a clumsy overwrite */
            processor_info->processor_type = DSPTYPE64;
        } else {
            dev_dbg(bridge, "%s: Failed to get DCD processor info "
                "%x\n", __func__, status2);
            status = -EPERM;
        }
    }
    *pu_num_procs = proc_index;
    if (proc_detect == false) {
        dev_dbg(bridge, "%s: Failed to get proc info from DCD, so use "
            "CFG registry\n", __func__);
        processor_info->processor_type = DSPTYPE64;
    }
func_end:
    return status;
}

/*
 *  ======== mgr_exit ========
 *      Decrement reference count, and free resources when reference count is
 *      0.
 */
void mgr_exit(void)
{
    refs--;
    if (refs == 0)
        dcd_exit();
}

/*
 *  ======== mgr_get_dcd_handle ========
 *      Retrieves the MGR handle. Accessor Function.
 */
int mgr_get_dcd_handle(struct mgr_object *mgr_handle,
                  u32 *dcd_handle)
{
    int status = -EPERM;
    struct mgr_object *pmgr_obj = (struct mgr_object *)mgr_handle;

    *dcd_handle = (u32) NULL;
    if (pmgr_obj) {
        *dcd_handle = (u32) pmgr_obj->dcd_mgr;
        status = 0;
    }

    return status;
}

/*
 *  ======== mgr_init ========
 *      Initialize MGR's private state, keeping a reference count on each call.
 */
bool mgr_init(void)
{
    bool ret = true;

    if (refs == 0)
        ret = dcd_init();   /*  DCD Module */

    if (ret)
        refs++;

    return ret;
}

/*
 *  ======== mgr_wait_for_bridge_events ========
 *      Block on any Bridge event(s)
 */
int mgr_wait_for_bridge_events(struct dsp_notification **anotifications,
                      u32 count, u32 *pu_index,
                      u32 utimeout)
{
    int status;
    struct sync_object *sync_events[MAX_EVENTS];
    u32 i;

    for (i = 0; i < count; i++)
        sync_events[i] = anotifications[i]->handle;

    status = sync_wait_on_multiple_events(sync_events, count, utimeout,
                          pu_index);

    return status;

}