Return to gpdwrite.c CVS log

Up to [WindowsNT SDKs] / q_a / samples / ddk / portio

Annotation of q_a/samples/ddk/portio/gpdwrite.c, revision 1.1.1.1

1.1       root        1: // Write a byte to an port using the wkd driver.
                      2: // Robert R. Howell             January 6, 1993
                      3: // Robert B. Nelson (Microsoft) January 12, 1993
                      4: // Robert B. Nelson (Microsoft) April 5, 1993
                      5: // Robert B. Nelson (Microsoft) May 6, 1993
                      6: 
                      7: #include <windows.h>
                      8: #include <stddef.h>
                      9: #include <stdio.h>
                     10: #include <stdlib.h>
                     11: #include <winioctl.h>
                     12: #include "gpioctl.h"        // This defines the IOCTL constants.
                     13: 
                     14: void main(int argc, char **argv)
                     15: {
                     16: 
                     17:     // The following is returned by IOCTL.  It is true if the write succeeds.
                     18:     BOOL    IoctlResult;
                     19: 
                     20:     // The following parameters are used in the IOCTL call
                     21:     HANDLE              hndFile;        // Handle to device, obtain from CreateFile
                     22:     GENPORT_WRITE_INPUT InputBuffer;    // Input buffer for DeviceIoControl
                     23:     LONG                IoctlCode;
                     24:     ULONG               DataValue;
                     25:     ULONG               DataLength;
                     26:     ULONG               ReturnedLength; // Number of bytes returned in output buffer
                     27: 
                     28: 
                     29:     if (argc < 4)
                     30:     {
                     31:         printf("GpdWrite -b|-w|-d <Port#> <Value>\n\n");
                     32:         printf("        The byte (-b), word (-w), or doubleword (-d) specified\n");
                     33:         printf("        as value is written to the given port.  Ports are numbered\n");
                     34:         printf("        as 0, 1, ... relative to the base set in the driver or\n");
                     35:         printf("        the registry.  The default driver uses ports 300h through\n");
                     36:         printf("        303h.  All numbers are read in hex.\n");
                     37:         exit(1);
                     38:     }
                     39: 
                     40: 
                     41:     hndFile = CreateFile(
                     42:                     "\\\\.\\GpdDev",           // Open the Device "file"
                     43:                     GENERIC_WRITE,
                     44:                     FILE_SHARE_WRITE,
                     45:                     NULL,
                     46:                     OPEN_EXISTING,
                     47:                     0,
                     48:                     NULL);
                     49: 
                     50:     if (hndFile == INVALID_HANDLE_VALUE)        // Was the device opened?
                     51:     {
                     52:         printf("Unable to open the device.\n");
                     53:         exit(1);
                     54:     }
                     55: 
                     56:     sscanf(argv[2], "%x", &InputBuffer.PortNumber);     // Get the port number
                     57:     sscanf(argv[3], "%x", &DataValue);          // Get the data to be written.
                     58: 
                     59:     switch (argv[1][1])
                     60:     {
                     61:         case 'b':
                     62:             IoctlCode = IOCTL_GPD_WRITE_PORT_UCHAR;
                     63:             InputBuffer.CharData = (UCHAR)DataValue;
                     64:             DataLength = offsetof(GENPORT_WRITE_INPUT, CharData) +
                     65:                          sizeof(InputBuffer.CharData);
                     66:             break;
                     67:             
                     68:         case 'w':
                     69:             IoctlCode = IOCTL_GPD_WRITE_PORT_USHORT;
                     70:             InputBuffer.ShortData = (USHORT)DataValue;
                     71:             DataLength = offsetof(GENPORT_WRITE_INPUT, ShortData) +
                     72:                          sizeof(InputBuffer.ShortData);
                     73:             break;
                     74: 
                     75:         case 'd':
                     76:             IoctlCode = IOCTL_GPD_WRITE_PORT_ULONG;
                     77:             InputBuffer.LongData = (ULONG)DataValue;
                     78:             DataLength = offsetof(GENPORT_WRITE_INPUT, LongData) +
                     79:                          sizeof(InputBuffer.LongData);
                     80:             break;
                     81:     }
                     82: 
                     83:     IoctlResult = DeviceIoControl(
                     84:                         hndFile,                // Handle to device
                     85:                         IoctlCode,              // IO Control code for Write
                     86:                         &InputBuffer,           // Buffer to driver.  Holds port & data.
                     87:                         DataLength,             // Length of buffer in bytes.
                     88:                         NULL,                   // Buffer from driver.   Not used.
                     89:                         0,                      // Length of buffer in bytes.
                     90:                         &ReturnedLength,        // Bytes placed in outbuf.  Should be 0.
                     91:                         NULL                    // NULL means wait till I/O completes.
                     92:                         );
                     93: 
                     94: 
                     95:     if (IoctlResult)                            // Did the IOCTL succeed?
                     96:     {
                     97:         printf(
                     98:             "Wrote to port %x the data %x\n",
                     99:             InputBuffer.PortNumber, DataValue);
                    100:     }
                    101:     else
                    102:     {
                    103:         printf(
                    104:             "Ioctl failed with code %ld\n", GetLastError() );
                    105:     }
                    106: 
                    107: 
                    108:     if (!CloseHandle(hndFile))                  // Close the Device "file".
                    109:     {
                    110:         printf("Failed to close device.\n");
                    111:     }
                    112: 
                    113:     exit(0);
                    114: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.