arch/i386-pc/Drivers/serial.hidd/SerialUnitClass.c

   1 /*
   2     Copyright © 1995-2006, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Serial Unit hidd class implementation.
   6     Lang: english
   7 */
   8
   9 /*
  10   Right now I am assuming that there is a 1.8432 MHZ crystal connected to
  11   the 16550 UART.
  12 */
  13
  14
  15 #include <asm/io.h>
  16 /* the rest are Amiga includes */
  17 #include <proto/exec.h>
  18 #include <proto/utility.h>
  19 #include <proto/oop.h>
  20 #include <proto/alib.h>
  21 #include <proto/intuition.h>
  22 #include <exec/libraries.h>
  23 #include <exec/ports.h>
  24 #include <exec/memory.h>
  25 #include <exec/interrupts.h>
  26 #include <exec/lists.h>
  27
  28 #include <utility/tagitem.h>
  29 #include <hidd/serial.h>
  30 #include <hidd/unixio.h>
  31 #include <hidd/irq.h>
  32 #include <intuition/preferences.h>
  33
  34 #include <devices/serial.h>
  35
  36 #include "serial_intern.h"
  37
  38 #undef  SDEBUG
  39 #undef  DEBUG
  40 #define SDEBUG 0
  41 #define DEBUG 0
  42 #include <aros/debug.h>
  43
  44 /* The speed of the crystal */
  45 #define CRYSTAL_SPEED   1843200
  46
  47
  48 void serialunit_receive_data();
  49 ULONG serialunit_write_more_data();
  50
  51 unsigned char get_lcr(struct HIDDSerialUnitData * data);
  52 unsigned char get_fcr(ULONG baudrate);
  53 BOOL set_baudrate(struct HIDDSerialUnitData * data, ULONG speed);
  54 static void adapt_data(struct HIDDSerialUnitData * data,
  55                        struct Preferences * prefs);
  56
  57 static inline void serial_out(struct HIDDSerialUnitData * data,
  58                               int offset,
  59                               int value)
  60 {
  61   outb(value, data->baseaddr+offset);
  62 }
  63
  64 static inline void serial_outp(struct HIDDSerialUnitData * data,
  65                                int offset,
  66                                int value)
  67 {
  68   outb_p(value, data->baseaddr+offset);
  69 }
  70
  71 static inline unsigned int serial_in(struct HIDDSerialUnitData * data,
  72                                      int offset)
  73 {
  74   return inb(data->baseaddr+offset);
  75 }
  76
  77 static inline unsigned int serial_inp(struct HIDDSerialUnitData * data,
  78                                       int offset)
  79 {
  80   return inb_p(data->baseaddr+offset);
  81 }
  82
  83
  84
  85 /*************************** Classes *****************************/
  86
  87 /* IO bases for every COM port */
  88 ULONG bases[] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
  89
  90 /******* SerialUnit::New() ***********************************/
  91 OOP_Object *PCSerUnit__Root__New(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
  92 {
  93   struct HIDDSerialUnitData * data;
  94   struct TagItem *tag, *tstate;
  95   ULONG unitnum = 0;
  96
  97   EnterFunc(bug("SerialUnit::New()\n"));
  98
  99   tstate = msg->attrList;
 100   while ((tag = NextTagItem((const struct TagItem **)&tstate)))
 101   {
 102       ULONG idx;
 103
 104 #define csd CSD(cl->UserData)
 105       if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx))
 106 #undef csd
 107       {
 108           switch (idx)
 109           {
 110               case aoHidd_SerialUnit_Unit:
 111                   unitnum = (ULONG)tag->ti_Data;
 112                   break;
 113           }
 114       }
 115
 116   } /* while (tags to process) */
 117
 118   obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
 119
 120   if (obj)
 121   {
 122     struct IntuitionBase * IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0);
 123     data = OOP_INST_DATA(cl, obj);
 124
 125     data->baseaddr = bases[unitnum];
 126
 127     if (NULL != IntuitionBase) {
 128       struct Preferences prefs;
 129       GetPrefs(&prefs,sizeof(prefs));
 130       data->baudrate      = prefs.BaudRate;
 131       adapt_data(data, &prefs);
 132       CloseLibrary((struct Library *)IntuitionBase);
 133     } else {
 134       data->datalength = 8;
 135       data->parity     = FALSE;
 136       data->baudrate   = 9600; /* will be initialize in set_baudrate() */
 137     }
 138     data->unitnum    = unitnum;
 139
 140     Disable();
 141     CSD(cl->UserData)->units[data->unitnum] = data;
 142     Enable();
 143
 144     D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr));
 145
 146     /* Wake up UART */
 147     serial_outp(data, UART_LCR, 0xBF);
 148     serial_outp(data, UART_EFR, UART_EFR_ECB);
 149     serial_outp(data, UART_IER, 0);
 150     serial_outp(data, UART_EFR, 0);
 151     serial_outp(data, UART_LCR, 0);
 152
 153     /* clear the FIFOs */
 154     serial_outp(data, UART_FCR, (UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT));
 155
 156     /* clear the interrupt registers */
 157     (void)serial_inp(data, UART_RX);
 158     (void)serial_inp(data, UART_IIR);
 159     (void)serial_inp(data, UART_MSR);
 160
 161     /* initilize the UART */
 162     serial_outp(data, UART_LCR, get_lcr(data));
 163
 164     serial_outp(data, UART_MCR, UART_MCR_OUT2 | UART_MCR_DTR | UART_MCR_RTS);
 165     serial_outp(data, UART_IER, UART_IER_RDI | UART_IER_THRI | UART_IER_RLSI | UART_IER_MSI);
 166
 167     /* clear the interrupt registers again ... */
 168     (void)serial_inp(data, UART_LSR);
 169     (void)serial_inp(data, UART_RX);
 170     (void)serial_inp(data, UART_IIR);
 171     (void)serial_inp(data, UART_MSR);
 172
 173     set_baudrate(data, data->baudrate);
 174   } /* if (obj) */
 175
 176   ReturnPtr("SerialUnit::New()", OOP_Object *, obj);
 177 }
 178
 179 /******* SerialUnit::Dispose() ***********************************/
 180 OOP_Object *PCSerUnit__Root__Dispose(OOP_Class *cl, OOP_Object *obj, OOP_Msg msg)
 181 {
 182   struct HIDDSerialUnitData * data;
 183   EnterFunc(bug("SerialUnit::Dispose()\n"));
 184
 185   data = OOP_INST_DATA(cl, obj);
 186
 187   Disable();
 188   CSD(cl->UserData)->units[data->unitnum] = NULL;
 189   Enable();
 190
 191   /* stop all interrupts */
 192   serial_outp(data, UART_IER, 0);
 193
 194   OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
 195   ReturnPtr("SerialUnit::Dispose()", OOP_Object *, obj);
 196 }
 197
 198
 199
 200 /******* SerialUnit::Init() **********************************/
 201 BOOL PCSerUnit__Hidd_SerialUnit__Init(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Init *msg)
 202 {
 203   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 204
 205   EnterFunc(bug("SerialUnit::Init()\n"));
 206   Disable();
 207   data->DataReceivedCallBack = msg->DataReceived;
 208   data->DataReceivedUserData = msg->DataReceivedUserData;
 209   data->DataWriteCallBack    = msg->WriteData;
 210   data->DataWriteUserData    = msg->WriteDataUserData;
 211   Enable();
 212
 213   ReturnBool("SerialUnit::Init()", TRUE);
 214 }
 215
 216 /******* SerialUnit::Write() **********************************/
 217 ULONG PCSerUnit__Hidd_SerialUnit__Write(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Write *msg)
 218 {
 219   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 220   unsigned char status;
 221   ULONG len = msg->Length;
 222   ULONG count = 0;
 223
 224   EnterFunc(bug("SerialUnit::Write()\n"));
 225
 226   /*
 227    * If the output is currently stopped just don't do anything here.
 228    */
 229   if (TRUE == data->stopped)
 230     return 0;
 231
 232   status = serial_inp(data, UART_LSR);
 233
 234   if (status & UART_LSR_THRE)
 235   {
 236     /* write data into FIFO */
 237     do
 238     {
 239       serial_outp(data, UART_TX, msg->Outbuffer[count++]);
 240       len--;
 241     } while (len > 0 && serial_inp(data, UART_LSR & UART_LSR_TEMT));
 242   }
 243
 244   ReturnInt("SerialUnit::Write()",ULONG, count);
 245 }
 246
 247 /***************************************************************************/
 248
 249 static ULONG valid_baudrates[] =
 250 {
 251   2 | LIMIT_LOWER_BOUND,
 252   115200 | LIMIT_UPPER_BOUND,
 253   ~0
 254 };
 255
 256
 257 /******* SerialUnit::SetBaudrate() **********************************/
 258 BOOL PCSerUnit__Hidd_SerialUnit__SetBaudrate(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_SetBaudrate *msg)
 259 {
 260   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 261   BOOL valid = FALSE;
 262
 263   if (msg->baudrate != data->baudrate)
 264   {
 265     valid = set_baudrate(data, msg->baudrate);
 266   } /* if */
 267   return valid;
 268 }
 269
 270 static UBYTE valid_datalengths[] =
 271 {
 272   5,
 273   6,
 274   7,
 275   8,
 276   ~0
 277 };
 278
 279 /******* SerialUnit::SetParameters() **********************************/
 280 BOOL PCSerUnit__Hidd_SerialUnit__SetParameters(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_SetParameters *msg)
 281 {
 282   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 283   BOOL valid = TRUE;
 284   int i = 0;
 285   struct TagItem * tags = msg->tags;
 286
 287   while (TAG_END != tags[i].ti_Tag && TRUE == valid)
 288   {
 289     switch (tags[i].ti_Tag)
 290     {
 291       case TAG_DATALENGTH:
 292         if ((BYTE)tags[i].ti_Data >= 5 && (BYTE)tags[i].ti_Data <= 8)
 293           data->datalength = tags[i].ti_Data;
 294         else
 295           valid = FALSE;
 296       break;
 297
 298       case TAG_STOP_BITS: /* 3 means 1.5 stopbits (if supported) */
 299         if (1 == tags[i].ti_Data ||
 300             2 == tags[i].ti_Data ||
 301             3 == tags[i].ti_Data)
 302           data->stopbits = tags[i].ti_Data;
 303         else
 304           valid = FALSE;
 305       break;
 306
 307       case TAG_PARITY:
 308         if (PARITY_0    == tags[i].ti_Data ||
 309             PARITY_1    == tags[i].ti_Data ||
 310             PARITY_EVEN == tags[i].ti_Data ||
 311             PARITY_ODD  == tags[i].ti_Data)
 312         {
 313           data->parity     = TRUE;
 314           data->paritytype = tags[i].ti_Data;
 315         }
 316         else
 317           valid = FALSE;
 318       break;
 319
 320       case TAG_PARITY_OFF:
 321         data->parity = FALSE;
 322       break;
 323
 324       case TAG_SET_MCR:
 325         serial_outp(data, UART_MCR, (tags[i].ti_Data & 0x0f) | 0x08);
 326       break;
 327
 328       case TAG_SKIP:
 329       case TAG_IGNORE:
 330       break;
 331
 332       default:
 333         valid = FALSE;
 334     }
 335     i++;
 336   }
 337
 338   if (TRUE == valid)
 339     serial_outp(data, UART_LCR, get_lcr(data));
 340
 341   return valid;
 342 }
 343
 344 /******* SerialUnit::SendBreak() **********************************/
 345 BYTE PCSerUnit__Hidd_SerialUnit__SendBreak(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_SendBreak *msg)
 346 {
 347   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 348
 349   return SerErr_LineErr;
 350 }
 351
 352 /******* SerialUnit::Start() **********************************/
 353 VOID PCSerUnit__Hidd_SerialUnit__Start(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Start *msg)
 354 {
 355         struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 356
 357         /*
 358          * Allow or start feeding the UART with data. Get the data
 359          * from upper layer.
 360          */
 361         if (TRUE == data->stopped) {
 362                 if (NULL != data->DataWriteCallBack)
 363                         data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 364                 /*
 365                  * Also mark the stopped flag as FALSE.
 366                  */
 367                 data->stopped = FALSE;
 368         }
 369 }
 370
 371 /******* SerialUnit::Stop() **********************************/
 372 VOID PCSerUnit__Hidd_SerialUnit__Stop(OOP_Class *cl, OOP_Object *o, struct pHidd_SerialUnit_Stop *msg)
 373 {
 374   struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 375
 376   /*
 377    * The next time the interrupt comes along and asks for
 378    * more data we just don't do anything...
 379    */
 380   data->stopped = TRUE;
 381 }
 382
 383 /****** SerialUnit::GetCapabilities ********************************/
 384 VOID PCSerUnit__Hidd_SerialUnit__GetCapabilities(OOP_Class * cl, OOP_Object *o, struct TagItem * tags)
 385 {
 386   if (NULL != tags)
 387   {
 388     int i = 0;
 389     BOOL end = FALSE;
 390     while (FALSE == end)
 391     {
 392       switch (tags[i].ti_Tag)
 393       {
 394         case HIDDA_SerialUnit_BPSRate:
 395           tags[i].ti_Data = (STACKIPTR)valid_baudrates;
 396         break;
 397
 398         case HIDDA_SerialUnit_DataLength:
 399           tags[i].ti_Data = (STACKIPTR)valid_datalengths;
 400         break;
 401
 402         case TAG_DONE:
 403           end = TRUE;
 404         break;
 405       }
 406       i++;
 407     }
 408   }
 409 }
 410
 411 /****** SerialUnit::GetStatus ********************************/
 412 UWORD PCSerUnit__Hidd_SerialUnit__GetStatus(OOP_Class * cl, OOP_Object *o, struct pHidd_SerialUnit_GetStatus *msg)
 413 {
 414         struct HIDDSerialUnitData * data = OOP_INST_DATA(cl, o);
 415         UWORD status = 0;
 416         UBYTE msr = serial_inp(data, UART_MSR);
 417         UBYTE mcr = serial_inp(data, UART_MCR);
 418
 419         if (msr & UART_MSR_DCD)
 420                 status |= (1<<5);
 421         if (msr & UART_MSR_DSR)
 422                 status |= (1<<3);
 423         if (msr & UART_MSR_CTS)
 424                 status |= (1<<4);
 425
 426         if (mcr & UART_MCR_DTR)
 427                 status |= (1<<7);
 428         if (mcr & UART_MCR_RTS)
 429                 status |= (1<<6);  /* old RKMs say 'ready to send' */
 430         return status;
 431 }
 432
 433 /************* The software interrupt handler that gets data from UART *****/
 434
 435
 436 #define READBUFFER_SIZE 513
 437
 438 AROS_UFH3(void, serialunit_receive_data,
 439    AROS_UFHA(APTR, iD, A1),
 440    AROS_UFHA(APTR, iC, A5),
 441    AROS_UFHA(struct ExecBase *, SysBase, A6))
 442 {
 443   AROS_USERFUNC_INIT
 444
 445   struct HIDDSerialUnitData * data = iD;
 446   int len = 0;
 447   UBYTE buffer[READBUFFER_SIZE];
 448
 449   /*
 450   ** Read the data from the port ...
 451   */
 452   do
 453   {
 454     buffer[len++] = serial_inp(data, UART_RX);
 455   }
 456   while (serial_inp(data, UART_LSR) & UART_LSR_DR);
 457
 458   /*
 459   ** ... and deliver them to whoever is interested.
 460   */
 461
 462   if (NULL != data->DataReceivedCallBack)
 463     data->DataReceivedCallBack(buffer, len, data->unitnum, data->DataReceivedUserData);
 464
 465   return;
 466
 467   AROS_USERFUNC_EXIT
 468 }
 469
 470 AROS_UFH3(ULONG, serialunit_write_more_data,
 471    AROS_UFHA(APTR, iD, A1),
 472    AROS_UFHA(APTR, iC, A5),
 473    AROS_UFHA(struct ExecBase *, SysBase, A6))
 474 {
 475   AROS_USERFUNC_INIT
 476
 477   ULONG bytes = 0;
 478   struct HIDDSerialUnitData * data = iD;
 479
 480   /*
 481    * If the output is currently stopped just don't do
 482    * anything here.
 483    */
 484   if (TRUE == data->stopped)
 485     return 0;
 486
 487   /*
 488   ** Ask for more data be written to the unit
 489   */
 490   D(bug("Asking for more data to be written to unit %d\n",data->unitnum));
 491
 492   if (NULL != data->DataWriteCallBack)
 493     bytes = data->DataWriteCallBack(data->unitnum, data->DataWriteUserData);
 494   return bytes;
 495
 496   AROS_USERFUNC_EXIT
 497 }
 498
 499
 500 /* some help routines */
 501
 502 unsigned char get_lcr(struct HIDDSerialUnitData * data)
 503 {
 504   char lcr;
 505   switch (data->datalength)
 506   {
 507     case 5: lcr = 0;
 508     break;
 509
 510     case 6: lcr = 1;
 511     break;
 512
 513     case 7: lcr = 2;
 514     break;
 515
 516     case 8: lcr = 3;
 517     break;
 518
 519     default: lcr = 3;
 520   }
 521
 522   switch (data->stopbits)
 523   {
 524     case 1: /* 1 stopbit */
 525       /* nothing to do */
 526     break;
 527
 528     case 3: /* 1.5 stopbits (is this supported ?!!!) */
 529       if (data->datalength == 5)
 530         lcr |= (1 << 2);
 531     break;
 532
 533     case 2: /* 2 stopbits */
 534       if (data->datalength >= 6 && data->datalength <= 8)
 535         lcr |= (1 << 2);
 536     break;
 537
 538     default:
 539     break;
 540   }
 541
 542   if (TRUE == data->parity)
 543   {
 544     lcr |= (1 << 3);
 545
 546     switch (data->paritytype)
 547     {
 548       case PARITY_EVEN:
 549         lcr |= (1 << 4);
 550       break;
 551
 552       case PARITY_1:
 553         lcr |= (1 << 5);
 554       break;
 555
 556       case PARITY_0:
 557         lcr |= (1 << 4) | (1 << 5);
 558       break;
 559
 560     }
 561   }
 562
 563   if (TRUE == data->breakcontrol)
 564     lcr |= (1 << 6);
 565   return lcr;
 566 }
 567
 568 unsigned char get_fcr(ULONG baudrate)
 569 {
 570   unsigned char fcr;
 571   fcr = (1 << 0);
 572
 573   /*
 574     Depending on the baudrate set the fifo interrupt threshold to a
 575     different value.
 576   */
 577
 578   if (baudrate < 1200)
 579     fcr |= (3 << 6);
 580   else
 581   if (baudrate < 9600)
 582     fcr |= (2 << 6);
 583   else
 584   if (baudrate < 38400)
 585     fcr |= (1 << 6);
 586
 587   return fcr;
 588 }
 589
 590 BOOL set_baudrate(struct HIDDSerialUnitData * data, ULONG speed)
 591 {
 592     int quot;
 593
 594     if (!(speed >= 50 && speed <= 115200))
 595       return FALSE;
 596
 597     quot = CRYSTAL_SPEED / (speed << 4);
 598
 599     /* set the speed on the UART now */
 600     serial_outp(data, UART_LCR, get_lcr(data) | UART_LCR_DLAB);
 601     serial_outp(data, UART_DLL, quot & 0xff);
 602     serial_outp(data, UART_DLM, quot >> 8);
 603     serial_outp(data, UART_LCR, get_lcr(data));
 604     serial_outp(data, UART_FCR, get_fcr(speed) | UART_FCR_ENABLE_FIFO);
 605
 606     return TRUE;
 607 }
 608
 609 /* Serial interrupts */
 610
 611 #undef SysBase
 612 #define SysBase (hw->sysBase)
 613 #define csd ((struct class_static_data *)(irq->h_Data))
 614
 615 static void common_serial_int_handler(HIDDT_IRQ_Handler *irq,
 616                                       HIDDT_IRQ_HwInfo *hw,
 617                                       ULONG unitnum)
 618 {
 619         UBYTE code = UART_IIR_NO_INT;
 620
 621         if (csd->units[unitnum])
 622                 code = serial_inp(csd->units[unitnum], UART_IIR) & 0x07;
 623
 624         switch (code)
 625         {
 626                 case UART_IIR_RLSI:
 627                         (void)serial_inp(csd->units[unitnum], UART_LSR);
 628                 break;
 629
 630                 case UART_IIR_RDI:
 631                         if (csd->units[unitnum]) {
 632                                 AROS_UFC3(void, serialunit_receive_data,
 633                                   AROS_UFCA(APTR               , csd->units[unitnum], A1),
 634                                   AROS_UFCA(APTR               , NULL   , A5),
 635                                   AROS_UFCA(struct ExecBase *  , SysBase, A6));
 636                         }
 637                 break;
 638
 639                 case UART_IIR_MSI:
 640                         (void)serial_inp(csd->units[unitnum], UART_MSR);
 641                 break;
 642
 643                 case UART_IIR_THRI:
 644                         if (csd->units[unitnum])
 645                                 if (0 == serialunit_write_more_data(csd->units[unitnum], NULL, SysBase))
 646                                         (void)serial_inp(csd->units[unitnum], UART_IIR);
 647                 break;
 648         }
 649 }
 650
 651 void serial_int_13(HIDDT_IRQ_Handler *irq, HIDDT_IRQ_HwInfo *hw)
 652 {
 653         common_serial_int_handler(irq, hw, 0);
 654         common_serial_int_handler(irq, hw, 2);
 655 }
 656
 657 void serial_int_24(HIDDT_IRQ_Handler * irq, HIDDT_IRQ_HwInfo *hw)
 658 {
 659         common_serial_int_handler(irq, hw, 1);
 660         common_serial_int_handler(irq, hw, 3);
 661 }
 662
 663 static void adapt_data(struct HIDDSerialUnitData * data,
 664                        struct Preferences * prefs)
 665 {
 666         /*
 667          * Parity.
 668          */
 669         data->parity = TRUE;
 670
 671         switch ((prefs->SerParShk >> 4) & 0x0f) {
 672
 673                 case SPARITY_NONE:
 674                 default:             /* DEFAULT !! */
 675                         data->parity = FALSE;
 676                 break;
 677
 678                 case SPARITY_EVEN:
 679                         data->paritytype = PARITY_EVEN;
 680                 break;
 681
 682                 case SPARITY_ODD:
 683                         data->paritytype = PARITY_ODD;
 684                 break;
 685
 686                 case SPARITY_MARK:
 687                         data->paritytype = PARITY_1;
 688                 break;
 689                 case SPARITY_SPACE:
 690                         data->paritytype = PARITY_0;
 691                 break;
 692
 693         }
 694
 695         /*
 696          * Bit per character
 697          */
 698         switch ((prefs->SerRWBits & 0x0f)) {
 699                 default: /* 8 bit */
 700                 case 0:
 701                         data->datalength = 8;
 702                 break;
 703
 704                 case 1: /* 7 bit */
 705                         data->datalength = 7;
 706                 break;
 707
 708                 case 2: /* 6 bit */
 709                         data->datalength = 6;
 710                 break;
 711
 712                 case 3: /* 5 bit */
 713                         data->datalength = 5;
 714                 break;
 715         }
 716
 717         /*
 718          * 2 stop bits ? default is '1'.
 719          */
 720         if (1 == (prefs->SerStopBuf >> 4))
 721                 data->stopbits = 2;
 722         else
 723                 data->stopbits = 1;
 724
 725         /*
 726          * Handshake to be used.
 727          */
 728         // MISSING!
 729 }