source: rtems/c/src/lib/libchip/serial/mc68681.c @ 25c3ff91

4.104.114.84.95
Last change on this file since 25c3ff91 was 25c3ff91, checked in by Joel Sherrill <joel.sherrill@…>, on Jun 23, 1998 at 2:55:21 PM

Added set attributes and written initialize and first open.

  • Property mode set to 100644
File size: 19.4 KB
Line 
1/*
2 *  This file contains the termios TTY driver for the Motorola MC68681.
3 *
4 *  This part is available from a number of secondary sources.
5 *  In particular, we know about the following:
6 *
7 *     + Exar 88c681 and 68c681
8 *
9 *  COPYRIGHT (c) 1989-1998.
10 *  On-Line Applications Research Corporation (OAR).
11 *  Copyright assigned to U.S. Government, 1994.
12 *
13 *  The license and distribution terms for this file may be
14 *  found in the file LICENSE in this distribution or at
15 *  http://www.OARcorp.com/rtems/license.html.
16 *
17 *  $Id$
18 */
19
20#include <rtems.h>
21#include <rtems/libio.h>
22#include <stdlib.h>
23#include <ringbuf.h>
24
25#include <libchip/serial.h>
26#include "mc68681_p.h"
27#include "mc68681.h"
28
29/*
30 * Flow control is only supported when using interrupts
31 */
32
33console_flow mc68681_flow_RTSCTS =
34{
35  mc68681_negate_RTS,             /* deviceStopRemoteTx */
36  mc68681_assert_RTS              /* deviceStartRemoteTx */
37};
38
39console_flow mc68681_flow_DTRCTS =
40{
41  mc68681_negate_DTR,             /* deviceStopRemoteTx */
42  mc68681_assert_DTR              /* deviceStartRemoteTx */
43};
44
45console_fns mc68681_fns =
46{
47  mc68681_probe,                  /* deviceProbe */
48  mc68681_open,                   /* deviceFirstOpen */
49  mc68681_flush,                  /* deviceLastClose */
50  NULL,                           /* deviceRead */
51  mc68681_write_support_int,      /* deviceWrite */
52  mc68681_initialize_interrupts,  /* deviceInitialize */
53  mc68681_write_polled,           /* deviceWritePolled */
54  mc68681_set_attributes,         /* deviceSetAttributes */
55  FALSE,                          /* deviceOutputUsesInterrupts */
56};
57
58console_fns mc68681_fns_polled =
59{
60  mc68681_probe,                       /* deviceProbe */
61  mc68681_open,                        /* deviceFirstOpen */
62  mc68681_close,                       /* deviceLastClose */
63  mc68681_inbyte_nonblocking_polled,   /* deviceRead */
64  mc68681_write_support_polled,        /* deviceWrite */
65  mc68681_init,                        /* deviceInitialize */
66  mc68681_write_polled,                /* deviceWritePolled */
67  mc68681_set_attributes,              /* deviceSetAttributes */
68  FALSE,                               /* deviceOutputUsesInterrupts */
69};
70
71extern void set_vector( rtems_isr_entry, rtems_vector_number, int );
72
73/*
74 *  Console Device Driver Entry Points
75 */
76
77static boolean mc68681_probe(int minor)
78{
79  /*
80   * If the configuration dependent probe has located the device then
81   * assume it is there
82   */
83  return(TRUE);
84}
85
86static int mc68681_baud_rate(
87  int           minor,
88  int           baud,
89  unsigned int *baud_mask_p,
90  unsigned int *acr_bit_p
91)
92{
93  unsigned int baud_mask;
94  unsigned int acr_bit;
95  int          status;
96
97  baud_mask = 0;
98  acr_bit = 0;
99  status = 0;
100
101  if ( !(Console_Port_Tbl[minor].ulDataPort & MC68681_DATA_BAUD_RATE_SET_1) )
102    acr_bit = 1;
103
104  if (!(baud & CBAUD)) {
105    *baud_mask_p = 0x0B;     /* default to 9600 baud */
106    *acr_bit_p   = acr_bit;
107    return status;
108  }
109
110  if ( !acr_bit ) {
111    switch (baud & CBAUD) {
112      case B50:    baud_mask = 0x00; break;
113      case B110:   baud_mask = 0x01; break;
114      case B134:   baud_mask = 0x02; break;
115      case B200:   baud_mask = 0x03; break;
116      case B300:   baud_mask = 0x04; break;
117      case B600:   baud_mask = 0x05; break;
118      case B1200:  baud_mask = 0x06; break;
119      case B2400:  baud_mask = 0x08; break;
120      case B4800:  baud_mask = 0x09; break;
121      case B9600:  baud_mask = 0x0B; break;
122      case B38400: baud_mask = 0x0C; break;
123
124      case B0:
125      case B75:
126      case B150:
127      case B1800:
128      case B19200:
129      case B57600:
130      case B115200:
131      case B230400:
132      case B460800:
133        status = -1;
134        break;
135    }
136  } else {
137    switch (baud & CBAUD) {
138      case B75:    baud_mask = 0x00; break;
139      case B110:   baud_mask = 0x01; break;
140      case B134:   baud_mask = 0x02; break;
141      case B150:   baud_mask = 0x03; break;
142      case B300:   baud_mask = 0x04; break;
143      case B600:   baud_mask = 0x05; break;
144      case B1200:  baud_mask = 0x06; break;
145      case B1800:  baud_mask = 0x0A; break;
146      case B2400:  baud_mask = 0x08; break;
147      case B4800:  baud_mask = 0x09; break;
148      case B9600:  baud_mask = 0x0B; break;
149      case B19200: baud_mask = 0x0C; break;
150
151      case B0:
152      case B50:
153      case B200:
154      case B38400:
155      case B57600:
156      case B115200:
157      case B230400:
158      case B460800:
159        status = -1;
160        break;
161    }
162  }
163
164  *baud_mask_p = baud_mask;
165  *acr_bit_p   = acr_bit;
166  return status;
167}
168
169#define MC68681_PORT_MASK( _port, _bits ) \
170  ((_port) ? ((_bits) << 4) : (_bits))
171
172static int mc68681_set_attributes( 
173  int minor,
174  const struct termios *t
175)
176{
177  unsigned32             pMC68681_port;
178  unsigned32             pMC68681;
179  unsigned int           mode1;
180  unsigned int           mode2;
181  unsigned int           baud_mask;
182  unsigned int           acr_bit;
183  setRegister_f          setReg;
184  rtems_interrupt_level  Irql;
185
186  pMC68681_port = Console_Port_Tbl[minor].ulCtrlPort1;
187  pMC68681      = Console_Port_Tbl[minor].ulCtrlPort2;
188  setReg        = Console_Port_Tbl[minor].setRegister;
189
190  /*
191   *  Set the baud rate
192   */
193
194  if ( mc68681_baud_rate( minor, t->c_cflag, &baud_mask, &acr_bit ) == -1 )
195    return -1;
196
197  baud_mask |=  baud_mask << 4;
198  acr_bit   <<= 7;
199
200  /*
201   *  Parity
202   */
203
204  mode1 = 0;
205  mode2 = 0;
206
207  if (t->c_cflag & PARENB) {
208    if (t->c_cflag & PARODD)
209      mode1 |= 0x04;
210    else
211      mode1 |= 0x04;
212  } else {
213   mode1 |= 0x10;
214  }
215
216  /*
217   *  Character Size
218   */
219
220  if (t->c_cflag & CSIZE) {
221    switch (t->c_cflag & CSIZE) {
222      case CS5:  break;
223      case CS6:  mode1 |= 0x01;  break;
224      case CS7:  mode1 |= 0x02;  break;
225      case CS8:  mode1 |= 0x03;  break;
226    }
227  } else {
228    mode1 |= 0x03;       /* default to 9600,8,N,1 */
229  }
230
231  /*
232   *  Stop Bits
233   */
234 
235  if (t->c_cflag & CSTOPB) {
236    mode2 |= 0x07;                      /* 2 stop bits */
237  } else {
238    if ((t->c_cflag & CSIZE) == CS5)    /* CS5 and 2 stop bits not supported */
239      return -1;
240    mode2 |= 0x0F;                      /* 1 stop bit */
241  }
242
243  rtems_interrupt_disable(Irql);
244    (*setReg)( pMC68681, MC68681_AUX_CTRL_REG, acr_bit );
245    (*setReg)( pMC68681_port, MC68681_CLOCK_SELECT, baud_mask );
246    (*setReg)( pMC68681_port, MC68681_COMMAND, MC68681_MODE_REG_RESET_MR_PTR );
247    (*setReg)( pMC68681_port, MC68681_MODE, mode1 );
248    (*setReg)( pMC68681_port, MC68681_MODE, mode2 );
249  rtems_interrupt_enable(Irql);
250  return 0;
251}
252
253static void mc68681_init(int minor)
254{
255/* XXX */
256  unsigned32              pMC68681_port;
257  unsigned32              pMC68681;
258  mc68681_context        *pmc68681Context;
259  setRegister_f           setReg;
260  getRegister_f           getReg;
261  unsigned int            port;
262
263  pmc68681Context = (mc68681_context *) malloc(sizeof(mc68681_context));
264
265  Console_Port_Data[minor].pDeviceContext = (void *)pmc68681Context;
266#if 0
267  pmc68681Context->ucModemCtrl = SP_MODEM_IRQ;
268#endif
269
270  pMC68681_port = Console_Port_Tbl[minor].ulCtrlPort1;
271  pMC68681      = Console_Port_Tbl[minor].ulCtrlPort2;
272  setReg        = Console_Port_Tbl[minor].setRegister;
273  getReg        = Console_Port_Tbl[minor].getRegister;
274  port          = Console_Port_Tbl[minor].ulDataPort;
275
276  /*
277   *  Reset everything and leave this port disabled.
278   */
279
280  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_RESET_RX );
281  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_RESET_TX );
282  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_RESET_ERROR );
283  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_RESET_BREAK );
284  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_STOP_BREAK );
285  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_DISABLE_TX );
286  (*setReg)( pMC68681, MC68681_COMMAND, MC68681_MODE_REG_DISABLE_RX );
287
288
289  (*setReg)( pMC68681, MC68681_MODE_REG_1A, 0x00 );
290  (*setReg)( pMC68681, MC68681_MODE_REG_2A, 0x02 );
291}
292
293/*
294 *  Initialize to 9600, 8, N, 1
295 */
296
297static int mc68681_open(
298  int      major,
299  int      minor,
300  void    *arg
301)
302{
303/* XXX */
304  unsigned32             pMC68681;
305  unsigned32             pMC68681_port;
306  unsigned int           baud;
307  unsigned int           acr;
308  unsigned int           port;
309  unsigned int           vector;
310  rtems_interrupt_level  Irql;
311  setRegister_f          setReg;
312  getRegister_f          getReg;
313
314  pMC68681      = Console_Port_Tbl[minor].ulCtrlPort1;
315  pMC68681_port = Console_Port_Tbl[minor].ulCtrlPort2;
316  getReg        = Console_Port_Tbl[minor].getRegister;
317  setReg        = Console_Port_Tbl[minor].setRegister;
318  port          = Console_Port_Tbl[minor].ulDataPort;
319  vector        = Console_Port_Tbl[minor].ulIntVector;
320
321  (void) mc68681_baud_rate( minor, B9600, &baud, &acr );
322
323  rtems_interrupt_disable(Irql);
324    (*setReg)( pMC68681, MC68681_AUX_CTRL_REG, acr );
325    (*setReg)( pMC68681_port, MC68681_CLOCK_SELECT, baud );
326    (*setReg)( pMC68681_port, MC68681_COMMAND, MC68681_MODE_REG_RESET_MR_PTR );
327    (*setReg)( pMC68681_port, MC68681_MODE, 0x13 );
328    (*setReg)( pMC68681_port, MC68681_MODE, 0x07 );
329  rtems_interrupt_enable(Irql);
330
331  (*setReg)(
332     pMC68681,
333     MC68681_INTERRUPT_MASK_REG,
334     MC68681_PORT_MASK( port, 0x03 )  /* intr on RX and TX -- not break */
335  );
336
337  (*setReg)( pMC68681_port, MC68681_COMMAND, MC68681_MODE_REG_ENABLE_TX );
338  (*setReg)( pMC68681_port, MC68681_COMMAND, MC68681_MODE_REG_ENABLE_RX );
339
340  (*setReg)( pMC68681, MC68681_INTERRUPT_VECTOR_REG, vector );
341
342  /*
343   * Assert DTR
344   */
345
346  if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_DTRCTS) {
347    mc68681_assert_DTR(minor);
348  }
349
350  return(RTEMS_SUCCESSFUL);
351}
352
353static int mc68681_close(
354  int      major,
355  int      minor,
356  void    *arg
357)
358{
359/* XXX */
360  /*
361   * Negate DTR
362   */
363  if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_DTRCTS) {
364    mc68681_negate_DTR(minor);
365  }
366
367  return(RTEMS_SUCCESSFUL);
368}
369
370/*
371 *  mc68681_write_polled
372 */
373
374static void mc68681_write_polled(
375  int   minor, 
376  char  cChar
377)
378{
379  unsigned32              pMC68681_port;
380  unsigned char           ucLineStatus;
381  int                     iTimeout;
382  getRegister_f           getReg;
383  setRegister_f           setReg;
384
385  pMC68681_port = Console_Port_Tbl[minor].ulCtrlPort2;
386  getReg        = Console_Port_Tbl[minor].getRegister;
387  setReg        = Console_Port_Tbl[minor].setRegister;
388
389  /*
390   * wait for transmitter holding register to be empty
391   */
392  iTimeout = 1000;
393  ucLineStatus = (*getReg)(pMC68681_port, MC68681_STATUS);
394  while ((ucLineStatus & MC68681_TX_READY) == 0) {
395
396    /*
397     * Yield while we wait
398     */
399
400     if(_System_state_Is_up(_System_state_Get())) {
401       rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
402     }
403     ucLineStatus = (*getReg)(pMC68681_port, MC68681_STATUS);
404     if(!--iTimeout) {
405       break;
406     }
407  }
408
409  /*
410   * transmit character
411   */
412
413  (*setReg)(pMC68681_port, MC68681_TX_BUFFER, cChar);
414}
415
416/*
417 * These routines provide control of the RTS and DTR lines
418 */
419
420/*
421 *  mc68681_assert_RTS
422 */
423
424static int mc68681_assert_RTS(int minor)
425{
426/* XXX */
427
428  unsigned32              pMC68681;
429  unsigned32              Irql;
430  mc68681_context        *pmc68681Context;
431  setRegister_f           setReg;
432
433
434  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
435
436  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
437  setReg   = Console_Port_Tbl[minor].setRegister;
438
439  /*
440   * Assert RTS
441   */
442  rtems_interrupt_disable(Irql);
443#if 0
444  pmc68681Context->ucModemCtrl |= SP_MODEM_RTS;
445  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
446#endif
447  rtems_interrupt_enable(Irql);
448  return 0;
449}
450
451/*
452 *  mc68681_negate_RTS
453 */
454static int mc68681_negate_RTS(int minor)
455{
456/* XXX */
457  unsigned32              pMC68681;
458  unsigned32              Irql;
459  mc68681_context        *pmc68681Context;
460  setRegister_f           setReg;
461
462  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
463
464  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
465  setReg   = Console_Port_Tbl[minor].setRegister;
466
467  /*
468   * Negate RTS
469   */
470  rtems_interrupt_disable(Irql);
471#if 0
472  pmc68681Context->ucModemCtrl &= ~SP_MODEM_RTS;
473  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
474#endif
475  rtems_interrupt_enable(Irql);
476  return 0;
477}
478
479/*
480 * These flow control routines utilise a connection from the local DTR
481 * line to the remote CTS line
482 */
483
484/*
485 *  mc68681_assert_DTR
486 */
487
488static int mc68681_assert_DTR(int minor)
489{
490/* XXX */
491  unsigned32              pMC68681;
492  unsigned32              Irql;
493  mc68681_context        *pmc68681Context;
494  setRegister_f           setReg;
495
496  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
497
498  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
499  setReg   = Console_Port_Tbl[minor].setRegister;
500
501  /*
502   * Assert DTR
503   */
504  rtems_interrupt_disable(Irql);
505#if 0
506  pmc68681Context->ucModemCtrl |= SP_MODEM_DTR;
507  (*setReg)(pMC68681, MC68681_MODEM_CONTROL, pmc68681Context->ucModemCtrl);
508#endif
509  rtems_interrupt_enable(Irql);
510  return 0;
511}
512
513/*
514 *  mc68681_negate_DTR
515 */
516
517static int mc68681_negate_DTR(int minor)
518{
519/* XXX */
520  unsigned32              pMC68681;
521  unsigned32              Irql;
522  mc68681_context        *pmc68681Context;
523  setRegister_f           setReg;
524
525  pmc68681Context = (mc68681_context *) Console_Port_Data[minor].pDeviceContext;
526
527  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
528  setReg   = Console_Port_Tbl[minor].setRegister;
529
530  /*
531   * Negate DTR
532   */
533  rtems_interrupt_disable(Irql);
534#if 0
535  pmc68681Context->ucModemCtrl &= ~SP_MODEM_DTR;
536  (*setReg)(pMC68681, MC68681_MODEM_CONTROL,pmc68681Context->ucModemCtrl);
537#endif
538  rtems_interrupt_enable(Irql);
539  return 0;
540}
541
542/*
543 *  mc68681_isr
544 *
545 *  This routine is the console interrupt handler.
546 *
547 *  Input parameters:
548 *    vector - vector number
549 *
550 *  Output parameters: NONE
551 *
552 *  Return values:     NONE
553 */
554
555static void mc68681_process(
556        int             minor
557)
558{
559/* XXX */
560  unsigned32              pMC68681;
561  volatile unsigned8      ucLineStatus; 
562  volatile unsigned8      ucInterruptId;
563  char                    cChar;
564  getRegister_f           getReg;
565  setRegister_f           setReg;
566
567#if 1
568cChar = ucInterruptId = ucLineStatus = 0;
569#endif
570  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
571  getReg   = Console_Port_Tbl[minor].getRegister;
572  setReg   = Console_Port_Tbl[minor].setRegister;
573
574#if 0
575  do {
576    /*
577     * Deal with any received characters
578     */
579    while(TRUE) {
580      ucLineStatus = (*getReg)(pMC68681, MC68681_LINE_STATUS);
581      if(~ucLineStatus & SP_LSR_RDY) {
582        break;
583      }
584      cChar = (*getReg)(pMC68681, MC68681_RECEIVE_BUFFER);
585      rtems_termios_enqueue_raw_characters(
586        Console_Port_Data[minor].termios_data,
587        &cChar,
588        1
589      );
590    }
591
592    while(TRUE) {
593      if(Ring_buffer_Is_empty(&Console_Port_Data[minor].TxBuffer)) {
594        Console_Port_Data[minor].bActive = FALSE;
595        if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_RTSCTS) {
596          mc68681_negate_RTS(minor);
597        }
598
599        /*
600         * There is no data to transmit
601         */
602        break;
603      }
604
605      ucLineStatus = (*getReg)(pMC68681, MC68681_LINE_STATUS);
606      if(~ucLineStatus & SP_LSR_THOLD) {
607        /*
608         * We'll get another interrupt when
609         * the transmitter holding reg. becomes
610         * free again
611         */
612        break;
613      }
614
615      Ring_buffer_Remove_character( &Console_Port_Data[minor].TxBuffer, cChar);
616      /*
617       * transmit character
618       */
619      (*setReg)(pMC68681, MC68681_TRANSMIT_BUFFER, cChar);
620    }
621
622    ucInterruptId = (*getReg)(pMC68681, MC68681_INTERRUPT_ID);
623  }
624  while((ucInterruptId&0xf) != 0x1);
625#endif
626}
627
628static rtems_isr mc68681_isr(
629  rtems_vector_number vector
630)
631{
632  int     minor;
633
634  for(minor=0 ; minor<Console_Port_Count ; minor++) {
635    if(vector == Console_Port_Tbl[minor].ulIntVector) {
636      mc68681_process(minor);
637    }
638  }
639}
640
641/*
642 *  mc68681_flush
643 */
644
645static int mc68681_flush(int major, int minor, void *arg)
646{
647  while(!Ring_buffer_Is_empty(&Console_Port_Data[minor].TxBuffer)) {
648    /*
649     * Yield while we wait
650     */
651    if(_System_state_Is_up(_System_state_Get())) {
652      rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
653    }
654  }
655
656  mc68681_close(major, minor, arg);
657
658  return(RTEMS_SUCCESSFUL);
659}
660
661/*
662 *  mc68681_initialize_interrupts
663 *
664 *  This routine initializes the console's receive and transmit
665 *  ring buffers and loads the appropriate vectors to handle the interrupts.
666 *
667 *  Input parameters:  NONE
668 *
669 *  Output parameters: NONE
670 *
671 *  Return values:     NONE
672 */
673
674static void mc68681_enable_interrupts(
675  int minor
676)
677{
678/* XXX */
679  unsigned32            pMC68681;
680  unsigned8             ucDataByte;
681  setRegister_f         setReg;
682
683#if 1
684ucDataByte = 0;
685#endif
686  pMC68681 = Console_Port_Tbl[minor].ulCtrlPort1;
687  setReg   = Console_Port_Tbl[minor].setRegister;
688
689#if 0
690  /*
691   * Enable interrupts
692   */
693  ucDataByte = SP_INT_RX_ENABLE | SP_INT_TX_ENABLE;
694  (*setReg)(pMC68681, MC68681_INTERRUPT_ENABLE, ucDataByte);
695#endif
696}
697
698static void mc68681_initialize_interrupts(int minor)
699{
700  mc68681_init(minor);
701
702  Ring_buffer_Initialize(&Console_Port_Data[minor].TxBuffer);
703
704  Console_Port_Data[minor].bActive = FALSE;
705
706  set_vector(mc68681_isr, Console_Port_Tbl[minor].ulIntVector, 1);
707
708  mc68681_enable_interrupts(minor);
709}
710
711/*
712 *  mc68681_write_support_int
713 *
714 *  Console Termios output entry point.
715 */
716
717static int mc68681_write_support_int(
718  int   minor, 
719  const char *buf, 
720  int   len
721)
722{
723  int i;
724  unsigned32 Irql;
725
726  for(i=0 ; i<len ;) {
727    if(Ring_buffer_Is_full(&Console_Port_Data[minor].TxBuffer)) {
728      if(!Console_Port_Data[minor].bActive) {
729        /*
730         * Wake up the device
731         */
732        rtems_interrupt_disable(Irql);
733        Console_Port_Data[minor].bActive = TRUE;
734        if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_RTSCTS) {
735          mc68681_assert_RTS(minor);
736        }
737        mc68681_process(minor);
738        rtems_interrupt_enable(Irql);
739      } else {
740        /*
741         * Yield
742         */
743        rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
744      }
745
746      /*
747       * Wait for ring buffer to empty
748       */
749      continue;
750    }
751    else {
752      Ring_buffer_Add_character( &Console_Port_Data[minor].TxBuffer, buf[i]);
753      i++;
754    }
755  }
756
757  /*
758   * Ensure that characters are on the way
759   */
760
761  if(!Console_Port_Data[minor].bActive) {
762    /*
763     * Wake up the device
764     */
765    rtems_interrupt_disable(Irql);
766    Console_Port_Data[minor].bActive = TRUE;
767    if(Console_Port_Tbl[minor].pDeviceFlow != &mc68681_flow_RTSCTS) {
768      mc68681_assert_RTS(minor);
769    }
770    mc68681_process(minor);
771    rtems_interrupt_enable(Irql);
772  }
773
774  return (len);
775}
776
777/*
778 *  mc68681_write_support_polled
779 *
780 *  Console Termios output entry point.
781 *
782 */
783
784static int mc68681_write_support_polled(
785  int         minor, 
786  const char *buf, 
787  int         len
788)
789{
790  int nwrite = 0;
791
792  /*
793   * poll each byte in the string out of the port.
794   */
795  while (nwrite < len) {
796    /*
797     * transmit character
798     */
799    mc68681_write_polled(minor, *buf++);
800    nwrite++;
801  }
802
803  /*
804   * return the number of bytes written.
805   */
806  return nwrite;
807}
808
809/*
810 *  mc68681_inbyte_nonblocking_polled
811 *
812 *  Console Termios polling input entry point.
813 */
814
815static int mc68681_inbyte_nonblocking_polled( 
816  int minor
817)
818{
819  unsigned32           pMC68681_port;
820  unsigned char        ucLineStatus;
821  char                 cChar;
822  getRegister_f        getReg;
823
824  pMC68681_port = Console_Port_Tbl[minor].ulCtrlPort2;
825  getReg        = Console_Port_Tbl[minor].getRegister;
826
827  ucLineStatus = (*getReg)(pMC68681_port, MC68681_STATUS);
828  if(ucLineStatus & MC68681_RX_READY) {
829    cChar = (*getReg)(pMC68681_port, MC68681_RX_BUFFER);
830    return (int)cChar;
831  } else {
832    return -1;
833  }
834}
Note: See TracBrowser for help on using the repository browser.