OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gdb/] [gdb-6.8/] [sim/] [mn10300/] [dv-mn103ser.c] - Blame information for rev 26

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 26 jlechner 
/*  This file is part of the program GDB, the GNU debugger.
2 
 
3 
    Copyright (C) 1998, 2007, 2008 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 
#include "sim-main.h"
22 
#include "hw-main.h"
23 
#include "dv-sockser.h"
24 
 
25 
 
26 
/* DEVICE
27 
 
28 
 
29 
   mn103ser - mn103002 serial devices 0, 1 and 2.
30 
 
31 
 
32 
   DESCRIPTION
33 
 
34 
   Implements the mn103002 serial interfaces as described in the
35 
   mn103002 user guide.
36 
 
37 
 
38 
   PROPERTIES
39 
 
40 
   reg = <serial-addr> <serial-size>
41 
 
42 
 
43 
   BUGS
44 
 
45 
   */
46 
 
47 
 
48 
/* The serial devices' registers' address block */
49 
 
50 
struct mn103ser_block {
51 
  unsigned_word base;
52 
  unsigned_word bound;
53 
};
54 
 
55 
 
56 
 
57 
enum serial_register_types {
58 
    SC0CTR,
59 
    SC1CTR,
60 
    SC2CTR,
61 
    SC0ICR,
62 
    SC1ICR,
63 
    SC2ICR,
64 
    SC0TXB,
65 
    SC1TXB,
66 
    SC2TXB,
67 
    SC0RXB,
68 
    SC1RXB,
69 
    SC2RXB,
70 
    SC0STR,
71 
    SC1STR,
72 
    SC2STR,
73 
    SC2TIM,
74 
};
75 
 
76 
 
77 
/* Access dv-sockser state */
78 
extern char* sockser_addr;
79 
#define USE_SOCKSER_P (sockser_addr != NULL)
80 
 
81 
 
82 
#define NR_SERIAL_DEVS  3
83 
#define SIO_STAT_RRDY 0x0010
84 
 
85 
typedef struct _mn10300_serial {
86 
  unsigned16 status, control;
87 
  unsigned8  txb, rxb, intmode;
88 
  struct hw_event *event;
89 
} mn10300_serial;
90 
 
91 
 
92 
 
93 
struct mn103ser {
94 
  struct mn103ser_block block;
95 
  mn10300_serial device[NR_SERIAL_DEVS];
96 
  unsigned8      serial2_timer_reg;
97 
  do_hw_poll_read_method *reader;
98 
};
99 
 
100 
/* output port ID's */
101 
 
102 
/* for mn103002 */
103 
enum {
104 
  SERIAL0_RECEIVE,
105 
  SERIAL1_RECEIVE,
106 
  SERIAL2_RECEIVE,
107 
  SERIAL0_SEND,
108 
  SERIAL1_SEND,
109 
  SERIAL2_SEND,
110 
};
111 
 
112 
 
113 
static const struct hw_port_descriptor mn103ser_ports[] = {
114 
 
115 
  { "serial-0-receive",  SERIAL0_RECEIVE, 0, output_port, },
116 
  { "serial-1-receive",  SERIAL1_RECEIVE, 0, output_port, },
117 
  { "serial-2-receive",  SERIAL2_RECEIVE, 0, output_port, },
118 
  { "serial-0-transmit", SERIAL0_SEND, 0, output_port, },
119 
  { "serial-1-transmit", SERIAL1_SEND, 0, output_port, },
120 
  { "serial-2-transmit", SERIAL2_SEND, 0, output_port, },
121 
 
122 
  { NULL, },
123 
};
124 
 
125 
 
126 
 
127 
/* Finish off the partially created hw device.  Attach our local
128 
   callbacks.  Wire up our port names etc */
129 
 
130 
static hw_io_read_buffer_method mn103ser_io_read_buffer;
131 
static hw_io_write_buffer_method mn103ser_io_write_buffer;
132 
 
133 
static void
134 
attach_mn103ser_regs (struct hw *me,
135 
                      struct mn103ser *serial)
136 
{
137 
  unsigned_word attach_address;
138 
  int attach_space;
139 
  unsigned attach_size;
140 
  reg_property_spec reg;
141 
 
142 
  if (hw_find_property (me, "reg") == NULL)
143 
    hw_abort (me, "Missing \"reg\" property");
144 
 
145 
  if (!hw_find_reg_array_property (me, "reg", 0, &reg))
146 
    hw_abort (me, "\"reg\" property must contain three addr/size entries");
147 
  hw_unit_address_to_attach_address (hw_parent (me),
148 
                                     &reg.address,
149 
                                     &attach_space,
150 
                                     &attach_address,
151 
                                     me);
152 
  serial->block.base = attach_address;
153 
  hw_unit_size_to_attach_size (hw_parent (me),
154 
                               &reg.size,
155 
                               &attach_size, me);
156 
  serial->block.bound = attach_address + (attach_size - 1);
157 
  hw_attach_address (hw_parent (me),
158 
                     0,
159 
                     attach_space, attach_address, attach_size,
160 
                     me);
161 
}
162 
 
163 
static void
164 
mn103ser_finish (struct hw *me)
165 
{
166 
  struct mn103ser *serial;
167 
  int i;
168 
 
169 
  serial = HW_ZALLOC (me, struct mn103ser);
170 
  set_hw_data (me, serial);
171 
  set_hw_io_read_buffer (me, mn103ser_io_read_buffer);
172 
  set_hw_io_write_buffer (me, mn103ser_io_write_buffer);
173 
  set_hw_ports (me, mn103ser_ports);
174 
 
175 
  /* Attach ourself to our parent bus */
176 
  attach_mn103ser_regs (me, serial);
177 
 
178 
  /* If so configured, enable polled input */
179 
  if (hw_find_property (me, "poll?") != NULL
180 
      && hw_find_boolean_property (me, "poll?"))
181 
    {
182 
      serial->reader = sim_io_poll_read;
183 
    }
184 
  else
185 
    {
186 
      serial->reader = sim_io_read;
187 
    }
188 
 
189 
  /* Initialize the serial device registers. */
190 
  for ( i=0; i<NR_SERIAL_DEVS; ++i )
191 
    {
192 
      serial->device[i].txb = 0;
193 
      serial->device[i].rxb = 0;
194 
      serial->device[i].status = 0;
195 
      serial->device[i].control = 0;
196 
      serial->device[i].intmode = 0;
197 
      serial->device[i].event = NULL;
198 
    }
199 
}
200 
 
201 
 
202 
/* read and write */
203 
 
204 
static int
205 
decode_addr (struct hw *me,
206 
             struct mn103ser *serial,
207 
             unsigned_word address)
208 
{
209 
  unsigned_word offset;
210 
  offset = address - serial->block.base;
211 
  switch (offset)
212 
    {
213 
    case 0x00: return SC0CTR;
214 
    case 0x04: return SC0ICR;
215 
    case 0x08: return SC0TXB;
216 
    case 0x09: return SC0RXB;
217 
    case 0x0C: return SC0STR;
218 
    case 0x10: return SC1CTR;
219 
    case 0x14: return SC1ICR;
220 
    case 0x18: return SC1TXB;
221 
    case 0x19: return SC1RXB;
222 
    case 0x1C: return SC1STR;
223 
    case 0x20: return SC2CTR;
224 
    case 0x24: return SC2ICR;
225 
    case 0x28: return SC2TXB;
226 
    case 0x29: return SC2RXB;
227 
    case 0x2C: return SC2STR;
228 
    case 0x2D: return SC2TIM;
229 
    default:
230 
      {
231 
        hw_abort (me, "bad address");
232 
        return -1;
233 
      }
234 
    }
235 
}
236 
 
237 
static void
238 
do_polling_event (struct hw *me,
239 
                  void *data)
240 
{
241 
  struct mn103ser *serial = hw_data(me);
242 
  long serial_reg = (long) data;
243 
  char c;
244 
  int count;
245 
 
246 
  if(USE_SOCKSER_P)
247 
    {
248 
      int rd;
249 
      rd = dv_sockser_read (hw_system (me));
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 *)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 
      *(unsigned16 *)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 
      *(unsigned8 *)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 
      *(unsigned8 *)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 
      *(unsigned8 *)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 
      /* FIFO is empty */
379 
      /* Kill current poll event */
380 
      if ( NULL != serial->device[serial_reg].event )
381 
        {
382 
          hw_event_queue_deschedule (me, serial->device[serial_reg].event);
383 
          serial->device[serial_reg].event = NULL;
384 
        }
385 
 
386 
      if(USE_SOCKSER_P)
387 
        {
388 
          int rd;
389 
          rd = dv_sockser_read (hw_system (me));
390 
          if(rd != -1)
391 
            {
392 
              c = (char) rd;
393 
              count = 1;
394 
            }
395 
          else
396 
            {
397 
              count = HW_IO_NOT_READY;
398 
            }
399 
        }
400 
      else
401 
        {
402 
          count = do_hw_poll_read (me, serial->reader,
403 
                                   0/*STDIN*/, &c, sizeof(c));
404 
        }
405 
 
406 
      switch (count)
407 
        {
408 
        case HW_IO_NOT_READY:
409 
        case HW_IO_EOF:
410 
          serial->device[serial_reg].rxb = 0;
411 
          serial->device[serial_reg].status &= ~SIO_STAT_RRDY;
412 
          break;
413 
        default:
414 
          serial->device[serial_reg].rxb = c;
415 
          serial->device[serial_reg].status |= SIO_STAT_RRDY;
416 
          hw_port_event (me, serial_reg+SERIAL0_RECEIVE, 1);
417 
        }
418 
 
419 
      /* schedule polling event */
420 
      serial->device[serial_reg].event
421 
        = hw_event_queue_schedule (me, 1000,
422 
                                   do_polling_event,
423 
                                   (void *) (long) serial_reg);
424 
    }
425 
 
426 
  if ( nr_bytes == 1 )
427 
    {
428 
      *(unsigned8 *)dest = (unsigned8)serial->device[serial_reg].status;
429 
    }
430 
  else if ( nr_bytes == 2 && serial_reg != SC2STR )
431 
    {
432 
      *(unsigned16 *)dest = H2LE_2 (serial->device[serial_reg].status);
433 
    }
434 
  else
435 
    {
436 
      hw_abort (me, "bad read size of %d bytes from SC%dSTR.", nr_bytes,
437 
                serial_reg);
438 
    }
439 
}
440 
 
441 
 
442 
static void
443 
read_serial2_timer_reg (struct hw *me,
444 
                        struct mn103ser *serial,
445 
                        void *dest,
446 
                        unsigned  nr_bytes)
447 
{
448 
  if ( nr_bytes == 1 )
449 
    {
450 
      * (unsigned8 *) dest = (unsigned8) serial->serial2_timer_reg;
451 
    }
452 
  else
453 
    {
454 
      hw_abort (me, "bad read size of %d bytes to SC2TIM.", nr_bytes);
455 
    }
456 
}
457 
 
458 
 
459 
static unsigned
460 
mn103ser_io_read_buffer (struct hw *me,
461 
                         void *dest,
462 
                         int space,
463 
                         unsigned_word base,
464 
                         unsigned nr_bytes)
465 
{
466 
  struct mn103ser *serial = hw_data (me);
467 
  enum serial_register_types serial_reg;
468 
  HW_TRACE ((me, "read 0x%08lx %d", (long) base, (int) nr_bytes));
469 
 
470 
  serial_reg = decode_addr (me, serial, base);
471 
  switch (serial_reg)
472 
    {
473 
    /* control registers */
474 
    case SC0CTR:
475 
    case SC1CTR:
476 
    case SC2CTR:
477 
      read_control_reg(me, serial, serial_reg-SC0CTR, dest, nr_bytes);
478 
      HW_TRACE ((me, "read - ctrl reg%d has 0x%x\n", serial_reg-SC0CTR,
479 
                 *(unsigned8 *)dest));
480 
      break;
481 
 
482 
    /* interrupt mode registers */
483 
    case SC0ICR:
484 
    case SC1ICR:
485 
    case SC2ICR:
486 
      read_intmode_reg(me, serial, serial_reg-SC0ICR, dest, nr_bytes);
487 
      HW_TRACE ((me, "read - intmode reg%d has 0x%x\n", serial_reg-SC0ICR,
488 
                 *(unsigned8 *)dest));
489 
      break;
490 
 
491 
    /* transmission buffers */
492 
    case SC0TXB:
493 
    case SC1TXB:
494 
    case SC2TXB:
495 
      read_txb(me, serial, serial_reg-SC0TXB, dest, nr_bytes);
496 
      HW_TRACE ((me, "read - txb%d has %c\n", serial_reg-SC0TXB,
497 
                 *(char *)dest));
498 
      break;
499 
 
500 
    /* reception buffers */
501 
    case SC0RXB:
502 
    case SC1RXB:
503 
    case SC2RXB:
504 
      read_rxb(me, serial, serial_reg-SC0RXB, dest, nr_bytes);
505 
      HW_TRACE ((me, "read - rxb%d has %c\n", serial_reg-SC0RXB,
506 
                 *(char *)dest));
507 
     break;
508 
 
509 
    /* status registers */
510 
    case SC0STR:
511 
    case SC1STR:
512 
    case SC2STR:
513 
      read_status_reg(me, serial, serial_reg-SC0STR, dest, nr_bytes);
514 
      HW_TRACE ((me, "read - status reg%d has 0x%x\n", serial_reg-SC0STR,
515 
                 *(unsigned8 *)dest));
516 
      break;
517 
 
518 
    case SC2TIM:
519 
      read_serial2_timer_reg(me, serial, dest, nr_bytes);
520 
      HW_TRACE ((me, "read - serial2 timer reg %d\n", *(unsigned8 *)dest));
521 
      break;
522 
 
523 
    default:
524 
      hw_abort(me, "invalid address");
525 
    }
526 
 
527 
  return nr_bytes;
528 
}
529 
 
530 
 
531 
static void
532 
write_control_reg (struct hw *me,
533 
                   struct mn103ser *serial,
534 
                   unsigned_word serial_reg,
535 
                   const void *source,
536 
                   unsigned  nr_bytes)
537 
{
538 
  unsigned16 val = LE2H_2 (*(unsigned16 *)source);
539 
 
540 
  /* really allow 1 byte write, too */
541 
  if ( nr_bytes == 2 )
542 
    {
543 
      if ( serial_reg == 2 && (val & 0x0C04) != 0 )
544 
        {
545 
          hw_abort(me, "Cannot write to read-only bits of SC2CTR.");
546 
        }
547 
      else
548 
        {
549 
          serial->device[serial_reg].control = val;
550 
        }
551 
    }
552 
  else
553 
    {
554 
      hw_abort (me, "bad read size of %d bytes from SC%dSTR.", nr_bytes,
555 
                serial_reg);
556 
    }
557 
}
558 
 
559 
 
560 
static void
561 
write_intmode_reg (struct hw *me,
562 
                   struct mn103ser *serial,
563 
                   unsigned_word serial_reg,
564 
                   const void *source,
565 
                   unsigned  nr_bytes)
566 
{
567 
unsigned8 val = *(unsigned8 *)source;
568 
 
569 
  if ( nr_bytes == 1 )
570 
    {
571 
      /* Check for attempt to write to read-only bits of register. */
572 
      if ( ( serial_reg == 2 && (val & 0xCA) != 0 )
573 
           || ( serial_reg != 2 && (val & 0x4A) != 0 ) )
574 
        {
575 
          hw_abort(me, "Cannot write to read-only bits of SC%dICR.",
576 
                   serial_reg);
577 
        }
578 
      else
579 
        {
580 
          serial->device[serial_reg].intmode = val;
581 
        }
582 
    }
583 
  else
584 
    {
585 
      hw_abort (me, "bad write size of %d bytes to SC%dICR.", nr_bytes,
586 
                serial_reg);
587 
    }
588 
}
589 
 
590 
 
591 
static void
592 
write_txb (struct hw *me,
593 
           struct mn103ser *serial,
594 
           unsigned_word serial_reg,
595 
           const void *source,
596 
           unsigned  nr_bytes)
597 
{
598 
  if ( nr_bytes == 1 )
599 
    {
600 
      serial->device[serial_reg].txb = *(unsigned8 *)source;
601 
 
602 
      if(USE_SOCKSER_P)
603 
        {
604 
          dv_sockser_write(hw_system (me), * (char*) source);
605 
        }
606 
      else
607 
        {
608 
          sim_io_write_stdout(hw_system (me), (char *)source, 1);
609 
          sim_io_flush_stdout(hw_system (me));
610 
        }
611 
 
612 
      hw_port_event (me, serial_reg+SERIAL0_SEND, 1);
613 
    }
614 
  else
615 
    {
616 
      hw_abort (me, "bad write size of %d bytes to SC%dTXB.", nr_bytes,
617 
                serial_reg);
618 
    }
619 
}
620 
 
621 
 
622 
static void
623 
write_serial2_timer_reg (struct hw *me,
624 
                         struct mn103ser *serial,
625 
                         const void *source,
626 
                         unsigned  nr_bytes)
627 
{
628 
  if ( nr_bytes == 1 )
629 
    {
630 
      serial->serial2_timer_reg = *(unsigned8 *)source;
631 
    }
632 
  else
633 
    {
634 
      hw_abort (me, "bad write size of %d bytes to SC2TIM.", nr_bytes);
635 
    }
636 
}
637 
 
638 
 
639 
static unsigned
640 
mn103ser_io_write_buffer (struct hw *me,
641 
                          const void *source,
642 
                          int space,
643 
                          unsigned_word base,
644 
                          unsigned nr_bytes)
645 
{
646 
  struct mn103ser *serial = hw_data (me);
647 
  enum serial_register_types serial_reg;
648 
  HW_TRACE ((me, "write 0x%08lx %d", (long) base, (int) nr_bytes));
649 
 
650 
  serial_reg = decode_addr (me, serial, base);
651 
  switch (serial_reg)
652 
    {
653 
    /* control registers */
654 
    case SC0CTR:
655 
    case SC1CTR:
656 
    case SC2CTR:
657 
      HW_TRACE ((me, "write - ctrl reg%d has 0x%x, nrbytes=%d.\n",
658 
                 serial_reg-SC0CTR, *(unsigned8 *)source, nr_bytes));
659 
      write_control_reg(me, serial, serial_reg-SC0CTR, source, nr_bytes);
660 
      break;
661 
 
662 
    /* interrupt mode registers */
663 
    case SC0ICR:
664 
    case SC1ICR:
665 
    case SC2ICR:
666 
      HW_TRACE ((me, "write - intmode reg%d has 0x%x, nrbytes=%d.\n",
667 
                 serial_reg-SC0ICR, *(unsigned8 *)source, nr_bytes));
668 
      write_intmode_reg(me, serial, serial_reg-SC0ICR, source, nr_bytes);
669 
      break;
670 
 
671 
    /* transmission buffers */
672 
    case SC0TXB:
673 
    case SC1TXB:
674 
    case SC2TXB:
675 
      HW_TRACE ((me, "write - txb%d has %c, nrbytes=%d.\n",
676 
                 serial_reg-SC0TXB, *(char *)source, nr_bytes));
677 
      write_txb(me, serial, serial_reg-SC0TXB, source, nr_bytes);
678 
      break;
679 
 
680 
    /* reception buffers */
681 
    case SC0RXB:
682 
    case SC1RXB:
683 
    case SC2RXB:
684 
      hw_abort(me, "Cannot write to reception buffer.");
685 
     break;
686 
 
687 
    /* status registers */
688 
    case SC0STR:
689 
    case SC1STR:
690 
    case SC2STR:
691 
      hw_abort(me, "Cannot write to status register.");
692 
      break;
693 
 
694 
    case SC2TIM:
695 
      HW_TRACE ((me, "read - serial2 timer reg %d (nrbytes=%d)\n",
696 
                 *(unsigned8 *)source, nr_bytes));
697 
      write_serial2_timer_reg(me, serial, source, nr_bytes);
698 
      break;
699 
 
700 
    default:
701 
      hw_abort(me, "invalid address");
702 
    }
703 
 
704 
  return nr_bytes;
705 
}
706 
 
707 
 
708 
const struct hw_descriptor dv_mn103ser_descriptor[] = {
709 
  { "mn103ser", mn103ser_finish, },
710 
  { NULL },
711 
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.