palacios/src/devices/8254.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  11  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  12  * All rights reserved.
  13  *
  14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
  15  *
  16  * This is free software.  You are permitted to use,
  17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  18  */
  19
  20 #include <devices/8254.h>
  21 #include <palacios/vmm.h>
  22 #include <palacios/vmm_time.h>
  23 #include <palacios/vmm_util.h>
  24 #include <palacios/vmm_intr.h>
  25
  26
  27
  28 #ifndef DEBUG_PIT
  29 #undef PrintDebug
  30 #define PrintDebug(fmt, args...)
  31 #endif
  32
  33
  34
  35 // constants
  36 #define OSC_HZ 1193182
  37
  38
  39 /* The 8254 has three counters and one control port */
  40 #define CHANNEL0_PORT 0x40
  41 #define CHANNEL1_PORT 0x41
  42 #define CHANNEL2_PORT 0x42
  43 #define COMMAND_PORT 0x43
  44
  45
  46 #define PIT_INTR_NUM 0
  47
  48 /* The order of these typedefs is important because the numerical values correspond to the
  49  * values coming from the io ports
  50  */
  51 typedef enum {NOT_RUNNING, PENDING, RUNNING} channel_run_state_t;
  52 typedef enum {NOT_WAITING, WAITING_LOBYTE, WAITING_HIBYTE} channel_access_state_t;
  53 typedef enum {LATCH_COUNT, LOBYTE_ONLY, HIBYTE_ONLY, LOBYTE_HIBYTE} channel_access_mode_t;
  54 typedef enum {IRQ_ON_TERM_CNT, ONE_SHOT, RATE_GEN, SQR_WAVE, SW_STROBE, HW_STROBE} channel_op_mode_t;
  55
  56
  57 struct channel {
  58     channel_access_mode_t access_mode;
  59     channel_access_state_t access_state;
  60     channel_run_state_t run_state;
  61
  62     channel_op_mode_t op_mode;
  63
  64
  65     // Time til interrupt trigger
  66
  67     ushort_t counter;
  68     ushort_t reload_value;
  69
  70     ushort_t latched_value;
  71
  72     enum {NOTLATCHED, LATCHED} latch_state;
  73
  74     enum {LSB, MSB} read_state;
  75
  76     uint_t output_pin : 1;
  77     uint_t gate_input_pin : 1;
  78 };
  79
  80
  81 struct pit {
  82
  83     ullong_t pit_counter;
  84     ullong_t pit_reload;
  85
  86
  87     struct channel ch_0;
  88     struct channel ch_1;
  89     struct channel ch_2;
  90 };
  91
  92
  93 struct pit_cmd_word {
  94     uint_t bcd_mode    : 1;
  95     uint_t op_mode     : 3;
  96     uint_t access_mode : 2;
  97     uint_t channel     : 2;
  98 };
  99
 100 struct pit_rdb_cmd_word {
 101     uint_t rsvd         : 1; // SBZ
 102     uint_t ch_0         : 1;
 103     uint_t ch_1         : 1;
 104     uint_t ch_2         : 1;
 105     uint_t latch_status : 1;
 106     uint_t latch_count  : 1;
 107     uint_t readback_cmd : 2; // Must Be 0x3
 108 };
 109
 110 struct pit_rdb_status_word {
 111     uint_t bcd_mode     : 1;
 112     uint_t op_mode      : 3;
 113     uint_t access_mode  : 2;
 114     uint_t null_count   : 1;
 115     uint_t pin_state    : 1;
 116 };
 117
 118
 119
 120 /*
 121  * This should call out to handle_SQR_WAVE_tics, etc...
 122  */
 123 // Returns true if the the output signal changed state
 124 static int handle_crystal_tics(struct vm_device * dev, struct channel * ch, uint_t oscillations) {
 125     uint_t channel_cycles = 0;
 126     uint_t output_changed = 0;
 127
 128     // PrintDebug("8254 PIT: %d crystal tics\n", oscillations);
 129     if (ch->run_state == PENDING) {
 130         oscillations--;
 131         ch->counter = ch->reload_value;
 132
 133         if (ch->op_mode == SQR_WAVE) {
 134             ch->counter -= ch->counter % 2;
 135         }
 136
 137         ch->run_state = RUNNING;
 138     } else if (ch->run_state != RUNNING) {
 139         return output_changed;
 140     }
 141
 142     /*
 143       PrintDebug("8254 PIT: Channel Run State = %d, counter=", ch->run_state);
 144       PrintTraceLL(ch->counter);
 145       PrintDebug("\n");
 146     */
 147     if (ch->op_mode == SQR_WAVE) {
 148         oscillations *= 2;
 149     }
 150
 151     if (ch->counter > oscillations) {
 152         ch->counter -= oscillations;
 153         return output_changed;
 154     } else {
 155         ushort_t reload_val = ch->reload_value;
 156
 157         if (ch->op_mode == SW_STROBE) {
 158             reload_val = 0xffff;
 159         }
 160
 161         // TODO: Check this....
 162         // Is this correct???
 163         if (reload_val == 0) {
 164             reload_val = 1;
 165         }
 166
 167         oscillations -= ch->counter;
 168         ch->counter = 0;
 169         channel_cycles = 1;
 170
 171         if (ch->op_mode == SQR_WAVE) {
 172             reload_val -= reload_val % 2;
 173         }
 174
 175         channel_cycles += oscillations / reload_val;
 176         oscillations = oscillations % reload_val;
 177
 178         ch->counter = reload_val - oscillations;
 179     }
 180
 181     //  PrintDebug("8254 PIT: Channel Cycles: %d\n", channel_cycles);
 182
 183
 184
 185     switch (ch->op_mode) {
 186         case IRQ_ON_TERM_CNT:
 187             if ((channel_cycles > 0) && (ch->output_pin == 0)) {
 188                 ch->output_pin = 1;
 189                 output_changed = 1;
 190             }
 191             break;
 192         case ONE_SHOT:
 193             if ((channel_cycles > 0) && (ch->output_pin == 0)) {
 194                 ch->output_pin = 1;
 195                 output_changed = 1;
 196             }
 197             break;
 198         case RATE_GEN:
 199             // See the data sheet: we ignore the output pin cycle...
 200             if (channel_cycles > 0) {
 201                 output_changed = 1;
 202             }
 203             break;
 204         case SQR_WAVE:
 205             ch->output_pin = (ch->output_pin + 1) % 2;
 206
 207             if (ch->output_pin == 1) {
 208                 output_changed = 1;
 209             }
 210
 211             break;
 212         case SW_STROBE:
 213
 214             if (channel_cycles > 0) {
 215                 if (ch->output_pin == 1) {
 216                     ch->output_pin = 0;
 217                     output_changed = 1;
 218                 }
 219             }
 220             break;
 221         case HW_STROBE:
 222             PrintError("Hardware strobe not implemented\n");
 223             return -1;
 224             break;
 225         default:
 226             break;
 227     }
 228
 229     return output_changed;
 230 }
 231
 232
 233
 234 static void pit_update_time(ullong_t cpu_cycles, ullong_t cpu_freq, void * private_data) {
 235     struct vm_device * dev = (struct vm_device *)private_data;
 236     struct pit * state = (struct pit *)dev->private_data;
 237     //  ullong_t tmp_ctr = state->pit_counter;
 238     ullong_t tmp_cycles;
 239     uint_t oscillations = 0;
 240
 241
 242     /*
 243       PrintDebug("updating cpu_cycles=");
 244       PrintTraceLL(cpu_cycles);
 245       PrintDebug("\n");
 246
 247       PrintDebug("pit_counter=");
 248       PrintTraceLL(state->pit_counter);
 249       PrintDebug("\n");
 250
 251       PrintDebug("pit_reload=");
 252       PrintTraceLL(state->pit_reload);
 253       PrintDebug("\n");
 254     */
 255
 256     if (state->pit_counter > cpu_cycles) {
 257         // Easy...
 258         state->pit_counter -= cpu_cycles;
 259     } else {
 260         ushort_t reload_val = state->pit_reload;
 261         // Take off the first part
 262         cpu_cycles -= state->pit_counter;
 263         state->pit_counter = 0;
 264         oscillations = 1;
 265
 266         if (cpu_cycles > state->pit_reload) {
 267             // how many full oscillations
 268
 269             //PrintError("cpu_cycles = %p, reload = %p...\n",
 270             //   (void *)(addr_t)cpu_cycles,
 271             //   (void *)(addr_t)state->pit_reload);
 272
 273             // How do we check for a one shot....
 274             if (state->pit_reload == 0) {
 275                 reload_val = 1;
 276             }
 277
 278             tmp_cycles = cpu_cycles;
 279
 280
 281 #ifdef __V3_64BIT__
 282             cpu_cycles = tmp_cycles % state->pit_reload;
 283             tmp_cycles = tmp_cycles / state->pit_reload;
 284 #else
 285             cpu_cycles = do_divll(tmp_cycles, state->pit_reload);
 286 #endif
 287
 288             oscillations += tmp_cycles;
 289         }
 290
 291         // update counter with remainder (mod reload)
 292         state->pit_counter = state->pit_reload - cpu_cycles;
 293
 294         //PrintDebug("8254 PIT: Handling %d crystal tics\n", oscillations);
 295         if (handle_crystal_tics(dev, &(state->ch_0), oscillations) == 1) {
 296             // raise interrupt
 297             PrintDebug("8254 PIT: Injecting Timer interrupt to guest\n");
 298             v3_raise_irq(dev->vm, 0);
 299         }
 300
 301         //handle_crystal_tics(dev, &(state->ch_1), oscillations);
 302         //handle_crystal_tics(dev, &(state->ch_2), oscillations);
 303     }
 304
 305
 306
 307
 308     return;
 309 }
 310
 311
 312
 313 /* This should call out to handle_SQR_WAVE_write, etc...
 314  */
 315 static int handle_channel_write(struct channel * ch, char val) {
 316
 317     switch (ch->access_state) {
 318         case WAITING_HIBYTE:
 319             {
 320                 ushort_t tmp_val = ((ushort_t)val) << 8;
 321                 ch->reload_value &= 0x00ff;
 322                 ch->reload_value |= tmp_val;
 323
 324
 325                 if ((ch->op_mode != RATE_GEN) || (ch->run_state != RUNNING)){
 326                     ch->run_state = PENDING;
 327                 }
 328
 329                 if (ch->access_mode == LOBYTE_HIBYTE) {
 330                     ch->access_state = WAITING_LOBYTE;
 331                 }
 332
 333                 PrintDebug("8254 PIT: updated channel counter: %d\n", ch->reload_value);
 334                 PrintDebug("8254 PIT: Channel Run State=%d\n", ch->run_state);
 335                 break;
 336             }
 337         case WAITING_LOBYTE:
 338             ch->reload_value &= 0xff00;
 339             ch->reload_value |= val;
 340
 341             if (ch->access_mode == LOBYTE_HIBYTE) {
 342                 ch->access_state = WAITING_HIBYTE;
 343             } else if ((ch->op_mode != RATE_GEN) || (ch->run_state != RUNNING)) {
 344                 ch->run_state = PENDING;
 345             }
 346
 347             PrintDebug("8254 PIT: updated channel counter: %d\n", ch->reload_value);
 348             PrintDebug("8254 PIT: Channel Run State=%d\n", ch->run_state);
 349             break;
 350         default:
 351             PrintError("Invalid Access state\n");
 352             return -1;
 353     }
 354
 355
 356     switch (ch->op_mode) {
 357         case IRQ_ON_TERM_CNT:
 358             ch->output_pin = 0;
 359             break;
 360         case ONE_SHOT:
 361             ch->output_pin = 1;
 362             break;
 363         case RATE_GEN:
 364             ch->output_pin = 1;
 365             break;
 366         case SQR_WAVE:
 367             ch->output_pin = 1;
 368             break;
 369         case SW_STROBE:
 370             ch->output_pin = 1;
 371             break;
 372         default:
 373             PrintError("Invalid OP_MODE: %d\n", ch->op_mode);
 374             return -1;
 375             break;
 376     }
 377
 378
 379     return 0;
 380 }
 381
 382
 383 static int handle_channel_read(struct channel * ch, char * val) {
 384
 385     ushort_t * myval;
 386
 387     if (ch->latch_state == NOTLATCHED) {
 388         myval = &(ch->counter);
 389     } else {
 390         myval = &(ch->latched_value);
 391     }
 392
 393     if (ch->read_state == LSB) {
 394         *val = ((char*)myval)[0];  // little endian
 395         ch->read_state = MSB;
 396     } else {
 397         *val = ((char*)myval)[1];
 398         ch->read_state = LSB;
 399         if (ch->latch_state == LATCHED) {
 400             ch->latch_state = NOTLATCHED;
 401         }
 402     }
 403
 404     return 0;
 405
 406 }
 407
 408
 409
 410
 411
 412 static int handle_channel_cmd(struct channel * ch, struct pit_cmd_word cmd) {
 413     ch->op_mode = cmd.op_mode;
 414     ch->access_mode = cmd.access_mode;
 415
 416
 417
 418
 419     switch (cmd.access_mode) {
 420         case LATCH_COUNT:
 421             if (ch->latch_state == NOTLATCHED) {
 422                 ch->latched_value = ch->counter;
 423                 ch->latch_state = LATCHED;
 424             }
 425             break;
 426         case HIBYTE_ONLY:
 427             ch->access_state = WAITING_HIBYTE;
 428             break;
 429         case LOBYTE_ONLY:
 430         case LOBYTE_HIBYTE:
 431             ch->access_state = WAITING_LOBYTE;
 432             break;
 433     }
 434
 435
 436     switch (cmd.op_mode) {
 437         case IRQ_ON_TERM_CNT:
 438             ch->output_pin = 0;
 439             break;
 440         case ONE_SHOT:
 441             ch->output_pin = 1;
 442             break;
 443         case RATE_GEN:
 444             ch->output_pin = 1;
 445             break;
 446         case SQR_WAVE:
 447             ch->output_pin = 1;
 448             break;
 449         case SW_STROBE:
 450             ch->output_pin = 1;
 451             break;
 452         default:
 453             PrintError("Invalid OP_MODE: %d\n", cmd.op_mode);
 454             return -1;
 455     }
 456
 457     return 0;
 458
 459 }
 460
 461
 462
 463
 464 static int pit_read_channel(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
 465     struct pit * state = (struct pit *)dev->private_data;
 466     char * val = (char *)dst;
 467
 468     if (length != 1) {
 469         PrintError("8254 PIT: Invalid Read Write length \n");
 470         return -1;
 471     }
 472
 473     PrintDebug("8254 PIT: Read of PIT Channel %d\n", port - CHANNEL0_PORT);
 474
 475     switch (port) {
 476         case CHANNEL0_PORT:
 477             if (handle_channel_read(&(state->ch_0), val) == -1) {
 478                 PrintError("CHANNEL0 read error\n");
 479                 return -1;
 480             }
 481             break;
 482         case CHANNEL1_PORT:
 483             if (handle_channel_read(&(state->ch_1), val) == -1) {
 484                 PrintError("CHANNEL1 read error\n");
 485                 return -1;
 486             }
 487             break;
 488         case CHANNEL2_PORT:
 489             if (handle_channel_read(&(state->ch_2), val) == -1) {
 490                 PrintError("CHANNEL2 read error\n");
 491                 return -1;
 492             }
 493             break;
 494         default:
 495             PrintError("8254 PIT: Read from invalid port (%d)\n", port);
 496             return -1;
 497     }
 498
 499     return length;
 500 }
 501
 502
 503
 504 static int pit_write_channel(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 505     struct pit * state = (struct pit *)dev->private_data;
 506     char val = *(char *)src;
 507
 508     if (length != 1) {
 509         PrintError("8254 PIT: Invalid Write Length\n");
 510         return -1;
 511     }
 512
 513     PrintDebug("8254 PIT: Write to PIT Channel %d (%x)\n", port - CHANNEL0_PORT, *(char*)src);
 514
 515
 516     switch (port) {
 517         case CHANNEL0_PORT:
 518             if (handle_channel_write(&(state->ch_0), val) == -1) {
 519                 PrintError("CHANNEL0 write error\n");
 520                 return -1;
 521             }
 522             break;
 523         case CHANNEL1_PORT:
 524             if (handle_channel_write(&(state->ch_1), val) == -1) {
 525                 PrintError("CHANNEL1 write error\n");
 526                 return -1;
 527             }
 528             break;
 529         case CHANNEL2_PORT:
 530             if (handle_channel_write(&(state->ch_2), val) == -1) {
 531                 PrintError("CHANNEL2 write error\n");
 532                 return -1;
 533             }
 534             break;
 535         default:
 536             PrintError("8254 PIT: Write to invalid port (%d)\n", port);
 537             return -1;
 538     }
 539
 540     return length;
 541 }
 542
 543
 544
 545
 546 static int pit_write_command(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 547     struct pit * state = (struct pit *)dev->private_data;
 548     struct pit_cmd_word * cmd = (struct pit_cmd_word *)src;
 549
 550     PrintDebug("8254 PIT: Write to PIT Command port\n");
 551     PrintDebug("8254 PIT: Writing to channel %d (access_mode = %d, op_mode = %d)\n", cmd->channel, cmd->access_mode, cmd->op_mode);
 552     if (length != 1) {
 553         PrintError("8254 PIT: Write of Invalid length to command port\n");
 554         return -1;
 555     }
 556
 557     switch (cmd->channel) {
 558         case 0:
 559             if (handle_channel_cmd(&(state->ch_0), *cmd) == -1) {
 560                 PrintError("CHANNEL0 command error\n");
 561                 return -1;
 562             }
 563             break;
 564         case 1:
 565             if (handle_channel_cmd(&(state->ch_1), *cmd) == -1) {
 566                 PrintError("CHANNEL1 command error\n");
 567                 return -1;
 568             }
 569             break;
 570         case 2:
 571             if (handle_channel_cmd(&(state->ch_2), *cmd) == -1) {
 572                 PrintError("CHANNEL2 command error\n");
 573                 return -1;
 574             }
 575             break;
 576         case 3:
 577             // Read Back command
 578             PrintError("Read back command not implemented\n");
 579             return -1;
 580             break;
 581         default:
 582             break;
 583     }
 584
 585
 586     return length;
 587 }
 588
 589
 590
 591
 592 static struct vm_timer_ops timer_ops = {
 593     .update_time = pit_update_time,
 594 };
 595
 596
 597 static void init_channel(struct channel * ch) {
 598     ch->run_state = NOT_RUNNING;
 599     ch->access_state = NOT_WAITING;
 600     ch->access_mode = 0;
 601     ch->op_mode = 0;
 602
 603     ch->counter = 0;
 604     ch->reload_value = 0;
 605     ch->output_pin = 0;
 606     ch->gate_input_pin = 0;
 607
 608     ch->latched_value = 0;
 609     ch->latch_state = NOTLATCHED;
 610     ch->read_state = LSB;
 611
 612     return;
 613 }
 614
 615
 616 static int pit_init(struct vm_device * dev) {
 617     struct pit * state = (struct pit *)dev->private_data;
 618     uint_t cpu_khz = V3_CPU_KHZ();
 619     ullong_t reload_val = (ullong_t)cpu_khz * 1000;
 620
 621     v3_dev_hook_io(dev, CHANNEL0_PORT, &pit_read_channel, &pit_write_channel);
 622     v3_dev_hook_io(dev, CHANNEL1_PORT, &pit_read_channel, &pit_write_channel);
 623     v3_dev_hook_io(dev, CHANNEL2_PORT, &pit_read_channel, &pit_write_channel);
 624     v3_dev_hook_io(dev, COMMAND_PORT, NULL, &pit_write_command);
 625
 626 #ifdef DEBUG_PIT
 627     PrintDebug("8254 PIT: OSC_HZ=%d, reload_val=", OSC_HZ);
 628     PrintTraceLL(reload_val);
 629     PrintDebug("\n");
 630 #endif
 631
 632     v3_add_timer(dev->vm, &timer_ops, dev);
 633
 634     // Get cpu frequency and calculate the global pit oscilattor counter/cycle
 635
 636     do_divll(reload_val, OSC_HZ);
 637     state->pit_counter = reload_val;
 638     state->pit_reload = reload_val;
 639
 640
 641
 642     init_channel(&(state->ch_0));
 643     init_channel(&(state->ch_1));
 644     init_channel(&(state->ch_2));
 645
 646 #ifdef DEBUG_PIT
 647     PrintDebug("8254 PIT: CPU MHZ=%d -- pit count=", cpu_khz / 1000);
 648     PrintTraceLL(state->pit_counter);
 649     PrintDebug("\n");
 650 #endif
 651
 652     return 0;
 653 }
 654
 655 static int pit_deinit(struct vm_device * dev) {
 656
 657     return 0;
 658 }
 659
 660
 661 static struct vm_device_ops dev_ops = {
 662     .init = pit_init,
 663     .deinit = pit_deinit,
 664     .reset = NULL,
 665     .start = NULL,
 666     .stop = NULL,
 667
 668 };
 669
 670
 671 struct vm_device * v3_create_pit() {
 672     struct pit * pit_state = NULL;
 673     pit_state = (struct pit *)V3_Malloc(sizeof(struct pit));
 674     V3_ASSERT(pit_state != NULL);
 675
 676     struct vm_device * dev = v3_create_device("PIT", &dev_ops, pit_state);
 677
 678     return dev;
 679 }