Subversion Repositories funbase_ip_library

/*

 * Copyright (c) 2010, Mentor Graphics Corporation

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

#include <mcapi.h>

#include "../shm.h"

#include "../shm_os.h"

#include <stdio.h>

#include <fcntl.h>

#include <errno.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/mman.h>

#include <sys/ioctl.h>

typedef uint32_t mcomm_core_t;

typedef uint32_t mcomm_mbox_t;

/* Specify the layout of the mailboxes in shared memory */

#define MCOMM_INIT       _IOW('*', 0, struct mcomm_init_device)

/* All values in bytes */

struct mcomm_init_device {

    mcomm_mbox_t nr_mboxes;

    uint32_t offset; /* Offset from base of shared memory to first mailbox */

    uint32_t mbox_size;

    uint32_t mbox_stride; /* Offset from mailbox N to mailbox N+1 */

};

/* Get hardware-defined number for the current core */

#define MCOMM_CPUID      _IOR('*', 1, mcomm_core_t)

/* Block until data is available for specified mailbox */

#define MCOMM_WAIT_READ  _IOW('*', 2, mcomm_mbox_t)

/* Notify the specified core that data has been made available to it */

#define MCOMM_NOTIFY     _IOW('*', 3, mcomm_core_t)

static pthread_t shm_rx_thread;

/* XXX must close mcomm_fd somewhere */

static int mcomm_fd;

static size_t shm_bytes;

#define MCOMM_DEVICE "/dev/mcomm0"

static size_t shm_linux_read_size(void)

{

    unsigned long size;

    FILE *f;

    int rc;

    f = fopen("/sys/devices/platform/mcomm.0/size", "r");

    if (!f)

        f = fopen("/sys/devices/mcomm.0/size", "r");

    if (!f)

        return errno;

    rc = fscanf(f, "%lx", &size);

    if (rc < 0)

        size = errno;

    fclose(f);

    return size;

}

mcapi_status_t openmcapi_shm_notify(mcapi_uint32_t unit_id,

                                    mcapi_uint32_t node_id)

{

    mcapi_status_t mcapi_status = MCAPI_SUCCESS;

    int rc;

    rc = ioctl(mcomm_fd, MCOMM_NOTIFY, &unit_id);

    if (rc)

        mcapi_status = MCAPI_OS_ERROR;

    return mcapi_status;

}

mcapi_uint32_t openmcapi_shm_schedunitid(void)

{

    mcapi_uint32_t core_id;

    int rc;

    rc = ioctl(mcomm_fd, MCOMM_CPUID, &core_id);

    if (rc)

        return MCAPI_OS_ERROR;

    return core_id;

}

static int shm_linux_wait_notify(mcapi_uint32_t unitId)

{

    return ioctl(mcomm_fd, MCOMM_WAIT_READ, &unitId);

}

static int shm_linux_init_device(int fd)

{

    struct mcomm_init_device args;

    struct _shm_drv_mgmt_struct_ *mgmt = NULL;

    args.nr_mboxes = CONFIG_SHM_NR_NODES;

    args.offset = (unsigned int)&mgmt->shm_queues[0].count;

    args.mbox_size = sizeof(mgmt->shm_queues[0].count);

    args.mbox_stride = (void *)&mgmt->shm_queues[1].count -

                       (void *)&mgmt->shm_queues[0].count;

    return ioctl(fd, MCOMM_INIT, &args);

}

void *openmcapi_shm_map(void)

{

    void *shm;

    int fd;

    int rc;

    shm_bytes = shm_linux_read_size();

    if (shm_bytes <= 0) {

        perror("read shared memory size");

        return NULL;

    }

    fd = open(MCOMM_DEVICE, O_RDWR);

    if (fd < 0) {

        perror("open " MCOMM_DEVICE);

        goto out1;

    }

    /* Get the new file descriptor for the initialized device. */

    rc = shm_linux_init_device(fd);

    if (rc < 0) {

        perror("couldn't initialize device");

        goto out2;

    }

    mcomm_fd = rc;

    shm = mmap(NULL, shm_bytes, PROT_READ|PROT_WRITE, MAP_SHARED, mcomm_fd, 0);

    if (shm == MAP_FAILED) {

        perror("mmap shared memory");

        goto out3;

    }

    /* Don't need the original fd around any more. */

    close(fd);

    return shm;

out3:

    close(mcomm_fd);

out2:

    close(fd);

out1:

    return NULL;

}

/* pthread cancellation is tricky.

 *

 * First, we need to ensure that if we're blocked in the kernel (ioctl),

 * pthread_cancel must send us a signal so we return to userspace to handle it.

 * This is accomplished with PTHREAD_CANCEL_ASYNCHRONOUS, without which glibc

 * would set some state and then happily wait for us to hit the next

 * cancellation point (see pthreads(7)). However, we wouldn't, because we'd

 * never wake from the kernel.

 *

 * Second, pthread_cancel() could be called any time outside the

 * PTHREAD_CANCEL_ASYNCHRONOUS section. Since we don't necessarily have any

 * cancellation points inside the loop (including the shm_poll() path), we must

 * manually check by calling pthread_testcancel().

 */

static void *mcapi_receive_thread(void *data)

{

    int rc;

    int canceltype;

    do {

        /* Manually check if we're already dead. */

        pthread_testcancel();

        /* Block until data for this node is available or we are canceled with

         * a signal. */

        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &canceltype);

        rc = shm_linux_wait_notify(MCAPI_Node_ID);

        if (rc < 0) {

            perror("wait ioctl");

            break;

        }

        pthread_setcanceltype(canceltype, NULL);

        /* Obtain lock so we can safely manipulate the RX_Queue. */

        MCAPI_Lock_RX_Queue();

        /* Process the incoming data. */

        shm_poll();

        MCAPI_Unlock_RX_Queue(0);

    } while (1);

    printf("%s exiting!\n", __func__);

    return NULL;

}

/* Now that SM_Mgmt_Blk has been initialized, we can start the RX thread. */

mcapi_status_t openmcapi_shm_os_init(void)

{

    mcapi_status_t mcapi_status = MCAPI_SUCCESS;

    int rc;

    rc = pthread_create(&shm_rx_thread, NULL, mcapi_receive_thread, NULL);

    if (rc) {

        perror("couldn't create pthread");

        mcapi_status = MCAPI_OS_ERROR;

    }

    return mcapi_status;

}

/* Finalize the SM driver OS specific layer. */

mcapi_status_t openmcapi_shm_os_finalize(void)

{

    mcapi_status_t mcapi_status = MCAPI_SUCCESS;

    int rc;

    rc = pthread_cancel(shm_rx_thread);

    if (rc) {

        perror("couldn't cancel thread");

        mcapi_status = MCAPI_OS_ERROR;

    }

    /* Don't return until it's dead. */

    rc = pthread_join(shm_rx_thread, NULL);

    if (rc) {

        perror("couldn't joined canceled thread");

        mcapi_status = MCAPI_OS_ERROR;

    }

    return mcapi_status;

}

void openmcapi_shm_unmap(void *shm)

{

    munmap(shm, shm_bytes);

    close(mcomm_fd);

}