sam-t2/sam/system/blaze/term.cc

// ========== Copyright Header Begin ==========================================
//
// OpenSPARC T2 Processor File: term.cc
// Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
//
// The above named program 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.
//
// The above named 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 work; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
//
// ========== Copyright Header End ============================================
/*
 * Copyright (C) 2001 Sun Microsystems, Inc.
 * All rights reserved.
 */
#pragma ident "@(#)1.16 07/11/19        term.cc"

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <assert.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <stropts.h>
#include <unistd.h>
#include <sys/wait.h>
#include <signal.h>

#include "types.h"
#include "blaze_globals.h"
#include "term.h"
// Needed for FlexConfig
#include "mmi.h"
#include "ui.h"
#include "serial_mod.h"

//extern FILE *serial_file;

extern serialInterface * systemConsole;
typedef void (*serial_send)(void *, char *, int );
static int portnum = -1;


struct term {
        bool_t initialized;
        int port_fd;
        int mport_fd;
        char *port_name;
        serial_send input;
        void * cbData;
        FILE *serial_output_file;
};

static struct term terms[NUM_PORTS];

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

static bool_t get_pty(char *name, int *sfd, int *mfd)
{
        if ((*mfd = open("/dev/ptmx", O_RDWR|O_NDELAY)) == -1) {
                ui->error("serial: Cannot find a pseudo tty.\n");
                return FALSE;
        }

        if (grantpt(*mfd) < 0) {
                ui->error("serial: Could not grant access to slave pseudo tty\n");
                ui->perror("grantpt");
                close(*mfd);
                return FALSE;
        }

        if (unlockpt(*mfd) < 0) {
                ui->error("serial: Unable to unlock pseudo tty.\n");
                ui->perror("unlockpt");
                close(*mfd);
                return FALSE;
        }

        strcpy(name, ptsname(*mfd));
        *sfd = open(name, O_RDWR);

        if (*sfd < 0) {
                ui->error("serial: Unable to open slave side for %d\n", *mfd);
                close(*mfd);
                return FALSE;
        }

        if (ioctl(*sfd, I_PUSH, "ptem") < 0) {
                ui->error("serial: Ioctl I_PUSH ptem failed\n");
                ui->perror("ioctl i_push ptem");
                close(*mfd);
                return FALSE;
        }

        if (ioctl(*sfd, I_PUSH, "ldterm") < 0) {
                ui->error("serial: Ioctl I_PUSH ldterm failed\n");
                ui->perror("ioctl i_push ldterm");
                close(*mfd);
                return FALSE;
        }

        return TRUE;
}

static int xterm_pid = -1;
int term_console (char *pty_dev, char *display)
{
    int pid = 0;

        if ((pid = vfork()) == 0) {
            execl("/usr/openwin/bin/xterm", "/usr/openwin/bin/xterm", "-display", display,
                  "-T", "blaze-sim-console", "-n", "blz-sim-con", "-sb", "-sl", "10000",
                  "-e", "/bin/tip", pty_dev, NULL);

            // shouldn't get here
            ui->perror("/usr/openwin/bin/xterm for blaze console");
            exit(1);
        }

        return xterm_pid = pid;
}

void term_console_destroy ()
{
      if (xterm_pid != -1) {
          ui->verbose("\nkilling console window (pid %d)\n", xterm_pid);
          kill(xterm_pid, 9);
          int deadpid = wait(NULL);
          ui->verbose("  done\n");
      }
}


int term_init(FILE *fp, serial_send fn, void *cbData,char **tty_name)
{
        char pty_name[20];

        portnum++;
        terms[portnum].initialized = FALSE;

        if (fp == NULL) {
                if (!get_pty(pty_name, &terms[portnum].port_fd,
                        &terms[portnum].mport_fd)) {
                        ui->error("TERM : get_pty failed\n");
                        return NULL;
                }

                chmod(pty_name,
                    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH |
                    S_IWOTH);
                terms[portnum].port_name = strdup(pty_name);
                terms[portnum].input = fn;
                terms[portnum].cbData = cbData;
                terms[portnum].initialized = TRUE;
                terms[portnum].serial_output_file = fp;
                *tty_name = strdup(pty_name);
        }
        else {
                terms[portnum].serial_output_file = fp;
                terms[portnum].port_name = NULL;
                terms[portnum].input = fn;
                terms[portnum].cbData = cbData;
                terms[portnum].initialized = TRUE;
                terms[portnum].mport_fd = -1;
                terms[portnum].port_fd = -1;
                *tty_name = strdup("Op redirected !!");
        }
        return portnum;
}

void term_write(unsigned char *c, int port)
{
        FILE *fp =  terms[port].serial_output_file;

        if (fp) {
                if(*c == 0xd || *c == '\0')
                        return;
                putc(*c, fp);
                term_redirect_add (c[0]);
                fflush(fp);
        } else {
                write(terms[port].mport_fd, c, 1);
                term_redirect_add (c[0]) ;
        }
}

static void term_read_ports(fd_set readfds)
{
        int i;
        char chstr[2];

        for (i = 0; i < NUM_PORTS; i++) {
                if (FD_ISSET(terms[i].mport_fd, &readfds)) {
                    int nbytes;
                    uint8_t ch;

                    while ((nbytes = read(terms[i].mport_fd, &ch, 1)) == 1) {
                          sprintf(chstr,"%c", ch);
                           terms[i].input(terms[i].cbData,chstr,i);
                    }
                }
        }
}

void term_fake_input (uint8_t *cmd, int l, int port)
{
    systemConsole->chars_send((char *)cmd, systemConsole->portH);
}


extern volatile bool config_is_done;
// volatile is needed, otherwise the compiler eliminates the
// while loop as dead-code for opt version

void term_thread(void *)
{
        int i, n;
        fd_set readfds;

        // spin loop until the sysconf modules are loaded and initialized
        // not doing this results in a race condition where the select call is
        // made before the terms[i] struct is initialzed. The effect is, no
        // console input possible.
        // the variable config_is_done is set to true after the init_done() has
        // been called for all the sysconf modules.
        // better approaches are possible but would need to much work and cleanup.
        // untill later....
        while(!config_is_done);

        for (;;) {
                FD_ZERO(&readfds);

                for (i = 0; i <= portnum; i++) {
                        if (terms[i].initialized && terms[i].mport_fd != -1) {
                                FD_SET(terms[i].mport_fd, &readfds);
                        }
                }

                n = select(FD_SETSIZE, &readfds, (fd_set *)NULL,
                    (fd_set *)NULL, NULL);

                switch (n) {
                case -1: /* error */
                        break;
                case 0: /* timeout */
                        break;
                default: /* input available */
                        term_read_ports(readfds);
                        break;
                }
        }
}