reactos/ntoskrnl/ex/hdlsterm.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * LICENSE:         BSD - See COPYING.ARM in the top level directory
   4  * FILE:            ntoskrnl/ex/hdlsterm.c
   5  * PURPOSE:         Headless Terminal Support
   6  * PROGRAMMERS:     ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES ******************************************************************/
  10
  11 #include <ntoskrnl.h>
  12 #include <debug.h>
  13
  14 /* GLOBALS *******************************************************************/
  15
  16 PHEADLESS_GLOBALS HeadlessGlobals;
  17
  18 /* FUNCTIONS *****************************************************************/
  19
  20 FORCEINLINE
  21 KIRQL
  22 HdlspAcquireGlobalLock(VOID)
  23 {
  24     KIRQL OldIrql;
  25
  26     /* Don't acquire the lock if we are bugchecking */
  27     if (!HeadlessGlobals->InBugCheck)
  28     {
  29         KeAcquireSpinLock(&HeadlessGlobals->SpinLock, &OldIrql);
  30     }
  31     else
  32     {
  33         OldIrql = 0xFF;
  34     }
  35
  36     return OldIrql;
  37 }
  38
  39 FORCEINLINE
  40 VOID
  41 HdlspReleaselobalLock(IN KIRQL OldIrql)
  42 {
  43     /* Only release the lock if we aren't bugchecking */
  44     if (OldIrql != 0xFF)
  45     {
  46         KeReleaseSpinLock(&HeadlessGlobals->SpinLock, OldIrql);
  47     }
  48     else
  49     {
  50         ASSERT(HeadlessGlobals->InBugCheck == TRUE);
  51     }
  52 }
  53
  54 VOID
  55 NTAPI
  56 HdlspSendStringAtBaud(IN PUCHAR String)
  57 {
  58     /* Send every byte */
  59     while (*String++ != ANSI_NULL)
  60     {
  61         InbvPortPutByte(HeadlessGlobals->TerminalPort, *String);
  62     }
  63 }
  64
  65 NTSTATUS
  66 NTAPI
  67 HdlspEnableTerminal(IN BOOLEAN Enable)
  68 {
  69     /* Enable if requested, as long as this isn't a PCI serial port crashing */
  70     if ((Enable) &&
  71         !(HeadlessGlobals->TerminalEnabled) &&
  72         !((HeadlessGlobals->IsMMIODevice) && (HeadlessGlobals->InBugCheck)))
  73     {
  74         /* Initialize the COM port with cportlib */
  75         HeadlessGlobals->TerminalEnabled = InbvPortInitialize(HeadlessGlobals->
  76                                                               TerminalBaudRate,
  77                                                               HeadlessGlobals->
  78                                                               TerminalPortNumber,
  79                                                               HeadlessGlobals->
  80                                                               TerminalPortAddress,
  81                                                               &HeadlessGlobals->
  82                                                               TerminalPort,
  83                                                               HeadlessGlobals->
  84                                                               IsMMIODevice);
  85         if (!HeadlessGlobals->TerminalEnabled)
  86         {
  87             DPRINT1("Failed to initialize port through cportlib\n");
  88             return STATUS_UNSUCCESSFUL;
  89         }
  90
  91         /* Cleanup the screen and reset the cursor */
  92         HdlspSendStringAtBaud((PUCHAR)"\x1B[2J");
  93         HdlspSendStringAtBaud((PUCHAR)"\x1B[H");
  94
  95         /* Enable FIFO */
  96         InbvPortEnableFifo(HeadlessGlobals->TerminalPort, TRUE);
  97     }
  98     else if (!Enable)
  99     {
 100         /* Specific case when headless is being disabled */
 101         InbvPortTerminate(HeadlessGlobals->TerminalPort);
 102         HeadlessGlobals->TerminalPort = 0;
 103         HeadlessGlobals->TerminalEnabled = FALSE;
 104     }
 105
 106     /* All done */
 107     return STATUS_SUCCESS;
 108 }
 109
 110 VOID
 111 NTAPI
 112 INIT_FUNCTION
 113 HeadlessInit(IN PLOADER_PARAMETER_BLOCK LoaderBlock)
 114 {
 115     PHEADLESS_LOADER_BLOCK HeadlessBlock;
 116
 117     /* Only initialize further if the loader found EMS enabled */
 118     HeadlessBlock = LoaderBlock->Extension->HeadlessLoaderBlock;
 119     if (!HeadlessBlock) return;
 120
 121     /* Ignore invalid EMS settings */
 122     if ((HeadlessBlock->PortNumber > 4) && (HeadlessBlock->UsedBiosSettings)) return;
 123
 124     /* Allocate the global headless data */
 125     HeadlessGlobals = ExAllocatePoolWithTag(NonPagedPool,
 126                                             sizeof(*HeadlessGlobals),
 127                                             'sldH');
 128     if (!HeadlessGlobals) return;
 129
 130     /* Zero and copy loader data */
 131     RtlZeroMemory(HeadlessGlobals, sizeof(*HeadlessGlobals));
 132     HeadlessGlobals->TerminalPortNumber = HeadlessBlock->PortNumber;
 133     HeadlessGlobals->TerminalPortAddress = HeadlessBlock->PortAddress;
 134     HeadlessGlobals->TerminalBaudRate = HeadlessBlock->BaudRate;
 135     HeadlessGlobals->TerminalParity = HeadlessBlock->Parity;
 136     HeadlessGlobals->TerminalStopBits = HeadlessBlock->StopBits;
 137     HeadlessGlobals->UsedBiosSettings = HeadlessBlock->UsedBiosSettings;
 138     HeadlessGlobals->IsMMIODevice = HeadlessBlock->IsMMIODevice;
 139     HeadlessGlobals->TerminalType = HeadlessBlock->TerminalType;
 140     HeadlessGlobals->SystemGUID = HeadlessBlock->SystemGUID;
 141     DPRINT1("EMS on Port %d (0x%lx) at %d bps\n",
 142              HeadlessGlobals->TerminalPortNumber,
 143              HeadlessGlobals->TerminalPortAddress,
 144              HeadlessGlobals->TerminalBaudRate);
 145
 146     /* These two are opposites of each other */
 147     if (HeadlessGlobals->IsMMIODevice) HeadlessGlobals->IsNonLegacyDevice = TRUE;
 148
 149     /* Check for a PCI device, warn that this isn't supported */
 150     if (HeadlessBlock->PciDeviceId != PCI_INVALID_VENDORID)
 151     {
 152         DPRINT1("PCI Serial Ports not supported\n");
 153     }
 154
 155     /* Log entries are not yet supported */
 156     DPRINT1("FIXME: No Headless logging support\n");
 157
 158     /* Allocate temporary buffer */
 159     HeadlessGlobals->TmpBuffer = ExAllocatePoolWithTag(NonPagedPool, 80, 'sldH');
 160     if (!HeadlessGlobals->TmpBuffer) return;
 161
 162     /* Windows seems to apply some special hacks for 9600 bps */
 163     if (HeadlessGlobals->TerminalBaudRate == 9600)
 164     {
 165         DPRINT1("Please use other baud rate than 9600bps for now\n");
 166     }
 167
 168     /* Enable the terminal */
 169     HdlspEnableTerminal(TRUE);
 170 }
 171
 172 VOID
 173 NTAPI
 174 HdlspPutData(IN PUCHAR Data,
 175              IN ULONG DataSize)
 176 {
 177     ULONG i;
 178     for (i = 0; i < DataSize; i++)
 179     {
 180         InbvPortPutByte(HeadlessGlobals->TerminalPort, Data[i]++);
 181     }
 182 }
 183
 184 VOID
 185 NTAPI
 186 HdlspPutString(IN PUCHAR String)
 187 {
 188         PUCHAR Dest = HeadlessGlobals->TmpBuffer;
 189         UCHAR Char = 0;
 190
 191         /* Scan each character */
 192         while (*String != ANSI_NULL)
 193         {
 194                 /* Check for rotate, send existing buffer and restart from where we are */
 195                 if (Dest >= &HeadlessGlobals->TmpBuffer[79])
 196                 {
 197                         HeadlessGlobals->TmpBuffer[79] = ANSI_NULL;
 198                         HdlspSendStringAtBaud(HeadlessGlobals->TmpBuffer);
 199                         Dest = HeadlessGlobals->TmpBuffer;
 200                 }
 201                 else
 202                 {
 203                         /* Get the current character and check for special graphical chars */
 204                         Char = *String;
 205                         if (Char & 0x80)
 206                         {
 207                                 switch (Char)
 208                                 {
 209                                         case 0xB0: case 0xB3: case 0xBA:
 210                                                 Char = '|';
 211                                                 break;
 212                                         case 0xB1: case 0xDC: case 0xDD: case 0xDE: case 0xDF:
 213                                                 Char = '%';
 214                                                 break;
 215                                         case 0xB2: case 0xDB:
 216                                                 Char = '#';
 217                                                 break;
 218                                         case 0xA9: case 0xAA: case 0xBB: case 0xBC: case 0xBF:
 219                                         case 0xC0: case 0xC8: case 0xC9: case 0xD9: case 0xDA:
 220                                                 Char = '+';
 221                                                 break;
 222                                         case 0xC4:
 223                                                 Char = '-';
 224                                                 break;
 225                                         case 0xCD:
 226                                                 Char = '=';
 227                                                 break;
 228                                         }
 229                         }
 230
 231                         /* Anything else must be Unicode */
 232                         if (Char & 0x80)
 233                         {
 234                                 /* Can't do Unicode yet */
 235                                 UNIMPLEMENTED;
 236                         }
 237                         else
 238                         {
 239                                 /* Add the modified char to the temporary buffer */
 240                                 *Dest++ = Char;
 241                         }
 242
 243                         /* Check the next char */
 244                         String++;
 245                 }
 246         }
 247
 248         /* Finish and send */
 249         *Dest = ANSI_NULL;
 250         HdlspSendStringAtBaud(HeadlessGlobals->TmpBuffer);
 251 }
 252
 253 NTSTATUS
 254 NTAPI
 255 HdlspDispatch(IN HEADLESS_CMD Command,
 256               IN PVOID InputBuffer,
 257               IN SIZE_T InputBufferSize,
 258               OUT PVOID OutputBuffer,
 259               OUT PSIZE_T OutputBufferSize)
 260 {
 261     KIRQL OldIrql;
 262     PHEADLESS_RSP_QUERY_INFO HeadlessInfo;
 263     PHEADLESS_CMD_PUT_STRING PutString;
 264     PHEADLESS_CMD_ENABLE_TERMINAL EnableTerminal;
 265     NTSTATUS Status = STATUS_NOT_IMPLEMENTED;
 266     ASSERT(HeadlessGlobals != NULL);
 267 //      ASSERT(HeadlessGlobals->PageLockHandle != NULL);
 268
 269     /* Ignore non-reentrant commands */
 270     if ((Command != HeadlessCmdAddLogEntry) &&
 271         (Command != HeadlessCmdStartBugCheck) &&
 272         (Command != HeadlessCmdSendBlueScreenData) &&
 273         (Command != HeadlessCmdDoBugCheckProcessing))
 274     {
 275         OldIrql = HdlspAcquireGlobalLock();
 276
 277         if (HeadlessGlobals->ProcessingCmd)
 278         {
 279             HdlspReleaselobalLock(OldIrql);
 280             return STATUS_UNSUCCESSFUL;
 281         }
 282
 283         /* Don't allow these commands next time */
 284         HeadlessGlobals->ProcessingCmd = TRUE;
 285         HdlspReleaselobalLock(OldIrql);
 286     }
 287
 288     /* Handle each command */
 289     switch (Command)
 290     {
 291         case HeadlessCmdEnableTerminal:
 292
 293             /* Make sure the caller passed valid data */
 294             if (!(InputBuffer) ||
 295                 (InputBufferSize != sizeof(*EnableTerminal)))
 296             {
 297                 DPRINT1("Invalid buffer\n");
 298                 Status = STATUS_INVALID_PARAMETER;
 299                 break;
 300             }
 301
 302             /* Go and enable it */
 303             EnableTerminal = InputBuffer;
 304             Status = HdlspEnableTerminal(EnableTerminal->Enable);
 305             break;
 306
 307                 case HeadlessCmdCheckForReboot:
 308                         break;
 309
 310                 case HeadlessCmdPutString:
 311
 312             /* Validate the existence of an input buffer */
 313             if (!InputBuffer)
 314             {
 315                 Status = STATUS_INVALID_PARAMETER;
 316                 break;
 317             }
 318
 319             /* Terminal should be on */
 320             if (HeadlessGlobals->TerminalEnabled)
 321             {
 322                 /* Print each byte in the string making sure VT100 chars are used */
 323                 PutString = InputBuffer;
 324                 HdlspPutString(PutString->String);
 325             }
 326
 327             /* Return success either way */
 328             Status = STATUS_SUCCESS;
 329             break;
 330
 331                 case HeadlessCmdClearDisplay:
 332                         break;
 333                 case HeadlessCmdClearToEndOfDisplay:
 334                         break;
 335                 case HeadlessCmdClearToEndOfLine:
 336                         break;
 337                 case HeadlessCmdDisplayAttributesOff:
 338                         break;
 339                 case HeadlessCmdDisplayInverseVideo:
 340                         break;
 341                 case HeadlessCmdSetColor:
 342                         break;
 343                 case HeadlessCmdPositionCursor:
 344                         break;
 345                 case HeadlessCmdTerminalPoll:
 346                         break;
 347                 case HeadlessCmdGetByte:
 348                         break;
 349                 case HeadlessCmdGetLine:
 350                         break;
 351                 case HeadlessCmdStartBugCheck:
 352                         break;
 353                 case HeadlessCmdDoBugCheckProcessing:
 354                         break;
 355                 case HeadlessCmdQueryInformation:
 356
 357             /* Make sure the caller passed valid data */
 358             if (!(OutputBuffer) ||
 359                 !(OutputBufferSize) ||
 360                 (*OutputBufferSize < sizeof(*HeadlessInfo)))
 361             {
 362                 DPRINT1("Invalid buffer\n");
 363                 Status = STATUS_INVALID_PARAMETER;
 364                 break;
 365             }
 366
 367             /* If we got here, headless is enabled -- we know this much */
 368             HeadlessInfo = OutputBuffer;
 369             HeadlessInfo->PortType = HeadlessSerialPort;
 370             HeadlessInfo->Serial.TerminalAttached = TRUE;
 371             HeadlessInfo->Serial.UsedBiosSettings = HeadlessGlobals->UsedBiosSettings;
 372             HeadlessInfo->Serial.TerminalBaudRate = HeadlessGlobals->TerminalBaudRate;
 373             HeadlessInfo->Serial.TerminalType = HeadlessGlobals->TerminalType;
 374
 375             /* Now check on what port/baud it's enabled on */
 376             if ((HeadlessGlobals->TerminalPortNumber >= 1) ||
 377                 (HeadlessGlobals->UsedBiosSettings))
 378             {
 379                 /* Get the EMS information */
 380                 HeadlessInfo->Serial.TerminalPort = HeadlessGlobals->
 381                                                     TerminalPortNumber;
 382                 HeadlessInfo->Serial.TerminalPortBaseAddress = HeadlessGlobals->
 383                                                                TerminalPortAddress;
 384             }
 385             else
 386             {
 387                 /* We don't know for sure */
 388                 HeadlessInfo->Serial.TerminalPort = SerialPortUndefined;
 389                 HeadlessInfo->Serial.TerminalPortBaseAddress = 0;
 390             }
 391
 392             /* All done */
 393             Status = STATUS_SUCCESS;
 394             break;
 395                 case HeadlessCmdAddLogEntry:
 396                         break;
 397                 case HeadlessCmdDisplayLog:
 398                         break;
 399         case HeadlessCmdSetBlueScreenData:
 400
 401             /* Validate the existence of an input buffer */
 402             if (!InputBuffer)
 403             {
 404                 Status = STATUS_INVALID_PARAMETER;
 405                 break;
 406             }
 407
 408             /* Lie so that we can get Hdl bringup a little bit further */
 409             UNIMPLEMENTED;
 410             Status = STATUS_SUCCESS;
 411             break;
 412                 case HeadlessCmdSendBlueScreenData:
 413                         break;
 414                 case HeadlessCmdQueryGUID:
 415                         break;
 416                 case HeadlessCmdPutData:
 417
 418             /* Validate the existence of an input buffer */
 419             if (!(InputBuffer) || !(InputBufferSize))
 420             {
 421                 Status = STATUS_INVALID_PARAMETER;
 422                 break;
 423             }
 424
 425             /* Terminal should be on */
 426             if (HeadlessGlobals->TerminalEnabled)
 427             {
 428                 /* Print each byte in the string making sure VT100 chars are used */
 429                 PutString = InputBuffer;
 430                 HdlspPutData(PutString->String, InputBufferSize);
 431             }
 432
 433             /* Return success either way */
 434             Status = STATUS_SUCCESS;
 435             break;
 436
 437         default:
 438             break;
 439     }
 440
 441     /* Unset processing state */
 442     if ((Command != HeadlessCmdAddLogEntry) &&
 443         (Command != HeadlessCmdStartBugCheck) &&
 444         (Command != HeadlessCmdSendBlueScreenData) &&
 445         (Command != HeadlessCmdDoBugCheckProcessing))
 446     {
 447         ASSERT(HeadlessGlobals->ProcessingCmd == TRUE);
 448         HeadlessGlobals->ProcessingCmd = FALSE;
 449     }
 450
 451     /* All done */
 452     return Status;
 453 }
 454
 455 /*
 456  * @implemented
 457  */
 458 NTSTATUS
 459 NTAPI
 460 HeadlessDispatch(IN HEADLESS_CMD Command,
 461                  IN PVOID InputBuffer,
 462                  IN SIZE_T InputBufferSize,
 463                  OUT PVOID OutputBuffer,
 464                  OUT PSIZE_T OutputBufferSize)
 465 {
 466     /* Check for stubs that will expect something even with headless off */
 467     if (!HeadlessGlobals)
 468     {
 469         /* Don't allow the SAC to connect */
 470         if (Command == HeadlessCmdEnableTerminal) return STATUS_UNSUCCESSFUL;
 471
 472         /* Send bogus reply */
 473         if ((Command == HeadlessCmdQueryInformation) ||
 474             (Command == HeadlessCmdGetByte) ||
 475             (Command == HeadlessCmdGetLine) ||
 476             (Command == HeadlessCmdCheckForReboot) ||
 477             (Command == HeadlessCmdTerminalPoll))
 478         {
 479             if (!(OutputBuffer) || !(OutputBufferSize))
 480             {
 481                 return STATUS_INVALID_PARAMETER;
 482             }
 483
 484             RtlZeroMemory(OutputBuffer, *OutputBufferSize);
 485         }
 486         return STATUS_SUCCESS;
 487     }
 488
 489     /* Do the real work */
 490     return HdlspDispatch(Command,
 491                          InputBuffer,
 492                          InputBufferSize,
 493                          OutputBuffer,
 494                          OutputBufferSize);
 495 }
 496
 497 /* EOF */