usbhlib.pas

usb4开发

begin
 USB_ENDPOINT_DIRECTION_OUT := not (x and USB_ENDPOINT_DIRECTION_MASK);
end;

function USB_ENDPOINT_DIRECTION_IN(x :Cardinal) :Cardinal;
begin
 USB_ENDPOINT_DIRECTION_IN := x and USB_ENDPOINT_DIRECTION_MASK;
end;

function CTL_CODE(const DeviceType, Func, Method, Access :Cardinal) :cardinal;
begin
 Result := (DeviceType shl 16) or (Access shl 14) or (Func shl 2) or Method;
end;

function USB_CTL(const Func {id}:Cardinal) :cardinal;
begin
 USB_CTL := CTL_CODE(FILE_DEVICE_USB, Func, METHOD_BUFFERED, FILE_ANY_ACCESS);
end;

function USB_KERNEL_CTL(const Func {id}:Cardinal) :cardinal;
begin
 USB_KERNEL_CTL := CTL_CODE(FILE_DEVICE_USB, Func, METHOD_NEITHER, FILE_ANY_ACCESS);
end;

{------------------------------------------------------------------------}
var
 SA:TSecurityAttributes;{for Win2000}

function USB_OpenHost(HostNum :Byte) :THandle;
begin
 inc(HostNum, ord('0'));
 USB_OpenHost := CreateFile(pchar('\\.\HCD' + char(HostNum)),
                            GENERIC_WRITE,
                            FILE_SHARE_WRITE,
                            @SA, OPEN_EXISTING, 0, 0);
end;

function USB_OpenHub(HubName :string) :THandle;
begin
 USB_OpenHub := CreateFile(pchar('\\.\' + HubName),
                           GENERIC_WRITE,
                           FILE_SHARE_WRITE,
                           @SA, OPEN_EXISTING, 0, 0);
end;

function USB_OpenValid(h :THandle) :Boolean;
begin
 USB_OpenValid := (h <> INVALID_HANDLE_VALUE);
end;

function USB_Close(h :THandle) :Boolean;
begin
  USB_Close := CloseHandle(h);
end;
{------------------------------------------------------------------------}

function USB_HostName(hHost :THandle) :string;
var
 UnicodeName :USB_HCD_DRIVERKEY_NAME;
 BytesReturned :DWord;
begin
  if DeviceIoControl(hHost,
                     IOCTL_GET_HCD_DRIVERKEY_NAME,
                     @UnicodeName, sizeof(UnicodeName),
	             @UnicodeName, sizeof(UnicodeName),
                     BytesReturned, nil)
  then
     USB_HostName := UnicodeStrLen(UnicodeName.ActualLength,
                                   UnicodeName.DriverKeyName)
  else
     USB_HostName := USB_StrError;
end;

function USB_RootHubName(hHost :THandle) :string;
var
 UnicodeName :USB_HUB_NAME;
 BytesReturned :DWord;
begin
  if DeviceIoControl(hHost,
                     IOCTL_USB_GET_ROOT_HUB_NAME,
                     @UnicodeName, sizeof(UnicodeName),
	             @UnicodeName, sizeof(UnicodeName),
                     BytesReturned, nil)
  then
     USB_RootHubName := UnicodeStrLen(UnicodeName.ActualLength,
                                      UnicodeName.HubName)
  else
     USB_RootHubName := USB_StrError;
end;

function USB_HubNodeInfo(hHub :THandle; var NodeInfo :TNODE_INFORMATION) :Boolean;
var
 BytesReturned :DWord;
begin
  USB_HubNodeInfo :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_NODE_INFORMATION,
                     @NodeInfo, sizeof(NodeInfo),
	             @NodeInfo, sizeof(NodeInfo),
                     BytesReturned, nil)
end;

function USB_HubNodeConInfo(hHub :THandle; PortIndex :DWord; var ConInfo :TNODE_CONNECTION_INFORMATION) :Boolean;
var
 BytesReturned :DWord;
begin
  ConInfo.ConnectionIndex := PortIndex;
  USB_HubNodeConInfo :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_NODE_CONNECTION_INFORMATION,
                     @ConInfo, sizeof(ConInfo),
	             @ConInfo, sizeof(ConInfo),
                     BytesReturned, nil)
end;

function USB_HubNodeConName(hHub :THandle; PortIndex :DWord) :string;
var
 BytesReturned :DWord;
 ConnectedHub :USB_NODE_CONNECTION_NAME;
begin
  if DeviceIoControl(hHub,
                     IOCTL_USB_GET_NODE_CONNECTION_NAME,
                     @ConnectedHub, sizeof(ConnectedHub),
	             @ConnectedHub, sizeof(ConnectedHub),
                     BytesReturned, nil)
  then
     USB_HubNodeConName := UnicodeStrLen(ConnectedHub.ActualLength,
                                         ConnectedHub.NodeName)
  else
     USB_HubNodeConName := USB_StrError;
end;

function USB_GetLangID(hHub :THandle; PortIndex :DWord) :DWord;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_DESCRIPTOR;
    SetupPacket.wValueHi := USB_STRING_DESCRIPTOR_TYPE;
    SetupPacket.wLength := 4;
  end;
  if DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil)
  then
     USB_GetLangID := Packet.Data[2] or (Packet.Data[3] shl 8)
  else
     USB_GetLangID := USB_NumError;
end;

function USB_GetDescrStr(hHub :THandle; PortIndex :DWord; LangID :Word; Index :Byte) :string;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
 p :PUSB_STRING_DESCRIPTOR;
begin
  p:=@Packet.Data;
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_DESCRIPTOR;
    SetupPacket.wValueHi := USB_STRING_DESCRIPTOR_TYPE;
    SetupPacket.wValueLo := Index;
    SetupPacket.wIndex := LangID;
    SetupPacket.wLength := 255;
  end;
  if DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil)
  then
     USB_GetDescrStr := UnicodeStrLen(p^.bLength, p^.bString)
  else
     USB_GetDescrStr := USB_StrError;
end;

function USB_GetDescrConf(hHub :THandle; PortIndex :DWord; ConfID :Byte; var Packet :TDESCRIPTOR_REQUEST) :Boolean;
var
 BytesReturned :DWord;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_DESCRIPTOR;
    SetupPacket.wValueHi := USB_CONFIGURATION_DESCRIPTOR_TYPE;
    SetupPacket.wValueLo := ConfID;
    SetupPacket.wLength := sizeof(Packet.Data) - 1;
      {1023, 255}{lower 8bits must be > 0!!! for AVR device}
  end;
  USB_GetDescrConf :=
      DeviceIoControl(hHub,
                      IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                      @Packet, sizeof(TDESCRIPTOR_REQUEST),
   	              @Packet, sizeof(TDESCRIPTOR_REQUEST),
                      BytesReturned, nil);
end;

procedure USB_ExtractDescrConf(Packet :TDESCRIPTOR_REQUEST;
                               var Conf : USB_CONFIGURATION_DESCRIPTOR;
                               var Interf :USB_INTERFACE_DESCRIPTOR;
                               var EndPnt :USB_ENDPOINT_DESCRIPTOR;
                               var Hid :USB_HID_DESCRIPTOR);
var
 comm :PUSB_COMMON_DESCRIPTOR;
begin
 fillchar(Conf, sizeof(USB_CONFIGURATION_DESCRIPTOR), 0);
 fillchar(Interf, sizeof(USB_INTERFACE_DESCRIPTOR), 0);
 fillchar(EndPnt, sizeof(USB_ENDPOINT_DESCRIPTOR), 0);
 fillchar(Hid, sizeof(USB_HID_DESCRIPTOR), 0);
 comm := @Packet.Data;
 while (comm^.bLength <> 0) do begin
  case comm^.bDescriptorType of
   USB_CONFIGURATION_DESCRIPTOR_TYPE:
      move(comm^, Conf, sizeof(USB_CONFIGURATION_DESCRIPTOR));
   USB_INTERFACE_DESCRIPTOR_TYPE:
      move(comm^, Interf, sizeof(USB_INTERFACE_DESCRIPTOR));
   USB_ENDPOINT_DESCRIPTOR_TYPE:
      move(comm^, EndPnt, sizeof(USB_ENDPOINT_DESCRIPTOR));
   USB_HID_DESCRIPTOR_TYPE:
      move(comm^, Hid, sizeof(USB_HID_DESCRIPTOR));
   else begin
    {unknown}
   end;
  end;
  inc(PByte(comm), comm^.bLength); {position increment: length in bytes}
 end;
end;

{------------------------------------------------------------------------}
function USB_GetStatus(hHub :THandle; PortIndex :DWord; var Status :Word) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_STATUS;
    SetupPacket.wLength := 2{8};
  end;
  USB_GetStatus :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
  Status := Packet.Data[0] or (Packet.Data[1] shl 8);
end;

function USB_ClearFeature(hHub :THandle; PortIndex :DWord) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_CLEAR_FEATURE;
    SetupPacket.wLength := 1{8};
  end;
  USB_ClearFeature :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
end;

function USB_SetFeature(hHub :THandle; PortIndex :DWord) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_SET_FEATURE;
    SetupPacket.wLength := {1}8;
  end;
  USB_SetFeature :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
end;

function USB_SetAddress(hHub :THandle; PortIndex :DWord; Addr :Byte) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_SET_ADDRESS;
    SetupPacket.wValueLo := Addr;
    SetupPacket.wLength := 1{8};
  end;
  USB_SetAddress :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
end;

function USB_GetConfNum(hHub :THandle; PortIndex :DWord; var ConfNum :Byte) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_CONFIGURATION;
    SetupPacket.wLength := 1{8};
  end;
  USB_GetConfNum :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
  ConfNum := Packet.Data[0];
end;

function USB_SetConfNum(hHub :THandle; PortIndex :DWord; ConfNum :Byte) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_SET_CONFIGURATION;
    SetupPacket.wValueLo := ConfNum;
    SetupPacket.wLength := {1}8;
  end;
  USB_SetConfNum :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
end;

function USB_GetInterfNum(hHub :THandle; PortIndex :DWord; var InterfNum :Byte) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_GET_INTERFACE;
    SetupPacket.wLength := 1{8};
  end;
  USB_GetInterfNum :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
  InterfNum := Packet.Data[0];
end;

function USB_SetInterfNum(hHub :THandle; PortIndex :DWord; InterfNum :Byte) :Boolean;
var
 BytesReturned :DWord;
 Packet :TDESCRIPTOR_REQUEST;
begin
  fillchar(Packet, sizeof(Packet), 0);
  with Packet do begin
    ConnectionIndex := PortIndex;
    SetupPacket.bmRequest := $80;
    SetupPacket.bRequest := USB_REQUEST_SET_INTERFACE;
    SetupPacket.wValueLo := InterfNum;
    SetupPacket.wLength := 1{8};
  end;
  USB_SetInterfNum :=
     DeviceIoControl(hHub,
                     IOCTL_USB_GET_DESCRIPTOR_FROM_NODE_CONNECTION,
                     @Packet, sizeof(Packet),
	             @Packet, sizeof(Packet),
                     BytesReturned, nil);
end;

{------------------------------------------------------------------------}
initialization
 SA.nLength := sizeof(SA);  {for Win2000}
 SA.lpSecurityDescriptor := NIL;
 SA.bInheritHandle := false;

end.