Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-02 05:55:42 +00:00
Code Issues Projects Releases Packages Wiki Activity

[FORMATTING]

Browse source 
svn path=/trunk/; revision=23616
This commit is contained in:
Aleksey Bragin 2006-08-20 14:01:17 +00:00
parent 4e7aa7365f
commit f448f3bae0
12 changed files with 18078 additions and 20290 deletions
Download patch file Download diff file Expand all files Collapse all files

283
reactos/drivers/usb/nt4compat/usbdriver/bulkonly.c
View file

@ -32,71 +32,28 @@ typedef unsigned long ULONG_PTR, *PULONG_PTR;
#define OLYMPUS_CSW( pdev_EXT, staTUS ) \
( ( ( pdev_EXT )->flags & UMSS_DEV_FLAG_OLYMPUS_DEV ) ? ( ( staTUS ) == CSW_OLYMPUS_SIGNATURE ) : FALSE )
BOOL
umss_clear_pass_through_length(
PIO_PACKET io_packet
);
BOOL umss_clear_pass_through_length(PIO_PACKET io_packet);
NTSTATUS
umss_bulkonly_send_sense_req(
PUMSS_DEVICE_EXTENSION pdev_ext
);
NTSTATUS umss_bulkonly_send_sense_req(PUMSS_DEVICE_EXTENSION pdev_ext);
VOID
umss_bulkonly_send_cbw_completion(
IN PURB purb,
IN PVOID context
);
VOID umss_bulkonly_send_cbw_completion(IN PURB purb, IN PVOID context);
VOID
umss_bulkonly_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID umss_bulkonly_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext);
VOID
umss_sync_submit_urb_completion(
PURB purb,
PVOID context
);
VOID umss_sync_submit_urb_completion(PURB purb, PVOID context);
NTSTATUS
umss_sync_submit_urb(
PUMSS_DEVICE_EXTENSION pdev_ext,
PURB purb
);
NTSTATUS umss_sync_submit_urb(PUMSS_DEVICE_EXTENSION pdev_ext, PURB purb);
VOID
umss_bulkonly_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID umss_bulkonly_get_status(PUMSS_DEVICE_EXTENSION pdev_ext);
VOID
umss_bulkonly_transfer_data_complete(
PURB purb,
PVOID reference
);
VOID umss_bulkonly_transfer_data_complete(PURB purb, PVOID reference);
VOID
umss_bulkonly_reset_pipe_and_get_status(
IN PVOID reference
);
VOID umss_bulkonly_reset_pipe_and_get_status(IN PVOID reference);
VOID
umss_bulkonly_reset_recovery(
IN PVOID reference
);
VOID umss_bulkonly_reset_recovery(IN PVOID reference);
VOID
umss_bulkonly_get_status_complete(
IN PURB purb,
IN PVOID context
);
VOID umss_bulkonly_get_status_complete(IN PURB purb, IN PVOID context);
NTSTATUS
umss_bulkonly_startio(
IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN PIO_PACKET io_packet
)
/*++
Routine Description:
@ -111,7 +68,8 @@ Return Value:
NONE
--*/
NTSTATUS
umss_bulkonly_startio(IN PUMSS_DEVICE_EXTENSION pdev_ext, IN PIO_PACKET io_packet)
{
PCOMMAND_BLOCK_WRAPPER cbw;
NTSTATUS status;
@ -135,26 +93,17 @@ Return Value:
RtlZeroMemory(&pdev_ext->csw, sizeof(pdev_ext->csw));
// Send the command block wrapper to the device.
// Calls UMSS_BulkOnlySendCBWComplete when transfer completes.
status = umss_bulk_transfer(
pdev_ext,
status = umss_bulk_transfer(pdev_ext,
USB_DIR_OUT,
cbw,
sizeof( COMMAND_BLOCK_WRAPPER ),
umss_bulkonly_send_cbw_completion
);
cbw, sizeof(COMMAND_BLOCK_WRAPPER), umss_bulkonly_send_cbw_completion);
return status;
}
NTSTATUS
umss_bulk_transfer(
IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN UCHAR trans_dir,
IN PVOID buf,
IN ULONG buf_length,
IN PURBCOMPLETION completion
)
umss_bulk_transfer(IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN UCHAR trans_dir, IN PVOID buf, IN ULONG buf_length, IN PURBCOMPLETION completion)
{
PURB purb;
NTSTATUS status;
@ -180,13 +129,7 @@ IN PURBCOMPLETION completion
endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx);
}
UsbBuildInterruptOrBulkTransferRequest( purb,
endp_handle,
buf,
buf_length,
completion,
pdev_ext,
0 );
UsbBuildInterruptOrBulkTransferRequest(purb, endp_handle, buf, buf_length, completion, pdev_ext, 0);
dev_mgr_register_irp(pdev_ext->dev_mgr, pdev_ext->io_packet.pirp, purb);
status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status == STATUS_PENDING)
@ -204,10 +147,7 @@ IN PURBCOMPLETION completion
}
VOID
umss_bulkonly_send_cbw_completion(
IN PURB purb,
IN PVOID context
)
umss_bulkonly_send_cbw_completion(IN PURB purb, IN PVOID context)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -229,7 +169,8 @@ IN PVOID context
if (usb_halted(status))
{
//Schedule a work-item to do a reset recovery
if( !umss_schedule_workitem( (PVOID)pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
}
@ -253,12 +194,9 @@ IN PVOID context
return;
}
NTSTATUS
umss_sync_submit_urb(
PUMSS_DEVICE_EXTENSION pdev_ext,
PURB purb
)
//can only be called at passive level
NTSTATUS
umss_sync_submit_urb(PUMSS_DEVICE_EXTENSION pdev_ext, PURB purb)
{
NTSTATUS status;
@ -272,12 +210,7 @@ PURB purb
status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status == STATUS_PENDING)
{
KeWaitForSingleObject(
&pdev_ext->sync_event,
Executive,
KernelMode,
TRUE,
NULL );
KeWaitForSingleObject(&pdev_ext->sync_event, Executive, KernelMode, TRUE, NULL);
status = purb->status;
}
else
@ -287,10 +220,7 @@ PURB purb
}
VOID
umss_sync_submit_urb_completion(
PURB purb,
PVOID context
)
umss_sync_submit_urb_completion(PURB purb, PVOID context)
{
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -303,10 +233,6 @@ PVOID context
return;
}
VOID
umss_bulkonly_reset_recovery(
IN PVOID reference
)
/*++
Routine Description:
@ -321,7 +247,8 @@ Return Value:
NONE
--*/
VOID
umss_bulkonly_reset_recovery(IN PVOID reference)
{
PUMSS_DEVICE_EXTENSION pdev_ext;
URB urb;
@ -338,9 +265,7 @@ Return Value:
// Build the mass storage reset command
UsbBuildVendorRequest(
&urb,
pdev_ext->dev_handle | 0xffff, //default pipe
UsbBuildVendorRequest(&urb, pdev_ext->dev_handle | 0xffff, //default pipe
NULL, //no extra data
0, //no size
0x21, //class, interface
@ -362,36 +287,27 @@ Return Value:
{
//Reset Bulk-in endpoint
endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx);
status = umss_reset_pipe(
pdev_ext,
endp_handle
);
status = umss_reset_pipe(pdev_ext, endp_handle);
if (!NT_SUCCESS(status))
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_reset_recovery(): Unable to clear Bulk-in endpoint\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_reset_recovery(): Unable to clear Bulk-in endpoint\n"));
}
//Reset Bulk-out endpoint
endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->out_endp_idx);
status = umss_reset_pipe(
pdev_ext,
endp_handle
);
status = umss_reset_pipe(pdev_ext, endp_handle);
if (!NT_SUCCESS(status))
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_reset_recovery(): Unable to clear Bulk-out endpoint\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_reset_recovery(): Unable to clear Bulk-out endpoint\n"));
}
}
umss_complete_request(pdev_ext, status);
}
VOID
umss_bulkonly_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
)
/*++
Routine Description:
@ -406,7 +322,8 @@ Return Value:
NONE
--*/
VOID
umss_bulkonly_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext)
{
PVOID data_buf;
ULONG data_buf_length;
@ -437,13 +354,11 @@ Return Value:
else if ((pdev_ext->io_packet.flags & IOP_FLAG_STAGE_MASK) == IOP_FLAG_STAGE_SENSE)
trans_dir = USB_DIR_IN;
if( ( status = umss_bulk_transfer(
pdev_ext,
if ((status = umss_bulk_transfer(pdev_ext,
trans_dir,
data_buf,
data_buf_length,
umss_bulkonly_transfer_data_complete )
) != STATUS_PENDING )
umss_bulkonly_transfer_data_complete)) != STATUS_PENDING)
{
umss_complete_request(pdev_ext, status);
}
@ -451,17 +366,12 @@ Return Value:
return;
}
VOID
umss_bulkonly_transfer_data_complete(
PURB purb,
PVOID reference
)
/*++
Routine Description:
Completion handler for bulk data transfer requests.
--*/
VOID
umss_bulkonly_transfer_data_complete(PURB purb, PVOID reference)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -488,10 +398,13 @@ Routine Description:
buf[1] = (ULONG) purb->endp_handle;
usb_dbg_print(DBGLVL_MINIMUM, ("umss_transfer_data_complete(): transfer data error!\n"));
if (!umss_schedule_workitem( ( PVOID )buf, umss_bulkonly_reset_pipe_and_get_status, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) buf, umss_bulkonly_reset_pipe_and_get_status, pdev_ext->dev_mgr,
pdev_ext->dev_handle))
{
usb_free_mem(buf), buf = NULL;
usb_dbg_print( DBGLVL_MINIMUM,("umss_transfer_data_complete(): Failed to allocate work-item to reset pipe!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_transfer_data_complete(): Failed to allocate work-item to reset pipe!\n"));
TRAP();
umss_complete_request(pdev_ext, status);
}
@ -518,9 +431,7 @@ Routine Description:
VOID
umss_bulkonly_reset_pipe_and_get_status(
IN PVOID reference
)
umss_bulkonly_reset_pipe_and_get_status(IN PVOID reference)
{
PUMSS_DEVICE_EXTENSION pdev_ext;
DEV_HANDLE endp_handle;
@ -541,36 +452,26 @@ IN PVOID reference
return;
}
// Data phase is finished since the endpoint stalled, so go to status phase
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_reset_pipe_and_get_status(): reset pipe succeeds, continue to get status\n") );
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_reset_pipe_and_get_status(): reset pipe succeeds, continue to get status\n"));
umss_bulkonly_get_status(pdev_ext);
}
VOID
umss_bulkonly_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
)
umss_bulkonly_get_status(PUMSS_DEVICE_EXTENSION pdev_ext)
{
NTSTATUS status;
// Schedule bulk transfer to get command status wrapper from device
status = umss_bulk_transfer(
pdev_ext,
status = umss_bulk_transfer(pdev_ext,
USB_DIR_IN,
&(pdev_ext->csw),
sizeof( COMMAND_STATUS_WRAPPER ),
umss_bulkonly_get_status_complete
);
sizeof(COMMAND_STATUS_WRAPPER), umss_bulkonly_get_status_complete);
if (status != STATUS_PENDING)
{
umss_complete_request(pdev_ext, status);
}
}
VOID
umss_bulkonly_get_status_complete(
IN PURB purb,
IN PVOID context
)
/*++
Routine Description:
@ -587,7 +488,8 @@ Return Value:
Driver-originated IRPs always return STATUS_MORE_PROCESSING_REQUIRED.
--*/
VOID
umss_bulkonly_get_status_complete(IN PURB purb, IN PVOID context)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -607,10 +509,8 @@ Return Value:
// Received valid CSW with good status
if ((pdev_ext->io_packet.flags & IOP_FLAG_STAGE_MASK) == IOP_FLAG_STAGE_NORMAL &&
( pdev_ext->io_packet.flags & IOP_FLAG_REQ_SENSE ) &&
pdev_ext->io_packet.sense_data != NULL )
(pdev_ext->io_packet.flags & IOP_FLAG_REQ_SENSE) && pdev_ext->io_packet.sense_data != NULL)
UMSS_FORGE_GOOD_SENSE(pdev_ext->io_packet.sense_data)
umss_complete_request(pdev_ext, STATUS_SUCCESS);
}
else if (csw->bCSWStatus == CSW_STATUS_FAILED)
@ -632,7 +532,8 @@ Return Value:
else
{
// error occurred, reset device
if( !umss_schedule_workitem( (PVOID)pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
}
@ -641,7 +542,8 @@ Return Value:
else
{
// error occurred, reset device
if( !umss_schedule_workitem( (PVOID)pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
}
@ -657,10 +559,12 @@ Return Value:
buf[0] = (ULONG) pdev_ext;
buf[1] = (ULONG) purb->endp_handle;
if ( !umss_schedule_workitem( ( PVOID )buf, umss_bulkonly_reset_pipe_and_get_status, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) buf, umss_bulkonly_reset_pipe_and_get_status, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
usb_free_mem(buf), buf = NULL;
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_get_status_complete(): Failed to allocate work-item to reset pipe!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_get_status_complete(): Failed to allocate work-item to reset pipe!\n"));
TRAP();
umss_complete_request(pdev_ext, status);
}
@ -668,9 +572,11 @@ Return Value:
else if (status != STATUS_CANCELLED)
{
// An error has occured. Reset the device.
if ( !umss_schedule_workitem( ( PVOID )pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_bulkonly_reset_recovery, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_get_status_complete(): Failed to schedule work-item to reset pipe!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_get_status_complete(): Failed to schedule work-item to reset pipe!\n"));
TRAP();
umss_complete_request(pdev_ext, status);
}
@ -688,11 +594,6 @@ Return Value:
return;
}
CHAR
umss_bulkonly_get_maxlun(
IN PUMSS_DEVICE_EXTENSION pdev_ext
)
/*++
Routine Description:
@ -707,7 +608,8 @@ Return Value:
Maximum LUN number for device, or 0 if error occurred.
--*/
CHAR
umss_bulkonly_get_maxlun(IN PUMSS_DEVICE_EXTENSION pdev_ext)
{
PURB purb = NULL;
CHAR max_lun;
@ -717,31 +619,23 @@ Return Value:
if (!purb)
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_get_maxlun(): Failed to allocate URB, setting max LUN to 0\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_get_maxlun(): Failed to allocate URB, setting max LUN to 0\n"));
max_lun = 0;
}
else
{
// Build the get max lun command
UsbBuildVendorRequest(
purb,
( pdev_ext->dev_handle | 0xffff ),
&max_lun,
sizeof( max_lun ),
0xb1, //class, interface, in
BULK_ONLY_GET_MAX_LUN,
0,
pdev_ext->pif_desc->bInterfaceNumber,
NULL,
NULL,
0);
UsbBuildVendorRequest(purb, (pdev_ext->dev_handle | 0xffff), &max_lun, sizeof(max_lun), 0xb1, //class, interface, in
BULK_ONLY_GET_MAX_LUN, 0, pdev_ext->pif_desc->bInterfaceNumber, NULL, NULL, 0);
// Send get max lun command to device
status = umss_sync_submit_urb(pdev_ext, purb);
if (status != STATUS_PENDING)
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_bulkonly_get_maxlun(): Get Max LUN command failed, setting max LUN to 0!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_bulkonly_get_maxlun(): Get Max LUN command failed, setting max LUN to 0!\n"));
max_lun = 0;
}
}
@ -755,10 +649,7 @@ Return Value:
}
PVOID
umss_get_buffer(
PUMSS_DEVICE_EXTENSION pdev_ext,
ULONG* buf_length
)
umss_get_buffer(PUMSS_DEVICE_EXTENSION pdev_ext, ULONG * buf_length)
{
PVOID buffer;
@ -777,10 +668,7 @@ ULONG* buf_length
}
BOOL
umss_bulkonly_build_sense_cdb(
PUMSS_DEVICE_EXTENSION pdev_ext,
PCOMMAND_BLOCK_WRAPPER cbw
)
umss_bulkonly_build_sense_cdb(PUMSS_DEVICE_EXTENSION pdev_ext, PCOMMAND_BLOCK_WRAPPER cbw)
{
UCHAR sub_class;
PUCHAR cdb;
@ -817,14 +705,13 @@ PCOMMAND_BLOCK_WRAPPER cbw
}
NTSTATUS
umss_bulkonly_send_sense_req(
PUMSS_DEVICE_EXTENSION pdev_ext
)
umss_bulkonly_send_sense_req(PUMSS_DEVICE_EXTENSION pdev_ext)
{
PCOMMAND_BLOCK_WRAPPER cbw;
NTSTATUS status;
if( pdev_ext == NULL || pdev_ext->io_packet.sense_data == NULL || pdev_ext->io_packet.sense_data_length < 18 )
if (pdev_ext == NULL || pdev_ext->io_packet.sense_data == NULL
|| pdev_ext->io_packet.sense_data_length < 18)
return STATUS_INVALID_PARAMETER;
pdev_ext->retry = TRUE;
@ -847,13 +734,9 @@ PUMSS_DEVICE_EXTENSION pdev_ext
return STATUS_UNSUCCESSFUL;
}
status = umss_bulk_transfer(
pdev_ext,
status = umss_bulk_transfer(pdev_ext,
USB_DIR_OUT,
cbw,
sizeof( COMMAND_BLOCK_WRAPPER ),
umss_bulkonly_send_cbw_completion
);
cbw, sizeof(COMMAND_BLOCK_WRAPPER), umss_bulkonly_send_cbw_completion);
if (status != STATUS_PENDING)
{
@ -864,9 +747,7 @@ PUMSS_DEVICE_EXTENSION pdev_ext
}
BOOL
umss_clear_pass_through_length(
PIO_PACKET io_packet
)
umss_clear_pass_through_length(PIO_PACKET io_packet)
{
//
// clear the respective data length to meet request of scsi pass through requirement.

126
reactos/drivers/usb/nt4compat/usbdriver/cbi.c
View file

@ -23,61 +23,34 @@
#include "debug.h"
#include "umss.h"
VOID
umss_cbi_send_adsc_complete(
PURB purb,
PVOID context
);
VOID umss_cbi_send_adsc_complete(PURB purb, PVOID context);
VOID
umss_cbi_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID umss_cbi_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext);
VOID
umss_cbi_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID umss_cbi_get_status(PUMSS_DEVICE_EXTENSION pdev_ext);
VOID
umss_cbi_transfer_data_complete(
PURB purb,
PVOID context
);
VOID umss_cbi_transfer_data_complete(PURB purb, PVOID context);
VOID
umss_cbi_get_status_complete(
PURB purb,
PVOID context
);
VOID umss_cbi_get_status_complete(PURB purb, PVOID context);
NTSTATUS
umss_class_specific_request(
IN PUMSS_DEVICE_EXTENSION pdev_ext,
umss_class_specific_request(IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN UCHAR request,
IN UCHAR dir,
IN PVOID buffer,
IN ULONG buffer_length,
IN PURBCOMPLETION completion
)
IN PURBCOMPLETION completion)
{
PURB purb;
NTSTATUS status;
purb = usb_alloc_mem(NonPagedPool, sizeof(URB));
// Build URB for the ADSC command
UsbBuildVendorRequest(
purb,
UsbBuildVendorRequest(purb,
pdev_ext->dev_handle | 0xffff,
buffer,
buffer_length,
0x21,
request,
0,
pdev_ext->pif_desc->bInterfaceNumber,
completion,
pdev_ext,
0 );
0x21, request, 0, pdev_ext->pif_desc->bInterfaceNumber, completion, pdev_ext, 0);
status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status != STATUS_PENDING)
@ -91,10 +64,7 @@ IN PURBCOMPLETION completion
}
NTSTATUS
umss_cbi_startio(
IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN PIO_PACKET io_packet
)
umss_cbi_startio(IN PUMSS_DEVICE_EXTENSION pdev_ext, IN PIO_PACKET io_packet)
{
NTSTATUS status;
@ -105,14 +75,10 @@ IN PIO_PACKET io_packet
// Send the ADSC request to the device
// Calls UMSS_CbiSendADSCComplete when transfer completes
status = umss_class_specific_request(
pdev_ext,
status = umss_class_specific_request(pdev_ext,
ACCEPT_DEVICE_SPECIFIC_COMMAND,
USB_DIR_OUT,
io_packet->cdb,
io_packet->cdb_length,
umss_cbi_send_adsc_complete
);
io_packet->cdb, io_packet->cdb_length, umss_cbi_send_adsc_complete);
return status;
}
@ -120,10 +86,7 @@ IN PIO_PACKET io_packet
VOID
umss_cbi_send_adsc_complete(
PURB purb,
PVOID context
)
umss_cbi_send_adsc_complete(PURB purb, PVOID context)
{
NTSTATUS status;
PIO_STACK_LOCATION irpStack;
@ -173,21 +136,16 @@ PVOID context
VOID
umss_cbi_reset_pipe(
IN PVOID reference
)
umss_cbi_reset_pipe(IN PVOID reference)
{
PUMSS_DEVICE_EXTENSION pdev_ext;
pdev_ext = (PUMSS_DEVICE_EXTENSION) reference;
// Reset the appropriate pipe, based on data direction
umss_reset_pipe(
pdev_ext,
umss_reset_pipe(pdev_ext,
(pdev_ext->io_packet.flags & USB_DIR_IN) ?
usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx) :
usb_make_handle( ( pdev_ext->dev_handle >> 16 ), pdev_ext->if_idx, pdev_ext->out_endp_idx )
);
usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->out_endp_idx));
// Device stalled endpoint, so complete I/O operation with error.
// BUGBUG is this correct? Check spec...
@ -195,9 +153,7 @@ IN PVOID reference
}
VOID
umss_cbi_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
)
umss_cbi_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext)
{
PVOID buffer;
ULONG buffer_length;
@ -222,22 +178,15 @@ PUMSS_DEVICE_EXTENSION pdev_ext
else
{
// Transfer next element of the data phase
umss_bulk_transfer(
pdev_ext,
umss_bulk_transfer(pdev_ext,
(UCHAR) ((pdev_ext->io_packet.flags & USB_DIR_IN) ? USB_DIR_IN : USB_DIR_OUT),
buffer,
buffer_length,
umss_cbi_transfer_data_complete
);
buffer, buffer_length, umss_cbi_transfer_data_complete);
}
}
VOID
umss_cbi_transfer_data_complete(
PURB purb,
PVOID context
)
umss_cbi_transfer_data_complete(PURB purb, PVOID context)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -256,9 +205,11 @@ PVOID context
{
// Reset pipe can only be done at passive level, so we need
// to schedule a work item to do it.
if ( !umss_schedule_workitem( ( PVOID )pdev_ext, umss_cbi_reset_pipe, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_cbi_reset_pipe, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_cbi_transfer_data_complete(): Failed to allocate work-item to reset pipe!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_cbi_transfer_data_complete(): Failed to allocate work-item to reset pipe!\n"));
TRAP();
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
}
@ -277,9 +228,7 @@ PVOID context
VOID
umss_cbi_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
)
umss_cbi_get_status(PUMSS_DEVICE_EXTENSION pdev_ext)
{
PURB purb;
NTSTATUS status;
@ -289,15 +238,11 @@ PUMSS_DEVICE_EXTENSION pdev_ext
return;
// Build a URB for our interrupt transfer
UsbBuildInterruptOrBulkTransferRequest(
purb,
usb_make_handle( ( pdev_ext->dev_handle >> 16 ), pdev_ext->if_idx, pdev_ext->int_endp_idx ),
( PUCHAR )&pdev_ext->idb,
sizeof( INTERRUPT_DATA_BLOCK ),
umss_cbi_get_status_complete,
pdev_ext,
0
);
UsbBuildInterruptOrBulkTransferRequest(purb,
usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx,
pdev_ext->int_endp_idx), (PUCHAR) & pdev_ext->idb,
sizeof(INTERRUPT_DATA_BLOCK), umss_cbi_get_status_complete,
pdev_ext, 0);
// Call USB driver stack
status = usb_submit_urb(pdev_ext->dev_mgr, purb);
@ -313,10 +258,7 @@ PUMSS_DEVICE_EXTENSION pdev_ext
VOID
umss_cbi_get_status_complete(
PURB purb,
PVOID context
)
umss_cbi_get_status_complete(PURB purb, PVOID context)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -336,9 +278,11 @@ PVOID context
// Check if we need to clear stalled pipe
if (usb_halted(status))
{
if ( !umss_schedule_workitem( (PVOID)pdev_ext, umss_cbi_reset_pipe, pdev_ext->dev_mgr, pdev_ext->dev_handle ) )
if (!umss_schedule_workitem
((PVOID) pdev_ext, umss_cbi_reset_pipe, pdev_ext->dev_mgr, pdev_ext->dev_handle))
{
usb_dbg_print( DBGLVL_MINIMUM,("umss_cbi_get_status_complete(): Failed to allocate work-item to reset pipe!\n"));
usb_dbg_print(DBGLVL_MINIMUM,
("umss_cbi_get_status_complete(): Failed to allocate work-item to reset pipe!\n"));
TRAP();
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
return;

83
reactos/drivers/usb/nt4compat/usbdriver/compdrv.c
View file

@ -28,41 +28,18 @@
#include "hub.h"
#include "debug.h"
VOID
compdev_set_cfg_completion(
PURB purb,
PVOID context
);
VOID compdev_set_cfg_completion(PURB purb, PVOID context);
VOID
compdev_select_driver(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
VOID compdev_select_driver(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
BOOL compdev_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle);
BOOL compdev_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
BOOL compdev_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
BOOL
compdev_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
);
BOOL
compdev_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL
compdev_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL
compdev_driver_init(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
compdev_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
if (dev_mgr == NULL || pdriver == NULL)
return FALSE;
@ -97,19 +74,13 @@ PUSB_DRIVER pdriver
}
BOOL
compdev_driver_destroy(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
compdev_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
return TRUE;
}
BOOL
compdev_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
)
compdev_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle)
{
PURB purb;
PUSB_CTRL_SETUP_PACKET psetup;
@ -230,12 +201,7 @@ DEV_HANDLE dev_handle
}
VOID
compdev_event_select_if_driver(
PUSB_DEV pdev,
ULONG event,
ULONG context,
ULONG param
)
compdev_event_select_if_driver(PUSB_DEV pdev, ULONG event, ULONG context, ULONG param)
{
PUSB_DEV_MANAGER dev_mgr;
DEV_HANDLE dev_handle;
@ -254,10 +220,7 @@ ULONG param
}
BOOL
compdev_post_event_select_driver(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
compdev_post_event_select_driver(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
PUSB_EVENT pevent;
BOOL bret;
@ -308,10 +271,7 @@ DEV_HANDLE dev_handle
}
VOID
compdev_set_cfg_completion(
PURB purb,
PVOID context
)
compdev_set_cfg_completion(PURB purb, PVOID context)
{
DEV_HANDLE dev_handle;
PUSB_DEV_MANAGER dev_mgr;
@ -374,10 +334,7 @@ PVOID context
}
VOID
compdev_select_driver(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
compdev_select_driver(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
URB urb;
LONG i, j, k, credit;
@ -479,10 +436,7 @@ DEV_HANDLE dev_handle
}
BOOL
compdev_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
compdev_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
PUSB_DEV pdev;
LONG i;
@ -517,10 +471,7 @@ DEV_HANDLE dev_handle
}
BOOL
compdev_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
compdev_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
PUSB_DEV pdev;
LONG i;

53
reactos/drivers/usb/nt4compat/usbdriver/dmgrdisp.c
View file

@ -26,10 +26,7 @@
#include "hub.h"
VOID
disp_urb_completion(
PURB purb,
PVOID context
)
disp_urb_completion(PURB purb, PVOID context)
{
PUSB_CTRL_SETUP_PACKET psetup;
PUSB_DEV_MANAGER dev_mgr;
@ -90,10 +87,7 @@ PVOID context
}
VOID
disp_noio_urb_completion(
PURB purb,
PVOID context
)
disp_noio_urb_completion(PURB purb, PVOID context)
{
PUSB_CTRL_SETUP_PACKET psetup;
PURB purb2;
@ -107,12 +101,16 @@ PVOID context
psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet;
if( psetup->bmRequestType == 0x2
&& psetup->bRequest == USB_REQ_CLEAR_FEATURE
&& psetup->wIndex == 0 ) //reset pipe
if ((psetup->bmRequestType == 0x2) &&
(psetup->bRequest == USB_REQ_CLEAR_FEATURE) &&
(psetup->wIndex == 0)) //reset pipe
{
purb2 = (PURB) context;
}
else
{
purb2 = purb;
}
if (purb2->pirp == NULL)
return;
@ -139,13 +137,10 @@ PVOID context
return;
}
NTSTATUS
dev_mgr_dispatch(
IN PUSB_DEV_MANAGER dev_mgr,
IN PIRP irp
)
//this function is called by the hcd's
//dispatch when they have done their job.
NTSTATUS
dev_mgr_dispatch(IN PUSB_DEV_MANAGER dev_mgr, IN PIRP irp)
{
PIO_STACK_LOCATION irp_stack;
NTSTATUS status;
@ -262,7 +257,8 @@ IN PIRP irp
peda->dev_count = dev_count ? j : 0;
KeReleaseSpinLock(&dev_mgr->dev_list_lock, old_irql);
irp->IoStatus.Information = sizeof( ENUM_DEV_ARRAY ) + ( dev_count - 1 ) * sizeof( ENUM_DEV_ELEMENT );
irp->IoStatus.Information =
sizeof(ENUM_DEV_ARRAY) + (dev_count - 1) * sizeof(ENUM_DEV_ELEMENT);
EXIT_DISPATCH(STATUS_SUCCESS, irp);
}
case IOCTL_GET_DEV_DESC:
@ -304,7 +300,7 @@ IN PIRP irp
status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT;
}
if( dev_state( pdev ) != USB_DEV_STATE_ADDRESSED && \
if (dev_state(pdev) != USB_DEV_STATE_ADDRESSED &&
dev_state(pdev) != USB_DEV_STATE_CONFIGURED)
{
status = STATUS_DEVICE_NOT_READY;
@ -319,15 +315,13 @@ IN PIRP irp
if (gddr.desc_type == USB_DT_DEVICE)
{
RtlCopyMemory(
pusb_desc_header,
RtlCopyMemory(pusb_desc_header,
pdev->pusb_dev_desc,
buf_size > sizeof(USB_DEVICE_DESC)
? sizeof(USB_DEVICE_DESC) : buf_size);
irp->IoStatus.Information =
buf_size >= sizeof( USB_DEVICE_DESC )
? sizeof( USB_DEVICE_DESC ): buf_size ;
buf_size >= sizeof(USB_DEVICE_DESC) ? sizeof(USB_DEVICE_DESC) : buf_size;
}
else if (gddr.desc_type == USB_DT_CONFIG)
{
@ -338,10 +332,10 @@ IN PIRP irp
goto ERROR_OUT;
}
pusb_config_desc = usb_find_config_desc_by_idx(
( PUCHAR )&pdev->pusb_dev_desc[ 1 ],
pusb_config_desc = usb_find_config_desc_by_idx((PUCHAR) & pdev->pusb_dev_desc[1],
gddr.desc_idx,
pdev->pusb_dev_desc->bNumConfigurations );
pdev->pusb_dev_desc->
bNumConfigurations);
if (pusb_config_desc == NULL)
{
@ -349,8 +343,7 @@ IN PIRP irp
goto ERROR_OUT;
}
RtlCopyMemory(
pusb_desc_header,
RtlCopyMemory(pusb_desc_header,
pusb_config_desc,
buf_size >= pusb_config_desc->wTotalLength
? pusb_config_desc->wTotalLength : buf_size);
@ -412,16 +405,14 @@ IN PIRP irp
lock_dev(pdev, FALSE);
if( dev_state( pdev ) == USB_DEV_STATE_ZOMB \
|| ( dev_state( pdev ) < USB_DEV_STATE_ADDRESSED ) )
if (dev_state(pdev) == USB_DEV_STATE_ZOMB || (dev_state(pdev) < USB_DEV_STATE_ADDRESSED))
{
status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT1;
}
if( dev_state( pdev ) == USB_DEV_STATE_ADDRESSED
&& !default_endp_handle( endp_handle ) )
if (dev_state(pdev) == USB_DEV_STATE_ADDRESSED && !default_endp_handle(endp_handle))
{
status = STATUS_DEVICE_NOT_READY;
goto ERROR_OUT1;

1036
reactos/drivers/usb/nt4compat/usbdriver/ehci.c
View file

File diff suppressed because it is too large Load diff

189
reactos/drivers/usb/nt4compat/usbdriver/etd.c
View file

@ -67,66 +67,36 @@
max_liSTS = ( EHCI_MAX_ELEMS_POOL / ii1 ) > EHCI_MAX_LISTS_POOL ? EHCI_MAX_LISTS_POOL : ( EHCI_MAX_ELEMS_POOL / ii1 );\
}
VOID
elem_list_destroy_elem_list(
PEHCI_ELEM_LIST plist
);
VOID elem_list_destroy_elem_list(PEHCI_ELEM_LIST plist);
PLIST_ENTRY
elem_list_get_list_head(
PEHCI_ELEM_LIST plist
);
PLIST_ENTRY elem_list_get_list_head(PEHCI_ELEM_LIST plist);
LONG
elem_list_get_total_count(
PEHCI_ELEM_LIST plist
);
LONG elem_list_get_total_count(PEHCI_ELEM_LIST plist);
LONG
elem_list_get_elem_size(
PEHCI_ELEM_LIST plist
);
LONG elem_list_get_elem_size(PEHCI_ELEM_LIST plist);
LONG
elem_list_get_link_offset(
PEHCI_ELEM_LIST plist
);
LONG elem_list_get_link_offset(PEHCI_ELEM_LIST plist);
LONG
elem_list_add_ref(
PEHCI_ELEM_LIST plist
);
LONG elem_list_add_ref(PEHCI_ELEM_LIST plist);
LONG
elem_list_release_ref(
PEHCI_ELEM_LIST plist
);
LONG elem_list_release_ref(PEHCI_ELEM_LIST plist);
LONG
elem_list_get_ref(
PEHCI_ELEM_LIST plist
);
LONG elem_list_get_ref(PEHCI_ELEM_LIST plist);
BOOL
elem_pool_lock(
PEHCI_ELEM_POOL pool,
BOOL at_dpc
)
elem_pool_lock(PEHCI_ELEM_POOL pool, BOOL at_dpc)
{
return TRUE;
}
BOOL
elem_pool_unlock(
PEHCI_ELEM_POOL pool,
BOOL at_dpc
)
elem_pool_unlock(PEHCI_ELEM_POOL pool, BOOL at_dpc)
{
return TRUE;
}
LONG
get_elem_phys_part_size(
ULONG type
)
get_elem_phys_part_size(ULONG type)
{
// type is INIT_LIST_FLAG_XXX
LONG size;
@ -154,12 +124,7 @@ ULONG type
}
BOOL
elem_list_init_elem_list(
PEHCI_ELEM_LIST plist,
LONG init_flags,
PVOID context,
LONG count
)
elem_list_init_elem_list(PEHCI_ELEM_LIST plist, LONG init_flags, PVOID context, LONG count)
{
LONG pages, i, j, elms_per_page;
PEHCI_QH pqh;
@ -225,7 +190,7 @@ LONG count
elms_per_page = PAGE_SIZE / plist->elem_size;
plist->phys_addrs = usb_alloc_mem(NonPagedPool,
( sizeof( PHYSICAL_ADDRESS ) + sizeof( PBYTE ) ) * pages + \
(sizeof(PHYSICAL_ADDRESS) + sizeof(PBYTE)) * pages +
sizeof(EHCI_ELEM_LINKS) * plist->total_count);
if (plist->phys_addrs == NULL)
@ -237,27 +202,20 @@ LONG count
plist->phys_bufs = (PBYTE *) & plist->phys_addrs[pages];
plist->elem_head_buf = (PEHCI_ELEM_LINKS) & plist->phys_bufs[pages];
RtlZeroMemory(plist->phys_addrs,
( sizeof( PHYSICAL_ADDRESS ) + sizeof( PBYTE ) ) * pages + \
(sizeof(PHYSICAL_ADDRESS) + sizeof(PBYTE)) * pages +
sizeof(EHCI_ELEM_LINKS) * plist->total_count);
for(i = 0; i < pages; i++)
{
plist->phys_bufs[ i ] = HalAllocateCommonBuffer(
plist->padapter,
PAGE_SIZE,
&plist->phys_addrs[ i ],
FALSE);
plist->phys_bufs[i] = HalAllocateCommonBuffer(plist->padapter,
PAGE_SIZE, &plist->phys_addrs[i], FALSE);
if (plist->phys_bufs[i] == NULL)
{
// failed, roll back
for(j = i - 1; j >= 0; j--)
HalFreeCommonBuffer(
plist->padapter,
PAGE_SIZE,
plist->phys_addrs[ j ],
plist->phys_bufs[ j ],
FALSE );
HalFreeCommonBuffer(plist->padapter,
PAGE_SIZE, plist->phys_addrs[j], plist->phys_bufs[j], FALSE);
goto ERROR_OUT;
}
RtlZeroMemory(plist->phys_bufs[i], PAGE_SIZE);
@ -296,8 +254,8 @@ LONG count
}
}
return TRUE;
ERROR_OUT:
ERROR_OUT:
if (plist->phys_addrs != NULL)
usb_free_mem(plist->phys_addrs);
@ -306,9 +264,7 @@ ERROR_OUT:
}
VOID
elem_list_destroy_elem_list(
PEHCI_ELEM_LIST plist
)
elem_list_destroy_elem_list(PEHCI_ELEM_LIST plist)
{
LONG i, pages;
@ -317,21 +273,14 @@ PEHCI_ELEM_LIST plist
pages = (plist->total_count * plist->elem_size + PAGE_SIZE - 1) / PAGE_SIZE;
for(i = 0; i < pages; i++)
HalFreeCommonBuffer(
plist->padapter,
PAGE_SIZE,
plist->phys_addrs[ i ],
plist->phys_bufs[ i ],
FALSE );
HalFreeCommonBuffer(plist->padapter, PAGE_SIZE, plist->phys_addrs[i], plist->phys_bufs[i], FALSE);
usb_free_mem(plist->phys_addrs);
RtlZeroMemory(plist, sizeof(EHCI_ELEM_LIST));
}
PLIST_ENTRY
elem_list_get_list_head(
PEHCI_ELEM_LIST plist
)
elem_list_get_list_head(PEHCI_ELEM_LIST plist)
{
if (plist == NULL)
return NULL;
@ -339,9 +288,7 @@ PEHCI_ELEM_LIST plist
}
LONG
elem_list_get_total_count(
PEHCI_ELEM_LIST plist
)
elem_list_get_total_count(PEHCI_ELEM_LIST plist)
{
if (plist == NULL)
return 0;
@ -349,9 +296,7 @@ PEHCI_ELEM_LIST plist
}
LONG
elem_list_get_elem_size(
PEHCI_ELEM_LIST plist
)
elem_list_get_elem_size(PEHCI_ELEM_LIST plist)
{
if (plist == NULL)
return 0;
@ -359,9 +304,7 @@ PEHCI_ELEM_LIST plist
}
LONG
elem_list_get_link_offset(
PEHCI_ELEM_LIST plist
)
elem_list_get_link_offset(PEHCI_ELEM_LIST plist)
{
if (plist == NULL)
return 0;
@ -370,27 +313,21 @@ PEHCI_ELEM_LIST plist
}
LONG
elem_list_add_ref(
PEHCI_ELEM_LIST plist
)
elem_list_add_ref(PEHCI_ELEM_LIST plist)
{
plist->reference++;
return plist->reference;
}
LONG
elem_list_release_ref(
PEHCI_ELEM_LIST plist
)
elem_list_release_ref(PEHCI_ELEM_LIST plist)
{
plist->reference--;
return plist->reference;
}
LONG
elem_list_get_ref(
PEHCI_ELEM_LIST plist
)
elem_list_get_ref(PEHCI_ELEM_LIST plist)
{
return plist->reference;
}
@ -400,11 +337,7 @@ PEHCI_ELEM_LIST plist
//
BOOL
elem_pool_init_pool(
PEHCI_ELEM_POOL pool,
LONG flags,
PVOID context
)
elem_pool_init_pool(PEHCI_ELEM_POOL pool, LONG flags, PVOID context)
{
PADAPTER_OBJECT padapter;
INIT_ELEM_LIST_CONTEXT init_ctx;
@ -436,25 +369,19 @@ PVOID context
}
LONG
elem_pool_get_link_offset(
PEHCI_ELEM_POOL elem_pool
)
elem_pool_get_link_offset(PEHCI_ELEM_POOL elem_pool)
{
return elem_pool->link_offset;
}
LONG
elem_pool_get_total_count(
PEHCI_ELEM_POOL elem_pool
)
elem_pool_get_total_count(PEHCI_ELEM_POOL elem_pool)
{
return elem_pool->elem_lists[0]->get_total_count(elem_pool->elem_lists[0]) * elem_pool->list_count;
}
VOID
elem_pool_destroy_pool(
PEHCI_ELEM_POOL pool
)
elem_pool_destroy_pool(PEHCI_ELEM_POOL pool)
{
LONG i;
if (pool == NULL)
@ -470,9 +397,7 @@ PEHCI_ELEM_POOL pool
}
PEHCI_ELEM_LINKS
elem_pool_alloc_elem(
PEHCI_ELEM_POOL pool
)
elem_pool_alloc_elem(PEHCI_ELEM_POOL pool)
{
LONG i;
PEHCI_ELEM_LIST pel;
@ -508,9 +433,7 @@ PEHCI_ELEM_POOL pool
}
VOID
elem_pool_free_elem(
PEHCI_ELEM_LINKS elem_link
)
elem_pool_free_elem(PEHCI_ELEM_LINKS elem_link)
{
PLIST_HEAD lh;
LONG ref;
@ -530,9 +453,7 @@ PEHCI_ELEM_LINKS elem_link
}
BOOL
elem_pool_is_empty(
PEHCI_ELEM_POOL pool
)
elem_pool_is_empty(PEHCI_ELEM_POOL pool)
{
PEHCI_ELEM_LIST pel;
@ -543,9 +464,7 @@ PEHCI_ELEM_POOL pool
}
LONG
elem_pool_get_free_count(
PEHCI_ELEM_POOL pool
)
elem_pool_get_free_count(PEHCI_ELEM_POOL pool)
{
if (pool == NULL)
return 0;
@ -553,10 +472,7 @@ PEHCI_ELEM_POOL pool
}
PEHCI_ELEM_LINKS
elem_pool_alloc_elems(
PEHCI_ELEM_POOL pool,
LONG count
)
elem_pool_alloc_elems(PEHCI_ELEM_POOL pool, LONG count)
{
LIST_HEAD lh;
PLIST_ENTRY pthis;
@ -601,9 +517,7 @@ LONG count
}
BOOL
elem_pool_free_elems(
PEHCI_ELEM_LINKS elem_chains
)
elem_pool_free_elems(PEHCI_ELEM_LINKS elem_chains)
{
// note: no list head exists.
LIST_HEAD lh;
@ -617,10 +531,9 @@ PEHCI_ELEM_LINKS elem_chains
}
return TRUE;
}
LONG
elem_pool_get_type(
PEHCI_ELEM_POOL pool
)
elem_pool_get_type(PEHCI_ELEM_POOL pool)
{
if (pool == NULL)
return -1;
@ -628,10 +541,7 @@ PEHCI_ELEM_POOL pool
}
BOOL
elem_pool_expand_pool(
PEHCI_ELEM_POOL pool,
LONG elem_count
)
elem_pool_expand_pool(PEHCI_ELEM_POOL pool, LONG elem_count)
{
LONG elem_cnt_list, list_count, i, j;
INIT_ELEM_LIST_CONTEXT init_ctx;
@ -675,9 +585,7 @@ LONG elem_count
}
BOOL
elem_pool_collect_garbage(
PEHCI_ELEM_POOL pool
)
elem_pool_collect_garbage(PEHCI_ELEM_POOL pool)
{
LONG i, j, k, fl;
LONG free_elem_lists[EHCI_MAX_LISTS_POOL - 1];
@ -713,21 +621,16 @@ PEHCI_ELEM_POOL pool
}
BOOL
elem_pool_can_transfer(
PEHCI_ELEM_POOL pool,
LONG td_count
)
elem_pool_can_transfer(PEHCI_ELEM_POOL pool, LONG td_count)
{
LONG i;
if (pool == NULL || td_count <= 0)
return FALSE;
get_max_lists_count(pool, i);
if ((i - pool->list_count)
* pool->elem_lists[ 0 ]->get_total_count( pool->elem_lists[ 0 ] )
+ pool->free_count < td_count )
* pool->elem_lists[0]->get_total_count(pool->elem_lists[0]) + pool->free_count < td_count)
return FALSE;
return TRUE;
}
//----------------------------------------------------------

438
reactos/drivers/usb/nt4compat/usbdriver/gendrv.c
View file

@ -59,181 +59,73 @@
extern POBJECT_TYPE NTSYSAPI IoDriverObjectType;
extern VOID
disp_urb_completion(
PURB purb,
PVOID context
);
extern VOID disp_urb_completion(PURB purb, PVOID context);
VOID
disp_noio_urb_completion(
PURB purb,
PVOID context
);
VOID disp_noio_urb_completion(PURB purb, PVOID context);
NTSYSAPI NTSTATUS NTAPI ZwLoadDriver(IN PUNICODE_STRING DriverServiceName);
NTSYSAPI NTSTATUS NTAPI ZwClose(IN HANDLE Handle);
NTSYSAPI
NTSTATUS
NTAPI
ZwLoadDriver(
IN PUNICODE_STRING DriverServiceName
);
NTSYSAPI
NTSTATUS
NTAPI
ZwClose(
IN HANDLE Handle
);
NTSYSAPI
NTSTATUS
NTAPI
ObOpenObjectByName(
IN POBJECT_ATTRIBUTES ObjectAttributes,
ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
IN POBJECT_TYPE ObjectType OPTIONAL,
IN KPROCESSOR_MODE AccessMode,
IN OUT PACCESS_STATE AccessState OPTIONAL,
IN ACCESS_MASK DesiredAccess OPTIONAL,
IN OUT PVOID ParseContext OPTIONAL,
OUT PHANDLE Handle
);
IN OUT PVOID ParseContext OPTIONAL, OUT PHANDLE Handle);
BOOL
gendrv_if_driver_destroy(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
);
BOOL gendrv_if_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver);
VOID
gendrv_set_cfg_completion(
PURB purb,
PVOID context
);
VOID gendrv_set_cfg_completion(PURB purb, PVOID context);
BOOL
gendrv_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
);
BOOL gendrv_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle);
BOOL
gendrv_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL gendrv_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
BOOL
gendrv_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL gendrv_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
VOID
gendrv_startio(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
);
VOID gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
VOID
gendrv_cancel_queued_irp(
PDEVICE_OBJECT pdev_obj,
PIRP pirp
);
VOID gendrv_cancel_queued_irp(PDEVICE_OBJECT pdev_obj, PIRP pirp);
VOID
gendrv_release_ext_drvr_entry(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PGENDRV_EXT_DRVR_ENTRY pentry
);
VOID gendrv_release_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext, PGENDRV_EXT_DRVR_ENTRY pentry);
VOID
gendrv_clean_up_queued_irps(
PDEVICE_OBJECT dev_obj
);
VOID gendrv_clean_up_queued_irps(PDEVICE_OBJECT dev_obj);
PGENDRV_EXT_DRVR_ENTRY
gendrv_alloc_ext_drvr_entry(
PGENDRV_DRVR_EXTENSION pdrvr_ext
);
PGENDRV_EXT_DRVR_ENTRY gendrv_alloc_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext);
PDRIVER_OBJECT
gendrv_open_ext_driver(
PUNICODE_STRING unicode_string
);
PDRIVER_OBJECT gendrv_open_ext_driver(PUNICODE_STRING unicode_string);
NTSTATUS
gendrv_get_key_value(
IN HANDLE KeyHandle,
IN PWSTR ValueName,
OUT PKEY_VALUE_FULL_INFORMATION *Information
);
gendrv_get_key_value(IN HANDLE KeyHandle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION * Information);
NTSTATUS
gendrv_open_reg_key(
OUT PHANDLE handle,
gendrv_open_reg_key(OUT PHANDLE handle,
IN HANDLE base_handle OPTIONAL,
IN PUNICODE_STRING keyname,
IN ACCESS_MASK desired_access,
IN BOOLEAN create
);
IN PUNICODE_STRING keyname, IN ACCESS_MASK desired_access, IN BOOLEAN create);
BOOL gendrv_do_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle, BOOL is_if);
BOOL gendrv_do_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle, BOOL is_if);
NTSTATUS gendrv_send_pnp_msg(ULONG msg, PDEVICE_OBJECT pdev_obj, PVOID pctx);
BOOL gendrv_delete_device(PUSB_DEV_MANAGER dev_mgr, PDEVICE_OBJECT dev_obj);
PDEVICE_OBJECT gendrv_create_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER gen_drvr, DEV_HANDLE dev_handle);
PDRIVER_OBJECT gendrv_load_ext_drvr(PGENDRV_DRVR_EXTENSION pdrvr_ext, PUSB_DESC_HEADER pdesc);
PDRIVER_OBJECT gendrv_find_drvr_by_key(PGENDRV_DRVR_EXTENSION pdrvr_ext, ULONG key);
ULONG gendrv_make_key(PUSB_DESC_HEADER pdesc);
BOOL
gendrv_do_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle,
BOOL is_if
);
BOOL
gendrv_do_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle,
BOOL is_if
);
NTSTATUS
gendrv_send_pnp_msg(
ULONG msg,
PDEVICE_OBJECT pdev_obj,
PVOID pctx
);
BOOL
gendrv_delete_device(
PUSB_DEV_MANAGER dev_mgr,
PDEVICE_OBJECT dev_obj
);
PDEVICE_OBJECT
gendrv_create_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER gen_drvr,
DEV_HANDLE dev_handle
);
PDRIVER_OBJECT
gendrv_load_ext_drvr(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PUSB_DESC_HEADER pdesc
);
PDRIVER_OBJECT
gendrv_find_drvr_by_key(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
ULONG key
);
ULONG
gendrv_make_key(
PUSB_DESC_HEADER pdesc
);
BOOL
gendrv_driver_init(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
gendrv_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PGENDRV_DRVR_EXTENSION pdrvr_ext;
@ -277,19 +169,13 @@ PUSB_DRIVER pdriver
}
BOOL
gendrv_driver_destroy(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
gendrv_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
return gendrv_if_driver_destroy(dev_mgr, pdriver);
}
BOOL
gendrv_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
)
gendrv_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle)
{
PURB purb;
PUSB_CTRL_SETUP_PACKET psetup;
@ -387,12 +273,8 @@ DEV_HANDLE dev_handle
}
BOOL
gendrv_event_select_driver(
PUSB_DEV pdev, //always null. we do not use this param
ULONG event,
ULONG context,
ULONG param
)
gendrv_event_select_driver(PUSB_DEV pdev, //always null. we do not use this param
ULONG event, ULONG context, ULONG param)
{
//
// try to search the registry to find one driver.
@ -499,10 +381,7 @@ ERROR_OUT:
}
VOID
gendrv_set_cfg_completion(
PURB purb,
PVOID context
)
gendrv_set_cfg_completion(PURB purb, PVOID context)
{
DEV_HANDLE dev_handle;
PUSB_DEV_MANAGER dev_mgr;
@ -585,10 +464,7 @@ PVOID context
BOOL
gendrv_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
gendrv_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
if (dev_mgr == NULL)
return FALSE;
@ -596,10 +472,7 @@ DEV_HANDLE dev_handle
}
BOOL
gendrv_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
gendrv_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
if (dev_mgr == NULL)
return FALSE;
@ -607,10 +480,7 @@ DEV_HANDLE dev_handle
}
BOOL
gendrv_build_reg_string(
PUSB_DESC_HEADER pdesc,
PUNICODE_STRING pus
)
gendrv_build_reg_string(PUSB_DESC_HEADER pdesc, PUNICODE_STRING pus)
{
CHAR desc_str[128];
@ -625,8 +495,7 @@ PUNICODE_STRING pus
pdev_desc = (PUSB_DEVICE_DESC) pdesc;
sprintf(desc_str, "%sv_%04x&p_%04x",
"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\device\\",
pdev_desc->idVendor,
pdev_desc->idProduct );
pdev_desc->idVendor, pdev_desc->idProduct);
}
else if (pdesc->bDescriptorType == USB_DT_INTERFACE)
{
@ -634,9 +503,7 @@ PUNICODE_STRING pus
pif_desc = (PUSB_INTERFACE_DESC) pdesc;
sprintf(desc_str, "%sc_%04x&s_%04x&p_%04x",
"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\interface\\",
pif_desc->bInterfaceClass,
pif_desc->bInterfaceSubClass,
pif_desc->bInterfaceProtocol );
pif_desc->bInterfaceClass, pif_desc->bInterfaceSubClass, pif_desc->bInterfaceProtocol);
}
else
return FALSE;
@ -647,9 +514,7 @@ PUNICODE_STRING pus
}
ULONG
gendrv_make_key(
PUSB_DESC_HEADER pdesc
)
gendrv_make_key(PUSB_DESC_HEADER pdesc)
{
PUSB_DEVICE_DESC pdev_desc;
PUSB_INTERFACE_DESC pif_desc;
@ -664,18 +529,14 @@ PUSB_DESC_HEADER pdesc
else if (pdesc->bDescriptorType == USB_DT_INTERFACE)
{
pif_desc = (PUSB_INTERFACE_DESC) pdesc;
return ( ( ( ( ULONG )pif_desc->bInterfaceClass ) << 16 ) | \
( ( ( ULONG )pif_desc->bInterfaceSubClass ) << 8 ) | \
( ( ULONG )pif_desc->bInterfaceProtocol ) );
return ((((ULONG) pif_desc->bInterfaceClass) << 16) |
(((ULONG) pif_desc->bInterfaceSubClass) << 8) | ((ULONG) pif_desc->bInterfaceProtocol));
}
return (ULONG) - 1;
}
PDRIVER_OBJECT
gendrv_find_drvr_by_key(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
ULONG key
)
gendrv_find_drvr_by_key(PGENDRV_DRVR_EXTENSION pdrvr_ext, ULONG key)
{
PGENDRV_EXT_DRVR_ENTRY pentry;
PLIST_ENTRY pthis, pnext;
@ -701,10 +562,7 @@ ULONG key
}
PDRIVER_OBJECT
gendrv_load_ext_drvr(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PUSB_DESC_HEADER pdesc
)
gendrv_load_ext_drvr(PGENDRV_DRVR_EXTENSION pdrvr_ext, PUSB_DESC_HEADER pdesc)
{
PDRIVER_OBJECT pdrvr_obj;
PGENDRV_EXT_DRVR_ENTRY pentry;
@ -790,10 +648,7 @@ ERROR_OUT:
}
VOID
gendrv_release_drvr(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PDRIVER_OBJECT pdrvr_obj
)
gendrv_release_drvr(PGENDRV_DRVR_EXTENSION pdrvr_ext, PDRIVER_OBJECT pdrvr_obj)
{
PLIST_ENTRY pthis, pnext;
PGENDRV_EXT_DRVR_ENTRY pentry;
@ -818,11 +673,7 @@ PDRIVER_OBJECT pdrvr_obj
}
NTSTATUS
gendrv_send_pnp_msg(
ULONG msg,
PDEVICE_OBJECT pdev_obj,
PVOID pctx
)
gendrv_send_pnp_msg(ULONG msg, PDEVICE_OBJECT pdev_obj, PVOID pctx)
{
if (pdev_obj == NULL)
return STATUS_INVALID_PARAMETER;
@ -868,10 +719,7 @@ PVOID pctx
BOOL
gendrv_if_connect(
PCONNECT_DATA params,
DEV_HANDLE if_handle
)
gendrv_if_connect(PCONNECT_DATA params, DEV_HANDLE if_handle)
{
//
// try to search the registry to find one driver.
@ -970,7 +818,8 @@ DEV_HANDLE if_handle
pdev_ext = (PGENDRV_DEVICE_EXTENSION) pdev_obj->DeviceExtension;
pdev_ext->desc_buf = usb_alloc_mem(NonPagedPool, 512);
RtlCopyMemory(pdev_ext->desc_buf, pconfig_desc, 512);
pdev_ext->if_ctx.pif_desc = ( PUSB_INTERFACE_DESC )&pdev_ext->desc_buf[ ( PBYTE )pif_desc - ( PBYTE )pconfig_desc ];
pdev_ext->if_ctx.pif_desc =
(PUSB_INTERFACE_DESC) & pdev_ext->desc_buf[(PBYTE) pif_desc - (PBYTE) pconfig_desc];
// insert the device to the dev_list
ExAcquireFastMutex(&pdrvr_ext->drvr_ext_mutex);
@ -1003,11 +852,7 @@ ERROR_OUT:
}
BOOL
gendrv_do_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle,
BOOL is_if
)
gendrv_do_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle, BOOL is_if)
{
PUSB_DEV pdev;
PDEVICE_OBJECT pdev_obj;
@ -1037,10 +882,7 @@ BOOL is_if
}
BOOL
gendrv_if_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
gendrv_if_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
if (dev_mgr == NULL)
return FALSE;
@ -1049,11 +891,7 @@ DEV_HANDLE dev_handle
}
BOOL
gendrv_do_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle,
BOOL is_if
)
gendrv_do_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle, BOOL is_if)
{
PUSB_DEV pdev;
PDEVICE_OBJECT dev_obj = NULL;
@ -1107,19 +945,13 @@ BOOL is_if
}
BOOL
gendrv_if_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
gendrv_if_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
{
return gendrv_do_disconnect(dev_mgr, if_handle, TRUE);
}
BOOL
gendrv_if_driver_init(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
gendrv_if_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PGENDRV_DRVR_EXTENSION pdrvr_ext;
if (dev_mgr == NULL || pdriver == NULL)
@ -1164,10 +996,7 @@ PUSB_DRIVER pdriver
}
BOOL
gendrv_if_driver_destroy(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
gendrv_if_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PGENDRV_DRVR_EXTENSION pdrvr_ext;
PLIST_ENTRY pthis;
@ -1208,9 +1037,7 @@ PUSB_DRIVER pdriver
}
PDRIVER_OBJECT
gendrv_open_ext_driver(
PUNICODE_STRING unicode_string
)
gendrv_open_ext_driver(PUNICODE_STRING unicode_string)
{
NTSTATUS status;
OBJECT_ATTRIBUTES oa;
@ -1225,8 +1052,7 @@ PUNICODE_STRING unicode_string
RtlInitUnicodeString(&oname, L"");
RtlAppendUnicodeStringToString(&oname, unicode_string);
status = ObOpenObjectByName( &oa,
IoDriverObjectType, // object type
status = ObOpenObjectByName(&oa, IoDriverObjectType, // object type
KernelMode, // access mode
NULL, // access state
FILE_READ_DATA, // STANDARD_RIGHTS_READ, access right
@ -1242,8 +1068,8 @@ PUNICODE_STRING unicode_string
IoDriverObjectType,
KernelMode,
(PVOID)&pdrvr,
NULL // OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL
);
NULL); // OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL
ZwClose(drvr_handle);
return pdrvr;
}
@ -1258,10 +1084,7 @@ gendrv_close_ext_driver( PDRIVER_OBJECT pdrvr )
}
NTSTATUS
gendrv_dispatch(
PDEVICE_OBJECT dev_obj,
PIRP irp
)
gendrv_dispatch(PDEVICE_OBJECT dev_obj, PIRP irp)
{
IO_STACK_LOCATION *irpstack;
PUSB_DEV_MANAGER dev_mgr;
@ -1311,8 +1134,7 @@ PIRP irp
if (!default_endp_handle(endp_handle))
{
//no permit to other interface if interface dev
if( if_dev( dev_obj ) &&
if_idx_from_handle( endp_handle ) != pdev_ext->if_ctx.if_idx )
if (if_dev(dev_obj) && if_idx_from_handle(endp_handle) != pdev_ext->if_ctx.if_idx)
GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp);
}
@ -1358,8 +1180,7 @@ PIRP irp
if (!default_endp_handle(endp_handle))
{
//no permit to other interface if interface dev
if( if_dev( dev_obj ) &&
if_idx_from_handle( endp_handle ) != pdev_ext->if_ctx.if_idx )
if (if_dev(dev_obj) && if_idx_from_handle(endp_handle) != pdev_ext->if_ctx.if_idx)
GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp);
}
@ -1390,11 +1211,9 @@ PIRP irp
return STATUS_NOT_SUPPORTED;
}
BOOL
gendrv_init_dev_ext_hdr(
PDEVICE_OBJECT dev_obj,
PUSB_DEV_MANAGER dev_mgr
)
gendrv_init_dev_ext_hdr(PDEVICE_OBJECT dev_obj, PUSB_DEV_MANAGER dev_mgr)
{
PDEVEXT_HEADER dev_hdr = NULL;
if (dev_obj == NULL || dev_mgr == NULL)
@ -1408,11 +1227,7 @@ PUSB_DEV_MANAGER dev_mgr
}
PDEVICE_OBJECT
gendrv_create_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER gen_drvr,
DEV_HANDLE dev_handle
)
gendrv_create_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER gen_drvr, DEV_HANDLE dev_handle)
{
BOOL is_if;
PDEVICE_OBJECT pdev;
@ -1441,14 +1256,8 @@ DEV_HANDLE dev_handle
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL;
status = IoCreateDevice(
dev_mgr->usb_driver_obj,
sizeof( GENDRV_DEVICE_EXTENSION ),
&name_string,
FILE_USB_DEV_TYPE,
0,
TRUE,
&pdev);
status = IoCreateDevice(dev_mgr->usb_driver_obj,
sizeof(GENDRV_DEVICE_EXTENSION), &name_string, FILE_USB_DEV_TYPE, 0, TRUE, &pdev);
if (status == STATUS_SUCCESS)
{
@ -1492,9 +1301,7 @@ DEV_HANDLE dev_handle
VOID
gendrv_deferred_delete_device(
PVOID context
)
gendrv_deferred_delete_device(PVOID context)
{
PDEVICE_OBJECT dev_obj;
PGENDRV_DEVICE_EXTENSION pdev_ext;
@ -1533,10 +1340,7 @@ PVOID context
}
BOOL
gendrv_delete_device(
PUSB_DEV_MANAGER dev_mgr,
PDEVICE_OBJECT dev_obj
)
gendrv_delete_device(PUSB_DEV_MANAGER dev_mgr, PDEVICE_OBJECT dev_obj)
{
BOOL is_if;
PUSB_DRIVER pdrvr;
@ -1588,9 +1392,7 @@ PDEVICE_OBJECT dev_obj
// must have the drvr_ext_mutex acquired.
PGENDRV_EXT_DRVR_ENTRY
gendrv_alloc_ext_drvr_entry(
PGENDRV_DRVR_EXTENSION pdrvr_ext
)
gendrv_alloc_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext)
{
LONG i;
if (pdrvr_ext == NULL)
@ -1610,10 +1412,7 @@ PGENDRV_DRVR_EXTENSION pdrvr_ext
// must have the drvr_ext_mutex acquired.
VOID
gendrv_release_ext_drvr_entry(
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PGENDRV_EXT_DRVR_ENTRY pentry
)
gendrv_release_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext, PGENDRV_EXT_DRVR_ENTRY pentry)
{
if (pdrvr_ext == NULL || pentry == NULL)
return;
@ -1623,14 +1422,9 @@ PGENDRV_EXT_DRVR_ENTRY pentry
}
NTSTATUS
gendrv_open_reg_key(
OUT PHANDLE handle,
gendrv_open_reg_key(OUT PHANDLE handle,
IN HANDLE base_handle OPTIONAL,
IN PUNICODE_STRING keyname,
IN ACCESS_MASK desired_access,
IN BOOLEAN create
)
IN PUNICODE_STRING keyname, IN ACCESS_MASK desired_access, IN BOOLEAN create)
/*++
Routine Description:
@ -1657,7 +1451,6 @@ Return Value:
The function value is the final status of the operation.
--*/
{
OBJECT_ATTRIBUTES object_attr;
ULONG disposition;
@ -1667,10 +1460,7 @@ Return Value:
//
InitializeObjectAttributes(&object_attr,
keyname,
OBJ_CASE_INSENSITIVE,
base_handle,
(PSECURITY_DESCRIPTOR) NULL );
keyname, OBJ_CASE_INSENSITIVE, base_handle, (PSECURITY_DESCRIPTOR) NULL);
//
// Create the key or open it, as appropriate based on the caller's
@ -1681,28 +1471,17 @@ Return Value:
{
return ZwCreateKey(handle,
desired_access,
&object_attr,
0,
(PUNICODE_STRING) NULL,
REG_OPTION_VOLATILE,
&disposition );
&object_attr, 0, (PUNICODE_STRING) NULL, REG_OPTION_VOLATILE, &disposition);
}
else
{
return ZwOpenKey( handle,
desired_access,
&object_attr );
return ZwOpenKey(handle, desired_access, &object_attr);
}
return STATUS_INVALID_PARAMETER;
}
NTSTATUS
gendrv_get_key_value(
IN HANDLE KeyHandle,
IN PWSTR ValueName,
OUT PKEY_VALUE_FULL_INFORMATION *Information
)
gendrv_get_key_value(IN HANDLE KeyHandle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION * Information)
/*++
Routine Description:
@ -1727,7 +1506,6 @@ Return Value:
The function value is the final status of the query operation.
--*/
{
UNICODE_STRING unicodeString;
NTSTATUS status;
@ -1744,13 +1522,9 @@ Return Value:
//
status = ZwQueryValueKey(KeyHandle,
&unicodeString,
KeyValueFullInformation,
(PVOID) NULL,
0,
&keyValueLength );
if (status != STATUS_BUFFER_OVERFLOW &&
status != STATUS_BUFFER_TOO_SMALL) {
&unicodeString, KeyValueFullInformation, (PVOID) NULL, 0, &keyValueLength);
if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL)
{
return status;
}
@ -1759,7 +1533,8 @@ Return Value:
//
infoBuffer = usb_alloc_mem(NonPagedPool, keyValueLength);
if (!infoBuffer) {
if (!infoBuffer)
{
return STATUS_INSUFFICIENT_RESOURCES;
}
@ -1769,11 +1544,9 @@ Return Value:
status = ZwQueryValueKey(KeyHandle,
&unicodeString,
KeyValueFullInformation,
infoBuffer,
keyValueLength,
&keyValueLength );
if (!NT_SUCCESS( status )) {
KeyValueFullInformation, infoBuffer, keyValueLength, &keyValueLength);
if (!NT_SUCCESS(status))
{
usb_free_mem(infoBuffer);
return status;
}
@ -1788,10 +1561,7 @@ Return Value:
}
VOID
gendrv_startio(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
)
gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp)
{
PIO_STACK_LOCATION irp_stack;
ULONG ctrl_code;
@ -1875,16 +1645,14 @@ IN PIRP irp
}
lock_dev(pdev, FALSE);
if( dev_state( pdev ) == USB_DEV_STATE_ZOMB \
|| ( dev_state( pdev ) < USB_DEV_STATE_ADDRESSED ) )
if (dev_state(pdev) == USB_DEV_STATE_ZOMB || (dev_state(pdev) < USB_DEV_STATE_ADDRESSED))
{
status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT1;
}
if( dev_state( pdev ) == USB_DEV_STATE_ADDRESSED
&& !default_endp_handle( endp_handle ) )
if (dev_state(pdev) == USB_DEV_STATE_ADDRESSED && !default_endp_handle(endp_handle))
{
status = STATUS_DEVICE_NOT_READY;
goto ERROR_OUT1;
@ -1979,9 +1747,7 @@ ERROR_OUT1:
}
VOID
gendrv_clean_up_queued_irps(
PDEVICE_OBJECT dev_obj
)
gendrv_clean_up_queued_irps(PDEVICE_OBJECT dev_obj)
{
// called when device may not function or about to be removed, need cleanup
KIRQL cancelIrql;
@ -2024,10 +1790,7 @@ PDEVICE_OBJECT dev_obj
}
VOID
gendrv_cancel_queued_irp(
PDEVICE_OBJECT dev_obj,
PIRP pirp
)
gendrv_cancel_queued_irp(PDEVICE_OBJECT dev_obj, PIRP pirp)
{
// cancel routine for irps queued in the device queue
PUSB_DEV_MANAGER dev_mgr;
@ -2054,4 +1817,3 @@ PIRP pirp
// the device queue is moved on, no need to call IoStartNextPacket
return;
}

939
reactos/drivers/usb/nt4compat/usbdriver/hub.c
View file

File diff suppressed because it is too large Load diff

181
reactos/drivers/usb/nt4compat/usbdriver/td.c
View file

@ -24,22 +24,13 @@
#define UHCI_MIN_TD_POOLS 4
BOOL
free_td_to_pool(
PUHCI_TD_POOL ptd_pool,
PUHCI_TD ptd
); //add tds till pnext == NULL
BOOL free_td_to_pool(PUHCI_TD_POOL ptd_pool, PUHCI_TD ptd); //add tds till pnext == NULL
PUHCI_QH
alloc_qh(
PUHCI_QH_POOL pqh_pool
); //null if failed
PUHCI_QH alloc_qh(PUHCI_QH_POOL pqh_pool); //null if failed
BOOL
init_td_pool(
PUHCI_TD_POOL ptd_pool
)
init_td_pool(PUHCI_TD_POOL ptd_pool)
{
int i, pages;
PTD_EXTENSION ptde;
@ -58,17 +49,12 @@ PUHCI_TD_POOL ptd_pool
for(i = 0; i < pages; i++)
{
ptd_pool->td_array[i] =
HalAllocateCommonBuffer(
ptd_pool->padapter,
PAGE_SIZE,
&ptd_pool->logic_addr[ i ],
FALSE);
HalAllocateCommonBuffer(ptd_pool->padapter, PAGE_SIZE, &ptd_pool->logic_addr[i], FALSE);
if (ptd_pool->td_array[i] == NULL)
goto failed;
}
ptd_pool->tde_array = ( PTD_EXTENSION )usb_alloc_mem(
NonPagedPool,
ptd_pool->tde_array = (PTD_EXTENSION) usb_alloc_mem(NonPagedPool,
sizeof(TD_EXTENSION) * UHCI_MAX_POOL_TDS);
if (ptd_pool->tde_array == NULL)
@ -79,9 +65,7 @@ PUHCI_TD_POOL ptd_pool
RtlZeroMemory(ptd_pool->td_array[i], PAGE_SIZE);
}
RtlZeroMemory(
ptd_pool->tde_array,
sizeof( TD_EXTENSION ) * UHCI_MAX_POOL_TDS );
RtlZeroMemory(ptd_pool->tde_array, sizeof(TD_EXTENSION) * UHCI_MAX_POOL_TDS);
ptde = ptd_pool->tde_array;
ptd_pool->free_count = 0;
@ -94,7 +78,8 @@ PUHCI_TD_POOL ptd_pool
ptd_pool->td_array[i >> 7][i & 0x7f].ptde = &ptde[i];
ptde[i].ptd = &ptd_pool->td_array[i >> 7][i & 0x7f];
ptde[i].flags = UHCI_ITEM_FLAG_TD;
ptd_pool->td_array[ i >> 7 ][ i & 0x7f ].phy_addr = ptd_pool->logic_addr[ i >> 7 ].LowPart + ( i & 0x7f ) * sizeof( UHCI_TD );
ptd_pool->td_array[i >> 7][i & 0x7f].phy_addr =
ptd_pool->logic_addr[i >> 7].LowPart + (i & 0x7f) * sizeof(UHCI_TD);
ptd_pool->td_array[i >> 7][i & 0x7f].pool = ptd_pool;
ptd_pool->td_array[i >> 7][i & 0x7f].purb = NULL;
free_td_to_pool(ptd_pool, &ptd_pool->td_array[i >> 7][i & 0x7f]);
@ -108,10 +93,7 @@ PUHCI_TD_POOL ptd_pool
if (ptd_pool->td_array[i])
{
HalFreeCommonBuffer(ptd_pool->padapter,
PAGE_SIZE,
ptd_pool->logic_addr[ i ],
ptd_pool->td_array[ i ],
FALSE);
PAGE_SIZE, ptd_pool->logic_addr[i], ptd_pool->td_array[i], FALSE);
ptd_pool->td_array[i] = NULL;
ptd_pool->logic_addr[i].QuadPart = 0;
}
@ -127,11 +109,9 @@ PUHCI_TD_POOL ptd_pool
return FALSE;
}
//add tds till pnext == NULL
BOOL
free_td_to_pool(
PUHCI_TD_POOL ptd_pool,
PUHCI_TD ptd
) //add tds till pnext == NULL
free_td_to_pool(PUHCI_TD_POOL ptd_pool, PUHCI_TD ptd)
{
if (ptd_pool == NULL || ptd == NULL)
{
@ -147,11 +127,12 @@ PUHCI_TD ptd
return TRUE;
}
// qh routines
//null if failed
PUHCI_TD
alloc_td_from_pool(
PUHCI_TD_POOL ptd_pool
) //null if failed
alloc_td_from_pool(PUHCI_TD_POOL ptd_pool)
{
PTD_EXTENSION ptde;
PLIST_ENTRY temp;
@ -178,10 +159,9 @@ PUHCI_TD_POOL ptd_pool
}
//test whether the pool is all free
BOOL
is_pool_free(
PUHCI_TD_POOL pool
) //test whether the pool is all free
is_pool_free(PUHCI_TD_POOL pool)
{
if (pool == NULL)
return FALSE;
@ -193,9 +173,7 @@ PUHCI_TD_POOL pool
}
BOOL
is_pool_empty(
PUHCI_TD_POOL pool
)
is_pool_empty(PUHCI_TD_POOL pool)
{
if (pool == NULL)
return FALSE;
@ -204,9 +182,7 @@ PUHCI_TD_POOL pool
}
BOOL
destroy_td_pool(
PUHCI_TD_POOL ptd_pool
)
destroy_td_pool(PUHCI_TD_POOL ptd_pool)
{
int i, pages;
PADAPTER_OBJECT padapter; //we need this garbage for allocation
@ -223,10 +199,7 @@ PUHCI_TD_POOL ptd_pool
if (ptd_pool->td_array[i])
{
HalFreeCommonBuffer(ptd_pool->padapter,
PAGE_SIZE,
ptd_pool->logic_addr[ i ],
ptd_pool->td_array[ i ],
FALSE);
PAGE_SIZE, ptd_pool->logic_addr[i], ptd_pool->td_array[i], FALSE);
ptd_pool->td_array[i] = NULL;
ptd_pool->logic_addr[i].QuadPart = 0;
}
@ -242,10 +215,7 @@ PUHCI_TD_POOL ptd_pool
}
BOOL
init_td_pool_list(
PUHCI_TD_POOL_LIST pool_list,
PADAPTER_OBJECT padapter
)
init_td_pool_list(PUHCI_TD_POOL_LIST pool_list, PADAPTER_OBJECT padapter)
{
int i;
RtlZeroMemory(pool_list, sizeof(UHCI_TD_POOL_LIST));
@ -266,9 +236,7 @@ PADAPTER_OBJECT padapter
}
BOOL
destroy_td_pool_list(
PUHCI_TD_POOL_LIST pool_list
)
destroy_td_pool_list(PUHCI_TD_POOL_LIST pool_list)
{
PUHCI_TD_POOL pool;
while (IsListEmpty(&pool_list->busy_pools) == FALSE)
@ -282,10 +250,7 @@ PUHCI_TD_POOL_LIST pool_list
}
BOOL
expand_pool_list(
PUHCI_TD_POOL_LIST pool_list,
LONG pool_count
) //private
expand_pool_list(PUHCI_TD_POOL_LIST pool_list, LONG pool_count) //private
{
PUHCI_TD_POOL pool;
int i;
@ -316,9 +281,7 @@ LONG pool_count
}
BOOL
collect_garbage(
PUHCI_TD_POOL_LIST pool_list
)
collect_garbage(PUHCI_TD_POOL_LIST pool_list)
{
PLIST_ENTRY prev, next;
@ -354,27 +317,21 @@ PUHCI_TD_POOL_LIST pool_list
//private
LONG
get_num_free_tds(
PUHCI_TD_POOL_LIST pool_list
)
get_num_free_tds(PUHCI_TD_POOL_LIST pool_list)
{
return pool_list->free_tds;
}
//private
LONG
get_max_free_tds(
PUHCI_TD_POOL_LIST pool_list
)
get_max_free_tds(PUHCI_TD_POOL_LIST pool_list)
{
return pool_list->free_tds + pool_list->free_count * UHCI_MAX_POOL_TDS;
}
//add tds till pnext == NULL
BOOL
free_td(
PUHCI_TD_POOL_LIST pool_list,
PUHCI_TD ptd
) //add tds till pnext == NULL
free_td(PUHCI_TD_POOL_LIST pool_list, PUHCI_TD ptd)
{
if (pool_list == NULL || ptd == NULL)
return FALSE;
@ -391,10 +348,9 @@ PUHCI_TD ptd
return TRUE;
}
//null if failed
PUHCI_TD
alloc_td(
PUHCI_TD_POOL_LIST pool_list
) //null if failed
alloc_td(PUHCI_TD_POOL_LIST pool_list)
{
PLIST_ENTRY prev, next;
PUHCI_TD new_td;
@ -432,10 +388,7 @@ PUHCI_TD_POOL_LIST pool_list
}
PUHCI_TD
alloc_tds(
PUHCI_TD_POOL_LIST pool_list,
LONG count
)
alloc_tds(PUHCI_TD_POOL_LIST pool_list, LONG count)
{
//return value is a list of tds, vert_link chain.
@ -462,19 +415,15 @@ LONG count
TRAP();
}
uhci_dbg_print( DBGLVL_MEDIUM, ("alloc_tds(): td pool-list free_tds=0x%x, free pools=0x%x\n", \
pool_list->free_tds,
pool_list->free_count ) );
uhci_dbg_print(DBGLVL_MEDIUM, ("alloc_tds(): td pool-list free_tds=0x%x, free pools=0x%x\n",
pool_list->free_tds, pool_list->free_count));
return ptd;
}
VOID
free_tds(
PUHCI_TD_POOL_LIST pool_list,
PUHCI_TD ptd
)
free_tds(PUHCI_TD_POOL_LIST pool_list, PUHCI_TD ptd)
{
PUHCI_TD ptofree;
PLIST_ENTRY pthis;
@ -496,10 +445,7 @@ PUHCI_TD ptd
BOOL
can_transfer(
PUHCI_TD_POOL_LIST pool_list,
LONG td_count
)
can_transfer(PUHCI_TD_POOL_LIST pool_list, LONG td_count)
{
if (td_count > get_max_free_tds(pool_list))
return FALSE;
@ -508,10 +454,7 @@ LONG td_count
}
VOID
lock_td_pool(
PUHCI_TD_POOL_LIST pool_list,
BOOL at_dpc
)
lock_td_pool(PUHCI_TD_POOL_LIST pool_list, BOOL at_dpc)
{
//if( !at_dpc )
// KeAcquireSpinLock( &pool_list->pool_lock );
@ -520,10 +463,7 @@ BOOL at_dpc
}
VOID
unlock_td_pool(
PUHCI_TD_POOL_LIST pool_list,
BOOL at_dpc
)
unlock_td_pool(PUHCI_TD_POOL_LIST pool_list, BOOL at_dpc)
{
//if( !at_dpc )
// KeReleaseSpinLock( &pool_list->pool_lock );
@ -532,10 +472,7 @@ BOOL at_dpc
}
BOOL
init_qh_pool(
PUHCI_QH_POOL pqh_pool,
PADAPTER_OBJECT padapter
)
init_qh_pool(PUHCI_QH_POOL pqh_pool, PADAPTER_OBJECT padapter)
{
PQH_EXTENSION pqhe;
LONG i;
@ -545,19 +482,15 @@ PADAPTER_OBJECT padapter
pqh_pool->padapter = padapter;
pqh_pool->qhe_array = (PQH_EXTENSION)usb_alloc_mem(
NonPagedPool,
pqh_pool->qhe_array = (PQH_EXTENSION) usb_alloc_mem(NonPagedPool,
sizeof(QH_EXTENSION) * UHCI_MAX_POOL_QHS);
if (pqh_pool->qhe_array == NULL)
return FALSE;
pqh_pool->qh_array = \
(PUHCI_QH)HalAllocateCommonBuffer(
padapter,
sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS,
&pqh_pool->logic_addr,
FALSE);
pqh_pool->qh_array =
(PUHCI_QH) HalAllocateCommonBuffer(padapter,
sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS, &pqh_pool->logic_addr, FALSE);
if (pqh_pool->qh_array == NULL)
{
@ -593,11 +526,9 @@ PADAPTER_OBJECT padapter
}
//add qhs till pnext == NULL
BOOL
free_qh(
PUHCI_QH_POOL pqh_pool,
PUHCI_QH pqh
) //add qhs till pnext == NULL
free_qh(PUHCI_QH_POOL pqh_pool, PUHCI_QH pqh)
{
if (pqh_pool == NULL || pqh == NULL)
return FALSE;
@ -610,10 +541,9 @@ PUHCI_QH pqh
return TRUE;
}
//null if failed
PUHCI_QH
alloc_qh(
PUHCI_QH_POOL pqh_pool
) //null if failed
alloc_qh(PUHCI_QH_POOL pqh_pool)
{
PQH_EXTENSION pqhe;
@ -636,9 +566,7 @@ PUHCI_QH_POOL pqh_pool
}
BOOL
destroy_qh_pool(
PUHCI_QH_POOL pqh_pool
)
destroy_qh_pool(PUHCI_QH_POOL pqh_pool)
{
int i;
@ -648,9 +576,7 @@ PUHCI_QH_POOL pqh_pool
HalFreeCommonBuffer(pqh_pool->padapter,
sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS,
pqh_pool->logic_addr,
pqh_pool->qh_array,
FALSE);
pqh_pool->logic_addr, pqh_pool->qh_array, FALSE);
RtlZeroMemory(pqh_pool, sizeof(UHCI_QH_POOL));
@ -662,10 +588,7 @@ PUHCI_QH_POOL pqh_pool
}
VOID
lock_qh_pool(
PUHCI_QH_POOL pool,
BOOL at_dpc
)
lock_qh_pool(PUHCI_QH_POOL pool, BOOL at_dpc)
{
//if( !at_dpc )
// KeAcquireSpinLock( &pool->pool_lock );
@ -674,14 +597,10 @@ BOOL at_dpc
}
VOID
unlock_qh_pool(
PUHCI_QH_POOL pool,
BOOL at_dpc
)
unlock_qh_pool(PUHCI_QH_POOL pool, BOOL at_dpc)
{
//if( !at_dpc )
// KeReleaseSpinLock( &pool->pool_lock );
//else
// KeReleaseSpinLockFromDpcLevel( &pool->pool_lock );
}

838
reactos/drivers/usb/nt4compat/usbdriver/uhci.c
View file

File diff suppressed because it is too large Load diff

400
reactos/drivers/usb/nt4compat/usbdriver/umss.c
View file

@ -63,119 +63,50 @@ typedef unsigned long ULONG_PTR, *PULONG_PTR;
return;\
}
extern VOID
gendrv_startio(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
);
extern VOID gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
NTSYSAPI NTSTATUS NTAPI ZwLoadDriver(IN PUNICODE_STRING DriverServiceName);
NTSYSAPI
NTSTATUS
NTAPI
ZwLoadDriver(
IN PUNICODE_STRING DriverServiceName
);
NTSYSAPI
NTSTATUS
NTAPI
ObOpenObjectByName(
IN POBJECT_ATTRIBUTES ObjectAttributes,
ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
IN POBJECT_TYPE ObjectType OPTIONAL,
IN KPROCESSOR_MODE AccessMode,
IN OUT PACCESS_STATE AccessState OPTIONAL,
IN ACCESS_MASK DesiredAccess OPTIONAL,
IN OUT PVOID ParseContext OPTIONAL,
OUT PHANDLE Handle
);
IN OUT PVOID ParseContext OPTIONAL, OUT PHANDLE Handle);
VOID
umss_start_io(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
);
VOID umss_start_io(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
NTSTATUS
umss_port_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
);
NTSTATUS umss_port_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp);
BOOL
umss_connect(
PCONNECT_DATA dev_mgr,
DEV_HANDLE dev_handle
);
BOOL umss_connect(PCONNECT_DATA dev_mgr, DEV_HANDLE dev_handle);
BOOL
umss_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL umss_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
BOOL
umss_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
NTSTATUS
umss_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
);
NTSTATUS umss_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp);
VOID
umss_set_cfg_completion(
PURB purb,
PVOID pcontext
);
VOID umss_set_cfg_completion(PURB purb, PVOID pcontext);
VOID
umss_start_create_device(
IN PVOID Parameter
);
VOID umss_start_create_device(IN PVOID Parameter);
BOOL
umss_delete_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdrvr,
PDEVICE_OBJECT dev_obj,
BOOL is_if
);
BOOL umss_delete_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdrvr, PDEVICE_OBJECT dev_obj, BOOL is_if);
BOOL
umss_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
NTSTATUS
umss_process_srb(
PDEVICE_OBJECT dev_obj,
PIRP irp );
NTSTATUS umss_process_srb(PDEVICE_OBJECT dev_obj, PIRP irp);
VOID
umss_load_class_driver(
PVOID context
);
VOID umss_load_class_driver(PVOID context);
BOOL
umss_tsc_to_sff(
PIO_PACKET io_packet
);
BOOL umss_tsc_to_sff(PIO_PACKET io_packet);
VOID
umss_fix_sff_result(
PIO_PACKET io_packet,
SCSI_REQUEST_BLOCK *srb
);
VOID umss_fix_sff_result(PIO_PACKET io_packet, SCSI_REQUEST_BLOCK * srb);
PDEVICE_OBJECT
umss_create_port_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
umss_create_port_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
// currently a port device is a connection point
@ -195,14 +126,8 @@ PUSB_DRIVER pdriver
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL;
status = IoCreateDevice(
dev_mgr->usb_driver_obj,
sizeof( UMSS_PORT_DEV_EXT ),
&name_string,
FILE_USB_DEV_TYPE,
0,
TRUE,
&pdev);
status = IoCreateDevice(dev_mgr->usb_driver_obj,
sizeof(UMSS_PORT_DEV_EXT), &name_string, FILE_USB_DEV_TYPE, 0, TRUE, &pdev);
if (status == STATUS_SUCCESS)
{
@ -236,9 +161,7 @@ PUSB_DRIVER pdriver
}
BOOL
umss_delete_port_device(
PDEVICE_OBJECT dev_obj
)
umss_delete_port_device(PDEVICE_OBJECT dev_obj)
{
UCHAR dev_name[64];
STRING string;
@ -262,15 +185,12 @@ PDEVICE_OBJECT dev_obj
return TRUE;
}
NTSTATUS
umss_port_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
)
// FIXME!!! there can not be sent IOCTL_SUBMIT_URB_XXX while
// the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device.
// not resolved yet.
// 2004-03-22 23:12:26
NTSTATUS
umss_port_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp)
{
KIRQL irql;
ULONG ctrl_code;
@ -335,10 +255,7 @@ PIRP irp
}
BOOL
umss_driver_init(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
umss_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PUMSS_DRVR_EXTENSION pdrvr_ext;
UNICODE_STRING unicode_string;
@ -398,10 +315,7 @@ PUSB_DRIVER pdriver
}
BOOL
umss_driver_destroy(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
umss_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PUMSS_DRVR_EXTENSION pdrvr_ext;
if (dev_mgr == NULL || pdriver == NULL)
@ -420,12 +334,7 @@ PUSB_DRIVER pdriver
}
PDEVICE_OBJECT
umss_create_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER umss_drvr,
DEV_HANDLE dev_handle,
BOOL is_if
)
umss_create_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER umss_drvr, DEV_HANDLE dev_handle, BOOL is_if)
{
UCHAR dev_name[64], dev_id;
@ -449,8 +358,7 @@ BOOL is_if
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL;
status = IoCreateDevice(
dev_mgr->usb_driver_obj,
status = IoCreateDevice(dev_mgr->usb_driver_obj,
sizeof(UMSS_DEVICE_EXTENSION),
&name_string,
FILE_USB_DEV_TYPE,
@ -508,10 +416,7 @@ BOOL is_if
}
BOOL
umss_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
)
umss_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle)
{
PURB purb;
NTSTATUS status;
@ -554,10 +459,7 @@ DEV_HANDLE dev_handle
}
VOID
umss_set_cfg_completion(
PURB purb,
PVOID pcontext
)
umss_set_cfg_completion(PURB purb, PVOID pcontext)
{
PUSB_CTRL_SETUP_PACKET psetup;
PUCHAR buf;
@ -636,9 +538,7 @@ PVOID pcontext
}
VOID
umss_start_create_device(
IN PVOID Parameter
)
umss_start_create_device(IN PVOID Parameter)
{
LONG i;
PUCHAR desc_buf;
@ -677,8 +577,8 @@ IN PVOID Parameter
pdev_obj = umss_create_device(dev_mgr, pdrvr, dev_handle, FALSE);
lock_dev(pdev, FALSE);
if( pdev_obj == NULL || \
dev_state( pdev ) == USB_DEV_STATE_ZOMB || \
if (pdev_obj == NULL ||
dev_state(pdev) == USB_DEV_STATE_ZOMB ||
dev_mgr_set_driver(dev_mgr, dev_handle, pdrvr, pdev) == FALSE)
{
usb_free_mem(desc_buf);
@ -703,8 +603,7 @@ IN PVOID Parameter
//search for our if
for(i = 0; ((UCHAR) i) < pconfig_desc->bNumInterfaces; i++)
{
if( pif_desc->bLength == sizeof( USB_INTERFACE_DESC ) \
&& pif_desc->bDescriptorType == USB_DT_INTERFACE )
if (pif_desc->bLength == sizeof(USB_INTERFACE_DESC) && pif_desc->bDescriptorType == USB_DT_INTERFACE)
{
if (pif_desc->bInterfaceClass == USB_CLASS_MASS_STORAGE)
{
@ -729,17 +628,15 @@ IN PVOID Parameter
pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1];
for(i = 0; ((UCHAR) i) < pif_desc->bNumEndpoints; i++)
{
if( pendp_desc->bDescriptorType == USB_DT_ENDPOINT \
if (pendp_desc->bDescriptorType == USB_DT_ENDPOINT
&& pendp_desc->bLength == sizeof(USB_ENDPOINT_DESC))
{
if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \
== USB_ENDPOINT_XFER_INT )
if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
{
pdev_ext->pint_endp_desc = pendp_desc;
pdev_ext->int_endp_idx = (UCHAR) i;
}
else if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \
== USB_ENDPOINT_XFER_BULK )
else if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
{
if (pendp_desc->bEndpointAddress & USB_DIR_IN)
{
@ -763,19 +660,13 @@ IN PVOID Parameter
}
BOOL
umss_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
return TRUE;
}
BOOL
umss_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
umss_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
PDEVICE_OBJECT dev_obj;
NTSTATUS status;
@ -806,9 +697,7 @@ DEV_HANDLE dev_handle
}
VOID
umss_deferred_delete_device(
PVOID context
)
umss_deferred_delete_device(PVOID context)
{
PDEVICE_OBJECT dev_obj;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -847,12 +736,7 @@ PVOID context
}
BOOL
umss_delete_device(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdrvr,
PDEVICE_OBJECT dev_obj,
BOOL is_if
)
umss_delete_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdrvr, PDEVICE_OBJECT dev_obj, BOOL is_if)
{
UCHAR dev_name[64];
STRING string;
@ -916,10 +800,7 @@ BOOL is_if
}
VOID
umss_submit_io_packet(
PDEVICE_OBJECT dev_obj,
PIO_PACKET io_packet
)
umss_submit_io_packet(PDEVICE_OBJECT dev_obj, PIO_PACKET io_packet)
{
NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext;
@ -928,8 +809,7 @@ PIO_PACKET io_packet
pdev_ext = dev_obj->DeviceExtension;
// lock the dev, the pdev_ext->pif_desc won't go away.
if( ( status = usb_query_and_lock_dev( pdev_ext->dev_mgr, pdev_ext->dev_handle, &pdev ) )
!= STATUS_SUCCESS )
if ((status = usb_query_and_lock_dev(pdev_ext->dev_mgr, pdev_ext->dev_handle, &pdev)) != STATUS_SUCCESS)
{
usb_dbg_print(DBGLVL_MAXIMUM, ("umss_start_io(): error, device is not valid\n"));
UMSS_COMPLETE_START_IO(dev_obj, status, io_packet->pirp);
@ -955,10 +835,7 @@ PIO_PACKET io_packet
}
VOID
umss_start_io(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
)
umss_start_io(IN PDEVICE_OBJECT dev_obj, IN PIRP irp)
{
KIRQL irql;
ULONG ctrl_code;
@ -1060,8 +937,7 @@ IN PIRP irp
if (irp_stack->Parameters.DeviceIoControl.InputBufferLength <
(sizeof(SCSI_PASS_THROUGH) +
pass_through->SenseInfoLength +
pass_through->DataTransferLength ) )
pass_through->SenseInfoLength + pass_through->DataTransferLength))
UMSS_COMPLETE_START_IO(dev_obj, STATUS_BUFFER_TOO_SMALL, irp);
RtlZeroMemory(&io_packet, sizeof(io_packet));
@ -1138,14 +1014,11 @@ IN PIRP irp
return;
}
NTSTATUS
umss_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
)
// bugbug!!! there can not be sent IOCTL_SUBMIT_URB_XXX while
// the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device.
// not resolved yet.
NTSTATUS
umss_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp)
{
KIRQL irql;
ULONG ctrl_code;
@ -1186,7 +1059,8 @@ PIRP irp
PUSB_DEV pdev;
USE_IRQL;
if( irp_stack->Parameters.DeviceIoControl.InputBufferLength < sizeof( PDEVICE_OBJECT ) ) {
if (irp_stack->Parameters.DeviceIoControl.InputBufferLength < sizeof(PDEVICE_OBJECT))
{
EXIT_DISPATCH(STATUS_INVALID_PARAMETER, irp);
}
@ -1197,13 +1071,13 @@ PIRP irp
// we have to test the usb dev's state to determine whether set or not the fdo
//
if( usb_query_and_lock_dev( pdev_ext->dev_mgr, pdev_ext->dev_handle, &pdev ) != STATUS_SUCCESS )
if (usb_query_and_lock_dev(pdev_ext->dev_mgr, pdev_ext->dev_handle, &pdev) !=
STATUS_SUCCESS)
EXIT_DISPATCH(STATUS_DEVICE_DOES_NOT_EXIST, irp);
lock_dev(pdev, FALSE);
if( dev_state( pdev ) >= USB_DEV_STATE_BEFORE_ZOMB ||
dev_state( pdev ) == USB_DEV_STATE_ZOMB )
if (dev_state(pdev) >= USB_DEV_STATE_BEFORE_ZOMB || dev_state(pdev) == USB_DEV_STATE_ZOMB)
{
unlock_dev(pdev, FALSE);
usb_unlock_dev(pdev);
@ -1293,9 +1167,7 @@ PIRP irp
ULONG required_size;
required_size = sizeof(SCSI_ADAPTER_BUS_INFO)
+ sizeof( SCSI_BUS_DATA )
+ sizeof( SCSI_INQUIRY_DATA )
+ INQUIRYDATABUFFERSIZE;
+ sizeof(SCSI_BUS_DATA) + sizeof(SCSI_INQUIRY_DATA) + INQUIRYDATABUFFERSIZE;
if (irp_stack->Parameters.DeviceIoControl.OutputBufferLength < required_size)
UMSS_EXIT_DISPATCH(pdev_obj, STATUS_BUFFER_TOO_SMALL, irp);
@ -1355,7 +1227,8 @@ PIRP irp
{
PIO_SCSI_CAPABILITIES port_cap;
if( irp_stack->Parameters.DeviceIoControl.OutputBufferLength < sizeof( IO_SCSI_CAPABILITIES ) )
if (irp_stack->Parameters.DeviceIoControl.OutputBufferLength <
sizeof(IO_SCSI_CAPABILITIES))
EXIT_DISPATCH(STATUS_INVALID_PARAMETER, irp);
port_cap = (PIO_SCSI_CAPABILITIES) irp->AssociatedIrp.SystemBuffer;
@ -1402,10 +1275,7 @@ PIRP irp
}
VOID
umss_reset_pipe_completion(
PURB purb,
PVOID context
)
umss_reset_pipe_completion(PURB purb, PVOID context)
{
PUMSS_DEVICE_EXTENSION pdev_ext;
if (context == NULL)
@ -1417,12 +1287,9 @@ PVOID context
return;
}
NTSTATUS
umss_reset_pipe(
PUMSS_DEVICE_EXTENSION pdev_ext,
DEV_HANDLE endp_handle
)
//can only be called at passive level
NTSTATUS
umss_reset_pipe(PUMSS_DEVICE_EXTENSION pdev_ext, DEV_HANDLE endp_handle)
{
NTSTATUS status;
PUSB_DEV pdev;
@ -1436,20 +1303,11 @@ DEV_HANDLE endp_handle
if (status != STATUS_SUCCESS)
return STATUS_UNSUCCESSFUL;
status = usb_reset_pipe_ex(
pdev_ext->dev_mgr,
endp_handle,
umss_reset_pipe_completion,
pdev_ext );
status = usb_reset_pipe_ex(pdev_ext->dev_mgr, endp_handle, umss_reset_pipe_completion, pdev_ext);
if (status == STATUS_PENDING)
{
KeWaitForSingleObject(
&pdev_ext->sync_event,
Executive,
KernelMode,
TRUE,
NULL );
KeWaitForSingleObject(&pdev_ext->sync_event, Executive, KernelMode, TRUE, NULL);
status = pdev_ext->reset_pipe_status;
}
usb_unlock_dev(pdev);
@ -1457,11 +1315,7 @@ DEV_HANDLE endp_handle
}
BOOL
umss_gen_result_srb(
PIO_PACKET io_packet,
PSCSI_REQUEST_BLOCK srb,
NTSTATUS status
)
umss_gen_result_srb(PIO_PACKET io_packet, PSCSI_REQUEST_BLOCK srb, NTSTATUS status)
{
if (srb == NULL || io_packet == NULL)
@ -1537,7 +1391,8 @@ NTSTATUS status
srb->SrbStatus = SRB_STATUS_ERROR;
}
if( ( io_packet->pirp->Flags & ( IRP_READ_OPERATION | IRP_WRITE_OPERATION ) ) && !( io_packet->pirp->Flags & IRP_PAGING_IO ) )
if ((io_packet->pirp->Flags & (IRP_READ_OPERATION | IRP_WRITE_OPERATION))
&& !(io_packet->pirp->Flags & IRP_PAGING_IO))
{
if (io_packet->data_buffer)
{
@ -1549,11 +1404,7 @@ NTSTATUS status
}
BOOL
umss_gen_result_ctrl(
PDEVICE_OBJECT dev_obj,
PIRP irp,
NTSTATUS status
)
umss_gen_result_ctrl(PDEVICE_OBJECT dev_obj, PIRP irp, NTSTATUS status)
{
PIO_STACK_LOCATION irp_stack;
ULONG ctrl_code;
@ -1598,7 +1449,8 @@ NTSTATUS status
// pass_through_direct->SenseInfoLength = pdev_ext->io_packet.sense_data_length;
if (status == STATUS_SUCCESS)
irp->IoStatus.Information = pass_through_direct->SenseInfoOffset + pass_through_direct->SenseInfoLength;
irp->IoStatus.Information =
pass_through_direct->SenseInfoOffset + pass_through_direct->SenseInfoLength;
else
pass_through_direct->ScsiStatus = SCSISTAT_CHECK_CONDITION;
@ -1610,10 +1462,7 @@ NTSTATUS status
VOID
umss_complete_request(
PUMSS_DEVICE_EXTENSION pdev_ext,
NTSTATUS status
)
umss_complete_request(PUMSS_DEVICE_EXTENSION pdev_ext, NTSTATUS status)
{
PIRP pirp;
KIRQL old_irql;
@ -1668,10 +1517,7 @@ NTSTATUS status
}
BOOL
umss_if_connect(
PCONNECT_DATA params,
DEV_HANDLE if_handle
)
umss_if_connect(PCONNECT_DATA params, DEV_HANDLE if_handle)
{
PURB purb;
LONG if_idx, i;
@ -1813,17 +1659,15 @@ DEV_HANDLE if_handle
pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1];
for(i = 0; ((UCHAR) i) < pif_desc->bNumEndpoints; i++)
{
if( pendp_desc->bDescriptorType == USB_DT_ENDPOINT \
if (pendp_desc->bDescriptorType == USB_DT_ENDPOINT
&& pendp_desc->bLength == sizeof(USB_ENDPOINT_DESC))
{
if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \
== USB_ENDPOINT_XFER_INT )
if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
{
pdev_ext->pint_endp_desc = pendp_desc;
pdev_ext->int_endp_idx = (UCHAR) i;
}
else if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \
== USB_ENDPOINT_XFER_BULK )
else if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
{
if (pendp_desc->bEndpointAddress & USB_DIR_IN)
{
@ -1845,16 +1689,13 @@ DEV_HANDLE if_handle
// notify the class driver, some device comes
pdrvr_ext = (PUMSS_DRVR_EXTENSION) pdrvr->driver_ext;
if( pdrvr_ext &&
pdrvr_ext->class_driver_info.add_device &&
pdrvr_ext->class_driver_info.fdo_driver )
if (pdrvr_ext && pdrvr_ext->class_driver_info.add_device && pdrvr_ext->class_driver_info.fdo_driver)
pdrvr_ext->class_driver_info.add_device(pdrvr_ext->class_driver_info.fdo_driver, pdev_obj);
usb_unlock_dev(pdev);
return TRUE;
ERROR_OUT:
if (desc_buf)
usb_free_mem(desc_buf);
@ -1870,10 +1711,7 @@ ERROR_OUT:
}
BOOL
umss_if_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
umss_if_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
{
LONG if_idx;
NTSTATUS status;
@ -1919,10 +1757,7 @@ DEV_HANDLE if_handle
}
BOOL
umss_if_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
umss_if_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
{
LONG if_idx;
NTSTATUS status;
@ -1971,9 +1806,7 @@ DEV_HANDLE if_handle
}
VOID
umss_load_class_driver(
PVOID context
)
umss_load_class_driver(PVOID context)
{
NTSTATUS status;
UNICODE_STRING unicode_string;
@ -1981,15 +1814,15 @@ PVOID context
//
// let's load the class driver
//
RtlInitUnicodeString(&unicode_string, L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\usbstor");
RtlInitUnicodeString(&unicode_string,
L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\usbstor");
status = ZwLoadDriver(&unicode_string);
usb_dbg_print( DBGLVL_MAXIMUM, ( "umss_load_class_driver(): try to load class driver, status=0x%x\n", status ) );
usb_dbg_print(DBGLVL_MAXIMUM,
("umss_load_class_driver(): try to load class driver, status=0x%x\n", status));
}
BOOL
umss_if_driver_init(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
umss_if_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
{
PUMSS_DRVR_EXTENSION pdrvr_ext;
UNICODE_STRING unicode_string;
@ -2046,7 +1879,6 @@ PUSB_DRIVER pdriver
//
// let's load the class driver
//
umss_load_class_driver(NULL);
// umss_schedule_workitem( NULL, umss_load_class_driver, NULL, 0 );
@ -2055,18 +1887,14 @@ PUSB_DRIVER pdriver
return TRUE;
}
PCLASS_DRV_REG_INFO
umss_get_if_driver_info(
PUSB_DEV_MANAGER dev_mgr,
PUSB_DEV pdev,
DEV_HANDLE if_handle
)
// get the driver reg information for pnp notification to class
// driver.
// bug??? how if the driver info is returned while the driver
// is being unloaded.
// So the routine must be called when usb_query_and_lock_dev is
// called.
PCLASS_DRV_REG_INFO
umss_get_if_driver_info(PUSB_DEV_MANAGER dev_mgr, PUSB_DEV pdev, DEV_HANDLE if_handle)
{
PUMSS_DRVR_EXTENSION drvr_ext;
ULONG if_idx;
@ -2104,9 +1932,7 @@ DEV_HANDLE if_handle
}
VOID
umss_worker(
IN PVOID reference
)
umss_worker(IN PVOID reference)
{
PUMSS_WORKER_PACKET worker_packet;
PUSB_DEV pdev;
@ -2124,13 +1950,6 @@ IN PVOID reference
usb_dbg_print(DBGLVL_MAXIMUM, ("umss_worker(): exit\n"));
}
BOOL
umss_schedule_workitem(
PVOID context,
UMSS_WORKER_ROUTINE completion,
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
/*++
Routine Description:
@ -2151,7 +1970,9 @@ Return Value:
FALSE if work item not queued
--*/
BOOL
umss_schedule_workitem(PVOID context,
UMSS_WORKER_ROUTINE completion, PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
{
BOOL ret_val = TRUE;
PWORK_QUEUE_ITEM workitem;
@ -2182,17 +2003,10 @@ Return Value:
}
}
// Initialize the work-item
ExInitializeWorkItem(
workitem,
umss_worker,
worker_packet
);
ExInitializeWorkItem(workitem, umss_worker, worker_packet);
// Schedule the work-item
ExQueueWorkItem(
workitem,
DelayedWorkQueue
);
ExQueueWorkItem(workitem, DelayedWorkQueue);
usb_dbg_print(DBGLVL_MINIMUM, ("umss_schedule_workitem(): work-item queued\n"));
}
@ -2206,10 +2020,7 @@ Return Value:
}
NTSTATUS
umss_process_srb(
PDEVICE_OBJECT dev_obj,
PIRP irp
)
umss_process_srb(PDEVICE_OBJECT dev_obj, PIRP irp)
{
NTSTATUS status;
PUSB_DEV pdev;
@ -2242,7 +2053,6 @@ PIRP irp
//
// let's build the srb status for class driver
//
srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
RtlZeroMemory(srb->SenseInfoBuffer, srb->SenseInfoBufferLength);
if (!(srb->SrbFlags & SRB_FLAGS_DISABLE_AUTOSENSE))
@ -2281,7 +2091,8 @@ PIRP irp
}
else
{
if( ( irp->Flags & ( IRP_READ_OPERATION | IRP_WRITE_OPERATION ) ) && !( irp->Flags & IRP_PAGING_IO ) )
if ((irp->Flags & (IRP_READ_OPERATION | IRP_WRITE_OPERATION))
&& !(irp->Flags & IRP_PAGING_IO))
{
//
// since these operations does not allign the buffer on page boundary
@ -2326,8 +2137,8 @@ PIRP irp
{
status = STATUS_DEVICE_PROTOCOL_ERROR;
usb_dbg_print( DBGLVL_MAXIMUM, ( "umss_process_srb(): error converting to sff proto, 0x%x\n",
status ) );
usb_dbg_print(DBGLVL_MAXIMUM,
("umss_process_srb(): error converting to sff proto, 0x%x\n", status));
srb->SrbStatus = SRB_STATUS_ERROR;
break;
}
@ -2338,7 +2149,7 @@ PIRP irp
//
// currently we support only transparent scsi command set
//
if( pdev_ext->pif_desc->bInterfaceSubClass == UMSS_SUBCLASS_SCSI_TCS || \
if (pdev_ext->pif_desc->bInterfaceSubClass == UMSS_SUBCLASS_SCSI_TCS ||
pdev_ext->pif_desc->bInterfaceSubClass == UMSS_SUBCLASS_SFF8070I)
status = umss_bulkonly_startio(pdev_ext, &io_packet);
else
@ -2357,8 +2168,7 @@ PIRP irp
if (status != STATUS_PENDING && status != STATUS_SUCCESS)
{
// error occured
usb_dbg_print( DBGLVL_MAXIMUM, ( "umss_process_srb(): error sending request, 0x%x\n",
status ) );
usb_dbg_print(DBGLVL_MAXIMUM, ("umss_process_srb(): error sending request, 0x%x\n", status));
srb->SrbStatus = SRB_STATUS_ERROR;
}
break;
@ -2390,13 +2200,13 @@ PIRP irp
pdev = NULL;
ERROR_OUT:
irp->IoStatus.Status = status;
if (status != STATUS_PENDING)
{
IoStartNextPacket(dev_obj, FALSE);
IoCompleteRequest(irp, IO_NO_INCREMENT);
}
//
// UMSS_COMPLETE_START_IO( dev_obj, status, irp );
//
@ -2404,9 +2214,7 @@ ERROR_OUT:
}
BOOL
umss_tsc_to_sff(
PIO_PACKET io_packet
)
umss_tsc_to_sff(PIO_PACKET io_packet)
{
if (io_packet == NULL)
return FALSE;
@ -2423,17 +2231,15 @@ PIO_PACKET io_packet
io_packet->data_length = 8;
return TRUE;
}
if( io_packet->cdb[ 0 ] == SCSIOP_REASSIGN_BLOCKS || \
io_packet->cdb[ 0 ] == SCSIOP_RESERVE_UNIT || \
io_packet->cdb[ 0 ] == SCSIOP_RELEASE_UNIT )
if (io_packet->cdb[0] == SCSIOP_REASSIGN_BLOCKS ||
io_packet->cdb[0] == SCSIOP_RESERVE_UNIT || io_packet->cdb[0] == SCSIOP_RELEASE_UNIT)
return FALSE;
return TRUE;
}
VOID
umss_fix_sff_result(
PIO_PACKET io_packet,
SCSI_REQUEST_BLOCK *srb )
umss_fix_sff_result(PIO_PACKET io_packet, SCSI_REQUEST_BLOCK *srb)
{
PBYTE buf;
if (io_packet->cdb[0] != 0x5a)

224
reactos/drivers/usb/nt4compat/usbdriver/usb.c
View file

@ -27,28 +27,14 @@
LONG g_alloc_cnt = 0;
ULONG cpu_clock_freq = 0;
NTSTATUS
usb_get_descriptor(
PUSB_DEV pdev,
PURB purb
);
NTSTATUS usb_get_descriptor(PUSB_DEV pdev, PURB purb);
VOID
usb_set_interface_completion(
PURB purb,
PVOID context
);
VOID usb_set_interface_completion(PURB purb, PVOID context);
NTSTATUS
usb_set_interface(
PURB purb
);
NTSTATUS usb_set_interface(PURB purb);
PVOID
usb_alloc_mem(
POOL_TYPE pool_type,
LONG size
)
usb_alloc_mem(POOL_TYPE pool_type, LONG size)
{
PVOID ret;
g_alloc_cnt++;
@ -58,29 +44,18 @@ LONG size
}
VOID
usb_free_mem(
PVOID pbuf
)
usb_free_mem(PVOID pbuf)
{
g_alloc_cnt--;
usb_dbg_print(DBGLVL_MAXIMUM, ("usb_free_mem(): alloced=0x%x\n", g_alloc_cnt));
ExFreePool(pbuf);
}
VOID
usb_config_dev_completion(
PURB purb,
PVOID context
);
VOID usb_config_dev_completion(PURB purb, PVOID context);
LONG
usb_calc_bus_time(
LONG speed,
LONG input_dir,
LONG is_iso,
LONG byte_count
)
//shamelessly pasted from linux's usb.c
LONG
usb_calc_bus_time(LONG speed, LONG input_dir, LONG is_iso, LONG byte_count)
{
LONG tmp;
@ -134,18 +109,14 @@ LONG byte_count
return 125001;
}
NTSTATUS
usb_query_and_lock_dev(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle,
PUSB_DEV* ppdev
)
//
// if the dev is not in the list, return value is not success and the pointer is nulled
// if the dev is in the list but zomb, return value is error code and the pointer is the dev( no ref_count guarded )
// if the dev is alive and in the list, return is success and the pointer is the dev.
// one must be aware of what his doing before he uses the ppdev
//
NTSTATUS
usb_query_and_lock_dev(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle, PUSB_DEV * ppdev)
{
int i;
PLIST_ENTRY pthis, pnext;
@ -208,9 +179,7 @@ PUSB_DEV* ppdev
}
NTSTATUS
usb_unlock_dev(
PUSB_DEV dev
)
usb_unlock_dev(PUSB_DEV dev)
{
USE_BASIC_NON_PENDING_IRQL;
@ -226,12 +195,10 @@ PUSB_DEV dev
}
NTSTATUS
usb_reset_pipe_ex(
PUSB_DEV_MANAGER dev_mgr,
usb_reset_pipe_ex(PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE endp_handle, //endp handle to reset
PURBCOMPLETION reset_completion, //note: this reset completion has no right to delete the urb, that is only for reference
PVOID param
)
PVOID param)
{
NTSTATUS status;
PUSB_DEV pdev;
@ -269,8 +236,7 @@ PVOID param
}
pendp = &pdev->usb_config->interf[if_idx].endp[endp_idx];
unlock_dev( pdev, FALSE )
status = usb_reset_pipe( pdev, pendp, reset_completion, param );
unlock_dev(pdev, FALSE) status = usb_reset_pipe(pdev, pendp, reset_completion, param);
usb_unlock_dev(pdev);
return status;
@ -281,14 +247,9 @@ LBL_OUT:
return status;
}
NTSTATUS
usb_reset_pipe(
PUSB_DEV pdev,
PUSB_ENDPOINT pendp,
PURBCOMPLETION client_reset_pipe_completion,
PVOID param
)
// caller must guarantee the pdev exist before the routine exit
NTSTATUS
usb_reset_pipe(PUSB_DEV pdev, PUSB_ENDPOINT pendp, PURBCOMPLETION client_reset_pipe_completion, PVOID param)
{
PHCD hcd;
@ -337,10 +298,7 @@ PVOID param
}
VOID
usb_reset_pipe_completion(
PURB purb,
PVOID context
)
usb_reset_pipe_completion(PURB purb, PVOID context)
{
PUSB_DEV pdev;
PUSB_ENDPOINT pendp;
@ -367,7 +325,7 @@ PVOID context
pendp->flags &= ~USB_ENDP_FLAG_STAT_MASK;
//reset toggle endp_type
if( ( pendp->pusb_endp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) == USB_ENDPOINT_XFER_BULK || \
if ((pendp->pusb_endp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK ||
(pendp->pusb_endp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
{
pendp->flags &= ~USB_ENDP_FLAG_DATATOGGLE;
@ -386,12 +344,8 @@ LBL_OUT:
}
void
usb_reset_pipe_from_dispatch_completion(
PURB purb,
PVOID param
)
usb_reset_pipe_from_dispatch_completion(PURB purb, PVOID param)
{
PURB pclient_urb;
if (purb == NULL || param == NULL)
TRAP();
@ -407,11 +361,9 @@ PVOID param
return;
}
//used to check descriptor validity
BOOL
is_header_match(
PBYTE pbuf,
ULONG type
) //used to check descriptor validity
is_header_match(PBYTE pbuf, ULONG type)
{
BOOL ret;
PUSB_DESC_HEADER phdr;
@ -421,26 +373,22 @@ ULONG type
{
case USB_DT_DEVICE:
{
ret = ( phdr->bLength == sizeof( USB_DEVICE_DESC )
&& phdr->bDescriptorType == USB_DT_DEVICE );
ret = (phdr->bLength == sizeof(USB_DEVICE_DESC) && phdr->bDescriptorType == USB_DT_DEVICE);
break;
}
case USB_DT_CONFIG:
{
ret = ( phdr->bLength == sizeof( USB_CONFIGURATION_DESC )
&& phdr->bDescriptorType == USB_DT_CONFIG );
ret = (phdr->bLength == sizeof(USB_CONFIGURATION_DESC) && phdr->bDescriptorType == USB_DT_CONFIG);
break;
}
case USB_DT_INTERFACE:
{
ret = ( phdr->bLength == sizeof( USB_INTERFACE_DESC )
&& phdr->bDescriptorType == USB_DT_INTERFACE );
ret = (phdr->bLength == sizeof(USB_INTERFACE_DESC) && phdr->bDescriptorType == USB_DT_INTERFACE);
break;
}
case USB_DT_ENDPOINT:
{
ret = ( phdr->bLength == sizeof( USB_ENDPOINT_DESC )
&& phdr->bDescriptorType == USB_DT_ENDPOINT );
ret = (phdr->bLength == sizeof(USB_ENDPOINT_DESC) && phdr->bDescriptorType == USB_DT_ENDPOINT);
break;
}
default:
@ -450,10 +398,7 @@ ULONG type
}
BOOL
usb_skip_endp_desc(
PBYTE* pbUF,
LONG n
)
usb_skip_endp_desc(PBYTE * pbUF, LONG n)
{
if (is_header_match(*pbUF, USB_DT_ENDPOINT))
{
@ -464,9 +409,7 @@ LONG n
}
BOOL
usb_skip_if_desc(
PBYTE* pBUF
)
usb_skip_if_desc(PBYTE * pBUF)
{
BOOL ret;
PUSB_INTERFACE_DESC pif_desc = (PUSB_INTERFACE_DESC) * pBUF;
@ -489,9 +432,7 @@ PBYTE* pBUF
}
BOOL
usb_skip_if_and_altif(
PUCHAR* pdesc_BUF
)
usb_skip_if_and_altif(PUCHAR * pdesc_BUF)
{
BOOL ret;
PUSB_INTERFACE_DESC pif_desc1 = (PUSB_INTERFACE_DESC) * pdesc_BUF;
@ -512,10 +453,9 @@ PUCHAR* pdesc_BUF
return ret;
}
BOOL
usb_skip_one_config(
PUCHAR* pconfig_desc_BUF
)
usb_skip_one_config(PUCHAR *pconfig_desc_BUF)
{
LONG if_count, i;
BOOL ret;
@ -549,11 +489,7 @@ PUCHAR* pconfig_desc_BUF
}
PUSB_CONFIGURATION_DESC
usb_find_config_desc_by_idx(
PUCHAR pbuf,
LONG idx,
LONG cfg_count
)
usb_find_config_desc_by_idx(PUCHAR pbuf, LONG idx, LONG cfg_count)
{
LONG i;
BOOL ret;
@ -580,11 +516,7 @@ LONG cfg_count
}
PUSB_CONFIGURATION_DESC
usb_find_config_desc_by_val(
PBYTE pbuf,
LONG val,
LONG cfg_count
)
usb_find_config_desc_by_val(PBYTE pbuf, LONG val, LONG cfg_count)
{
LONG i;
BOOL ret;
@ -611,9 +543,7 @@ LONG cfg_count
#define if_from_handle( handle ) ( ( handle & 0xff00 ) >> 8 )
NTSTATUS
usb_submit_config_urb(
PURB purb
)
usb_submit_config_urb(PURB purb)
{
PUSB_DEV pdev;
PUSB_DEV_MANAGER dev_mgr;
@ -642,8 +572,7 @@ PURB purb
goto LBL_OUT;
}
if( dev_state( pdev ) == USB_DEV_STATE_FIRST_CONFIG
|| dev_state( pdev ) == USB_DEV_STATE_RECONFIG )
if (dev_state(pdev) == USB_DEV_STATE_FIRST_CONFIG || dev_state(pdev) == USB_DEV_STATE_RECONFIG)
{
//outstanding request of set configuration exists in process
status = STATUS_UNSUCCESSFUL;
@ -678,10 +607,7 @@ PURB purb
UsbBuildSelectConfigurationRequest(purb1,
usb_make_handle(pdev->dev_id, 0, 0) | 0xffff,
psetup->wValue,
usb_config_dev_completion,
0,
( ( ULONG )purb ) );
psetup->wValue, usb_config_dev_completion, 0, ((ULONG) purb));
purb1->pdev = pdev;
purb1->pendp = pendp;
@ -706,10 +632,7 @@ PURB purb
NTSTATUS
usb_submit_urb(
PUSB_DEV_MANAGER dev_mgr,
PURB purb
)
usb_submit_urb(PUSB_DEV_MANAGER dev_mgr, PURB purb)
{
NTSTATUS status;
PUSB_DEV pdev;
@ -786,26 +709,22 @@ PURB purb
if (default_endp_handle(endp_handle))
{
psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet;
if( psetup->bmRequestType == 0
&& psetup->bRequest == USB_REQ_SET_CONFIGURATION )
if (psetup->bmRequestType == 0 && psetup->bRequest == USB_REQ_SET_CONFIGURATION)
{
unlock_dev(pdev, FALSE);
status = usb_submit_config_urb(purb);
goto LBL_OUT;
}
else if( psetup->bmRequestType == 1
&& psetup->bRequest == USB_REQ_SET_INTERFACE )
else if (psetup->bmRequestType == 1 && psetup->bRequest == USB_REQ_SET_INTERFACE)
{
unlock_dev(pdev, FALSE);
// status = STATUS_NOT_SUPPORTED;
status = usb_set_interface(purb);
goto LBL_OUT;
}
else if( psetup->bmRequestType == 0x80
&& psetup->bRequest == USB_REQ_GET_DESCRIPTOR )
else if (psetup->bmRequestType == 0x80 && psetup->bRequest == USB_REQ_GET_DESCRIPTOR)
{
if( ( psetup->wValue >> 8 ) == USB_DT_CONFIG
|| ( psetup->wValue >> 8 ) == USB_DT_DEVICE )
if ((psetup->wValue >> 8) == USB_DT_CONFIG || (psetup->wValue >> 8) == USB_DT_DEVICE)
{
unlock_dev(pdev, FALSE);
status = usb_get_descriptor(pdev, purb);
@ -816,9 +735,7 @@ PURB purb
//goto LBL_OUT;
}
}
else if( psetup->bmRequestType == 0x02
&& psetup->bRequest == USB_REQ_CLEAR_FEATURE
&& psetup->wValue == 0 ) //reset pipe
else if (psetup->bmRequestType == 0x02 && psetup->bRequest == USB_REQ_CLEAR_FEATURE && psetup->wValue == 0) //reset pipe
{
ULONG endp_addr;
BOOL found;
@ -855,11 +772,7 @@ PURB purb
goto LBL_OUT;
}
unlock_dev(pdev, FALSE);
status = usb_reset_pipe_ex(
dev_mgr,
endp_handle,
usb_reset_pipe_from_dispatch_completion,
purb );
status = usb_reset_pipe_ex(dev_mgr, endp_handle, usb_reset_pipe_from_dispatch_completion, purb);
goto LBL_OUT;
}
@ -875,10 +788,7 @@ PURB purb
void
usb_config_dev_completion(
PURB purb,
PVOID context
)
usb_config_dev_completion(PURB purb, PVOID context)
{
PURB puser_urb;
PUSB_DEV pdev;
@ -936,8 +846,7 @@ PVOID context
config_val = psetup->wValue;
status = dev_mgr_build_usb_config(pdev,
&pdev->desc_buf[sizeof(USB_DEVICE_DESC)],
config_val,
pdev->pusb_dev_desc->bNumConfigurations );
config_val, pdev->pusb_dev_desc->bNumConfigurations);
if (status != STATUS_SUCCESS)
{
pdev->flags &= ~USB_DEV_STATE_MASK;
@ -947,8 +856,7 @@ PVOID context
pdev->flags &= ~USB_DEV_STATE_MASK;
pdev->flags |= USB_DEV_STATE_CONFIGURED;
//this usb dev represents physical dev
if( pdev->pusb_dev_desc->bDeviceClass == USB_CLASS_HUB
&& pdev->pusb_dev_desc->bDeviceSubClass == 0 )
if (pdev->pusb_dev_desc->bDeviceClass == USB_CLASS_HUB && pdev->pusb_dev_desc->bDeviceSubClass == 0)
{
pdev->flags &= ~USB_DEV_CLASS_MASK;
pdev->flags |= USB_DEV_CLASS_HUB;
@ -972,6 +880,7 @@ PVOID context
pdev->flags &= ~USB_DEV_STATE_MASK;
pdev->flags |= USB_DEV_STATE_CONFIGURED;
}
LBL_OUT:
unlock_dev(pdev, TRUE);
usb_free_mem(purb);
@ -982,10 +891,7 @@ PVOID context
}
NTSTATUS
usb_get_descriptor(
PUSB_DEV pdev,
PURB purb
)
usb_get_descriptor(PUSB_DEV pdev, PURB purb)
{
PUSB_CTRL_SETUP_PACKET psetup;
LONG idx, size, count, i;
@ -1041,9 +947,7 @@ PURB purb
}
else if ((psetup->wValue >> 8) == USB_DT_DEVICE)
{
size = purb->data_length > sizeof( USB_DEVICE_DESC )
? sizeof( USB_DEVICE_DESC )
: purb->data_length;
size = purb->data_length > sizeof(USB_DEVICE_DESC) ? sizeof(USB_DEVICE_DESC) : purb->data_length;
for(i = 0; i < size; i++)
{
@ -1051,12 +955,14 @@ PURB purb
}
purb->status = STATUS_SUCCESS;
}
LBL_OUT:
unlock_dev(pdev, FALSE);
return purb->status;
}
LONG usb_count_list( PLIST_HEAD list_head )
LONG
usb_count_list(PLIST_HEAD list_head)
{
LONG count;
PLIST_ENTRY pthis, pnext;
@ -1078,9 +984,7 @@ LONG usb_count_list( PLIST_HEAD list_head )
// checks if processor supports Time Stamp Counter
__inline BOOL
usb_query_clicks(
PLARGE_INTEGER clicks
)
usb_query_clicks(PLARGE_INTEGER clicks)
{
BOOL ret_val;
//so we have to use intel's cpu???
@ -1112,9 +1016,7 @@ LBL_OUT:
}
VOID
usb_wait_ms_dpc(
ULONG ms
)
usb_wait_ms_dpc(ULONG ms)
{
LARGE_INTEGER start;
LARGE_INTEGER ticker;
@ -1154,9 +1056,7 @@ ULONG ms
VOID
usb_wait_us_dpc(
ULONG us
)
usb_wait_us_dpc(ULONG us)
{
LARGE_INTEGER start;
LARGE_INTEGER ticker;
@ -1219,9 +1119,7 @@ usb_cal_cpu_freq()
}
NTSTATUS
usb_set_interface(
PURB purb
)
usb_set_interface(PURB purb)
{
ULONG u;
PURB purb1;
@ -1354,10 +1252,7 @@ LBL_SEND_URB:
}
VOID
usb_set_interface_completion(
PURB purb,
PVOID context
)
usb_set_interface_completion(PURB purb, PVOID context)
{
PUSB_CTRL_SETUP_PACKET psetup;
PUSB_INTERFACE pif, palt_if;
@ -1445,13 +1340,11 @@ PVOID context
usb_complete_and_free_ctrl_urb(purb);
}
VOID
usb_call_ctrl_completion(
PURB purb
)
// can only be called when current completion finished and called only in
// urb completion. And this func may be called recursively, if this routine
// is called, the urb must be treated as released.
VOID
usb_call_ctrl_completion(PURB purb)
{
PURB parent_urb;
PCTRL_REQ_STACK pstack;
@ -1520,4 +1413,3 @@ PURB purb
else
return;
}