Subversion Repositories or1k

/* channel.h -- Definition of types and structures for

   peripheral to communicate with host.  Addapted from UML.

   Copyright (C) 2002 Richard Prescott <rip@step.polymtl.ca>

This file is part of OpenRISC 1000 Architectural Simulator.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */

#define _GNU_SOURCE     /* for strndup */

#include <stdio.h>      /* perror */

#include <stdlib.h>     /* exit */

#include <malloc.h>     /* calloc, free */

#include <string.h>     /* strndup, strcmp, strlen, strchr */

#include <errno.h>      /* errno */

#include "channel.h"

struct channel_factory

{

        const char * name;

        const struct channel_ops * ops;

        struct channel_factory * next;

};

extern struct channel_ops fd_channel_ops, file_channel_ops, xterm_channel_ops;

static struct channel_factory preloaded[] =

{

        { "fd",     &fd_channel_ops,     &preloaded[1] },

        { "file",   &file_channel_ops,   &preloaded[2] },

        { "xterm",  &xterm_channel_ops,  NULL          }

};

static struct channel_factory * head = &preloaded[0];

static struct channel_factory * find_channel_factory(const char * name);

struct channel * channel_init(const char * descriptor)

{

        struct channel * retval;

        struct channel_factory * current;

        char * args, * name;

        int count;

        if(!descriptor)

        {

                return NULL;

        }

        retval = (struct channel*)calloc(1, sizeof(struct channel));

        if(!retval)

        {

                perror(descriptor);

                exit(1);

        }

        args = strchr(descriptor, ':');

        if(args)

        {

                count = args - descriptor;

                args++;

        }

        else

        {

                count = strlen(descriptor);

        }

        name = (char*)strndup(descriptor, count);

        if(!name)

        {

                perror(name);

                exit(1);

        }

        current = find_channel_factory(name);

        if(!current)

        {

                errno = ENODEV;

                perror(descriptor);

                exit(1);

        }

        retval->ops = current->ops;

        free(name);

        if(!retval->ops)

        {

                errno = ENODEV;

                perror(descriptor);

                exit(1);

        }

        if(retval->ops->init)

        {

                retval->data = (retval->ops->init)(args);

                if(!retval->data)

                {

                        perror(descriptor);

                        exit(1);

                }

        }

        return retval;

}

int channel_open(struct channel * channel)

{

        if(channel && channel->ops && channel->ops->open)

        {

                return (channel->ops->open)(channel->data);

        }

        errno = ENOSYS;

        return -1;

}

int channel_read(struct channel * channel, char * buffer, int size)

{

        if(channel && channel->ops && channel->ops->read)

        {

                return (channel->ops->read)(channel->data, buffer, size);

        }

        errno = ENOSYS;

        return -1;

}

int channel_write(struct channel * channel, const char * buffer, int size)

{

        if(channel && channel->ops && channel->ops->write)

        {

                return (channel->ops->write)(channel->data, buffer, size);

        }

        errno = ENOSYS;

        return -1;

}

void channel_close(struct channel * channel)

{

        if(channel && channel->ops && channel->ops->close)

        {

                (channel->ops->close)(channel->data);

        }

}

void channel_free(struct channel * channel)

{

        if(channel && channel->ops && channel->ops->close)

        {

                (channel->ops->free)(channel->data);

                free(channel);

        }

}

int channel_ok(struct channel * channel)

{

        if(channel && channel->ops)

        {

                if(channel->ops->isok)

                        return (channel->ops->isok)(channel->data);

                else

                        return 1;

        }

        return 0;

}

char * channel_status(struct channel * channel)

{

        if(channel && channel->ops && channel->ops->status)

        {

                return (channel->ops->status)(channel->data);

        }

        return "";

}

static struct channel_factory * find_channel_factory(const char * name)

{

        struct channel_factory * current = head;

        current = head;

        while(current && strcmp(current->name, name))

        {

                current = current->next;

        }

        return current;

}

int register_channel(const char * name, const struct channel_ops * ops)

{

        struct channel_factory * new;

        if(find_channel_factory(name))

        {

                errno = EEXIST;

                perror(name);

                exit(1);

        }

        new = (struct channel_factory *)calloc(1, sizeof(struct channel_factory));

        if(!new)

        {

                perror(name);

                exit(1);

        }

        new->name = name;

        new->ops  = ops;

        new->next = head;

        head = new;

        return (int)new;        /* dummy */

}

/*

 * Local variables:

 * c-file-style: "linux"

 * End:

 */