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