Subversion Repositories igor

#include <stdlib.h>

#include "device.h"

//#include "global.h"

#include "req.h"

//#include "dev/7seg.h"

#if 0

static uint8_t req_exists(struct igordev *, uint8_t, uint8_t, uint32_t,

    req_fn_t *);

#endif

static uint8_t  increqptr(uint8_t);

/*

 * Initialize an rqueue.

 */

void

rqueue_init(struct rqueue *rq)

{

        struct req *req;

        uint8_t i;

        for (i = 0 ; i < MAXREQ; i++) {

                req = &rq->queue[i];

                req->dev = NULL;

                req->type = 0;

                req->flags = 0;

                req->devnum = 0xFF;

                req->func = NULL;

        }

        rq->off_read = 0;

        rq->off_write = 0;

        rq->wcount = 0;

        rq->rcount = 0;

        rq->status = RQUEUE_STATUS_EMPTY;

}

/* Allocate space for new request, if possible. */

int8_t

req_alloc(struct rqueue *rq, struct igordev *dev, uint8_t type, uint8_t flags,

    uint32_t devnum, req_fn_t *func)

{

        struct req *req;

        if (rqueue_unused(rq) == 0) {

                rq->status |= RQUEUE_STATUS_FULL;

                return (-1);

        }

        req = &rq->queue[rq->off_write];

        req->dev = dev;

        req->type = type;

        req->flags = flags;

        req->devnum = devnum;

        req->func = func;

        rq->off_write = increqptr(rq->off_write);

        rq->wcount++;

        rq->status &= ~RQUEUE_STATUS_EMPTY;

        return (0);

}

/* Just peak at the next element. */

struct req *

req_peak(struct rqueue *rq)

{

        struct req *req;

        if (rqueue_used(rq) == 0) {

                rq->status |= RQUEUE_STATUS_EMPTY;

                return (NULL);

        }

        req = &rq->queue[rq->off_read];

        return (req);

}

/* Free the next element. */

int8_t

req_free(struct rqueue *rq)

{

        struct req *req;

        if (rqueue_used(rq) == 0) {

                rq->status |= RQUEUE_STATUS_EMPTY;

                return (-1);

        }

        /* Initialize struct again. */

        req = &rq->queue[rq->off_read];

        req->dev = NULL;

        req->type = 0;

        req->flags = 0;

        req->devnum = 0xFF;

        req->func = NULL;

        rq->off_read = increqptr(rq->off_read);

        rq->rcount++;

        rq->status &= ~RQUEUE_STATUS_FULL;

        return (0);

}

/* Calculate number of allocations done. */

uint8_t

rqueue_used(struct rqueue *rq)

{

        return (rq->wcount > rq->rcount ?

            rq->wcount - rq->rcount :

            rq->rcount - rq->wcount);

}

/* Calculate the number of allocations left */

uint8_t

rqueue_unused(struct rqueue *rq)

{

        return (MAXREQ - rqueue_used(rq));

}

static uint8_t

increqptr(uint8_t val)

{

        return ((val + 1) % MAXREQ);

}

#if 0

/*

 * Check if a request of the same type have already been allocated.

 */

static uint8_t

req_exists(struct igordev *dev, uint8_t type, uint8_t flags, uint32_t devnum,

    req_fn_t *func)

{

        volatile struct req *nreq;

        int8_t i;

        /*

         * XXX: This should perhaps check the queue, but since the taken field

         * in principle marks the request to be executed, we use that as a

         * requirement for an active request

         */

        for (i = 0; i < MAXREQ; i++) {

                if (reqpool[i].taken) {

                        nreq = &reqpool[i];

                        /* It is the same. */

                        if (nreq->dev == dev && nreq->type == type &&

                            nreq->flags == flags && nreq->func == func &&

                            nreq->devnum == devnum) {

                                return (1);

                        }

                }

                display_char(i);

                _delay_ms(50);

        }

        return (0);

}

volatile struct req *

req_make(struct igordev *dev, uint8_t type, uint8_t flags, uint32_t devnum,

    req_fn_t *func)

{

        volatile struct req *nreq;

        /* Do not make a request if it already exists in the pool. */

        if (req_exists(dev, type, flags, devnum, func)) {

                display_char(8);

                _delay_ms(1000);

                return (NULL);

        }

        nreq = req_alloc();

        if ( nreq == NULL) {

                display_char(3);

                _delay_ms(1000);

                return (NULL);

        }

        nreq->dev = dev;

        nreq->type = type;

        nreq->flags = flags;

        nreq->func = func;

        nreq->devnum = devnum;

        return (nreq);

}

#endif