sim/ppc/hw_com.c

   1 /*  This file is part of the program psim.
   2
   3     Copyright (C) 1994-1996, Andrew Cagney <cagney@highland.com.au>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, see <http://www.gnu.org/licenses/>.
  17
  18     */
  19
  20
  21 #ifndef _HW_COM_C_
  22 #define _HW_COM_C_
  23
  24 #ifndef STATIC_INLINE_HW_COM
  25 #define STATIC_INLINE_HW_COM STATIC_INLINE
  26 #endif
  27
  28 #include "device_table.h"
  29
  30 #ifdef HAVE_STRING_H
  31 #include <string.h>
  32 #else
  33 #ifdef HAVE_STRINGS_H
  34 #include <strings.h>
  35 #endif
  36 #endif
  37
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41 #ifdef HAVE_STDLIB_H
  42 #include <stdlib.h>
  43 #endif
  44
  45 /* DEVICE
  46
  47
  48    com - '550 compatible serial device
  49
  50
  51    DESCRIPTION
  52
  53
  54    Models the basics of the 8 register '550 serial device.  The model
  55    includes an interrupt line, input and output fifos, and status
  56    information.
  57
  58    Independent configuration of the devices input and output streams is
  59    allowed: use either the console or a file (buffered or unbuffered) as
  60    the data source/sink; specify the real-time delay between each character
  61    transfer.
  62
  63    When the devices input stream is being taken from a file, the end of
  64    file is signaled by a loss of carrier (the loss of carrier may be
  65    incorrectly proceeded by a single null character).
  66
  67
  68    PROPERTIES
  69
  70
  71    reg = <address> <size> ... (optional - note 1)
  72
  73    List of <address> <size> pairs.  Each pair specifies an address for
  74    the devices 8 registers.  The address should be 8 byte aligned.
  75
  76
  77    alternate-reg = <address> <size> ... (optional - note 1)
  78
  79    Alternative addreses for the registers.
  80
  81
  82    assigned-addresses = <address> <size> ... (optional - note 1)
  83
  84    On a PCI bus, this property specifies the addresses assigned to the
  85    device.  The values reflect the devices configuration base registers.
  86
  87    Note 1: At least one of "assigned-addresses", "reg" or "alternative-reg"
  88    must be specified.  If "assigned-addresses" is specified the other
  89    address specifications are ignored.
  90
  91
  92    input-file = <file-name> (optional)
  93
  94    File to take all serial port input from (instead of the simulation
  95    console).
  96
  97
  98    output-file = <file-name> (optional)
  99
 100    File to send all output to (instead of the simulation console).
 101
 102
 103    input-buffering = "unbuffered" (optional)
 104
 105    Specifying "unbuffered" buffering disables buffering on the serial
 106    devices input stream (all data is immediately read).  In the future,
 107    this option may be used to provide input buffering alternatives.
 108
 109
 110    output-buffering = "unbuffered" (optional)
 111
 112    Specifying "unbuffered" buffering disables buffering on the serial
 113    devices output stream (all data is immediately written).  In the future,
 114    this option may be extended to include other buffering alternatives.
 115
 116
 117    input-delay = <integer-delay> (optional)
 118
 119    Specify the number of ticks after the current character has been
 120    read from the serial port that the next character becomes
 121    available.
 122
 123
 124    output-delay = <integer-delay> (optional)
 125
 126    Specify the number of ticks after a character has been written to
 127    the empty output fifo that the fifo finishes draining.  Any
 128    characters written to the output fifo before it has drained will
 129    not be lost and will still be displayed.
 130
 131
 132    EXAMPLES
 133
 134
 135    |  /iobus@0xf0000000/com@0x3000/reg 0x3000 8
 136
 137    Create a simple console device at address <<0x3000>> within
 138    <<iobus>>.  Since iobus starts at address <<0xf0000000>> the
 139    absolute address of the serial port will be <<0xf0003000>>.
 140
 141    The device will always be ready for I/O (no delay properties specified)
 142    and both the input and output streams will use the simulation console
 143    (no file properties).
 144
 145
 146    |  $ psim \
 147    |    -o '/cpus/cpu@0' \
 148    |    -o '/iobus@0xf0000000/com@0x4000/reg 0x4000 8' \
 149    |    -o '/iobus@0xf0000000/com@0x4000/input-file /etc/passwd' \
 150    |    -o '/iobus@0xf0000000/com@0x4000/input-delay 1000' \
 151    |    -o '/iobus@0xf0000000/com@0x4000 > 0 int /cpus/cpu@0x0' \
 152    |    psim-test/hw-com/cat.be 0xf0004000
 153
 154    The serial port (at address <<0xf0004000>> is configured so that it
 155    takes its input from the file <</etc/passwd>> while its output is
 156    allowed to appear on the simulation console.
 157
 158    The node <</cpus/cpu@0>> was explicitly specified to ensure that it had
 159    been created before any interrupts were attached to it.
 160
 161    The program <<psim-test/hw-com/cat>> copies any characters on the serial
 162    port's input (<</etc/passwd>>) to its output (the console).
 163    Consequently, the aove program will display the contents of the file
 164    <</etc/passwd>> on the screen.
 165
 166
 167    BUGS
 168
 169
 170    IEEE 1275 requires that a device on a PCI bus have, as its first reg
 171    entry, the address of its configuration space registers.  Currently,
 172    this device does not even implement configuration registers.
 173
 174    This model does not attempt to model the '550's input and output fifos.
 175    Instead, the input fifo is limited to a single character at a time,
 176    while the output fifo is effectivly infinite.  Consequently, unlike the
 177    '550, this device will not discard output characters once a stream of 16
 178    have been written to the data output register.
 179
 180    The input and output can only be taken from a file (or the current
 181    terminal device).  In the future, the <<com>> device should allow the
 182    specification of other data streams (such as an xterm or TK window).
 183
 184    The input blocks if no data is available.
 185
 186    Interrupts have not been tested.
 187
 188    */
 189
 190 enum {
 191   max_hw_com_registers = 8,
 192 };
 193
 194 typedef struct _com_port {
 195   int ready;
 196   int delay;
 197   int interrupting;
 198   FILE *file;
 199 } com_port;
 200
 201 typedef struct _com_modem {
 202   int carrier;
 203   int carrier_changed;
 204   int interrupting;
 205 } com_modem;
 206
 207 typedef struct _hw_com_device {
 208   com_port input;
 209   com_port output;
 210   com_modem modem;
 211   char dlab[2];
 212   char reg[max_hw_com_registers];
 213   int interrupting;
 214 } hw_com_device;
 215
 216
 217 static void
 218 hw_com_device_init_data(device *me)
 219 {
 220   hw_com_device *com = (hw_com_device*)device_data(me);
 221   /* clean up */
 222   if (com->output.file != NULL)
 223     fclose(com->output.file);
 224   if (com->input.file != NULL)
 225     fclose(com->input.file);
 226   memset(com, 0, sizeof(hw_com_device));
 227
 228   /* the fifo speed */
 229   com->output.delay = (device_find_property(me, "output-delay") != NULL
 230                        ? device_find_integer_property(me, "output-delay")
 231                        : 0);
 232   com->input.delay = (device_find_property(me, "input-delay") != NULL
 233                       ? device_find_integer_property(me, "input-delay")
 234                       : 0);
 235
 236   /* the data source/sink */
 237   if (device_find_property(me, "input-file") != NULL) {
 238     const char *input_file = device_find_string_property(me, "input-file");
 239     com->input.file = fopen(input_file, "r");
 240     if (com->input.file == NULL)
 241       device_error(me, "Problem opening input file %s\n", input_file);
 242     if (device_find_property(me, "input-buffering") != NULL) {
 243       const char *buffering = device_find_string_property(me, "input-buffering");
 244       if (strcmp(buffering, "unbuffered") == 0)
 245         setbuf(com->input.file, NULL);
 246     }
 247   }
 248   if (device_find_property(me, "output-file") != NULL) {
 249     const char *output_file = device_find_string_property(me, "output-file");
 250     com->output.file = fopen(output_file, "w");
 251     if (com->output.file == NULL)
 252       device_error(me, "Problem opening output file %s\n", output_file);
 253     if (device_find_property(me, "output-buffering") != NULL) {
 254       const char *buffering = device_find_string_property(me, "output-buffering");
 255       if (strcmp(buffering, "unbuffered") == 0)
 256         setbuf(com->output.file, NULL);
 257     }
 258   }
 259
 260   /* ready from the start */
 261   com->input.ready = 1;
 262   com->modem.carrier = 1;
 263   com->output.ready = 1;
 264 }
 265
 266
 267 static void
 268 update_com_interrupts(device *me,
 269                       hw_com_device *com)
 270 {
 271   int interrupting;
 272   com->modem.interrupting = (com->modem.carrier_changed && (com->reg[1] & 0x80));
 273   com->input.interrupting = (com->input.ready && (com->reg[1] & 0x1));
 274   com->output.interrupting = (com->output.ready && (com->reg[1] & 0x2));
 275   interrupting = (com->input.interrupting
 276                   || com->output.interrupting
 277                   || com->modem.interrupting);
 278
 279   if (interrupting) {
 280     if (!com->interrupting) {
 281       device_interrupt_event(me, 0 /*port*/, 1 /*value*/, NULL, 0);
 282     }
 283   }
 284   else /*!interrupting*/ {
 285     if (com->interrupting)
 286       device_interrupt_event(me, 0 /*port*/, 0 /*value*/, NULL, 0);
 287   }
 288   com->interrupting = interrupting;
 289 }
 290
 291
 292 static void
 293 make_read_ready(void *data)
 294 {
 295   device *me = (device*)data;
 296   hw_com_device *com = (hw_com_device*)device_data(me);
 297   com->input.ready = 1;
 298   update_com_interrupts(me, com);
 299 }
 300
 301 static void
 302 read_com(device *me,
 303          hw_com_device *com,
 304          unsigned_word a,
 305          char val[1])
 306 {
 307   unsigned_word addr = a % 8;
 308
 309   /* the divisor latch is special */
 310   if (com->reg[3] & 0x8 && addr < 2) {
 311     *val = com->dlab[addr];
 312     return;
 313   }
 314
 315   switch (addr) {
 316
 317   case 0:
 318     /* fifo */
 319     if (!com->modem.carrier)
 320       *val = '\0';
 321     if (com->input.ready) {
 322       /* read the char in */
 323       if (com->input.file == NULL) {
 324         if (sim_io_read_stdin(val, 1) < 0)
 325           com->modem.carrier_changed = 1;
 326       }
 327       else {
 328         if (fread(val, 1, 1, com->input.file) == 0)
 329           com->modem.carrier_changed = 1;
 330       }
 331       /* setup for next read */
 332       if (com->modem.carrier_changed) {
 333         /* once lost carrier, never ready */
 334         com->modem.carrier = 0;
 335         com->input.ready = 0;
 336         *val = '\0';
 337       }
 338       else if (com->input.delay > 0) {
 339         com->input.ready = 0;
 340         device_event_queue_schedule(me, com->input.delay, make_read_ready, me);
 341       }
 342     }
 343     else {
 344       /* discard it? */
 345       /* overflow input fifo? */
 346       *val = '\0';
 347     }
 348     break;
 349
 350   case 2:
 351     /* interrupt ident */
 352     if (com->interrupting) {
 353       if (com->input.interrupting)
 354         *val = 0x4;
 355       else if (com->output.interrupting)
 356         *val = 0x2;
 357       else if (com->modem.interrupting == 0)
 358         *val = 0;
 359       else
 360         device_error(me, "bad elif for interrupts\n");
 361     }
 362     else
 363       *val = 0x1;
 364     break;
 365
 366   case 5:
 367     /* line status */
 368     *val = ((com->input.ready ? 0x1 : 0)
 369             | (com->output.ready ? 0x60 : 0)
 370             );
 371     break;
 372
 373   case 6:
 374     /* modem status */
 375     *val = ((com->modem.carrier_changed ? 0x08 : 0)
 376             | (com->modem.carrier ? 0x80 : 0)
 377             );
 378     com->modem.carrier_changed = 0;
 379     break;
 380
 381   default:
 382     *val = com->reg[addr];
 383     break;
 384
 385   }
 386   update_com_interrupts(me, com);
 387 }
 388
 389 static unsigned
 390 hw_com_io_read_buffer_callback(device *me,
 391                                void *dest,
 392                                int space,
 393                                unsigned_word addr,
 394                                unsigned nr_bytes,
 395                                cpu *processor,
 396                                unsigned_word cia)
 397 {
 398   hw_com_device *com = device_data(me);
 399   int i;
 400   for (i = 0; i < nr_bytes; i++) {
 401     read_com(me, com, addr + i, &((char*)dest)[i]);
 402   }
 403   return nr_bytes;
 404 }
 405
 406
 407 static void
 408 make_write_ready(void *data)
 409 {
 410   device *me = (device*)data;
 411   hw_com_device *com = (hw_com_device*)device_data(me);
 412   com->output.ready = 1;
 413   update_com_interrupts(me, com);
 414 }
 415
 416 static void
 417 write_com(device *me,
 418           hw_com_device *com,
 419           unsigned_word a,
 420           char val)
 421 {
 422   unsigned_word addr = a % 8;
 423
 424   /* the divisor latch is special */
 425   if (com->reg[3] & 0x8 && addr < 2) {
 426     com->dlab[addr] = val;
 427     return;
 428   }
 429
 430   switch (addr) {
 431
 432   case 0:
 433     /* fifo */
 434     if (com->output.file == NULL) {
 435       sim_io_write_stdout(&val, 1);
 436     }
 437     else {
 438       fwrite(&val, 1, 1, com->output.file);
 439     }
 440     /* setup for next write */
 441     if (com->output.ready && com->output.delay > 0) {
 442       com->output.ready = 0;
 443       device_event_queue_schedule(me, com->output.delay, make_write_ready, me);
 444     }
 445     break;
 446
 447   default:
 448     com->reg[addr] = val;
 449     break;
 450
 451   }
 452   update_com_interrupts(me, com);
 453 }
 454
 455 static unsigned
 456 hw_com_io_write_buffer_callback(device *me,
 457                                 const void *source,
 458                                 int space,
 459                                 unsigned_word addr,
 460                                 unsigned nr_bytes,
 461                                 cpu *processor,
 462                                 unsigned_word cia)
 463 {
 464   hw_com_device *com = device_data(me);
 465   int i;
 466   for (i = 0; i < nr_bytes; i++) {
 467     write_com(me, com, addr + i, ((char*)source)[i]);
 468   }
 469   return nr_bytes;
 470 }
 471
 472
 473 /* instances of the hw_com device */
 474
 475 static void
 476 hw_com_instance_delete(device_instance *instance)
 477 {
 478   /* nothing to delete, the hw_com is attached to the device */
 479   return;
 480 }
 481
 482 static int
 483 hw_com_instance_read(device_instance *instance,
 484                      void *buf,
 485                      unsigned_word len)
 486 {
 487   device *me = device_instance_device(instance);
 488   hw_com_device *com = device_data(me);
 489   if (com->input.file == NULL)
 490     return sim_io_read_stdin(buf, len);
 491   else {
 492     return fread(buf, 1, len, com->input.file);
 493   }
 494 }
 495
 496 static int
 497 hw_com_instance_write(device_instance *instance,
 498                       const void *buf,
 499                       unsigned_word len)
 500 {
 501   device *me = device_instance_device(instance);
 502   hw_com_device *com = device_data(me);
 503   if (com->output.file == NULL)
 504     return sim_io_write_stdout(buf, len);
 505   else {
 506     return fwrite(buf, 1, len, com->output.file);
 507   }
 508 }
 509
 510 static const device_instance_callbacks hw_com_instance_callbacks = {
 511   hw_com_instance_delete,
 512   hw_com_instance_read,
 513   hw_com_instance_write,
 514 };
 515
 516 static device_instance *
 517 hw_com_create_instance(device *me,
 518                        const char *path,
 519                        const char *args)
 520 {
 521   /* point an instance directly at the device */
 522   return device_create_instance_from(me, NULL,
 523                                      device_data(me),
 524                                      path, args,
 525                                      &hw_com_instance_callbacks);
 526 }
 527
 528
 529 static device_callbacks const hw_com_callbacks = {
 530   { generic_device_init_address,
 531     hw_com_device_init_data },
 532   { NULL, }, /* address */
 533   { hw_com_io_read_buffer_callback,
 534       hw_com_io_write_buffer_callback, },
 535   { NULL, }, /* DMA */
 536   { NULL, }, /* interrupt */
 537   { NULL, }, /* unit */
 538   hw_com_create_instance,
 539 };
 540
 541
 542 static void *
 543 hw_com_create(const char *name,
 544               const device_unit *unit_address,
 545               const char *args)
 546 {
 547   /* create the descriptor */
 548   hw_com_device *hw_com = ZALLOC(hw_com_device);
 549   return hw_com;
 550 }
 551
 552
 553 const device_descriptor hw_com_device_descriptor[] = {
 554   { "com", hw_com_create, &hw_com_callbacks },
 555   { NULL },
 556 };
 557
 558 #endif /* _HW_COM_C_ */