Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / dev / serial / src / SS_Serial.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: SS_Serial.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 ============================================

#include "SS_Serial.h"
#include <sys/socket.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>

SS_Serial::SS_Serial( SS_AddressMap* map, SS_Paddr lo, SS_Paddr hi )/*{{{*/
:
 line_status(LINE_TX_EMPTY | LINE_TX_HOLD),
 buffer_len(0),
 buffer_ptr(0),
 serial_rd(0),
 serial_wr(0)
{
 map->add(lo,hi,this,SS_AddressMap::REL,SS_Serial::access);
}
/*}}}*/
SS_Serial::~SS_Serial()/*{{{*/
{
 if (serial_rd)
   close(serial_rd);
 if (serial_wr)
   close(serial_wr);
}
/*}}}*/

int SS_Serial::connect( const char* term )/*{{{*/
{
 char command[1024];
 char hostname[256];
 struct sockaddr_in server, client;
 int client_size = sizeof(client);
 int fd, on;

 if ((fd = socket(AF_INET,SOCK_STREAM,0)) < 0)
   return 1;
 
 if (setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(uint8_t*)&on,sizeof(on)) < 0) 
   return 2;

 server.sin_family      = AF_INET;
 server.sin_addr.s_addr = INADDR_ANY;
 server.sin_port        = htons(0);

 while (bind(fd,(struct sockaddr*)&server,sizeof(server)) < 0) 
   if (errno != EAGAIN)
     return 3;

 int length = sizeof(server);
 if (getsockname(fd,(struct sockaddr*)&server,&length) == -1)
   return 4;

 listen(fd,1);

 gethostname(hostname,256);
 sprintf(command,term,hostname,ntohs(server.sin_port));
 system(command);

 if ((serial_rd = accept(fd,(struct sockaddr*)&client,&client_size)) < 0)
   return 5;

 // Put the accepted socket in non-blocking mode

 int fl = fcntl(serial_rd,F_GETFL);
 if (fl < 0)
   return 6;
 if (fcntl(serial_rd,F_SETFL,fl|O_NONBLOCK) < 0)
   return 6;

 serial_wr = dup(serial_rd);

 close(fd);

 return 0;
}
/*}}}*/
int SS_Serial::file_io( const char* input, const char* output )/*{{{*/
{
 mode_t mode = S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP;
 int    flag = O_WRONLY|O_CREAT|O_TRUNC;

 if ((serial_wr = open(output,flag,mode)) < 0)
   return serial_wr;

 if ((serial_rd = open(input,O_RDONLY)) < 0)
   return serial_rd;

 return 0;
}
/*}}}*/

void SS_Serial::access( void* obj, uint_t sid, SS_Access::Type type, SS_Paddr pa, uint_t size, uint64_t* data )/*{{{*/
{
 SS_Serial* self = (SS_Serial*)obj;

 switch (type)
 {
   case SS_Access::LOAD:
     if (size != 1)
     {
       *data = 0;
       return;
     }
     switch(pa)
     {
       case INPUT:
         if (self->buffer_len)
         {
           *data = self->buffer[self->buffer_ptr++];
           self->buffer_len--;
         }
         else
         {
           *data = 0;
         }
         if (self->buffer_len == 0)
         {
           int n = read(self->serial_rd,self->buffer,BUFFER_SIZE);
           self->buffer_len = (n > 0) ? n : 0;
           self->buffer_ptr = 0;
         }
         if (self->buffer_len)
           self->line_status |= LINE_DATA_READY;
         else
           self->line_status &= ~LINE_DATA_READY;
         break;

       case LINE_STATUS:
         if (self->buffer_len == 0)
         {
           int n = read(self->serial_rd,self->buffer,BUFFER_SIZE);
           self->buffer_len = (n > 0) ? n : 0;
           self->buffer_ptr = 0;
         }
         if (self->buffer_len)
           self->line_status |= LINE_DATA_READY;
         *data = self->line_status;
         break;

       default:
         *data = 0;
         break;
     }
     break;

   case SS_Access::STORE:
     if (size != 1)
       return;

     switch (pa)
     {
       case OUTPUT:
       {
         char c = *data;
         write(self->serial_wr,&c,1);
         break;
       } 
       case LINE_STATUS:
         self->line_status = *data | LINE_TX_EMPTY | LINE_TX_HOLD;
         break;

       default:
         break;
     }
     break;

   default:
     fprintf(stderr,"Serial: Unsupported access type\n");
 }

}
/*}}}*/