pastebin - collaborative debugging

pastebin is a collaborative debugging tool allowing you to share and modify code snippets while chatting on IRC, IM or a message board.

This site is developed to XHTML and CSS2 W3C standards. If you see this paragraph, your browser does not support those standards and you need to upgrade. Visit WaSP for a variety of options.

C pastebin - collaborative debugging tool View Help


Posted by Gallon Sylvestre on Tue 13 May 14:39
report abuse | View followups from Anonymous | download | new post

  1. #include <ntddk.h>
  2. #include <usbdi.h>
  3. #include <wdf.h>
  4. #include <wdfio.h>
  5. #include <wdfusb.h>
  6. #include <ntstrsafe.h>
  7. #include <wdm.h>
  8. #include <ntddser.h>
  9. #include "public.h"
  10.  
  11.  
  12. void                    usb_device_interrupt(WDFUSBPIPE pipe, WDFMEMORY buffer, size_t len, WDFCONTEXT ctx)
  13. {
  14.         /*devargs               *args;*/
  15.  
  16.         UNREFERENCED_PARAMETER(pipe);
  17.         UNREFERENCED_PARAMETER(buffer);
  18.         UNREFERENCED_PARAMETER(len);
  19.         UNREFERENCED_PARAMETER(ctx);
  20.         KdPrint((DRIVER_NAME "-->USB interrupt into\n"));
  21.         /*args = (devargs *)ctx;*/
  22.         /*KdPrint(("usb_device_interrupt: %x @@ %i\n", buffer, len));*/
  23.         KdPrint((DRIVER_NAME "<--USB interrupt into\n"));
  24.         return ;
  25. }
  26.  
  27. void                    usb_read(IN WDFQUEUE queue, IN WDFREQUEST req, IN size_t len)
  28. {
  29.         devargs         *args;
  30.  
  31.         UNREFERENCED_PARAMETER(queue);
  32.         UNREFERENCED_PARAMETER(req);
  33.         UNREFERENCED_PARAMETER(len);
  34.         KdPrint((DRIVER_NAME "-->usb_read into\n"));
  35.         args = getdevargs(WdfIoQueueGetDevice(queue));
  36.         WdfWaitLockAcquire(args->lock, NULL);
  37.         args->status.AmountInOutQueue = 0;
  38.         WdfWaitLockRelease(args->lock);
  39.         WdfRequestCompleteWithInformation(req, STATUS_SUCCESS, 0);                              
  40.         KdPrint((DRIVER_NAME "<--usb_read into\n"));
  41.         return ;
  42. }
  43.  
  44. void                    usb_write_complete(IN WDFREQUEST req, IN WDFIOTARGET target, IN PWDF_REQUEST_COMPLETION_PARAMS param, IN WDFCONTEXT ctx)
  45. {
  46.         PWDF_USB_REQUEST_COMPLETION_PARAMS comp_params;
  47.         devargs         *args;
  48.  
  49.         UNREFERENCED_PARAMETER(target);
  50.         UNREFERENCED_PARAMETER(ctx);
  51.         KdPrint((DRIVER_NAME "-->usb_write_complete into\n"));
  52.         args = getdevargs(WdfIoQueueGetDevice(WdfRequestGetIoQueue(req)));
  53.         comp_params = param->Parameters.Usb.Completion;
  54.         if(NT_SUCCESS(param->IoStatus.Status))
  55.         {
  56.                 KdPrint((DRIVER_NAME "   Completed the write request with %d bytes\n", comp_params->Parameters.PipeWrite.Length));
  57.         }
  58.         else
  59.         {
  60.                 KdPrint((DRIVER_NAME "   Failed the read request with status 0x%08x\n", param->IoStatus.Status));
  61.         }
  62.         WdfWaitLockAcquire(args->lock, NULL);
  63.         args->status.AmountInInQueue = comp_params->Parameters.PipeWrite.Length;
  64.         WdfWaitLockRelease(args->lock);
  65.         WdfRequestCompleteWithInformation(req, param->IoStatus.Status, comp_params->Parameters.PipeWrite.Length);
  66.         KdPrint((DRIVER_NAME "<--usb_write_complete into\n"));
  67.         return ;
  68. }
  69.  
  70. void                    usb_write(IN WDFQUEUE queue, IN WDFREQUEST req, IN size_t len)
  71. {
  72.         NTSTATUS        stat = STATUS_SUCCESS;
  73.         WDFMEMORY       buf;
  74.         devargs         *args;
  75.  
  76.         UNREFERENCED_PARAMETER(len);
  77.         KdPrint((DRIVER_NAME "-->usb_write into\n"));
  78.         args = getdevargs(WdfIoQueueGetDevice(queue));
  79.         stat = WdfRequestRetrieveInputMemory(req, &buf);
  80.         if (!NT_SUCCESS(stat))
  81.         {
  82.                 KdPrint((DRIVER_NAME "   write failed\n"));
  83.                 WdfRequestComplete(req, stat);
  84.                 return ;
  85.         }
  86.  
  87.         stat = WdfUsbTargetPipeFormatRequestForWrite(args->usb_bulk_out, req, buf, NULL);
  88.         if (!NT_SUCCESS(stat))
  89.         {
  90.                 KdPrint((DRIVER_NAME "   write failed2\n"));
  91.                 WdfRequestComplete(req, stat);
  92.                 return ;
  93.         }
  94.         WdfRequestSetCompletionRoutine(req, usb_write_complete, args->usb_bulk_out);
  95.         if (WdfRequestSend(req, WdfUsbTargetPipeGetIoTarget(args->usb_bulk_out), NULL) == FALSE)
  96.         {
  97.                 KdPrint((DRIVER_NAME "   write failed3\n"));
  98.                 stat = WdfRequestGetStatus(req);
  99.                 WdfRequestComplete(req, stat);
  100.                 return;
  101.         }              
  102.         KdPrint((DRIVER_NAME "<--usb_write into\n"));
  103.         return ;
  104. }
  105.  
  106. const char                      *getioctlname(IN ULONG ioctcode)
  107. {
  108.         switch (ioctcode)
  109.         {
  110.                 case IOCTL_SERIAL_SET_BAUD_RATE:
  111.                         return "IOCTL_SERIAL_SET_BAUD_RATE";
  112.                 case IOCTL_SERIAL_SET_QUEUE_SIZE:
  113.                         return "IOCTL_SERIAL_SET_QUEUE_SIZE";
  114.                 case IOCTL_SERIAL_SET_LINE_CONTROL:
  115.                         return "IOCTL_SERIAL_SET_LINE_CONTROL";
  116.                 case IOCTL_SERIAL_SET_BREAK_ON:
  117.                         return "IOCTL_SERIAL_SET_BREAK_ON";
  118.                 case IOCTL_SERIAL_SET_BREAK_OFF:
  119.                         return "IOCTL_SERIAL_SET_BREAK_OFF";
  120.                 case IOCTL_SERIAL_IMMEDIATE_CHAR:
  121.                         return "IOCTL_SERIAL_IMMEDIATE_CHAR";
  122.                 case IOCTL_SERIAL_SET_TIMEOUTS:
  123.                         return "IOCTL_SERIAL_SET_TIMEOUTS";
  124.                 case IOCTL_SERIAL_GET_TIMEOUTS:
  125.                         return "IOCTL_SERIAL_GET_TIMEOUTS";
  126.                 case IOCTL_SERIAL_SET_DTR:
  127.                         return "IOCTL_SERIAL_SET_DTR";
  128.                 case IOCTL_SERIAL_CLR_DTR:
  129.                         return "IOCTL_SERIAL_CLR_DTR";
  130.                 case IOCTL_SERIAL_RESET_DEVICE:
  131.                         return "IOCTL_SERIAL_RESET_DEVICE";
  132.                 case IOCTL_SERIAL_SET_RTS:
  133.                         return "IOCTL_SERIAL_SET_RTS";
  134.                 case IOCTL_SERIAL_CLR_RTS:
  135.                         return "IOCTL_SERIAL_CLR_RTS";
  136.                 case IOCTL_SERIAL_SET_XOFF:
  137.                         return "IOCTL_SERIAL_SET_XOFF";
  138.                 case IOCTL_SERIAL_SET_XON:
  139.                         return "IOCTL_SERIAL_SET_XON";
  140.                 case IOCTL_SERIAL_GET_WAIT_MASK:
  141.                         return "IOCTL_SERIAL_GET_WAIT_MASK";
  142.                 case IOCTL_SERIAL_SET_WAIT_MASK:
  143.                         return "IOCTL_SERIAL_SET_WAIT_MASK";
  144.                 case IOCTL_SERIAL_WAIT_ON_MASK:
  145.                         return "IOCTL_SERIAL_WAIT_ON_MASK";
  146.                 case IOCTL_SERIAL_PURGE:
  147.                         return "IOCTL_SERIAL_PURGE";
  148.                 case IOCTL_SERIAL_GET_BAUD_RATE:
  149.                         return "IOCTL_SERIAL_GET_BAUD_RATE";
  150.                 case IOCTL_SERIAL_GET_LINE_CONTROL:
  151.                         return "IOCTL_SERIAL_GET_LINE_CONTROL";
  152.                 case IOCTL_SERIAL_GET_CHARS:
  153.                         return "IOCTL_SERIAL_GET_CHARS";
  154.                 case IOCTL_SERIAL_SET_CHARS:
  155.                         return "IOCTL_SERIAL_SET_CHARS";
  156.                 case IOCTL_SERIAL_GET_HANDFLOW:
  157.                         return "IOCTL_SERIAL_GET_HANDFLOW";
  158.                 case IOCTL_SERIAL_SET_HANDFLOW:
  159.                         return "IOCTL_SERIAL_SET_HANDFLOW";
  160.                 case IOCTL_SERIAL_GET_MODEMSTATUS:
  161.                         return "IOCTL_SERIAL_GET_MODEMSTATUS";
  162.                 case IOCTL_SERIAL_GET_COMMSTATUS:
  163.                         return "IOCTL_SERIAL_GET_COMMSTATUS";
  164.                 case IOCTL_SERIAL_XOFF_COUNTER:
  165.                         return "IOCTL_SERIAL_XOFF_COUNTER";
  166.                 case IOCTL_SERIAL_GET_PROPERTIES:
  167.                         return "IOCTL_SERIAL_GET_PROPERTIES";
  168.                 case IOCTL_SERIAL_GET_DTRRTS:
  169.                         return "IOCTL_SERIAL_GET_DTRRTS";
  170.                 default:
  171.                         return "Unknow";
  172.         }
  173. }
  174.  
  175. void                    usb_ioctl(IN WDFQUEUE queue, IN WDFREQUEST req, IN size_t outbuflen, IN size_t inbuflen, IN ULONG ioctcode)
  176. {       
  177.         NTSTATUS        stat;
  178.         void            *buffer;
  179.         size_t          len;
  180.         devargs         *args;
  181.         ULONG           Mask;
  182.  
  183.         UNREFERENCED_PARAMETER(queue);
  184.         UNREFERENCED_PARAMETER(outbuflen);
  185.         UNREFERENCED_PARAMETER(inbuflen);
  186.         switch (ioctcode)
  187.         {
  188.         case IOCTL_SERIAL_GET_BAUD_RATE:
  189.                 KdPrint(("   IOCTL_SERIAL_GET_BAUD_RATE\n"));
  190.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  191.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(ULONG), &buffer, &len);
  192.                 if(!NT_SUCCESS(stat))
  193.                 {
  194.                         KdPrint(("   Get memory error\n"));
  195.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  196.                         break;
  197.                 }
  198.                 *((ULONG*)buffer) = args->baudrate;
  199.                 WdfRequestCompleteWithInformation(req, stat, sizeof(ULONG));
  200.                 break;
  201.         case IOCTL_SERIAL_GET_LINE_CONTROL:
  202.                 KdPrint(("   IOCTL_SERIAL_GET_LINE_CONTROL\n"));
  203.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  204.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(SERIAL_LINE_CONTROL), &buffer, &len);
  205.                 if(!NT_SUCCESS(stat))
  206.                 {
  207.                         KdPrint(("   Get memory error\n"));
  208.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  209.                         break;
  210.                 }
  211.                 ((SERIAL_LINE_CONTROL*)buffer)->StopBits = args->StopBits;
  212.                 ((SERIAL_LINE_CONTROL*)buffer)->Parity = args->Parity;
  213.                 ((SERIAL_LINE_CONTROL*)buffer)->WordLength = args->WordLength;
  214.                 WdfRequestCompleteWithInformation(req, stat, sizeof(SERIAL_LINE_CONTROL));
  215.                 break;
  216.         case IOCTL_SERIAL_SET_QUEUE_SIZE:
  217.                 KdPrint(("   IOCTL_SERIAL_SET_QUEUE_SIZE\n"));
  218.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  219.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(SERIAL_QUEUE_SIZE), &buffer, &len);
  220.                 if(!NT_SUCCESS(stat))
  221.                 {
  222.                         KdPrint(("   Get memory error\n"));
  223.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  224.                         break;
  225.                 }
  226.                 WdfRequestComplete(req, STATUS_SUCCESS);
  227.                 break;
  228.         case IOCTL_SERIAL_PURGE:
  229.                 KdPrint(("   IOCTL_SERIAL_PURGE\n"));
  230.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(ULONG), &buffer, &len);
  231.                 if(!NT_SUCCESS(stat))
  232.                 {
  233.                         KdPrint(("   Get memory error\n"));
  234.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  235.                         break;
  236.                 }
  237.                 Mask = *((ULONG *)(buffer));
  238.                 if ((!Mask) || (Mask & (~(SERIAL_PURGE_TXABORT |
  239.                                                               SERIAL_PURGE_RXABORT |
  240.                                   SERIAL_PURGE_TXCLEAR |
  241.                                   SERIAL_PURGE_RXCLEAR))))
  242.                 {
  243.                 WdfRequestComplete(req, STATUS_INVALID_PARAMETER);
  244.                 break;
  245.         }
  246.                 WdfRequestComplete(req, STATUS_SUCCESS);
  247.                 break;
  248.         case IOCTL_SERIAL_GET_COMMSTATUS:
  249.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  250.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(SERIAL_STATUS), &buffer, &len);
  251.                 KdPrint(("   IOCTL_SERIAL_GET_COMMSTATUS : \n"/*, len*/));
  252.                 if(!NT_SUCCESS(stat))
  253.                 {
  254.                         KdPrint(("   Get memory error\n"));
  255.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  256.                         break;
  257.                 }
  258.                 WdfWaitLockAcquire(args->lock, NULL);
  259.                 ((PSERIAL_STATUS)buffer)->AmountInInQueue = args->status.AmountInInQueue;
  260.                 ((PSERIAL_STATUS)buffer)->AmountInOutQueue = args->status.AmountInOutQueue;
  261.                 ((PSERIAL_STATUS)buffer)->EofReceived = FALSE;
  262.                 ((PSERIAL_STATUS)buffer)->Errors = 0;
  263.                 ((PSERIAL_STATUS)buffer)->HoldReasons = 0;
  264.                 ((PSERIAL_STATUS)buffer)->WaitForImmediate = FALSE;
  265.                 buffer = &(args->status);
  266.                 WdfRequestCompleteWithInformation(req, stat, sizeof(SERIAL_STATUS));
  267.                 args->status.AmountInInQueue = 0;
  268.                 args->status.AmountInOutQueue = 0;
  269.                 /*WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);*/
  270.                 WdfWaitLockRelease(args->lock);
  271.                 break;
  272.         case IOCTL_SERIAL_SET_TIMEOUTS:
  273.                 KdPrint(("   IOCTL_SERIAL_SET_TIMEOUTS\n"));
  274.                 WdfRequestComplete(req, STATUS_SUCCESS);
  275.                 break;
  276.         case IOCTL_SERIAL_GET_CHARS:
  277.                 KdPrint(("   IOCTL_SERIAL_GET_CHARS\n"));
  278.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  279.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(SERIAL_CHARS), &buffer, &len);
  280.                 if(!NT_SUCCESS(stat))
  281.                 {
  282.                         KdPrint(("   Get memory error\n"));
  283.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  284.                         break;
  285.                 }
  286.                 ((SERIAL_CHARS*)buffer)->XonChar = args->chars.XonChar;
  287.                 ((SERIAL_CHARS*)buffer)->XoffChar = args->chars.XoffChar;
  288.                 WdfRequestCompleteWithInformation(req, stat, sizeof(SERIAL_CHARS));
  289.                 break ;
  290.         case IOCTL_SERIAL_GET_HANDFLOW:
  291.                 KdPrint(("   IOCTL_SERIAL_GET_HANDFLOW\n"));
  292.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  293.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(SERIAL_HANDFLOW), &buffer, &len);
  294.                 if(!NT_SUCCESS(stat))
  295.                 {
  296.                         KdPrint(("   Get memory error\n"));
  297.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  298.                         break;
  299.                 }
  300.                 ((SERIAL_HANDFLOW*)buffer)->ControlHandShake = args->hf.ControlHandShake;
  301.                 ((SERIAL_HANDFLOW*)buffer)->FlowReplace = args->hf.FlowReplace;
  302.                 ((SERIAL_HANDFLOW*)buffer)->XoffLimit = args->hf.XoffLimit;
  303.                 ((SERIAL_HANDFLOW*)buffer)->XonLimit = args->hf.XonLimit;
  304.                 WdfRequestCompleteWithInformation(req, stat, sizeof(SERIAL_HANDFLOW));
  305.                 break ;
  306.         case IOCTL_SERIAL_SET_BAUD_RATE:
  307.                 KdPrint(("   IOCTL_SERIAL_SET_BAUD_RATE\n"));
  308.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  309.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(ULONG), &buffer, &len);
  310.                 if(!NT_SUCCESS(stat))
  311.                 {
  312.                         KdPrint(("   Get memory error\n"));
  313.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  314.                         break;
  315.                 }
  316.                 args->baudrate = *((ULONG*)buffer);
  317.                 WdfRequestComplete(req, STATUS_SUCCESS);
  318.                 break;
  319.         case IOCTL_SERIAL_SET_LINE_CONTROL:
  320.                 KdPrint(("   IOCTL_SERIAL_SET_LINE_CONTROL\n"));
  321.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  322.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(SERIAL_LINE_CONTROL), &buffer, &len);
  323.                 if(!NT_SUCCESS(stat))
  324.                 {
  325.                         KdPrint(("   Get memory error\n"));
  326.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  327.                         break;
  328.                 }
  329.                 args->StopBits = ((SERIAL_LINE_CONTROL*)buffer)->StopBits;
  330.                 args->Parity = ((SERIAL_LINE_CONTROL*)buffer)->Parity;
  331.                 args->WordLength = ((SERIAL_LINE_CONTROL*)buffer)->WordLength;;
  332.                 WdfRequestComplete(req, STATUS_SUCCESS);
  333.                 break;
  334.         case IOCTL_SERIAL_CLR_DTR:
  335.         case IOCTL_SERIAL_SET_DTR:
  336.                 KdPrint(("   DTR\n"));
  337.                 WdfRequestComplete(req, STATUS_SUCCESS);
  338.                 break;
  339.         case IOCTL_SERIAL_CLR_RTS:
  340.         case IOCTL_SERIAL_SET_RTS:
  341.                 KdPrint(("   RTS\n"));
  342.                 WdfRequestComplete(req, STATUS_SUCCESS);
  343.                 break;
  344.         case IOCTL_SERIAL_SET_CHARS:
  345.                 KdPrint(("   SET_CHARS\n"));
  346.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  347.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(SERIAL_CHARS), &buffer, &len);
  348.                 if(!NT_SUCCESS(stat))
  349.                 {
  350.                         KdPrint(("   Get memory error\n"));
  351.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  352.                         break;
  353.                 }
  354.                 args->chars.XonChar = ((SERIAL_CHARS*)buffer)->XonChar;
  355.                 args->chars.XoffChar = ((SERIAL_CHARS*)buffer)->XoffChar;
  356.                 args->chars.EofChar = ((SERIAL_CHARS*)buffer)->EofChar;
  357.                 args->chars.ErrorChar = ((SERIAL_CHARS*)buffer)->ErrorChar;
  358.                 args->chars.BreakChar = ((SERIAL_CHARS*)buffer)->BreakChar;
  359.                 args->chars.EventChar = ((SERIAL_CHARS*)buffer)->EventChar;
  360.                 WdfRequestComplete(req, STATUS_SUCCESS);
  361.                 break ;
  362.         case IOCTL_SERIAL_SET_HANDFLOW:
  363.                 KdPrint(("   SET_HANFLOW\n"));
  364.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  365.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(SERIAL_HANDFLOW), &buffer, &len);
  366.                 if(!NT_SUCCESS(stat))
  367.                 {
  368.                         KdPrint(("   Get memory error\n"));
  369.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  370.                         break;
  371.                 }
  372.                 args->hf.ControlHandShake = ((SERIAL_HANDFLOW*)buffer)->ControlHandShake;
  373.                 args->hf.FlowReplace = ((SERIAL_HANDFLOW*)buffer)->FlowReplace;
  374.                 args->hf.XoffLimit = ((SERIAL_HANDFLOW*)buffer)->XoffLimit;
  375.                 args->hf.XonLimit = ((SERIAL_HANDFLOW*)buffer)->XonLimit;
  376.                 WdfRequestCompleteWithInformation(req, stat, sizeof(SERIAL_HANDFLOW));
  377.                 break ;
  378.         case IOCTL_SERIAL_GET_WAIT_MASK:
  379.                 KdPrint(("   GET_WAIT_MASK\n"));
  380.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  381.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(ULONG), &buffer, &len);
  382.                 if(!NT_SUCCESS(stat))
  383.                 {
  384.                         KdPrint(("   Get memory error\n"));
  385.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  386.                         break;
  387.                 }
  388.                 *((ULONG*)buffer) = 0;
  389.                 WdfRequestCompleteWithInformation(req, stat, sizeof(ULONG));
  390.                 break;
  391.         case IOCTL_SERIAL_SET_WAIT_MASK:
  392.                 KdPrint(("   SET_WAIT_MASK\n"));
  393.                 args = getdevargs(WdfIoQueueGetDevice(queue));
  394.                 stat = WdfRequestRetrieveInputBuffer(req, sizeof(ULONG), &buffer, &len);
  395.                 if(!NT_SUCCESS(stat))
  396.                 {
  397.                         KdPrint(("   Get memory error\n"));
  398.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  399.                         break;
  400.                 }
  401.                 *((ULONG*)buffer) = 0;
  402.                 WdfRequestCompleteWithInformation(req, stat, sizeof(ULONG));
  403.                 break ;
  404.         case IOCTL_SERIAL_WAIT_ON_MASK:
  405.                 stat = WdfRequestRetrieveOutputBuffer(req, sizeof(ULONG), &buffer, &len);
  406.                 if(!NT_SUCCESS(stat))
  407.                 {
  408.                         KdPrint(("   Get memory error\n"));
  409.                         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  410.                         break;
  411.                 }
  412.                 *((ULONG*)buffer) = 0;
  413.                 WdfRequestCompleteWithInformation(req, stat, sizeof(ULONG));
  414.                 break ;
  415.         case IOCTL_SERIAL_SET_BREAK_ON:
  416.         case IOCTL_SERIAL_SET_BREAK_OFF:
  417.         case IOCTL_SERIAL_IMMEDIATE_CHAR:
  418.         case IOCTL_SERIAL_GET_TIMEOUTS:
  419.         case IOCTL_SERIAL_RESET_DEVICE:
  420.         case IOCTL_SERIAL_SET_XOFF:
  421.         case IOCTL_SERIAL_SET_XON:
  422.         case IOCTL_SERIAL_GET_MODEMSTATUS:
  423.         case IOCTL_SERIAL_XOFF_COUNTER:
  424.         case IOCTL_SERIAL_GET_PROPERTIES:
  425.         case IOCTL_SERIAL_GET_DTRRTS:
  426.                 KdPrint(("   %s not implem\n", getioctlname(ioctcode)));
  427.                 WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  428.                 break;
  429.         default:
  430.                 KdPrint((DRIVER_NAME "   Ioctl %i not implemented\n"));
  431.                 WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  432.                 break;
  433.         }
  434.         return ;
  435. }
  436.  
  437. void                    usb_default(IN WDFQUEUE queue, IN WDFREQUEST req)
  438. {
  439.         UNREFERENCED_PARAMETER(queue);
  440.         KdPrint((DRIVER_NAME "-->usb_default into\n"));
  441.         WdfRequestComplete(req, STATUS_NOT_IMPLEMENTED);
  442.         KdPrint((DRIVER_NAME "<--usb_default into\n"));
  443.         return ;
  444. }

Submit a correction or amendment below (click here to make a fresh posting)
After submitting an amendment, you'll be able to view the differences between the old and new posts easily.

Syntax highlighting:

To highlight particular lines, prefix each line with @@


Remember me so that I can delete my post