Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / legion / src / devices / mem_bus / libdumbtod / dumbtod.c

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: dumbtod.c
* 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 2007 Sun Microsystems, Inc.  All rights reserved.
* Use is subject to license terms.
*/
#pragma ident   "@(#)dumbtod.c  1.13    07/02/15 SMI"
/*
* This is a very generic TOD device.
* It provides a single read-only 64-bit register that
* contains the time in standard Unix form: number of seconds
* since Jan 1, 1970 UST.
*/

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <time.h>
#include <strings.h>

#include "basics.h"
#include "allocate.h"
#include "lexer.h"
#include "simcore.h"
#include "config.h"
#include "dumpinfo.h"
#include "fatal.h"
#include "device.h"

#define DBGX(s) do { } while (0)


/*
* Registers
* addr     RW    SZ      Function
* -----    --    ------  --------------
* 0x00     R     64-bit  time_t
*/


static void dtod_parse(config_dev_t *);
static void dtod_init(config_dev_t *);
static void dtod_dump(config_dev_t *);
static bool_t dtod_cpu_access(simcpu_t *sp, config_addr_t * cap,
   tpaddr_t offset, maccess_t op, uint64_t * regp);

dev_type_t dev_type_dumbtod = {
       "dumbtod",
       dtod_parse,
       dtod_init,
       dtod_dump,
       generic_device_non_cacheable,
       dtod_cpu_access,
       DEV_MAGIC
};

typedef struct {
       time_t  start_time;
       uint64_t        sysclkfreq;
       uint64_t        todfreq;
} dtod_state_t;


/*
* Complete the creation and parsing of this specific device
*/
static void
dtod_parse(config_dev_t *config_devp)
{
       dtod_state_t * dtp;
       lexer_tok_t     tok;

       if (config_devp->addrp->range != 8)
               fatal("dumbtod: dumbtod requires address space size of 0x8");

DBG(    printf("dumbtod_parse: parsing device %d\n", config_devp->device_id); );

       dtp = (void*)Xcalloc(1, dtod_state_t);
       dtp->todfreq = 1;       /* defaults to 1 */

       config_devp->devp = dtp;

       tok = lex_get_token();
       switch(tok) {
       case T_S_Colon:
               return;
       case T_L_Brace:
               break;
       default:
               lex_fatal("unexpected token");
       }
       
       /*
        * Parse the optional tod frequency
        */
       tok = lex_get_token();
       if (strcmp(lex.strp,"frequency") == 0) {
               dtp->todfreq = parse_number_assign();
               if (dtp->todfreq == 0x0)
                       lex_fatal("dumbtod: dumbtod cannot have a tod freq of 0");
               printf("dumbtod_parse: setting tod frequency of %lld\n", dtp->todfreq);
       } 

       lex_get(T_R_Brace);     
}


/*
* Initialise the device after parsing is complete
*/
static void
dtod_init(config_dev_t *config_devp)
{
       dtod_state_t * dtp;

       dtp = config_devp->devp;
       dtp->start_time = time(NULL);
       dtp->sysclkfreq = 0;            /* find put from first CPU access */
}


/*
* Configuration dump
*/
void
dtod_dump(config_dev_t *config_devp)
{
}


static bool_t
dtod_cpu_access(simcpu_t *sp, config_addr_t *cap, tpaddr_t offset, maccess_t op,
   uint64_t *regp)
{
       dtod_state_t * dtp;

       if ((op & MA_Op_Mask) != MA_Ld && (op & MA_Op_Mask) != MA_LdSigned) {
               EXEC_WARNING(("dumbtod: Illegal access - only loads allowed "
                   "to TOD device"));
               return (false);
       }

       if (offset != 0 || (op & MA_Size_Mask) != MA_Size64) {
               EXEC_WARNING(("dumbtod: Illegal device load access (%d bytes) "
                   "- offset (0x%d) not 8-byte sized or aligned",
                   1<<(op & MA_Size_Mask), offset));
               return (false);
       }

       dtp = cap->config_devp->devp;

#if WALL_TIME /* { */
       if (options.walltime) {
               *regp = time(NULL) * dtp->todfreq;
               return (true);
       }
#endif /* } */
       if (dtp->sysclkfreq == 0) {
               /* First time through - obtain clock frequency. */
               dtp->sysclkfreq = sp->config_procp->domainp->sysclkfreq;
       }

       *regp = (dtp->start_time + (time_t)(sp->cycle / dtp->sysclkfreq)) * dtp->todfreq;

       return (true);
}