Home | History | Annotate | Line # | Download | only in mn10300 
      1 /*  This file is part of the program GDB, the GNU debugger.
      2 
      3     Copyright (C) 1998-2024 Free Software Foundation, Inc.
      4     Contributed by Cygnus Solutions.
      5 
      6     This program is free software; you can redistribute it and/or modify
      7     it under the terms of the GNU General Public License as published by
      8     the Free Software Foundation; either version 3 of the License, or
      9     (at your option) any later version.
     10 
     11     This program is distributed in the hope that it will be useful,
     12     but WITHOUT ANY WARRANTY; without even the implied warranty of
     13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     14     GNU General Public License for more details.
     15 
     16     You should have received a copy of the GNU General Public License
     17     along with this program.  If not, see <http://www.gnu.org/licenses/>.
     18 
     19     */
     20 
     21 /* This must come before any other includes.  */
     22 #include "defs.h"
     23 
     24 #include "sim-main.h"
     25 #include "hw-main.h"
     26 #include "dv-sockser.h"
     27 
     28 
     29 /* DEVICE
     30 
     31 
     32    mn103ser - mn103002 serial devices 0, 1 and 2.
     33 
     34 
     35    DESCRIPTION
     36 
     37    Implements the mn103002 serial interfaces as described in the
     38    mn103002 user guide.
     39 
     40 
     41    PROPERTIES
     42 
     43    reg = <serial-addr> <serial-size>
     44 
     45 
     46    BUGS
     47 
     48    */
     49 
     50 
     51 /* The serial devices' registers' address block */
     52 
     53 struct mn103ser_block {
     54   unsigned_word base;
     55   unsigned_word bound;
     56 };
     57 
     58 
     59 
     60 enum serial_register_types {
     61     SC0CTR,
     62     SC1CTR,
     63     SC2CTR,
     64     SC0ICR,
     65     SC1ICR,
     66     SC2ICR,
     67     SC0TXB,
     68     SC1TXB,
     69     SC2TXB,
     70     SC0RXB,
     71     SC1RXB,
     72     SC2RXB,
     73     SC0STR,
     74     SC1STR,
     75     SC2STR,
     76     SC2TIM,
     77 };
     78 
     79 
     80 #define NR_SERIAL_DEVS  3
     81 #define SIO_STAT_RRDY 0x0010
     82 
     83 typedef struct _mn10300_serial {
     84   uint16_t status, control;
     85   uint8_t  txb, rxb, intmode;
     86   struct hw_event *event;
     87 } mn10300_serial;
     88 
     89 
     90 
     91 struct mn103ser {
     92   struct mn103ser_block block;
     93   mn10300_serial device[NR_SERIAL_DEVS];
     94   uint8_t      serial2_timer_reg;
     95   do_hw_poll_read_method *reader;
     96 };
     97 
     98 /* output port ID's */
     99 
    100 /* for mn103002 */
    101 enum {
    102   SERIAL0_RECEIVE,
    103   SERIAL1_RECEIVE,
    104   SERIAL2_RECEIVE,
    105   SERIAL0_SEND,
    106   SERIAL1_SEND,
    107   SERIAL2_SEND,
    108 };
    109 
    110 
    111 static const struct hw_port_descriptor mn103ser_ports[] = {
    112 
    113   { "serial-0-receive",  SERIAL0_RECEIVE, 0, output_port, },
    114   { "serial-1-receive",  SERIAL1_RECEIVE, 0, output_port, },
    115   { "serial-2-receive",  SERIAL2_RECEIVE, 0, output_port, },
    116   { "serial-0-transmit", SERIAL0_SEND, 0, output_port, },
    117   { "serial-1-transmit", SERIAL1_SEND, 0, output_port, },
    118   { "serial-2-transmit", SERIAL2_SEND, 0, output_port, },
    119 
    120   { NULL, },
    121 };
    122 
    123 
    124 
    125 /* Finish off the partially created hw device.  Attach our local
    126    callbacks.  Wire up our port names etc */
    127 
    128 static hw_io_read_buffer_method mn103ser_io_read_buffer;
    129 static hw_io_write_buffer_method mn103ser_io_write_buffer;
    130 
    131 static void
    132 attach_mn103ser_regs (struct hw *me,
    133 		      struct mn103ser *serial)
    134 {
    135   unsigned_word attach_address;
    136   int attach_space;
    137   unsigned attach_size;
    138   reg_property_spec reg;
    139 
    140   if (hw_find_property (me, "reg") == NULL)
    141     hw_abort (me, "Missing \"reg\" property");
    142 
    143   if (!hw_find_reg_array_property (me, "reg", 0, &reg))
    144     hw_abort (me, "\"reg\" property must contain three addr/size entries");
    145   hw_unit_address_to_attach_address (hw_parent (me),
    146 				     &reg.address,
    147 				     &attach_space,
    148 				     &attach_address,
    149 				     me);
    150   serial->block.base = attach_address;
    151   hw_unit_size_to_attach_size (hw_parent (me),
    152 			       &reg.size,
    153 			       &attach_size, me);
    154   serial->block.bound = attach_address + (attach_size - 1);
    155   hw_attach_address (hw_parent (me),
    156 		     0,
    157 		     attach_space, attach_address, attach_size,
    158 		     me);
    159 }
    160 
    161 static void
    162 mn103ser_finish (struct hw *me)
    163 {
    164   struct mn103ser *serial;
    165   int i;
    166 
    167   serial = HW_ZALLOC (me, struct mn103ser);
    168   set_hw_data (me, serial);
    169   set_hw_io_read_buffer (me, mn103ser_io_read_buffer);
    170   set_hw_io_write_buffer (me, mn103ser_io_write_buffer);
    171   set_hw_ports (me, mn103ser_ports);
    172 
    173   /* Attach ourself to our parent bus */
    174   attach_mn103ser_regs (me, serial);
    175 
    176   /* If so configured, enable polled input */
    177   if (hw_find_property (me, "poll?") != NULL
    178       && hw_find_boolean_property (me, "poll?"))
    179     {
    180       serial->reader = sim_io_poll_read;
    181     }
    182   else
    183     {
    184       serial->reader = sim_io_read;
    185     }
    186 
    187   /* Initialize the serial device registers. */
    188   for ( i=0; i<NR_SERIAL_DEVS; ++i )
    189     {
    190       serial->device[i].txb = 0;
    191       serial->device[i].rxb = 0;
    192       serial->device[i].status = 0;
    193       serial->device[i].control = 0;
    194       serial->device[i].intmode = 0;
    195       serial->device[i].event = NULL;
    196     }
    197 }
    198 
    199 
    200 /* read and write */
    201 
    202 static int
    203 decode_addr (struct hw *me,
    204 	     struct mn103ser *serial,
    205 	     unsigned_word address)
    206 {
    207   unsigned_word offset;
    208   offset = address - serial->block.base;
    209   switch (offset)
    210     {
    211     case 0x00: return SC0CTR;
    212     case 0x04: return SC0ICR;
    213     case 0x08: return SC0TXB;
    214     case 0x09: return SC0RXB;
    215     case 0x0C: return SC0STR;
    216     case 0x10: return SC1CTR;
    217     case 0x14: return SC1ICR;
    218     case 0x18: return SC1TXB;
    219     case 0x19: return SC1RXB;
    220     case 0x1C: return SC1STR;
    221     case 0x20: return SC2CTR;
    222     case 0x24: return SC2ICR;
    223     case 0x28: return SC2TXB;
    224     case 0x29: return SC2RXB;
    225     case 0x2C: return SC2STR;
    226     case 0x2D: return SC2TIM;
    227     default:
    228       {
    229 	hw_abort (me, "bad address");
    230 	return -1;
    231       }
    232     }
    233 }
    234 
    235 static void
    236 do_polling_event (struct hw *me,
    237 		  void *data)
    238 {
    239   SIM_DESC sd = hw_system (me);
    240   struct mn103ser *serial = hw_data(me);
    241   long serial_reg = (uintptr_t) data;
    242   char c;
    243   int count, status;
    244 
    245   status = dv_sockser_status (sd);
    246   if (!(status & DV_SOCKSER_DISCONNECTED))
    247     {
    248       int rd;
    249       rd = dv_sockser_read (sd);
    250       if(rd != -1)
    251 	{
    252 	  c = (char) rd;
    253 	  count = 1;
    254 	}
    255       else
    256 	{
    257 	  count = HW_IO_NOT_READY;
    258 	}
    259     }
    260   else
    261     {
    262       count = do_hw_poll_read (me, serial->reader,
    263 			       0/*STDIN*/, &c, sizeof(c));
    264     }
    265 
    266 
    267   switch (count)
    268     {
    269     case HW_IO_NOT_READY:
    270     case HW_IO_EOF:
    271       serial->device[serial_reg].rxb = 0;
    272       serial->device[serial_reg].status &= ~SIO_STAT_RRDY;
    273       break;
    274     default:
    275       serial->device[serial_reg].rxb = c;
    276       serial->device[serial_reg].status |= SIO_STAT_RRDY;
    277       hw_port_event (me, serial_reg+SERIAL0_RECEIVE, 1);
    278     }
    279 
    280   /* Schedule next polling event */
    281   serial->device[serial_reg].event
    282     = hw_event_queue_schedule (me, 1000,
    283 			       do_polling_event, (void *)(uintptr_t)serial_reg);
    284 
    285 }
    286 
    287 static void
    288 read_control_reg (struct hw *me,
    289 		  struct mn103ser *serial,
    290 		  unsigned_word serial_reg,
    291 		  void *dest,
    292 		  unsigned  nr_bytes)
    293 {
    294   /* really allow 1 byte read, too */
    295   if ( nr_bytes == 2 )
    296     {
    297       *(uint16_t *)dest = H2LE_2 (serial->device[serial_reg].control);
    298     }
    299   else
    300     {
    301       hw_abort (me, "bad read size of %d bytes from SC%dCTR.", nr_bytes,
    302 		serial_reg);
    303     }
    304 }
    305 
    306 
    307 static void
    308 read_intmode_reg (struct hw *me,
    309 		  struct mn103ser *serial,
    310 		  unsigned_word serial_reg,
    311 		  void *dest,
    312 		  unsigned  nr_bytes)
    313 {
    314   if ( nr_bytes == 1 )
    315     {
    316       *(uint8_t *)dest = serial->device[serial_reg].intmode;
    317     }
    318   else
    319     {
    320       hw_abort (me, "bad read size of %d bytes from SC%dICR.", nr_bytes,
    321 		serial_reg);
    322     }
    323 }
    324 
    325 
    326 static void
    327 read_txb (struct hw *me,
    328 	  struct mn103ser *serial,
    329 	  unsigned_word serial_reg,
    330 	  void *dest,
    331 	  unsigned  nr_bytes)
    332 {
    333   if ( nr_bytes == 1 )
    334     {
    335       *(uint8_t *)dest = serial->device[serial_reg].txb;
    336     }
    337   else
    338     {
    339       hw_abort (me, "bad read size of %d bytes from SC%dTXB.", nr_bytes,
    340 		serial_reg);
    341     }
    342 }
    343 
    344 
    345 static void
    346 read_rxb (struct hw *me,
    347 	  struct mn103ser *serial,
    348 	  unsigned_word serial_reg,
    349 	  void *dest,
    350 	  unsigned  nr_bytes)
    351 {
    352   if ( nr_bytes == 1 )
    353     {
    354       *(uint8_t *)dest = serial->device[serial_reg].rxb;
    355       /* Reception buffer is now empty. */
    356       serial->device[serial_reg].status &= ~SIO_STAT_RRDY;
    357     }
    358   else
    359     {
    360       hw_abort (me, "bad read size of %d bytes from SC%dRXB.", nr_bytes,
    361 		serial_reg);
    362     }
    363 }
    364 
    365 
    366 static void
    367 read_status_reg (struct hw *me,
    368 		 struct mn103ser *serial,
    369 		 unsigned_word serial_reg,
    370 		 void *dest,
    371 		 unsigned  nr_bytes)
    372 {
    373   char c;
    374   int count;
    375 
    376   if ( (serial->device[serial_reg].status & SIO_STAT_RRDY) == 0 )
    377     {
    378       SIM_DESC sd = hw_system (me);
    379       int status;
    380 
    381       /* FIFO is empty */
    382       /* Kill current poll event */
    383       if ( NULL != serial->device[serial_reg].event )
    384 	{
    385 	  hw_event_queue_deschedule (me, serial->device[serial_reg].event);
    386 	  serial->device[serial_reg].event = NULL;
    387 	}
    388 
    389       status = dv_sockser_status (sd);
    390       if (!(status & DV_SOCKSER_DISCONNECTED))
    391 	{
    392 	  int rd;
    393 	  rd = dv_sockser_read (sd);
    394 	  if(rd != -1)
    395 	    {
    396 	      c = (char) rd;
    397 	      count = 1;
    398 	    }
    399 	  else
    400 	    {
    401 	      count = HW_IO_NOT_READY;
    402 	    }
    403 	}
    404       else
    405 	{
    406 	  count = do_hw_poll_read (me, serial->reader,
    407 				   0/*STDIN*/, &c, sizeof(c));
    408 	}
    409 
    410       switch (count)
    411 	{
    412 	case HW_IO_NOT_READY:
    413 	case HW_IO_EOF:
    414 	  serial->device[serial_reg].rxb = 0;
    415 	  serial->device[serial_reg].status &= ~SIO_STAT_RRDY;
    416 	  break;
    417 	default:
    418 	  serial->device[serial_reg].rxb = c;
    419 	  serial->device[serial_reg].status |= SIO_STAT_RRDY;
    420 	  hw_port_event (me, serial_reg+SERIAL0_RECEIVE, 1);
    421 	}
    422 
    423       /* schedule polling event */
    424       serial->device[serial_reg].event
    425 	= hw_event_queue_schedule (me, 1000,
    426 				   do_polling_event,
    427 				   (void *)(uintptr_t)serial_reg);
    428     }
    429 
    430   if ( nr_bytes == 1 )
    431     {
    432       *(uint8_t *)dest = (uint8_t)serial->device[serial_reg].status;
    433     }
    434   else if ( nr_bytes == 2 && serial_reg != SC2STR )
    435     {
    436       *(uint16_t *)dest = H2LE_2 (serial->device[serial_reg].status);
    437     }
    438   else
    439     {
    440       hw_abort (me, "bad read size of %d bytes from SC%dSTR.", nr_bytes,
    441 		serial_reg);
    442     }
    443 }
    444 
    445 
    446 static void
    447 read_serial2_timer_reg (struct hw *me,
    448 			struct mn103ser *serial,
    449 			void *dest,
    450 			unsigned  nr_bytes)
    451 {
    452   if ( nr_bytes == 1 )
    453     {
    454       * (uint8_t *) dest = (uint8_t) serial->serial2_timer_reg;
    455     }
    456   else
    457     {
    458       hw_abort (me, "bad read size of %d bytes to SC2TIM.", nr_bytes);
    459     }
    460 }
    461 
    462 
    463 static unsigned
    464 mn103ser_io_read_buffer (struct hw *me,
    465 			 void *dest,
    466 			 int space,
    467 			 unsigned_word base,
    468 			 unsigned nr_bytes)
    469 {
    470   struct mn103ser *serial = hw_data (me);
    471   enum serial_register_types serial_reg;
    472   HW_TRACE ((me, "read 0x%08lx %d", (long) base, (int) nr_bytes));
    473 
    474   serial_reg = decode_addr (me, serial, base);
    475   switch (serial_reg)
    476     {
    477     /* control registers */
    478     case SC0CTR:
    479     case SC1CTR:
    480     case SC2CTR:
    481       read_control_reg(me, serial, serial_reg-SC0CTR, dest, nr_bytes);
    482       HW_TRACE ((me, "read - ctrl reg%d has 0x%x\n", serial_reg-SC0CTR,
    483 		 *(uint8_t *)dest));
    484       break;
    485 
    486     /* interrupt mode registers */
    487     case SC0ICR:
    488     case SC1ICR:
    489     case SC2ICR:
    490       read_intmode_reg(me, serial, serial_reg-SC0ICR, dest, nr_bytes);
    491       HW_TRACE ((me, "read - intmode reg%d has 0x%x\n", serial_reg-SC0ICR,
    492 		 *(uint8_t *)dest));
    493       break;
    494 
    495     /* transmission buffers */
    496     case SC0TXB:
    497     case SC1TXB:
    498     case SC2TXB:
    499       read_txb(me, serial, serial_reg-SC0TXB, dest, nr_bytes);
    500       HW_TRACE ((me, "read - txb%d has %c\n", serial_reg-SC0TXB,
    501 		 *(char *)dest));
    502       break;
    503 
    504     /* reception buffers */
    505     case SC0RXB:
    506     case SC1RXB:
    507     case SC2RXB:
    508       read_rxb(me, serial, serial_reg-SC0RXB, dest, nr_bytes);
    509       HW_TRACE ((me, "read - rxb%d has %c\n", serial_reg-SC0RXB,
    510 		 *(char *)dest));
    511      break;
    512 
    513     /* status registers */
    514     case SC0STR:
    515     case SC1STR:
    516     case SC2STR:
    517       read_status_reg(me, serial, serial_reg-SC0STR, dest, nr_bytes);
    518       HW_TRACE ((me, "read - status reg%d has 0x%x\n", serial_reg-SC0STR,
    519 		 *(uint8_t *)dest));
    520       break;
    521 
    522     case SC2TIM:
    523       read_serial2_timer_reg(me, serial, dest, nr_bytes);
    524       HW_TRACE ((me, "read - serial2 timer reg %d\n", *(uint8_t *)dest));
    525       break;
    526 
    527     default:
    528       hw_abort(me, "invalid address");
    529     }
    530 
    531   return nr_bytes;
    532 }
    533 
    534 
    535 static void
    536 write_control_reg (struct hw *me,
    537 		   struct mn103ser *serial,
    538 		   unsigned_word serial_reg,
    539 		   const void *source,
    540 		   unsigned  nr_bytes)
    541 {
    542   uint16_t val = LE2H_2 (*(uint16_t *)source);
    543 
    544   /* really allow 1 byte write, too */
    545   if ( nr_bytes == 2 )
    546     {
    547       if ( serial_reg == 2 && (val & 0x0C04) != 0 )
    548 	{
    549 	  hw_abort(me, "Cannot write to read-only bits of SC2CTR.");
    550 	}
    551       else
    552 	{
    553 	  serial->device[serial_reg].control = val;
    554 	}
    555     }
    556   else
    557     {
    558       hw_abort (me, "bad read size of %d bytes from SC%dSTR.", nr_bytes,
    559 		serial_reg);
    560     }
    561 }
    562 
    563 
    564 static void
    565 write_intmode_reg (struct hw *me,
    566 		   struct mn103ser *serial,
    567 		   unsigned_word serial_reg,
    568 		   const void *source,
    569 		   unsigned  nr_bytes)
    570 {
    571 uint8_t val = *(uint8_t *)source;
    572 
    573   if ( nr_bytes == 1 )
    574     {
    575       /* Check for attempt to write to read-only bits of register. */
    576       if ( ( serial_reg == 2 && (val & 0xCA) != 0 )
    577 	   || ( serial_reg != 2 && (val & 0x4A) != 0 ) )
    578 	{
    579 	  hw_abort(me, "Cannot write to read-only bits of SC%dICR.",
    580 		   serial_reg);
    581 	}
    582       else
    583 	{
    584 	  serial->device[serial_reg].intmode = val;
    585 	}
    586     }
    587   else
    588     {
    589       hw_abort (me, "bad write size of %d bytes to SC%dICR.", nr_bytes,
    590 		serial_reg);
    591     }
    592 }
    593 
    594 
    595 static void
    596 write_txb (struct hw *me,
    597 	   struct mn103ser *serial,
    598 	   unsigned_word serial_reg,
    599 	   const void *source,
    600 	   unsigned  nr_bytes)
    601 {
    602   if ( nr_bytes == 1 )
    603     {
    604       SIM_DESC sd = hw_system (me);
    605       int status;
    606 
    607       serial->device[serial_reg].txb = *(uint8_t *)source;
    608 
    609       status = dv_sockser_status (sd);
    610       if (!(status & DV_SOCKSER_DISCONNECTED))
    611 	{
    612 	  dv_sockser_write(sd, * (char*) source);
    613 	}
    614       else
    615 	{
    616 	  sim_io_write_stdout(sd, (char *)source, 1);
    617 	  sim_io_flush_stdout(sd);
    618 	}
    619 
    620       hw_port_event (me, serial_reg+SERIAL0_SEND, 1);
    621     }
    622   else
    623     {
    624       hw_abort (me, "bad write size of %d bytes to SC%dTXB.", nr_bytes,
    625 		serial_reg);
    626     }
    627 }
    628 
    629 
    630 static void
    631 write_serial2_timer_reg (struct hw *me,
    632 			 struct mn103ser *serial,
    633 			 const void *source,
    634 			 unsigned  nr_bytes)
    635 {
    636   if ( nr_bytes == 1 )
    637     {
    638       serial->serial2_timer_reg = *(uint8_t *)source;
    639     }
    640   else
    641     {
    642       hw_abort (me, "bad write size of %d bytes to SC2TIM.", nr_bytes);
    643     }
    644 }
    645 
    646 
    647 static unsigned
    648 mn103ser_io_write_buffer (struct hw *me,
    649 			  const void *source,
    650 			  int space,
    651 			  unsigned_word base,
    652 			  unsigned nr_bytes)
    653 {
    654   struct mn103ser *serial = hw_data (me);
    655   enum serial_register_types serial_reg;
    656   HW_TRACE ((me, "write 0x%08lx %d", (long) base, (int) nr_bytes));
    657 
    658   serial_reg = decode_addr (me, serial, base);
    659   switch (serial_reg)
    660     {
    661     /* control registers */
    662     case SC0CTR:
    663     case SC1CTR:
    664     case SC2CTR:
    665       HW_TRACE ((me, "write - ctrl reg%d has 0x%x, nrbytes=%d.\n",
    666 		 serial_reg-SC0CTR, *(uint8_t *)source, nr_bytes));
    667       write_control_reg(me, serial, serial_reg-SC0CTR, source, nr_bytes);
    668       break;
    669 
    670     /* interrupt mode registers */
    671     case SC0ICR:
    672     case SC1ICR:
    673     case SC2ICR:
    674       HW_TRACE ((me, "write - intmode reg%d has 0x%x, nrbytes=%d.\n",
    675 		 serial_reg-SC0ICR, *(uint8_t *)source, nr_bytes));
    676       write_intmode_reg(me, serial, serial_reg-SC0ICR, source, nr_bytes);
    677       break;
    678 
    679     /* transmission buffers */
    680     case SC0TXB:
    681     case SC1TXB:
    682     case SC2TXB:
    683       HW_TRACE ((me, "write - txb%d has %c, nrbytes=%d.\n",
    684 		 serial_reg-SC0TXB, *(char *)source, nr_bytes));
    685       write_txb(me, serial, serial_reg-SC0TXB, source, nr_bytes);
    686       break;
    687 
    688     /* reception buffers */
    689     case SC0RXB:
    690     case SC1RXB:
    691     case SC2RXB:
    692       hw_abort(me, "Cannot write to reception buffer.");
    693      break;
    694 
    695     /* status registers */
    696     case SC0STR:
    697     case SC1STR:
    698     case SC2STR:
    699       hw_abort(me, "Cannot write to status register.");
    700       break;
    701 
    702     case SC2TIM:
    703       HW_TRACE ((me, "read - serial2 timer reg %d (nrbytes=%d)\n",
    704 		 *(uint8_t *)source, nr_bytes));
    705       write_serial2_timer_reg(me, serial, source, nr_bytes);
    706       break;
    707 
    708     default:
    709       hw_abort(me, "invalid address");
    710     }
    711 
    712   return nr_bytes;
    713 }
    714 
    715 
    716 const struct hw_descriptor dv_mn103ser_descriptor[] = {
    717   { "mn103ser", mn103ser_finish, },
    718   { NULL },
    719 };
    720