Subversion Repositories s6soc

////////////////////////////////////////////////////////////////////////////////

//

// Filename:    syspipe.c

//

// Project:     CMod S6 System on a Chip, ZipCPU demonstration project

//

// Purpose:     This "device" handles the primary device level interaction of

//              almost all devices on the ZipOS: the pipe.  A pipe, as defined

//      here, is an O/S supported FIFO.  Information written to the FIFO will

//      be read from the FIFO in the order it was received.  Attempts to read

//      from an empty FIFO, or equivalently to write to a full FIFO, will block

//      the reading (writing) process until memory is available.

//

// Creator:     Dan Gisselquist, Ph.D.

//              Gisselquist Technology, LLC

//

////////////////////////////////////////////////////////////////////////////////

//

// Copyright (C) 2015-2016, Gisselquist Technology, LLC

//

// This program is free software (firmware): 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 3 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 MERCHANTIBILITY 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.  (It's in the $(ROOT)/doc directory, run make with no

// target there if the PDF file isn't present.)  If not, see

// <http://www.gnu.org/licenses/> for a copy.

//

// License:     GPL, v3, as defined and found on www.gnu.org,

//              http://www.gnu.org/licenses/gpl.html

//

//

////////////////////////////////////////////////////////////////////////////////

//

//

#include "errno.h"

#include "board.h"

#include "taskp.h"

#include "syspipe.h"

#include "zipsys.h"

#include "ktraps.h"

#include "string.h"

#ifndef NULL

#define NULL    (void *)0

#endif

void    kpush_syspipe(SYSPIPE *pipe, char val) {

        int     tst = (pipe->m_head+1)&pipe->m_mask;

        if (tst != pipe->m_tail) {

                pipe->m_buf[pipe->m_head] = val;

                pipe->m_head = tst;             // Increment the head pointer

                if ((pipe->m_rdtask)&&(pipe->m_rdtask != INTERRUPT_READ_TASK))

                        pipe->m_rdtask->state = SCHED_READY;

        } else pipe->m_error = 1;

}

extern  void    pipe_panic(SYSPIPE *p);

/*

 * kpop_syspipe

 *

 * Called from an interrupt context to pop one byte off of the syspipe.

 */

int     kpop_syspipe(SYSPIPE *pipe, char *vl) {

        if (pipe->m_head != pipe->m_tail) {

                // The head will *only* equal the tail if the pipe is empty.

                // We come in here, therefore, if the pipe is non-empty

                *vl = pipe->m_buf[pipe->m_tail];

                pipe->m_tail = (pipe->m_tail+1)&pipe->m_mask;

                if (pipe->m_wrtask)

                        pipe->m_wrtask->state = SCHED_READY;

                return 0;

        }

        return 1; // Error condition

}

/*

 * kpop_short_syspipe

 *

 * This is identical to kpop_syspipe, save that we are pulling a short value

 * off of the syspipe (i.e. a pair of chars), not just a single char.

 */

int     kpop_short_syspipe(SYSPIPE *pipe, unsigned short *vl) {

        if (pipe->m_head == pipe->m_tail)

                return 1; // Error condition

        unsigned short *sptr = (unsigned short *)&pipe->m_buf[pipe->m_tail];

        // sv = pipe->m_buf[pipe->m_tail];

        *vl = *sptr;;

        pipe->m_tail = (pipe->m_tail+2)&pipe->m_mask;

        if (pipe->m_wrtask)

                pipe->m_wrtask->state = SCHED_READY;

        return 0;

}

/*

int     len_syspipe(SYSPIPE *p) {

        return (p->m_head-p->m_tail) & p->m_mask;

} */

/* Returns how many empty spaces are in the pipe

 */

int     num_avail_syspipe(SYSPIPE *p) {

        // if (head+1 == tail)  PIPE is full

        //      (mask+tail-tail+1)=mask+1 &mask = 0

        // if (head == tail) PIPE is empty

        //      (mask+tail-tail)=mask & mask = mask

        // if (head == tail+2) PIPE has two within it

        //      (mask+tail-tail-2)=mask-2 & mask = mask-2

        //

        return (p->m_tail-p->m_head-1) & p->m_mask;

}

// This will be called from a user context.

// Another task may write to the pipe during this call.  If the pipe becomes

// full, that task will block.

//

static int uread_syspipe(TASKP tsk __attribute__((__unused__)),

                SYSPIPE *p, char *dst, int len) {

        int nleft= len, h;

        if (len == 0) {

                // We'll only get here if we were released from within a 

                // writing task.

                return p->m_nread;

        } else do {

                // We have a valid read request, for a new process.  Continue

                // 'reading' until we have fulfilled the request.

                //

                // We can read from head, just not write to it

                // As for the tail pointer -- we own it, no one else can touch

                // it.

                h = ((volatile SYSPIPE *)p)->m_head;

                if (h < p->m_tail) {

                        // The buffer wraps around the end.  Thus, we first

                        // read anything between the tail pointer and the end

                        int ln1 = p->m_mask+1 - p->m_tail; // Navail to be read

                        ln1 = (ln1 > nleft) ? nleft : ln1;

                        if (ln1 > 0) {

                                memcpy(dst, &p->m_buf[p->m_tail], ln1);

                                dst += ln1;

                                p->m_nread += ln1;

                                nleft -= ln1;

                                int nt = p->m_tail+ln1;

                                if ((unsigned)nt > p->m_mask)

                                        nt = 0;

                                p->m_tail = nt;

                        }

                        // nleft is either zero, or tail

                        if (nleft & -2)

                                exit(nleft);

                        else if (p->m_nread & -2)

                                exit(p->m_nread);

                }

                // Then repeat with the second half of the buffer, from the

                // beginning to the head--unless we've exhausted our buffer.

                if (nleft > 0) {

                        // Still need to do more, wrap around our buffer and

                        // restart

                        int ln1 = h - p->m_tail;

                        ln1 = (ln1 < nleft) ? ln1 : nleft;

                        memcpy(dst, &p->m_buf[p->m_tail], ln1);

                        dst += ln1;

                        p->m_nread += ln1;

                        nleft -= ln1;

                        int nt = p->m_tail+ln1; // nt = new tail value

                        if ((unsigned)nt > p->m_mask)

                                nt = 0;

                        p->m_tail = nt;

                        if (nleft & -2)

                                exit(nleft);

                        else if (p->m_nread & -2)

                                exit(p->m_nread);

                }

                if (nleft == 0)

                        break;

                // We didn't finish our read, check for a blocked writing

                // process to copy directly from.  Note that we don't need

                // to check the status of the write task--if it is set and

                // we are active, then it is blocked and waiting for us to

                // complete.  Note also that this is treated as a volatile

                // pointer.  It can change from one time through our loop

                // to the next.

                if (((volatile SYSPIPE *)p)->m_wrtask) {

                        int     ln;

                        char    *src;

                        // If the head changed before the write task blocked,

                        // then go around again and copy some more before

                        // getting started

                        //

                        // This should never happen, however.  If a write task

                        // gets assigned while a read task exists, it doesn't

                        // write its values into the buffer, it just waits.

                        // therefore we don't need to check for this.

                        //

                        // if (p->m_head != h)

                        //      continue;

                        ln = nleft;

                        if (p->m_wrtask->context[4] < nleft)

                                ln = p->m_wrtask->context[4];

                        src = (char *)p->m_wrtask->context[3];

                        memcpy(dst, src, ln);

                        dst += ln;

                        src += ln;

                        p->m_nwritten += ln;

                        p->m_nread    += ln;

                        nleft -= ln;

                        p->m_wrtask->context[4] -= ln;

                        p->m_wrtask->context[3]  = (int)src;

                        // We have exhausted the write task.  Release it

                        if (p->m_wrtask->context[4] == 0) { // wr_len == 0

                                // Release the write task, it has exhausted

                                // its buffer

                                TASKP   w = p->m_wrtask;

                                // Now we allow other tasks to write into our

                                // pipe

                                p->m_wrtask = 0;

                                // And here we actually release the writing

                                // task

                                w->state = SCHED_READY;

                        }

                }

                // Realistically, we need to block here 'till more data is

                // available.  Need to determine how to do that.  Until then,

                // we'll just tell the scheduler to yield.  This will in

                // effect create a busy wait--not what we want, but it'll work.

                if (nleft > 0) {

                        DISABLE_INTS();

                        h = ((volatile SYSPIPE *)p)->m_head;

                        if (h == p->m_tail)

                                wait(0,-1);

                        else

                                ENABLE_INTS();

                }

        } while(nleft > 0);

        len = p->m_nread;

        p->m_nread = 0;

        // Release our ownership of the read end of the pipe

        DISABLE_INTS();

        p->m_rdtask = NULL;

        if (((volatile SYSPIPE *)p)->m_wrtask)

                p->m_wrtask->state = SCHED_READY;

        ENABLE_INTS();

        // We have accomplished our read

        //

        return len;

}

static int      uwrite_syspipe(TASKP tsk __attribute__((__unused__)),

                SYSPIPE *p, char *src, int len) {

        int nleft = len;

        // The kernel guarantees, before we come into here, that we have a 

        // valid write request.  

        do {

                // We try to fill this request without going through the pipes

                // memory at all.  Hence, if there is a read task that is

                // waiting/suspended, waiting on a write (this must've happened

                // since we started)--write directly into the read buffer first.

                // If there is a read task blocked, the pipe must be empty

                TASKP rdtask = ((volatile SYSPIPE *)p)->m_rdtask;

                if (rdtask == INTERRUPT_READ_TASK) {

                        // We need to copy everything to the buffer

                } else if (rdtask) {

                        int ln = nleft;

                        if (ln > p->m_rdtask->context[4])

                                ln = p->m_rdtask->context[4];

                        memcpy((char *)p->m_rdtask->context[3], src, ln);

                        src += ln;

                        p->m_nread += ln;

                        p->m_rdtask->context[3]+= ln;

                        p->m_rdtask->context[4]-= ln;

                        nleft -= ln;

                        p->m_nwritten += ln;

                        // Realistically, we always need to wake up the reader

                        // at this point.  Either 1) we exhausted the readers

                        // buffer, or 2) we exhausted our own and the reader

                        // needs to take over.  Here, we only handle the first

                        // case, leaving the rest for later.

                        if (p->m_rdtask->context[4] == 0) {

                                TASKP   r = p->m_rdtask;

                                // Detach the reader task

                                p->m_rdtask = 0;

                                // Wake up the reader

                                r->state = SCHED_READY;

                        }

                        // While it might appear that we might close our loop

                        // here, that's not quite the case.  It may be that the

                        // pipe is read from an interrupt context.  In that

                        // case, there will never be any reader tasks, but we

                        // will still need to loop.

                        // Now that we've filled any existing reader task, we

                        // check whether or not we fit into the buffer.  The

                        // rule is: don't write into the buffer unless

                        // everything will fit.  Why?  Well, if you have to

                        // block anyway, why not see if you can't avoid a

                        // double copy?

                        if (nleft == 0)

                                break;

                }

                // Copy whatever we have into the pipe's buffer

                int     navail = num_avail_syspipe(p);

                if ((nleft <= navail)

                        ||((rdtask == INTERRUPT_READ_TASK)&&(navail>0))) {

                        // Either there is no immediate reader task, or

                        // the reader has been exhausted, but we've go

                        // more to write.

                        //

                        // Note that we no longer need to check what

                        // will fit into the pipe.  We know the entire

                        // rest of our buffer will fit.

                        { // Write into the first half of the pipe

                        // Be careful not to change head until all is written

                        // so that it remains consistent under interrupt

                        // conditions.

                                int ln = p->m_mask+1-p->m_head;

                                if (ln > nleft) ln = nleft;

                                if (ln > navail) ln = navail;

                                memcpy((void *)&p->m_buf[p->m_head], src, ln);

                                src += ln;

                                p->m_head = (p->m_head+ln)&p->m_mask;

                                nleft           -= ln;

                                p->m_nwritten   += ln;

                                navail          -= ln;

                        }

                }

                if ((nleft > 0)&&(navail == 0)) {

                        if (rdtask == INTERRUPT_READ_TASK) {

                                DISABLE_INTS();

                                if (0==num_avail_syspipe(p))

                                        wait(0,-1);

                                else ENABLE_INTS();

                        } else {

                                DISABLE_INTS();

                                if (!((volatile SYSPIPE *)p)->m_rdtask)

                                        wait(0,-1); // Should really be a wait

                                        // on JIFFIES and if JIFFIES expired

                                        // (i.e. write timeout) then break;

                                else ENABLE_INTS();

                        }

                }

        } while(nleft > 0);

        int     nw= p->m_nwritten;

        p->m_wrtask = 0;

        return nw;

}

// This will be called from a kernel (interrupt) context

void    kread_syspipe(TASKP tsk, int dev, char *dst, int len) {

        SYSPIPE *p = (SYSPIPE *)dev;

        if (p->m_rdtask != NULL) {

                // If the pipe already has a read task, then we fail

                tsk->context[1] = -EBUSY;

                zip_halt();

        } else if (p->m_error) {

                // If there's been an overrun, let the reader know on the

                // next read--i.e. this one.  Also, clear the error condition

                // so that the following read will succeed.

                tsk->context[1] = -EIO;

                p->m_tail = p->m_head;

                p->m_error = 0;

        } else if (len <= 0) {

                tsk->context[1] = -EFAULT;

                zip_halt();

        } else if (!valid_ram_region(dst, len)) {

                // Bad parameters

                tsk->context[1] = -EFAULT;

                zip_halt();

        } else {

                // Take  ownership of the read end of the pipe

                p->m_rdtask = tsk;

                p->m_nread  = 0;

                tsk->context[1] = (int)tsk;

                tsk->context[2] = (int)p;

                // These are  already set, else we'd set them again

                // tsk->context[3] = (int)dst;

                // tsk->context[4] = len;

                tsk->context[15] = (int)uread_syspipe;

                // If there is already a write task, make sure it is awake

                if (p->m_wrtask) {

                        tsk->state = SCHED_WAITING;

                        p->m_wrtask->state = SCHED_READY;

                } else if (p->m_head == p->m_tail)

                        // If the pipe is empty, block the read task

                        tsk->state = SCHED_WAITING;

                // On return, this will bring us back to user space, inside our

                // user space version of the read system call

        }

}

void    kwrite_syspipe(TASKP tsk, int dev, char *src, int len) {

        SYSPIPE *p = (SYSPIPE *)dev;

        if (p->m_wrtask != NULL) {

                // If the pipe already has a write task, then we fail

                tsk->context[1] = -EBUSY;

        } else if (len <= 0) {

                tsk->context[1] = -EFAULT;

        } else if (!valid_mem_region(src, len)) {

                // Bad parameters

                tsk->context[1] = -EFAULT;

                zip_halt();

        } else {

                // Take  ownership of the write end of the pipe

                p->m_wrtask    = tsk;

                p->m_nwritten = 0;

                tsk->context[1] = (int)tsk;

                tsk->context[2] = (int)p;

                // These are  already set, else we'd set them again

                // tsk->context[3] = (int)src;

                // tsk->context[4] = len;

                tsk->context[15] = (int)uwrite_syspipe;

                // If a reader task currently exists, then block until that

                // task either finishes or releases us

                if ((p->m_rdtask)&&(p->m_rdtask != INTERRUPT_READ_TASK)) {

                        tsk->state = SCHED_WAITING;

                        p->m_rdtask->state = SCHED_READY;

                } else if (((p->m_head+1)&p->m_mask) == (unsigned)p->m_tail)

                        // If the pipe is empty, block until there's data

                        tsk->state = SCHED_WAITING;

                // On return, this will bring us back to user space, in our

                // user space write call

        }

}