git.gag.com Git - fw/sdcc/blob - sim/ucsim/s51.src/uc51.cc

   1 /*
   2  * Simulator of microcontrollers (uc51.cc)
   3  *
   4  * Copyright (C) 1999,99 Drotos Daniel, Talker Bt.
   5  *
   6  * To contact author send email to drdani@mazsola.iit.uni-miskolc.hu
   7  *
   8  */
   9
  10 /* This file is part of microcontroller simulator: ucsim.
  11
  12 UCSIM is free software; you can redistribute it and/or modify
  13 it under the terms of the GNU General Public License as published by
  14 the Free Software Foundation; either version 2 of the License, or
  15 (at your option) any later version.
  16
  17 UCSIM is distributed in the hope that it will be useful,
  18 but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 GNU General Public License for more details.
  21
  22 You should have received a copy of the GNU General Public License
  23 along with UCSIM; see the file COPYING.  If not, write to the Free
  24 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  25 02111-1307, USA. */
  26 /*@1@*/
  27
  28 #include "ddconfig.h"
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <ctype.h>
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36 #include <fcntl.h>
  37 #include <errno.h>
  38 #include <sys/types.h>
  39 #include <sys/time.h>
  40 #if FD_HEADER_OK
  41 # include HEADER_FD
  42 #endif
  43 #include "i_string.h"
  44
  45 // prj
  46 #include "utils.h"
  47 #include "globals.h"
  48
  49 // sim
  50 #include "optioncl.h"
  51
  52 //cmd.src
  53 #include "cmduccl.h"
  54
  55 // local
  56 #include "uc51cl.h"
  57 #include "glob.h"
  58 #include "regs51.h"
  59 #include "timer0cl.h"
  60 #include "timer1cl.h"
  61 #include "serialcl.h"
  62 #include "portcl.h"
  63 #include "interruptcl.h"
  64 #include "types51.h"
  65
  66
  67 /*
  68  * Options of uc51
  69  */
  70
  71 cl_irq_stop_option::cl_irq_stop_option(class cl_51core *the_uc51):
  72   cl_optref(the_uc51)
  73 {
  74   uc51= the_uc51;
  75 }
  76
  77 int
  78 cl_irq_stop_option::init(void)
  79 {
  80   cl_optref::init();
  81   create(uc51, bool_opt, "irq_stop", "Stop when IRQ accepted");
  82   return(0);
  83 }
  84
  85 void
  86 cl_irq_stop_option::option_changed(void)
  87 {
  88   if (!uc51)
  89     return;
  90   bool b;
  91   option->get_value(&b);
  92   uc51->stop_at_it= b;
  93 }
  94
  95
  96 /*
  97  * Making a new micro-controller and reset it
  98  */
  99
 100 cl_51core::cl_51core(int Itype, int Itech, class cl_sim *asim):
 101   cl_uc(asim)
 102 {
 103   type= Itype;
 104   technology= Itech;
 105
 106   irq_stop_option= new cl_irq_stop_option(this);
 107   stop_at_it= DD_FALSE;
 108 }
 109
 110
 111 /*
 112  * Initializing. Virtual calls go here
 113  * This method must be called first after object creation.
 114  */
 115
 116 int
 117 cl_51core::init(void)
 118 {
 119   irq_stop_option->init();
 120   cl_uc::init();
 121   set_name("mcs51_controller");
 122   reset();
 123   return(0);
 124 }
 125
 126 const char *
 127 cl_51core::id_string(void)
 128 {
 129   static char id_string_51[100];
 130   int i;
 131
 132   for (i= 0; cpus_51[i].type_str != NULL && cpus_51[i].type != type; i++) ;
 133   sprintf(id_string_51, "%s %s",
 134           cpus_51[i].type_str?cpus_51[i].type_str:"51",
 135           (technology==CPU_HMOS)?"HMOS":"CMOS");
 136   return(id_string_51);
 137 }
 138
 139 void
 140 cl_51core::mk_hw_elements(void)
 141 {
 142   class cl_hw *h;
 143
 144   acc= sfr->get_cell(ACC);
 145   psw= sfr->get_cell(PSW);
 146
 147   hws->add(h= new cl_timer0(this, 0, "timer0"));
 148   h->init();
 149   hws->add(h= new cl_timer1(this, 1, "timer1"));
 150   h->init();
 151   hws->add(h= new cl_serial(this));
 152   h->init();
 153   hws->add(h= new cl_port(this, 0));
 154   h->init();
 155   hws->add(h= new cl_port(this, 1));
 156   h->init();
 157   hws->add(h= new cl_port(this, 2));
 158   h->init();
 159   hws->add(h= new cl_port(this, 3));
 160   h->init();
 161   hws->add(interrupt= new cl_interrupt(this));
 162   interrupt->init();
 163   hws->add(h= new cl_uc51_dummy_hw(this));
 164   h->init();
 165   /*
 166   acc= sfr->get_cell(ACC);
 167   psw= sfr->get_cell(PSW);
 168   */
 169 }
 170
 171 void
 172 cl_51core::build_cmdset(class cl_cmdset *cmdset)
 173 {
 174   class cl_cmd *cmd;
 175   //class cl_super_cmd *super_cmd;
 176   //class cl_cmdset *cset;
 177
 178   cl_uc::build_cmdset(cmdset);
 179
 180   cmdset->add(cmd= new cl_di_cmd("di", DD_TRUE,
 181 "di [start [stop]]  Dump Internal RAM",
 182 "long help of di"));
 183   cmd->init();
 184
 185   cmdset->add(cmd= new cl_dx_cmd("dx", DD_TRUE,
 186 "dx [start [stop]]  Dump External RAM",
 187 "long help of dx"));
 188   cmd->init();
 189
 190   cmdset->add(cmd= new cl_ds_cmd("ds", DD_TRUE,
 191 "ds [start [stop]]  Dump SFR",
 192 "long help of ds"));
 193   cmd->init();
 194 }
 195
 196 /*
 197 class cl_m *
 198 cl_51core::mk_mem(enum mem_class type, char *class_name)
 199 {
 200   class cl_address_space *m= cl_uc::mk_mem(type, class_name);
 201   if (type == MEM_SFR)
 202     sfr= m;
 203   if (type == MEM_IRAM)
 204     iram= m;
 205   return(m);
 206 }
 207 */
 208
 209 void
 210 cl_51core::make_memories(void)
 211 {
 212   class cl_address_space *as;
 213
 214   rom= as= new cl_address_space(MEM_ROM_ID/*"rom"*/, 0, 0x10000, 8);
 215   as->init();
 216   address_spaces->add(as);
 217   iram= as= new cl_address_space(MEM_IRAM_ID/*"iram"*/, 0, 0x80, 8);
 218   as->init();
 219   address_spaces->add(as);
 220   sfr= as= new cl_address_space(MEM_SFR_ID/*"sfr"*/, 0x80, 0x80, 8);
 221   as->init();
 222   address_spaces->add(as);
 223   xram= as= new cl_address_space(MEM_XRAM_ID/*"xram"*/, 0, 0x10000, 8);
 224   as->init();
 225   address_spaces->add(as);
 226
 227   class cl_address_decoder *ad;
 228   class cl_memory_chip *chip;
 229
 230   chip= new cl_memory_chip("rom_chip", 0x10000, 8/*, 0xff*/);
 231   chip->init();
 232   memchips->add(chip);
 233   ad= new cl_address_decoder(as= rom/*address_space(MEM_ROM_ID)*/,
 234                              chip, 0, 0xffff, 0);
 235   ad->init();
 236   as->decoders->add(ad);
 237   ad->activate(0);
 238
 239   chip= new cl_memory_chip("iram_chip", 0x80, 8);
 240   chip->init();
 241   memchips->add(chip);
 242   ad= new cl_address_decoder(as= iram/*address_space(MEM_IRAM_ID)*/,
 243                              chip, 0, 0x7f, 0);
 244   ad->init();
 245   as->decoders->add(ad);
 246   ad->activate(0);
 247
 248   chip= new cl_memory_chip("xram_chip", 0x10000, 8);
 249   chip->init();
 250   memchips->add(chip);
 251   ad= new cl_address_decoder(as= xram/*address_space(MEM_XRAM_ID)*/,
 252                              chip, 0, 0xffff, 0);
 253   ad->init();
 254   as->decoders->add(ad);
 255   ad->activate(0);
 256
 257   chip= new cl_memory_chip("sfr_chip", 0x80, 8, 0);
 258   chip->init();
 259   memchips->add(chip);
 260   ad= new cl_address_decoder(as= sfr/*address_space(MEM_SFR_ID)*/,
 261                              chip, 0x80, 0xff, 0);
 262   ad->init();
 263   as->decoders->add(ad);
 264   ad->activate(0);
 265
 266   acc= sfr->get_cell(ACC);
 267   psw= sfr->get_cell(PSW);
 268 }
 269
 270
 271 /*
 272  * Destroying the micro-controller object
 273  */
 274
 275 cl_51core::~cl_51core(void)
 276 {
 277   /*
 278   if (serial_out)
 279     {
 280       if (isatty(fileno(serial_out)))
 281         tcsetattr(fileno(serial_out), TCSANOW, &saved_attributes_out);
 282       fclose(serial_out);
 283     }
 284   if (serial_in)
 285     {
 286       if (isatty(fileno(serial_in)))
 287         tcsetattr(fileno(serial_in), TCSANOW, &saved_attributes_in);
 288       fclose(serial_in);
 289     }
 290   */
 291   delete irq_stop_option;
 292 }
 293
 294
 295 /*
 296  * Disassembling an instruction
 297  */
 298
 299 struct dis_entry *
 300 cl_51core::dis_tbl(void)
 301 {
 302   return(disass_51);
 303 }
 304
 305 struct name_entry *
 306 cl_51core::sfr_tbl(void)
 307 {
 308   return(sfr_tab51);
 309 }
 310
 311 struct name_entry *
 312 cl_51core::bit_tbl(void)
 313 {
 314   return(bit_tab51);
 315 }
 316
 317 char *
 318 cl_51core::disass(t_addr addr, char *sep)
 319 {
 320   char work[256], temp[20], c[2];
 321   const char *b;
 322   char *buf, *p, *t;
 323   t_mem code= rom->get(addr);
 324
 325   p= work;
 326   b= dis_tbl()[code].mnemonic;
 327   while (*b)
 328     {
 329       if (*b == '%')
 330         {
 331           b++;
 332           switch (*(b++))
 333             {
 334             case 'A': // absolute address
 335               sprintf(temp, "%04"_A_"x",
 336                       t_addr((addr&0xf800)|
 337                              (((code>>5)&0x07)*256 +
 338                               rom->get(addr+1))));
 339               break;
 340             case 'l': // long address
 341               sprintf(temp, "%04"_A_"x",
 342                       t_addr(rom->get(addr+1)*256 +
 343                              rom->get(addr+2)));
 344               break;
 345             case 'a': // addr8 (direct address) at 2nd byte
 346               if (!get_name(rom->get(addr+1), sfr_tbl(), temp))
 347                 sprintf(temp, "%02"_M_"x", rom->get(addr+1));
 348               break;
 349             case '8': // addr8 (direct address) at 3rd byte
 350               if (!get_name(rom->get(addr+2), sfr_tbl(), temp))
 351                 sprintf(temp, "%02"_M_"x", rom->get(addr+2));
 352               //sprintf(temp, "%02"_M_"x", rom->get(addr+2));
 353               break;
 354             case 'b': // bitaddr at 2nd byte
 355               {
 356                 t_addr ba= rom->get(addr+1);
 357                 if (get_name(ba, bit_tbl(), temp))
 358                   break;
 359                 if (get_name((ba<128)?((ba/8)+32):(ba&0xf8), sfr_tbl(), temp))
 360                   {
 361                     strcat(temp, ".");
 362                     sprintf(c, "%1"_M_"d", ba & 0x07);
 363                     strcat(temp, c);
 364                     break;
 365                   }
 366                 sprintf(temp, "%02x.%"_M_"d", (ba<128)?((ba/8)+32):(ba&0xf8),
 367                         ba & 0x07);
 368                 break;
 369               }
 370             case 'r': // rel8 address at 2nd byte
 371               sprintf(temp, "%04"_A_"x",
 372                       t_addr(addr+2+(signed char)(rom->get(addr+1))));
 373               break;
 374             case 'R': // rel8 address at 3rd byte
 375               sprintf(temp, "%04"_A_"x",
 376                       t_addr(addr+3+(signed char)(rom->get(addr+2))));
 377               break;
 378             case 'd': // data8 at 2nd byte
 379               sprintf(temp, "%02"_M_"x", rom->get(addr+1));
 380               break;
 381             case 'D': // data8 at 3rd byte
 382               sprintf(temp, "%02"_M_"x", rom->get(addr+2));
 383               break;
 384             case '6': // data16 at 2nd(H)-3rd(L) byte
 385               sprintf(temp, "%04"_A_"x",
 386                       t_addr(rom->get(addr+1)*256 +
 387                              rom->get(addr+2)));
 388               break;
 389             default:
 390               strcpy(temp, "?");
 391               break;
 392             }
 393           t= temp;
 394           while (*t)
 395             *(p++)= *(t++);
 396         }
 397       else
 398         *(p++)= *(b++);
 399     }
 400   *p= '\0';
 401
 402   p= strchr(work, ' ');
 403   if (!p)
 404     {
 405       buf= strdup(work);
 406       return(buf);
 407     }
 408   if (sep == NULL)
 409     buf= (char *)malloc(6+strlen(p)+1);
 410   else
 411     buf= (char *)malloc((p-work)+strlen(sep)+strlen(p)+1);
 412   for (p= work, t= buf; *p != ' '; p++, t++)
 413     *t= *p;
 414   p++;
 415   *t= '\0';
 416   if (sep == NULL)
 417     {
 418       while (strlen(buf) < 6)
 419         strcat(buf, " ");
 420     }
 421   else
 422     strcat(buf, sep);
 423   strcat(buf, p);
 424   return(buf);
 425 }
 426
 427
 428 void
 429 cl_51core::print_regs(class cl_console_base *con)
 430 {
 431   t_addr start;
 432   uchar data;
 433
 434   start= psw->get() & 0x18;
 435   //dump_memory(iram, &start, start+7, 8, /*sim->cmd_out()*/con, sim);
 436   iram->dump(start, start+7, 8, con);
 437   start= psw->get() & 0x18;
 438   data= iram->get(iram->get(start));
 439   con->dd_printf("%06x %02x %c",
 440               iram->get(start), data, isprint(data)?data:'.');
 441
 442   con->dd_printf("  ACC= 0x%02x %3d %c  B= 0x%02x", sfr->get(ACC), sfr->get(ACC),
 443               isprint(sfr->get(ACC))?(sfr->get(ACC)):'.', sfr->get(B));
 444   //eram2xram();
 445   data= xram->get(sfr->get(DPH)*256+sfr->get(DPL));
 446   con->dd_printf("   DPTR= 0x%02x%02x @DPTR= 0x%02x %3d %c\n", sfr->get(DPH),
 447               sfr->get(DPL), data, data, isprint(data)?data:'.');
 448
 449   data= iram->get(iram->get(start+1));
 450   con->dd_printf("%06x %02x %c", iram->get(start+1), data,
 451               isprint(data)?data:'.');
 452   data= psw->get();
 453   con->dd_printf("  PSW= 0x%02x CY=%c AC=%c OV=%c P=%c\n", data,
 454               (data&bmCY)?'1':'0', (data&bmAC)?'1':'0',
 455               (data&bmOV)?'1':'0', (data&bmP)?'1':'0');
 456
 457   print_disass(PC, con);
 458 }
 459
 460
 461 /*
 462  * Converting bit address into real memory
 463  */
 464
 465 class cl_address_space *
 466 cl_51core::bit2mem(t_addr bitaddr, t_addr *memaddr, t_mem *bitmask)
 467 {
 468   class cl_address_space *m;
 469   t_addr ma;
 470
 471   bitaddr&= 0xff;
 472   if (bitaddr < 128)
 473     {
 474       m= iram;
 475       ma= bitaddr/8 + 0x20;
 476     }
 477   else
 478     {
 479       m= sfr;
 480       ma= bitaddr & 0xf8;
 481     }
 482   if (memaddr)
 483     *memaddr= ma;
 484   if (bitmask)
 485     *bitmask= 1 << (bitaddr & 0x7);
 486   return(m);
 487 }
 488
 489 t_addr
 490 cl_51core::bit_address(class cl_memory *mem,
 491                        t_addr mem_address, int bit_number)
 492 {
 493   if (bit_number < 0 ||
 494       bit_number > 7 ||
 495       mem_address < 0)
 496     return(-1);
 497   class cl_memory *sfrchip= memory("sfr_chip");
 498   if (mem == sfrchip)
 499     {
 500       mem= sfr;
 501       mem_address+= sfr->start_address;
 502     }
 503   if (mem == sfr)
 504     {
 505       if (mem_address < 128 ||
 506           mem_address % 8 != 0 ||
 507           mem_address > 255)
 508         return(-1);
 509       return(128 + (mem_address-128) + bit_number);
 510     }
 511   if (mem == iram)
 512     {
 513       if (mem_address < 0x20 ||
 514           mem_address >= 0x20+32)
 515         return(-1);
 516       return((mem_address-0x20)*8 + bit_number);
 517     }
 518   return(-1);
 519 }
 520
 521
 522 /*
 523  * Resetting the micro-controller
 524  */
 525
 526 void
 527 cl_51core::reset(void)
 528 {
 529   cl_uc::reset();
 530
 531   clear_sfr();
 532
 533   result= resGO;
 534
 535   //was_reti= DD_FALSE;
 536 }
 537
 538
 539 /*
 540  * Setting up SFR area to reset value
 541  */
 542
 543 void
 544 cl_51core::clear_sfr(void)
 545 {
 546   int i;
 547
 548   for (i= 0x80; i <= 0xff; i++)
 549     sfr->set(i, 0);
 550   sfr->/*set*/write(P0, 0xff);
 551   sfr->/*set*/write(P1, 0xff);
 552   sfr->/*set*/write(P2, 0xff);
 553   sfr->/*set*/write(P3, 0xff);
 554   prev_p1= /*port_pins[1] &*/ sfr->/*get*/read(P1);
 555   prev_p3= /*port_pins[3] &*/ sfr->/*get*/read(P3);
 556   sfr->write(ACC, 0);
 557   sfr->write(B, 0);
 558   sfr->write(PSW, 0);
 559   sfr->write(SP, 7);
 560   sfr->write(DPL, 0);
 561   sfr->write(DPH, 0);
 562   sfr->write(IP, 0);
 563   sfr->write(IE, 0);
 564   sfr->write(TMOD, 0);
 565   sfr->write(TCON, 0);
 566   sfr->write(TH0, 0);
 567   sfr->write(TL0, 0);
 568   sfr->write(TH1, 0);
 569   sfr->write(TL1, 0);
 570   sfr->write(SCON, 0);
 571   sfr->write(PCON, 0);
 572
 573   sfr->set_nuof_writes(0);
 574   sfr->set_nuof_reads(0);
 575 }
 576
 577
 578 /*
 579  * Analyzing code and settig up instruction map
 580  */
 581
 582 void
 583 cl_51core::analyze(t_addr addr)
 584 {
 585   uint code;
 586   struct dis_entry *tabl;
 587
 588   code= rom->get(addr);
 589   tabl= &(dis_tbl()[code]);
 590   while (!inst_at(addr) &&
 591          code != 0xa5 /* break point */)
 592     {
 593       set_inst_at(addr);
 594       switch (tabl->branch)
 595         {
 596         case 'a': // acall
 597           analyze((addr & 0xf800)|
 598                   ((rom->get(addr+1)&0x07)*256+
 599                    rom->get(addr+2)));
 600           analyze(addr+tabl->length);
 601           break;
 602         case 'A': // ajmp
 603           addr= (addr & 0xf800)|
 604             ((rom->get(addr+1) & 0x07)*256 + rom->get(addr+2));
 605           break;
 606         case 'l': // lcall
 607           analyze(rom->get(addr+1)*256 + rom->get(addr+2));
 608           analyze(addr+tabl->length);
 609           break;
 610         case 'L': // ljmp
 611           addr= rom->get(addr+1)*256 + rom->get(addr+2);
 612           break;
 613         case 'r': // reljmp (2nd byte)
 614           analyze(rom->validate_address(addr+(signed char)(rom->get(addr+1))));
 615           analyze(addr+tabl->length);
 616           break;
 617         case 'R': // reljmp (3rd byte)
 618           analyze(rom->validate_address(addr+(signed char)(rom->get(addr+2))));
 619           analyze(addr+tabl->length);
 620           break;
 621         case 's': // sjmp
 622           {
 623             signed char target;
 624             target= rom->get(addr+1);
 625             addr+= 2;
 626             addr= rom->validate_address(addr+target);
 627             break;
 628           }
 629         case '_':
 630           return;
 631         default:
 632           addr= rom->validate_address(addr+tabl->length);
 633           break;
 634         }
 635       code= rom->get(addr);
 636       tabl= &(dis_tbl()[code]);
 637     }
 638 }
 639
 640
 641 /*
 642  * Inform hardware elements that `cycles' machine cycles have elapsed
 643  */
 644
 645 /*int
 646 cl_51core::tick_hw(int cycles)
 647 {
 648   cl_uc::tick_hw(cycles);
 649   //do_hardware(cycles);
 650   return(0);
 651 }*/
 652
 653 /*int
 654 cl_51core::tick(int cycles)
 655 {
 656   cl_uc::tick(cycles);
 657   //do_hardware(cycles);
 658   return(0);
 659 }*/
 660
 661
 662 /*
 663  * Correcting direct address
 664  *
 665  * This function returns address of addressed element which can be an IRAM
 666  * or an SFR.
 667  */
 668
 669 class cl_memory_cell *
 670 cl_51core::get_direct(t_mem addr)
 671 {
 672   if (addr < sfr->start_address)
 673     return(iram->get_cell(addr));
 674   else
 675     return(sfr->get_cell(addr));
 676 }
 677
 678
 679 /*
 680  * Calculating address of specified register cell in IRAM
 681  */
 682
 683 class cl_memory_cell *
 684 cl_51core::get_reg(uchar regnum)
 685 {
 686   t_addr a= (psw->get() & (bmRS0|bmRS1)) | (regnum & 0x07);
 687   return(iram->get_cell(a));
 688 }
 689
 690
 691 /*
 692  * Fetching one instruction and executing it
 693  */
 694
 695 int
 696 cl_51core::exec_inst(void)
 697 {
 698   t_mem code;
 699   int res= resGO;
 700
 701   //pr_inst();
 702   instPC= PC;
 703   if (fetch(&code))
 704     return(resBREAKPOINT);
 705   //tick_hw(1);
 706   tick(1);
 707   switch (code)
 708     {
 709     case 0x00: res= inst_nop(code); break;
 710     case 0x01: case 0x21: case 0x41: case 0x61:
 711     case 0x81: case 0xa1: case 0xc1: case 0xe1:res=inst_ajmp_addr(code);break;
 712     case 0x02: res= inst_ljmp(code); break;
 713     case 0x03: res= inst_rr(code); break;
 714     case 0x04: res= inst_inc_a(code); break;
 715     case 0x05: res= inst_inc_addr(code); break;
 716     case 0x06: case 0x07: res= inst_inc_Sri(code); break;
 717     case 0x08: case 0x09: case 0x0a: case 0x0b:
 718     case 0x0c: case 0x0d: case 0x0e: case 0x0f: res= inst_inc_rn(code); break;
 719     case 0x10: res= inst_jbc_bit_addr(code); break;
 720     case 0x11: case 0x31: case 0x51: case 0x71:
 721     case 0x91: case 0xb1: case 0xd1: case 0xf1:res=inst_acall_addr(code);break;
 722     case 0x12: res= inst_lcall(code, 0, DD_FALSE); break;
 723     case 0x13: res= inst_rrc(code); break;
 724     case 0x14: res= inst_dec_a(code); break;
 725     case 0x15: res= inst_dec_addr(code); break;
 726     case 0x16: case 0x17: res= inst_dec_Sri(code); break;
 727     case 0x18: case 0x19: case 0x1a: case 0x1b:
 728     case 0x1c: case 0x1d: case 0x1e: case 0x1f: res= inst_dec_rn(code); break;
 729     case 0x20: res= inst_jb_bit_addr(code); break;
 730     case 0x22: res= inst_ret(code); break;
 731     case 0x23: res= inst_rl(code); break;
 732     case 0x24: res= inst_add_a_Sdata(code); break;
 733     case 0x25: res= inst_add_a_addr(code); break;
 734     case 0x26: case 0x27: res= inst_add_a_Sri(code); break;
 735     case 0x28: case 0x29: case 0x2a: case 0x2b:
 736     case 0x2c: case 0x2d: case 0x2e: case 0x2f:res= inst_add_a_rn(code);break;
 737     case 0x30: res= inst_jnb_bit_addr(code); break;
 738     case 0x32: res= inst_reti(code); break;
 739     case 0x33: res= inst_rlc(code); break;
 740     case 0x34: res= inst_addc_a_Sdata(code); break;
 741     case 0x35: res= inst_addc_a_addr(code); break;
 742     case 0x36: case 0x37: res= inst_addc_a_Sri(code); break;
 743     case 0x38: case 0x39: case 0x3a: case 0x3b:
 744     case 0x3c: case 0x3d: case 0x3e: case 0x3f:res= inst_addc_a_rn(code);break;
 745     case 0x40: res= inst_jc_addr(code); break;
 746     case 0x42: res= inst_orl_addr_a(code); break;
 747     case 0x43: res= inst_orl_addr_Sdata(code); break;
 748     case 0x44: res= inst_orl_a_Sdata(code); break;
 749     case 0x45: res= inst_orl_a_addr(code); break;
 750     case 0x46: case 0x47: res= inst_orl_a_Sri(code); break;
 751     case 0x48: case 0x49: case 0x4a: case 0x4b:
 752     case 0x4c: case 0x4d: case 0x4e: case 0x4f: res= inst_orl_a_rn(code);break;
 753     case 0x50: res= inst_jnc_addr(code); break;
 754     case 0x52: res= inst_anl_addr_a(code); break;
 755     case 0x53: res= inst_anl_addr_Sdata(code); break;
 756     case 0x54: res= inst_anl_a_Sdata(code); break;
 757     case 0x55: res= inst_anl_a_addr(code); break;
 758     case 0x56: case 0x57: res= inst_anl_a_Sri(code); break;
 759     case 0x58: case 0x59: case 0x5a: case 0x5b:
 760     case 0x5c: case 0x5d: case 0x5e: case 0x5f: res= inst_anl_a_rn(code);break;
 761     case 0x60: res= inst_jz_addr(code); break;
 762     case 0x62: res= inst_xrl_addr_a(code); break;
 763     case 0x63: res= inst_xrl_addr_Sdata(code); break;
 764     case 0x64: res= inst_xrl_a_Sdata(code); break;
 765     case 0x65: res= inst_xrl_a_addr(code); break;
 766     case 0x66: case 0x67: res= inst_xrl_a_Sri(code); break;
 767     case 0x68: case 0x69: case 0x6a: case 0x6b:
 768     case 0x6c: case 0x6d: case 0x6e: case 0x6f: res= inst_xrl_a_rn(code);break;
 769     case 0x70: res= inst_jnz_addr(code); break;
 770     case 0x72: res= inst_orl_c_bit(code); break;
 771     case 0x73: res= inst_jmp_Sa_dptr(code); break;
 772     case 0x74: res= inst_mov_a_Sdata(code); break;
 773     case 0x75: res= inst_mov_addr_Sdata(code); break;
 774     case 0x76: case 0x77: res= inst_mov_Sri_Sdata(code); break;
 775     case 0x78: case 0x79: case 0x7a: case 0x7b: case 0x7c:
 776     case 0x7d: case 0x7e: case 0x7f: res=inst_mov_rn_Sdata(code); break;
 777     case 0x80: res= inst_sjmp(code); break;
 778     case 0x82: res= inst_anl_c_bit(code); break;
 779     case 0x83: res= inst_movc_a_Sa_pc(code); break;
 780     case 0x84: res= inst_div_ab(code); break;
 781     case 0x85: res= inst_mov_addr_addr(code); break;
 782     case 0x86: case 0x87: res= inst_mov_addr_Sri(code); break;
 783     case 0x88: case 0x89: case 0x8a: case 0x8b:
 784     case 0x8c: case 0x8d: case 0x8e: case 0x8f:res=inst_mov_addr_rn(code);break;
 785     case 0x90: res= inst_mov_dptr_Sdata(code); break;
 786     case 0x92: res= inst_mov_bit_c(code); break;
 787     case 0x93: res= inst_movc_a_Sa_dptr(code); break;
 788     case 0x94: res= inst_subb_a_Sdata(code); break;
 789     case 0x95: res= inst_subb_a_addr(code); break;
 790     case 0x96: case 0x97: res= inst_subb_a_Sri(code); break;
 791     case 0x98: case 0x99: case 0x9a: case 0x9b:
 792     case 0x9c: case 0x9d: case 0x9e: case 0x9f:res= inst_subb_a_rn(code);break;
 793     case 0xa0: res= inst_orl_c_Sbit(code); break;
 794     case 0xa2: res= inst_mov_c_bit(code); break;
 795     case 0xa3: res= inst_inc_dptr(code); break;
 796     case 0xa4: res= inst_mul_ab(code); break;
 797     case 0xa5: res= inst_unknown(); break;
 798     case 0xa6: case 0xa7: res= inst_mov_Sri_addr(code); break;
 799     case 0xa8: case 0xa9: case 0xaa: case 0xab:
 800     case 0xac: case 0xad: case 0xae: case 0xaf:res=inst_mov_rn_addr(code);break;
 801     case 0xb0: res= inst_anl_c_Sbit(code); break;
 802     case 0xb2: res= inst_cpl_bit(code); break;
 803     case 0xb3: res= inst_cpl_c(code); break;
 804     case 0xb4: res= inst_cjne_a_Sdata_addr(code); break;
 805     case 0xb5: res= inst_cjne_a_addr_addr(code); break;
 806     case 0xb6: case 0xb7: res= inst_cjne_Sri_Sdata_addr(code); break;
 807     case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc:
 808     case 0xbd: case 0xbe: case 0xbf: res=inst_cjne_rn_Sdata_addr(code); break;
 809     case 0xc0: res= inst_push(code); break;
 810     case 0xc2: res= inst_clr_bit(code); break;
 811     case 0xc3: res= inst_clr_c(code); break;
 812     case 0xc4: res= inst_swap(code); break;
 813     case 0xc5: res= inst_xch_a_addr(code); break;
 814     case 0xc6: case 0xc7: res= inst_xch_a_Sri(code); break;
 815     case 0xc8: case 0xc9: case 0xca: case 0xcb:
 816     case 0xcc: case 0xcd: case 0xce: case 0xcf: res= inst_xch_a_rn(code);break;
 817     case 0xd0: res= inst_pop(code); break;
 818     case 0xd2: res= inst_setb_bit(code); break;
 819     case 0xd3: res= inst_setb_c(code); break;
 820     case 0xd4: res= inst_da_a(code); break;
 821     case 0xd5: res= inst_djnz_addr_addr(code); break;
 822     case 0xd6: case 0xd7: res= inst_xchd_a_Sri(code); break;
 823     case 0xd8: case 0xd9: case 0xda: case 0xdb: case 0xdc:
 824     case 0xdd: case 0xde: case 0xdf: res=inst_djnz_rn_addr(code); break;
 825     case 0xe0: res= inst_movx_a_Sdptr(code); break;
 826     case 0xe2: case 0xe3: res= inst_movx_a_Sri(code); break;
 827     case 0xe4: res= inst_clr_a(code); break;
 828     case 0xe5: res= inst_mov_a_addr(code); break;
 829     case 0xe6: case 0xe7: res= inst_mov_a_Sri(code); break;
 830     case 0xe8: case 0xe9: case 0xea: case 0xeb:
 831     case 0xec: case 0xed: case 0xee: case 0xef: res= inst_mov_a_rn(code);break;
 832     case 0xf0: res= inst_movx_Sdptr_a(code); break;
 833     case 0xf2: case 0xf3: res= inst_movx_Sri_a(code); break;
 834     case 0xf4: res= inst_cpl_a(code); break;
 835     case 0xf5: res= inst_mov_addr_a(code); break;
 836     case 0xf6: case 0xf7: res= inst_mov_Sri_a(code); break;
 837     case 0xf8: case 0xf9: case 0xfa: case 0xfb:
 838     case 0xfc: case 0xfd: case 0xfe: case 0xff: res= inst_mov_rn_a(code);break;
 839     default:
 840       res= inst_unknown();
 841       break;
 842     }
 843   //post_inst();
 844   return(res);
 845 }
 846
 847
 848 /*
 849  * Simulating execution of next instruction
 850  *
 851  * This is an endless loop if requested number of steps is negative.
 852  * In this case execution is stopped if an instruction results other
 853  * status than GO. Execution can be stopped if `cmd_in' is not NULL
 854  * and there is input available on that file. It is usefull if the
 855  * command console is on a terminal. If input is available then a
 856  * complete line is read and dropped out because input is buffered
 857  * (inp_avail will be TRUE if ENTER is pressed) and it can confuse
 858  * command interepter.
 859  */
 860 //static class cl_console_base *c= NULL;
 861 int
 862 cl_51core::do_inst(int step)
 863 {
 864   result= resGO;
 865   while ((result == resGO) &&
 866          (state != stPD) &&
 867          (step != 0))
 868     {
 869       if (step > 0)
 870         step--;
 871       if (state == stGO)
 872         {
 873           interrupt->was_reti= DD_FALSE;
 874           pre_inst();
 875           result= exec_inst();
 876           post_inst();
 877           /*
 878           {
 879             if (c)
 880               print_regs(c);
 881             else
 882               {
 883                 if (sim->app->get_commander()==NULL)
 884                   printf("no commander PC=0x%x\n",PC);
 885                 else
 886                   if (sim->app->get_commander()->frozen_console==NULL)
 887                     printf("no frozen console PC=0x%x\n",PC);
 888                   else
 889                     c= sim->app->get_commander()->frozen_console;
 890                 if (c)
 891                   print_regs(c);
 892                 else
 893                   printf("no console PC=0x%x\n",PC);
 894               }
 895           }
 896           */
 897           /*if (result == resGO)
 898             result= check_events();*/
 899         }
 900       else
 901         {
 902           // tick hw in idle state
 903           inst_ticks= 1;
 904           post_inst();
 905           tick(1);
 906         }
 907       if (result == resGO)
 908         {
 909           int res;
 910           if ((res= do_interrupt()) != resGO)
 911             result= res;
 912           else
 913             result= idle_pd();
 914         }
 915       if ((step < 0) &&
 916           ((ticks->ticks % 100000) < 50))
 917         {
 918           if (sim->app->get_commander()->input_avail_on_frozen())
 919             {
 920               result= resUSER;
 921             }
 922           else
 923             if (sim->app->get_commander()->input_avail())
 924               break;
 925         }
 926       if (((result == resINTERRUPT) &&
 927            stop_at_it) ||
 928           result >= resSTOP)
 929         {
 930           sim->stop(result);
 931           break;
 932         }
 933     }
 934   if (state == stPD)
 935     {
 936       //FIXME: tick outsiders eg. watchdog
 937       if (sim->app->get_commander()->input_avail_on_frozen())
 938         {
 939           //fprintf(stderr,"uc: inp avail in PD mode, user stop\n");
 940           result= resUSER;
 941           sim->stop(result);
 942         }
 943     }
 944   return(result);
 945 }
 946
 947 /*void
 948 cl_51core::post_inst(void)
 949 {*/
 950   //uint tcon= sfr->get(TCON);
 951   //uint p3= sfr->read(P3);
 952
 953   //cl_uc::post_inst();
 954   //set_p_flag();
 955
 956   // Setting up external interrupt request bits (IEx)
 957   /*if ((tcon & bmIT0))
 958     {
 959       // IE0 edge triggered
 960       if (p3_int0_edge)
 961         {
 962           // falling edge on INT0
 963           sim->app->get_commander()->
 964             debug("%g sec (%d clks): Falling edge detected on INT0 (P3.2)\n",
 965                           get_rtime(), ticks->ticks);
 966           sfr->set_bit1(TCON, bmIE0);
 967           p3_int0_edge= 0;
 968         }
 969     }
 970   else
 971     {
 972       // IE0 level triggered
 973       if (p3 & bm_INT0)
 974         sfr->set_bit0(TCON, bmIE0);
 975       else
 976         sfr->set_bit1(TCON, bmIE0);
 977     }
 978   if ((tcon & bmIT1))
 979     {
 980       // IE1 edge triggered
 981       if (p3_int1_edge)
 982         {
 983           // falling edge on INT1
 984           sfr->set_bit1(TCON, bmIE1);
 985           p3_int1_edge= 0;
 986         }
 987     }
 988   else
 989     {
 990       // IE1 level triggered
 991       if (p3 & bm_INT1)
 992         sfr->set_bit0(TCON, bmIE1);
 993       else
 994         sfr->set_bit1(TCON, bmIE1);
 995         }*/
 996   //prev_p3= p3 & port_pins[3];
 997   //prev_p1= p3 & port_pins[1];
 998 //}
 999
1000
1001 /*
1002  * Abstract method to handle WDT
1003  */
1004
1005 /*int
1006 cl_51core::do_wdt(int cycles)
1007 {
1008   return(resGO);
1009 }*/
1010
1011
1012 /*
1013  * Checking for interrupt requests and accept one if needed
1014  */
1015
1016 int
1017 cl_51core::do_interrupt(void)
1018 {
1019   int i, ie= 0;
1020
1021   if (interrupt->was_reti)
1022     {
1023       interrupt->was_reti= DD_FALSE;
1024       return(resGO);
1025     }
1026   if (!((ie= sfr->get(IE)) & bmEA))
1027     return(resGO);
1028   class it_level *il= (class it_level *)(it_levels->top()), *IL= 0;
1029   for (i= 0; i < it_sources->count; i++)
1030     {
1031       class cl_it_src *is= (class cl_it_src *)(it_sources->at(i));
1032       if (is->is_active() &&
1033           (ie & is->ie_mask) &&
1034           (sfr->get(is->src_reg) & is->src_mask))
1035         {
1036           int pr= it_priority(is->ie_mask);
1037           if (il->level >= 0 &&
1038               pr <= il->level)
1039             continue;
1040           if (state == stIDLE)
1041             {
1042               state= stGO;
1043               sfr->set_bit0(PCON, bmIDL);
1044               interrupt->was_reti= DD_TRUE;
1045               return(resGO);
1046             }
1047           if (is->clr_bit)
1048             sfr->set_bit0(is->src_reg, is->src_mask);
1049           sim->app->get_commander()->
1050             debug("%g sec (%d clks): Accepting interrupt `%s' PC= 0x%06x\n",
1051                           get_rtime(), ticks->ticks, object_name(is), PC);
1052           IL= new it_level(pr, is->addr, PC, is);
1053           return(accept_it(IL));
1054         }
1055     }
1056   return(resGO);
1057 }
1058
1059 int
1060 cl_51core::it_priority(uchar ie_mask)
1061 {
1062   if (sfr->get(IP) & ie_mask)
1063     return(1);
1064   return(0);
1065 }
1066
1067
1068 /*
1069  * Accept an interrupt
1070  */
1071
1072 int
1073 cl_51core::accept_it(class it_level *il)
1074 {
1075   state= stGO;
1076   sfr->set_bit0(PCON, bmIDL);
1077   it_levels->push(il);
1078   tick(1);
1079   int res= inst_lcall(0, il->addr, DD_TRUE);
1080   if (res != resGO)
1081     return(res);
1082   else
1083     return(resINTERRUPT);
1084 }
1085
1086
1087 /*
1088  * Checking if Idle or PowerDown mode should be activated
1089  */
1090
1091 int
1092 cl_51core::idle_pd(void)
1093 {
1094   uint pcon= sfr->get(PCON);
1095
1096   if (technology != CPU_CMOS)
1097     return(resGO);
1098   if (pcon & bmIDL)
1099     {
1100       if (state != stIDLE)
1101         sim->app->get_commander()->
1102           debug("%g sec (%d clks): CPU in Idle mode (PC=0x%x, PCON=0x%x)\n",
1103                 get_rtime(), ticks->ticks, PC, pcon);
1104       state= stIDLE;
1105       //was_reti= 1;
1106     }
1107   if (pcon & bmPD)
1108     {
1109       if (state != stPD)
1110         sim->app->get_commander()->
1111           debug("%g sec (%d clks): CPU in PowerDown mode\n",
1112                         get_rtime(), ticks->ticks);
1113       state= stPD;
1114     }
1115   return(resGO);
1116 }
1117
1118
1119 /*
1120  * Checking if EVENT break happened
1121  */
1122
1123 /*int
1124 cl_51core::check_events(void)
1125 {
1126   int i;
1127   class cl_ev_brk *eb;
1128
1129   if (!ebrk->count)
1130     return(resGO);
1131   for (i= 0; i < ebrk->count; i++)
1132     {
1133       eb= (class cl_ev_brk *)(ebrk->at(i));
1134       if (eb->match(&event_at))
1135         return(resBREAKPOINT);
1136     }
1137   return(resGO);
1138 }*/
1139
1140
1141 /*
1142  */
1143
1144 /*
1145 void
1146 cl_51core::mem_cell_changed(class cl_m *mem, t_addr addr)
1147 {
1148   if (mem == sfr)
1149     switch (addr)
1150       {
1151       case ACC: acc= mem->get_cell(ACC); break;
1152       case PSW: psw= mem->get_cell(PSW); break;
1153       }
1154   cl_uc::mem_cell_changed(mem, addr);
1155 }
1156 */
1157
1158
1159 /*
1160  * Simulating an unknown instruction
1161  *
1162  * Normally this function is called for unimplemented instructions, because
1163  * every instruction must be known!
1164  */
1165
1166 int
1167 cl_51core::inst_unknown(void)
1168 {
1169   //PC--;
1170   class cl_error_unknown_code *e= new cl_error_unknown_code(this);
1171   error(e);
1172   return(resGO);
1173 }
1174
1175
1176 /*
1177  * 0x00 1 12 NOP
1178  */
1179
1180 int
1181 cl_51core::inst_nop(uchar code)
1182 {
1183   return(resGO);
1184 }
1185
1186
1187 /*
1188  * 0xe4 1 12 CLR A
1189  */
1190
1191 int
1192 cl_51core::inst_clr_a(uchar code)
1193 {
1194   acc->write(0);
1195   return(resGO);
1196 }
1197
1198
1199 /*
1200  * 0xc4 1 1 SWAP A
1201  */
1202
1203 int
1204 cl_51core::inst_swap(uchar code)
1205 {
1206   uchar temp;
1207
1208   temp= (acc->read() >> 4) & 0x0f;
1209   sfr->write(ACC, (acc->get() << 4) | temp);
1210   return(resGO);
1211 }
1212
1213
1214 /*
1215  */
1216
1217 cl_uc51_dummy_hw::cl_uc51_dummy_hw(class cl_uc *auc):
1218   cl_hw(auc, HW_DUMMY, 0, "_51_dummy")
1219 {
1220   //uc51= (class cl_51core *)uc;
1221 }
1222
1223 int
1224 cl_uc51_dummy_hw::init(void)
1225 {
1226   class cl_address_space *sfr= uc->address_space(MEM_SFR_ID);
1227   if (!sfr)
1228     {
1229       fprintf(stderr, "No SFR to register %s[%d] into\n", id_string, id);
1230     }
1231   //acc= sfr->register_hw(ACC, this, 0);
1232   //sp = sfr->register_hw(SP , this, 0);
1233   use_cell(sfr, PSW, &cell_psw, wtd_restore);
1234   register_cell(sfr, ACC, &cell_acc, wtd_restore_write);
1235   register_cell(sfr, SP , &cell_sp , wtd_restore);
1236   //register_cell(sfr, PCON, &cell_pcon, wtd_restore);
1237   return(0);
1238 }
1239
1240 void
1241 cl_uc51_dummy_hw::write(class cl_memory_cell *cell, t_mem *val)
1242 {
1243   if (cell == cell_acc)
1244     {
1245       bool p;
1246       int i;
1247       uchar uc;
1248
1249       p = DD_FALSE;
1250       uc= *val;
1251       for (i= 0; i < 8; i++)
1252         {
1253           if (uc & 1)
1254             p= !p;
1255           uc>>= 1;
1256         }
1257       if (p)
1258         cell_psw->set_bit1(bmP);
1259       else
1260         cell_psw->set_bit0(bmP);
1261     }
1262   else if (cell == cell_sp)
1263     {
1264       if (*val > uc->sp_max)
1265         uc->sp_max= *val;
1266       uc->sp_avg= (uc->sp_avg+(*val))/2;
1267     }
1268   /*else if (cell == cell_pcon)
1269     {
1270       printf("PCON write 0x%x (PC=0x%x)\n", *val, uc->PC);
1271       uc->sim->stop(0);
1272       }*/
1273 }
1274
1275 /*void
1276 cl_uc51_dummy_hw::happen(class cl_hw *where, enum hw_event he, void *params)
1277 {
1278   struct ev_port_changed *ep= (struct ev_port_changed *)params;
1279
1280   if (where->cathegory == HW_PORT &&
1281       he == EV_PORT_CHANGED &&
1282       ep->id == 3)
1283     {
1284       t_mem p3o= ep->pins & ep->prev_value;
1285       t_mem p3n= ep->new_pins & ep->new_value;
1286       if ((p3o & bm_INT0) &&
1287           !(p3n & bm_INT0))
1288         uc51->p3_int0_edge++;
1289       if ((p3o & bm_INT1) &&
1290           !(p3n & bm_INT1))
1291         uc51->p3_int1_edge++;
1292     }
1293 }*/
1294
1295
1296 /* End of s51.src/uc51.cc */