Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-02 15:16:35 +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 ) \ #define OLYMPUS_CSW( pdev_EXT, staTUS ) \
( ( ( pdev_EXT )->flags & UMSS_DEV_FLAG_OLYMPUS_DEV ) ? ( ( staTUS ) == CSW_OLYMPUS_SIGNATURE ) : FALSE ) ( ( ( pdev_EXT )->flags & UMSS_DEV_FLAG_OLYMPUS_DEV ) ? ( ( staTUS ) == CSW_OLYMPUS_SIGNATURE ) : FALSE )
BOOL BOOL umss_clear_pass_through_length(PIO_PACKET io_packet);
umss_clear_pass_through_length(
PIO_PACKET io_packet
);
NTSTATUS NTSTATUS umss_bulkonly_send_sense_req(PUMSS_DEVICE_EXTENSION pdev_ext);
umss_bulkonly_send_sense_req(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID VOID umss_bulkonly_send_cbw_completion(IN PURB purb, IN PVOID context);
umss_bulkonly_send_cbw_completion(
IN PURB purb,
IN PVOID context
);
VOID VOID umss_bulkonly_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext);
umss_bulkonly_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID VOID umss_sync_submit_urb_completion(PURB purb, PVOID context);
umss_sync_submit_urb_completion(
PURB purb,
PVOID context
);
NTSTATUS NTSTATUS umss_sync_submit_urb(PUMSS_DEVICE_EXTENSION pdev_ext, PURB purb);
umss_sync_submit_urb(
PUMSS_DEVICE_EXTENSION pdev_ext,
PURB purb
);
VOID VOID umss_bulkonly_get_status(PUMSS_DEVICE_EXTENSION pdev_ext);
umss_bulkonly_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID VOID umss_bulkonly_transfer_data_complete(PURB purb, PVOID reference);
umss_bulkonly_transfer_data_complete(
PURB purb,
PVOID reference
);
VOID VOID umss_bulkonly_reset_pipe_and_get_status(IN PVOID reference);
umss_bulkonly_reset_pipe_and_get_status(
IN PVOID reference
);
VOID VOID umss_bulkonly_reset_recovery(IN PVOID reference);
umss_bulkonly_reset_recovery(
IN PVOID reference
);
VOID VOID umss_bulkonly_get_status_complete(IN PURB purb, IN PVOID context);
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: Routine Description:
@ -111,7 +68,8 @@ Return Value:
NONE NONE
--*/ --*/
NTSTATUS
umss_bulkonly_startio(IN PUMSS_DEVICE_EXTENSION pdev_ext, IN PIO_PACKET io_packet)
{ {
PCOMMAND_BLOCK_WRAPPER cbw; PCOMMAND_BLOCK_WRAPPER cbw;
NTSTATUS status; NTSTATUS status;
@ -135,26 +93,17 @@ Return Value:
RtlZeroMemory(&pdev_ext->csw, sizeof(pdev_ext->csw)); RtlZeroMemory(&pdev_ext->csw, sizeof(pdev_ext->csw));
// Send the command block wrapper to the device. // Send the command block wrapper to the device.
// Calls UMSS_BulkOnlySendCBWComplete when transfer completes. // Calls UMSS_BulkOnlySendCBWComplete when transfer completes.
status = umss_bulk_transfer( status = umss_bulk_transfer(pdev_ext,
pdev_ext,
USB_DIR_OUT, USB_DIR_OUT,
cbw, cbw, sizeof(COMMAND_BLOCK_WRAPPER), umss_bulkonly_send_cbw_completion);
sizeof( COMMAND_BLOCK_WRAPPER ),
umss_bulkonly_send_cbw_completion
);
return status; return status;
} }
NTSTATUS NTSTATUS
umss_bulk_transfer( umss_bulk_transfer(IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN PUMSS_DEVICE_EXTENSION pdev_ext, IN UCHAR trans_dir, IN PVOID buf, IN ULONG buf_length, IN PURBCOMPLETION completion)
IN UCHAR trans_dir,
IN PVOID buf,
IN ULONG buf_length,
IN PURBCOMPLETION completion
)
{ {
PURB purb; PURB purb;
NTSTATUS status; 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); endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx);
} }
UsbBuildInterruptOrBulkTransferRequest( purb, UsbBuildInterruptOrBulkTransferRequest(purb, endp_handle, buf, buf_length, completion, pdev_ext, 0);
endp_handle,
buf,
buf_length,
completion,
pdev_ext,
0 );
dev_mgr_register_irp(pdev_ext->dev_mgr, pdev_ext->io_packet.pirp, purb); dev_mgr_register_irp(pdev_ext->dev_mgr, pdev_ext->io_packet.pirp, purb);
status = usb_submit_urb(pdev_ext->dev_mgr, purb); status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status == STATUS_PENDING) if (status == STATUS_PENDING)
@ -204,10 +147,7 @@ IN PURBCOMPLETION completion
} }
VOID VOID
umss_bulkonly_send_cbw_completion( umss_bulkonly_send_cbw_completion(IN PURB purb, IN PVOID context)
IN PURB purb,
IN PVOID context
)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -229,7 +169,8 @@ IN PVOID context
if (usb_halted(status)) if (usb_halted(status))
{ {
//Schedule a work-item to do a reset recovery //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); umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
} }
@ -253,12 +194,9 @@ IN PVOID context
return; return;
} }
NTSTATUS
umss_sync_submit_urb(
PUMSS_DEVICE_EXTENSION pdev_ext,
PURB purb
)
//can only be called at passive level //can only be called at passive level
NTSTATUS
umss_sync_submit_urb(PUMSS_DEVICE_EXTENSION pdev_ext, PURB purb)
{ {
NTSTATUS status; NTSTATUS status;
@ -272,12 +210,7 @@ PURB purb
status = usb_submit_urb(pdev_ext->dev_mgr, purb); status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status == STATUS_PENDING) if (status == STATUS_PENDING)
{ {
KeWaitForSingleObject( KeWaitForSingleObject(&pdev_ext->sync_event, Executive, KernelMode, TRUE, NULL);
&pdev_ext->sync_event,
Executive,
KernelMode,
TRUE,
NULL );
status = purb->status; status = purb->status;
} }
else else
@ -287,10 +220,7 @@ PURB purb
} }
VOID VOID
umss_sync_submit_urb_completion( umss_sync_submit_urb_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -303,10 +233,6 @@ PVOID context
return; return;
} }
VOID
umss_bulkonly_reset_recovery(
IN PVOID reference
)
/*++ /*++
Routine Description: Routine Description:
@ -321,7 +247,8 @@ Return Value:
NONE NONE
--*/ --*/
VOID
umss_bulkonly_reset_recovery(IN PVOID reference)
{ {
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
URB urb; URB urb;
@ -338,9 +265,7 @@ Return Value:
// Build the mass storage reset command // Build the mass storage reset command
UsbBuildVendorRequest( UsbBuildVendorRequest(&urb, pdev_ext->dev_handle | 0xffff, //default pipe
&urb,
pdev_ext->dev_handle | 0xffff, //default pipe
NULL, //no extra data NULL, //no extra data
0, //no size 0, //no size
0x21, //class, interface 0x21, //class, interface
@ -362,36 +287,27 @@ Return Value:
{ {
//Reset Bulk-in endpoint //Reset Bulk-in endpoint
endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx); endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->in_endp_idx);
status = umss_reset_pipe( status = umss_reset_pipe(pdev_ext, endp_handle);
pdev_ext,
endp_handle
);
if (!NT_SUCCESS(status)) 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 //Reset Bulk-out endpoint
endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->out_endp_idx); endp_handle = usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx, pdev_ext->out_endp_idx);
status = umss_reset_pipe( status = umss_reset_pipe(pdev_ext, endp_handle);
pdev_ext,
endp_handle
);
if (!NT_SUCCESS(status)) 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); umss_complete_request(pdev_ext, status);
} }
VOID
umss_bulkonly_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
)
/*++ /*++
Routine Description: Routine Description:
@ -406,7 +322,8 @@ Return Value:
NONE NONE
--*/ --*/
VOID
umss_bulkonly_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext)
{ {
PVOID data_buf; PVOID data_buf;
ULONG data_buf_length; 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) else if ((pdev_ext->io_packet.flags & IOP_FLAG_STAGE_MASK) == IOP_FLAG_STAGE_SENSE)
trans_dir = USB_DIR_IN; trans_dir = USB_DIR_IN;
if( ( status = umss_bulk_transfer( if ((status = umss_bulk_transfer(pdev_ext,
pdev_ext,
trans_dir, trans_dir,
data_buf, data_buf,
data_buf_length, data_buf_length,
umss_bulkonly_transfer_data_complete ) umss_bulkonly_transfer_data_complete)) != STATUS_PENDING)
) != STATUS_PENDING )
{ {
umss_complete_request(pdev_ext, status); umss_complete_request(pdev_ext, status);
} }
@ -451,17 +366,12 @@ Return Value:
return; return;
} }
VOID
umss_bulkonly_transfer_data_complete(
PURB purb,
PVOID reference
)
/*++ /*++
Routine Description: Routine Description:
Completion handler for bulk data transfer requests. Completion handler for bulk data transfer requests.
--*/ --*/
VOID
umss_bulkonly_transfer_data_complete(PURB purb, PVOID reference)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -488,10 +398,13 @@ Routine Description:
buf[1] = (ULONG) purb->endp_handle; buf[1] = (ULONG) purb->endp_handle;
usb_dbg_print(DBGLVL_MINIMUM, ("umss_transfer_data_complete(): transfer data error!\n")); 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_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(); TRAP();
umss_complete_request(pdev_ext, status); umss_complete_request(pdev_ext, status);
} }
@ -518,9 +431,7 @@ Routine Description:
VOID VOID
umss_bulkonly_reset_pipe_and_get_status( umss_bulkonly_reset_pipe_and_get_status(IN PVOID reference)
IN PVOID reference
)
{ {
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
DEV_HANDLE endp_handle; DEV_HANDLE endp_handle;
@ -541,36 +452,26 @@ IN PVOID reference
return; return;
} }
// Data phase is finished since the endpoint stalled, so go to status phase // 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); umss_bulkonly_get_status(pdev_ext);
} }
VOID VOID
umss_bulkonly_get_status( umss_bulkonly_get_status(PUMSS_DEVICE_EXTENSION pdev_ext)
PUMSS_DEVICE_EXTENSION pdev_ext
)
{ {
NTSTATUS status; NTSTATUS status;
// Schedule bulk transfer to get command status wrapper from device // Schedule bulk transfer to get command status wrapper from device
status = umss_bulk_transfer( status = umss_bulk_transfer(pdev_ext,
pdev_ext,
USB_DIR_IN, USB_DIR_IN,
&(pdev_ext->csw), &(pdev_ext->csw),
sizeof( COMMAND_STATUS_WRAPPER ), sizeof(COMMAND_STATUS_WRAPPER), umss_bulkonly_get_status_complete);
umss_bulkonly_get_status_complete
);
if (status != STATUS_PENDING) if (status != STATUS_PENDING)
{ {
umss_complete_request(pdev_ext, status); umss_complete_request(pdev_ext, status);
} }
} }
VOID
umss_bulkonly_get_status_complete(
IN PURB purb,
IN PVOID context
)
/*++ /*++
Routine Description: Routine Description:
@ -587,7 +488,8 @@ Return Value:
Driver-originated IRPs always return STATUS_MORE_PROCESSING_REQUIRED. Driver-originated IRPs always return STATUS_MORE_PROCESSING_REQUIRED.
--*/ --*/
VOID
umss_bulkonly_get_status_complete(IN PURB purb, IN PVOID context)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -607,10 +509,8 @@ Return Value:
// Received valid CSW with good status // Received valid CSW with good status
if ((pdev_ext->io_packet.flags & IOP_FLAG_STAGE_MASK) == IOP_FLAG_STAGE_NORMAL && 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.flags & IOP_FLAG_REQ_SENSE) && pdev_ext->io_packet.sense_data != NULL)
pdev_ext->io_packet.sense_data != NULL )
UMSS_FORGE_GOOD_SENSE(pdev_ext->io_packet.sense_data) UMSS_FORGE_GOOD_SENSE(pdev_ext->io_packet.sense_data)
umss_complete_request(pdev_ext, STATUS_SUCCESS); umss_complete_request(pdev_ext, STATUS_SUCCESS);
} }
else if (csw->bCSWStatus == CSW_STATUS_FAILED) else if (csw->bCSWStatus == CSW_STATUS_FAILED)
@ -632,7 +532,8 @@ Return Value:
else else
{ {
// error occurred, reset device // 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); umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
} }
@ -641,7 +542,8 @@ Return Value:
else else
{ {
// error occurred, reset device // 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); umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
} }
@ -657,10 +559,12 @@ Return Value:
buf[0] = (ULONG) pdev_ext; buf[0] = (ULONG) pdev_ext;
buf[1] = (ULONG) purb->endp_handle; 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_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(); TRAP();
umss_complete_request(pdev_ext, status); umss_complete_request(pdev_ext, status);
} }
@ -668,9 +572,11 @@ Return Value:
else if (status != STATUS_CANCELLED) else if (status != STATUS_CANCELLED)
{ {
// An error has occured. Reset the device. // 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(); TRAP();
umss_complete_request(pdev_ext, status); umss_complete_request(pdev_ext, status);
} }
@ -688,11 +594,6 @@ Return Value:
return; return;
} }
CHAR
umss_bulkonly_get_maxlun(
IN PUMSS_DEVICE_EXTENSION pdev_ext
)
/*++ /*++
Routine Description: Routine Description:
@ -707,7 +608,8 @@ Return Value:
Maximum LUN number for device, or 0 if error occurred. Maximum LUN number for device, or 0 if error occurred.
--*/ --*/
CHAR
umss_bulkonly_get_maxlun(IN PUMSS_DEVICE_EXTENSION pdev_ext)
{ {
PURB purb = NULL; PURB purb = NULL;
CHAR max_lun; CHAR max_lun;
@ -717,31 +619,23 @@ Return Value:
if (!purb) 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; max_lun = 0;
} }
else else
{ {
// Build the get max lun command // Build the get max lun command
UsbBuildVendorRequest( UsbBuildVendorRequest(purb, (pdev_ext->dev_handle | 0xffff), &max_lun, sizeof(max_lun), 0xb1, //class, interface, in
purb, BULK_ONLY_GET_MAX_LUN, 0, pdev_ext->pif_desc->bInterfaceNumber, NULL, NULL, 0);
( 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 // Send get max lun command to device
status = umss_sync_submit_urb(pdev_ext, purb); status = umss_sync_submit_urb(pdev_ext, purb);
if (status != STATUS_PENDING) 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; max_lun = 0;
} }
} }
@ -755,10 +649,7 @@ Return Value:
} }
PVOID PVOID
umss_get_buffer( umss_get_buffer(PUMSS_DEVICE_EXTENSION pdev_ext, ULONG * buf_length)
PUMSS_DEVICE_EXTENSION pdev_ext,
ULONG* buf_length
)
{ {
PVOID buffer; PVOID buffer;
@ -777,10 +668,7 @@ ULONG* buf_length
} }
BOOL BOOL
umss_bulkonly_build_sense_cdb( umss_bulkonly_build_sense_cdb(PUMSS_DEVICE_EXTENSION pdev_ext, PCOMMAND_BLOCK_WRAPPER cbw)
PUMSS_DEVICE_EXTENSION pdev_ext,
PCOMMAND_BLOCK_WRAPPER cbw
)
{ {
UCHAR sub_class; UCHAR sub_class;
PUCHAR cdb; PUCHAR cdb;
@ -817,14 +705,13 @@ PCOMMAND_BLOCK_WRAPPER cbw
} }
NTSTATUS NTSTATUS
umss_bulkonly_send_sense_req( umss_bulkonly_send_sense_req(PUMSS_DEVICE_EXTENSION pdev_ext)
PUMSS_DEVICE_EXTENSION pdev_ext
)
{ {
PCOMMAND_BLOCK_WRAPPER cbw; PCOMMAND_BLOCK_WRAPPER cbw;
NTSTATUS status; 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; return STATUS_INVALID_PARAMETER;
pdev_ext->retry = TRUE; pdev_ext->retry = TRUE;
@ -847,13 +734,9 @@ PUMSS_DEVICE_EXTENSION pdev_ext
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
status = umss_bulk_transfer( status = umss_bulk_transfer(pdev_ext,
pdev_ext,
USB_DIR_OUT, USB_DIR_OUT,
cbw, cbw, sizeof(COMMAND_BLOCK_WRAPPER), umss_bulkonly_send_cbw_completion);
sizeof( COMMAND_BLOCK_WRAPPER ),
umss_bulkonly_send_cbw_completion
);
if (status != STATUS_PENDING) if (status != STATUS_PENDING)
{ {
@ -864,9 +747,7 @@ PUMSS_DEVICE_EXTENSION pdev_ext
} }
BOOL BOOL
umss_clear_pass_through_length( umss_clear_pass_through_length(PIO_PACKET io_packet)
PIO_PACKET io_packet
)
{ {
// //
// clear the respective data length to meet request of scsi pass through requirement. // 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 "debug.h"
#include "umss.h" #include "umss.h"
VOID VOID umss_cbi_send_adsc_complete(PURB purb, PVOID context);
umss_cbi_send_adsc_complete(
PURB purb,
PVOID context
);
VOID VOID umss_cbi_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext);
umss_cbi_transfer_data(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID VOID umss_cbi_get_status(PUMSS_DEVICE_EXTENSION pdev_ext);
umss_cbi_get_status(
PUMSS_DEVICE_EXTENSION pdev_ext
);
VOID VOID umss_cbi_transfer_data_complete(PURB purb, PVOID context);
umss_cbi_transfer_data_complete(
PURB purb,
PVOID context
);
VOID VOID umss_cbi_get_status_complete(PURB purb, PVOID context);
umss_cbi_get_status_complete(
PURB purb,
PVOID context
);
NTSTATUS NTSTATUS
umss_class_specific_request( umss_class_specific_request(IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN UCHAR request, IN UCHAR request,
IN UCHAR dir, IN UCHAR dir,
IN PVOID buffer, IN PVOID buffer,
IN ULONG buffer_length, IN ULONG buffer_length,
IN PURBCOMPLETION completion IN PURBCOMPLETION completion)
)
{ {
PURB purb; PURB purb;
NTSTATUS status; NTSTATUS status;
purb = usb_alloc_mem(NonPagedPool, sizeof(URB)); purb = usb_alloc_mem(NonPagedPool, sizeof(URB));
// Build URB for the ADSC command // Build URB for the ADSC command
UsbBuildVendorRequest( UsbBuildVendorRequest(purb,
purb,
pdev_ext->dev_handle | 0xffff, pdev_ext->dev_handle | 0xffff,
buffer, buffer,
buffer_length, buffer_length,
0x21, 0x21, request, 0, pdev_ext->pif_desc->bInterfaceNumber, completion, pdev_ext, 0);
request,
0,
pdev_ext->pif_desc->bInterfaceNumber,
completion,
pdev_ext,
0 );
status = usb_submit_urb(pdev_ext->dev_mgr, purb); status = usb_submit_urb(pdev_ext->dev_mgr, purb);
if (status != STATUS_PENDING) if (status != STATUS_PENDING)
@ -91,10 +64,7 @@ IN PURBCOMPLETION completion
} }
NTSTATUS NTSTATUS
umss_cbi_startio( umss_cbi_startio(IN PUMSS_DEVICE_EXTENSION pdev_ext, IN PIO_PACKET io_packet)
IN PUMSS_DEVICE_EXTENSION pdev_ext,
IN PIO_PACKET io_packet
)
{ {
NTSTATUS status; NTSTATUS status;
@ -105,14 +75,10 @@ IN PIO_PACKET io_packet
// Send the ADSC request to the device // Send the ADSC request to the device
// Calls UMSS_CbiSendADSCComplete when transfer completes // Calls UMSS_CbiSendADSCComplete when transfer completes
status = umss_class_specific_request( status = umss_class_specific_request(pdev_ext,
pdev_ext,
ACCEPT_DEVICE_SPECIFIC_COMMAND, ACCEPT_DEVICE_SPECIFIC_COMMAND,
USB_DIR_OUT, USB_DIR_OUT,
io_packet->cdb, io_packet->cdb, io_packet->cdb_length, umss_cbi_send_adsc_complete);
io_packet->cdb_length,
umss_cbi_send_adsc_complete
);
return status; return status;
} }
@ -120,10 +86,7 @@ IN PIO_PACKET io_packet
VOID VOID
umss_cbi_send_adsc_complete( umss_cbi_send_adsc_complete(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
NTSTATUS status; NTSTATUS status;
PIO_STACK_LOCATION irpStack; PIO_STACK_LOCATION irpStack;
@ -173,21 +136,16 @@ PVOID context
VOID VOID
umss_cbi_reset_pipe( umss_cbi_reset_pipe(IN PVOID reference)
IN PVOID reference
)
{ {
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
pdev_ext = (PUMSS_DEVICE_EXTENSION) reference; pdev_ext = (PUMSS_DEVICE_EXTENSION) reference;
// Reset the appropriate pipe, based on data direction // Reset the appropriate pipe, based on data direction
umss_reset_pipe( umss_reset_pipe(pdev_ext,
pdev_ext,
(pdev_ext->io_packet.flags & USB_DIR_IN) ? (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->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. // Device stalled endpoint, so complete I/O operation with error.
// BUGBUG is this correct? Check spec... // BUGBUG is this correct? Check spec...
@ -195,9 +153,7 @@ IN PVOID reference
} }
VOID VOID
umss_cbi_transfer_data( umss_cbi_transfer_data(PUMSS_DEVICE_EXTENSION pdev_ext)
PUMSS_DEVICE_EXTENSION pdev_ext
)
{ {
PVOID buffer; PVOID buffer;
ULONG buffer_length; ULONG buffer_length;
@ -222,22 +178,15 @@ PUMSS_DEVICE_EXTENSION pdev_ext
else else
{ {
// Transfer next element of the data phase // Transfer next element of the data phase
umss_bulk_transfer( umss_bulk_transfer(pdev_ext,
pdev_ext,
(UCHAR) ((pdev_ext->io_packet.flags & USB_DIR_IN) ? USB_DIR_IN : USB_DIR_OUT), (UCHAR) ((pdev_ext->io_packet.flags & USB_DIR_IN) ? USB_DIR_IN : USB_DIR_OUT),
buffer, buffer, buffer_length, umss_cbi_transfer_data_complete);
buffer_length,
umss_cbi_transfer_data_complete
);
} }
} }
VOID VOID
umss_cbi_transfer_data_complete( umss_cbi_transfer_data_complete(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -256,9 +205,11 @@ PVOID context
{ {
// Reset pipe can only be done at passive level, so we need // Reset pipe can only be done at passive level, so we need
// to schedule a work item to do it. // 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(); TRAP();
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR); umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
} }
@ -277,9 +228,7 @@ PVOID context
VOID VOID
umss_cbi_get_status( umss_cbi_get_status(PUMSS_DEVICE_EXTENSION pdev_ext)
PUMSS_DEVICE_EXTENSION pdev_ext
)
{ {
PURB purb; PURB purb;
NTSTATUS status; NTSTATUS status;
@ -289,15 +238,11 @@ PUMSS_DEVICE_EXTENSION pdev_ext
return; return;
// Build a URB for our interrupt transfer // Build a URB for our interrupt transfer
UsbBuildInterruptOrBulkTransferRequest( UsbBuildInterruptOrBulkTransferRequest(purb,
purb, usb_make_handle((pdev_ext->dev_handle >> 16), pdev_ext->if_idx,
usb_make_handle( ( pdev_ext->dev_handle >> 16 ), pdev_ext->if_idx, pdev_ext->int_endp_idx ), pdev_ext->int_endp_idx), (PUCHAR) & pdev_ext->idb,
( PUCHAR )&pdev_ext->idb, sizeof(INTERRUPT_DATA_BLOCK), umss_cbi_get_status_complete,
sizeof( INTERRUPT_DATA_BLOCK ), pdev_ext, 0);
umss_cbi_get_status_complete,
pdev_ext,
0
);
// Call USB driver stack // Call USB driver stack
status = usb_submit_urb(pdev_ext->dev_mgr, purb); status = usb_submit_urb(pdev_ext->dev_mgr, purb);
@ -313,10 +258,7 @@ PUMSS_DEVICE_EXTENSION pdev_ext
VOID VOID
umss_cbi_get_status_complete( umss_cbi_get_status_complete(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -336,9 +278,11 @@ PVOID context
// Check if we need to clear stalled pipe // Check if we need to clear stalled pipe
if (usb_halted(status)) 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(); TRAP();
umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR); umss_complete_request(pdev_ext, STATUS_IO_DEVICE_ERROR);
return; return;

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

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

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

@ -26,10 +26,7 @@
#include "hub.h" #include "hub.h"
VOID VOID
disp_urb_completion( disp_urb_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
PUSB_DEV_MANAGER dev_mgr; PUSB_DEV_MANAGER dev_mgr;
@ -90,10 +87,7 @@ PVOID context
} }
VOID VOID
disp_noio_urb_completion( disp_noio_urb_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
PURB purb2; PURB purb2;
@ -107,12 +101,16 @@ PVOID context
psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet; psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet;
if( psetup->bmRequestType == 0x2 if ((psetup->bmRequestType == 0x2) &&
&& psetup->bRequest == USB_REQ_CLEAR_FEATURE (psetup->bRequest == USB_REQ_CLEAR_FEATURE) &&
&& psetup->wIndex == 0 ) //reset pipe (psetup->wIndex == 0)) //reset pipe
{
purb2 = (PURB) context; purb2 = (PURB) context;
}
else else
{
purb2 = purb; purb2 = purb;
}
if (purb2->pirp == NULL) if (purb2->pirp == NULL)
return; return;
@ -139,13 +137,10 @@ PVOID context
return; return;
} }
NTSTATUS
dev_mgr_dispatch(
IN PUSB_DEV_MANAGER dev_mgr,
IN PIRP irp
)
//this function is called by the hcd's //this function is called by the hcd's
//dispatch when they have done their job. //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; PIO_STACK_LOCATION irp_stack;
NTSTATUS status; NTSTATUS status;
@ -262,7 +257,8 @@ IN PIRP irp
peda->dev_count = dev_count ? j : 0; peda->dev_count = dev_count ? j : 0;
KeReleaseSpinLock(&dev_mgr->dev_list_lock, old_irql); 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); EXIT_DISPATCH(STATUS_SUCCESS, irp);
} }
case IOCTL_GET_DEV_DESC: case IOCTL_GET_DEV_DESC:
@ -304,7 +300,7 @@ IN PIRP irp
status = STATUS_INVALID_DEVICE_STATE; status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT; 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) dev_state(pdev) != USB_DEV_STATE_CONFIGURED)
{ {
status = STATUS_DEVICE_NOT_READY; status = STATUS_DEVICE_NOT_READY;
@ -319,15 +315,13 @@ IN PIRP irp
if (gddr.desc_type == USB_DT_DEVICE) if (gddr.desc_type == USB_DT_DEVICE)
{ {
RtlCopyMemory( RtlCopyMemory(pusb_desc_header,
pusb_desc_header,
pdev->pusb_dev_desc, pdev->pusb_dev_desc,
buf_size > sizeof(USB_DEVICE_DESC) buf_size > sizeof(USB_DEVICE_DESC)
? sizeof(USB_DEVICE_DESC) : buf_size); ? sizeof(USB_DEVICE_DESC) : buf_size);
irp->IoStatus.Information = irp->IoStatus.Information =
buf_size >= sizeof( USB_DEVICE_DESC ) buf_size >= sizeof(USB_DEVICE_DESC) ? sizeof(USB_DEVICE_DESC) : buf_size;
? sizeof( USB_DEVICE_DESC ): buf_size ;
} }
else if (gddr.desc_type == USB_DT_CONFIG) else if (gddr.desc_type == USB_DT_CONFIG)
{ {
@ -338,10 +332,10 @@ IN PIRP irp
goto ERROR_OUT; goto ERROR_OUT;
} }
pusb_config_desc = usb_find_config_desc_by_idx( pusb_config_desc = usb_find_config_desc_by_idx((PUCHAR) & pdev->pusb_dev_desc[1],
( PUCHAR )&pdev->pusb_dev_desc[ 1 ],
gddr.desc_idx, gddr.desc_idx,
pdev->pusb_dev_desc->bNumConfigurations ); pdev->pusb_dev_desc->
bNumConfigurations);
if (pusb_config_desc == NULL) if (pusb_config_desc == NULL)
{ {
@ -349,8 +343,7 @@ IN PIRP irp
goto ERROR_OUT; goto ERROR_OUT;
} }
RtlCopyMemory( RtlCopyMemory(pusb_desc_header,
pusb_desc_header,
pusb_config_desc, pusb_config_desc,
buf_size >= pusb_config_desc->wTotalLength buf_size >= pusb_config_desc->wTotalLength
? pusb_config_desc->wTotalLength : buf_size); ? pusb_config_desc->wTotalLength : buf_size);
@ -412,16 +405,14 @@ IN PIRP irp
lock_dev(pdev, FALSE); lock_dev(pdev, FALSE);
if( dev_state( pdev ) == USB_DEV_STATE_ZOMB \ if (dev_state(pdev) == USB_DEV_STATE_ZOMB || (dev_state(pdev) < USB_DEV_STATE_ADDRESSED))
|| ( dev_state( pdev ) < USB_DEV_STATE_ADDRESSED ) )
{ {
status = STATUS_INVALID_DEVICE_STATE; status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT1; goto ERROR_OUT1;
} }
if( dev_state( pdev ) == USB_DEV_STATE_ADDRESSED if (dev_state(pdev) == USB_DEV_STATE_ADDRESSED && !default_endp_handle(endp_handle))
&& !default_endp_handle( endp_handle ) )
{ {
status = STATUS_DEVICE_NOT_READY; status = STATUS_DEVICE_NOT_READY;
goto ERROR_OUT1; 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 );\ max_liSTS = ( EHCI_MAX_ELEMS_POOL / ii1 ) > EHCI_MAX_LISTS_POOL ? EHCI_MAX_LISTS_POOL : ( EHCI_MAX_ELEMS_POOL / ii1 );\
} }
VOID VOID elem_list_destroy_elem_list(PEHCI_ELEM_LIST plist);
elem_list_destroy_elem_list(
PEHCI_ELEM_LIST plist
);
PLIST_ENTRY PLIST_ENTRY elem_list_get_list_head(PEHCI_ELEM_LIST plist);
elem_list_get_list_head(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_get_total_count(PEHCI_ELEM_LIST plist);
elem_list_get_total_count(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_get_elem_size(PEHCI_ELEM_LIST plist);
elem_list_get_elem_size(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_get_link_offset(PEHCI_ELEM_LIST plist);
elem_list_get_link_offset(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_add_ref(PEHCI_ELEM_LIST plist);
elem_list_add_ref(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_release_ref(PEHCI_ELEM_LIST plist);
elem_list_release_ref(
PEHCI_ELEM_LIST plist
);
LONG LONG elem_list_get_ref(PEHCI_ELEM_LIST plist);
elem_list_get_ref(
PEHCI_ELEM_LIST plist
);
BOOL BOOL
elem_pool_lock( elem_pool_lock(PEHCI_ELEM_POOL pool, BOOL at_dpc)
PEHCI_ELEM_POOL pool,
BOOL at_dpc
)
{ {
return TRUE; return TRUE;
} }
BOOL BOOL
elem_pool_unlock( elem_pool_unlock(PEHCI_ELEM_POOL pool, BOOL at_dpc)
PEHCI_ELEM_POOL pool,
BOOL at_dpc
)
{ {
return TRUE; return TRUE;
} }
LONG LONG
get_elem_phys_part_size( get_elem_phys_part_size(ULONG type)
ULONG type
)
{ {
// type is INIT_LIST_FLAG_XXX // type is INIT_LIST_FLAG_XXX
LONG size; LONG size;
@ -154,12 +124,7 @@ ULONG type
} }
BOOL BOOL
elem_list_init_elem_list( elem_list_init_elem_list(PEHCI_ELEM_LIST plist, LONG init_flags, PVOID context, LONG count)
PEHCI_ELEM_LIST plist,
LONG init_flags,
PVOID context,
LONG count
)
{ {
LONG pages, i, j, elms_per_page; LONG pages, i, j, elms_per_page;
PEHCI_QH pqh; PEHCI_QH pqh;
@ -225,7 +190,7 @@ LONG count
elms_per_page = PAGE_SIZE / plist->elem_size; elms_per_page = PAGE_SIZE / plist->elem_size;
plist->phys_addrs = usb_alloc_mem(NonPagedPool, 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); sizeof(EHCI_ELEM_LINKS) * plist->total_count);
if (plist->phys_addrs == NULL) if (plist->phys_addrs == NULL)
@ -237,27 +202,20 @@ LONG count
plist->phys_bufs = (PBYTE *) & plist->phys_addrs[pages]; plist->phys_bufs = (PBYTE *) & plist->phys_addrs[pages];
plist->elem_head_buf = (PEHCI_ELEM_LINKS) & plist->phys_bufs[pages]; plist->elem_head_buf = (PEHCI_ELEM_LINKS) & plist->phys_bufs[pages];
RtlZeroMemory(plist->phys_addrs, RtlZeroMemory(plist->phys_addrs,
( sizeof( PHYSICAL_ADDRESS ) + sizeof( PBYTE ) ) * pages + \ (sizeof(PHYSICAL_ADDRESS) + sizeof(PBYTE)) * pages +
sizeof(EHCI_ELEM_LINKS) * plist->total_count); sizeof(EHCI_ELEM_LINKS) * plist->total_count);
for(i = 0; i < pages; i++) for(i = 0; i < pages; i++)
{ {
plist->phys_bufs[ i ] = HalAllocateCommonBuffer( plist->phys_bufs[i] = HalAllocateCommonBuffer(plist->padapter,
plist->padapter, PAGE_SIZE, &plist->phys_addrs[i], FALSE);
PAGE_SIZE,
&plist->phys_addrs[ i ],
FALSE);
if (plist->phys_bufs[i] == NULL) if (plist->phys_bufs[i] == NULL)
{ {
// failed, roll back // failed, roll back
for(j = i - 1; j >= 0; j--) for(j = i - 1; j >= 0; j--)
HalFreeCommonBuffer( HalFreeCommonBuffer(plist->padapter,
plist->padapter, PAGE_SIZE, plist->phys_addrs[j], plist->phys_bufs[j], FALSE);
PAGE_SIZE,
plist->phys_addrs[ j ],
plist->phys_bufs[ j ],
FALSE );
goto ERROR_OUT; goto ERROR_OUT;
} }
RtlZeroMemory(plist->phys_bufs[i], PAGE_SIZE); RtlZeroMemory(plist->phys_bufs[i], PAGE_SIZE);
@ -296,8 +254,8 @@ LONG count
} }
} }
return TRUE; return TRUE;
ERROR_OUT:
ERROR_OUT:
if (plist->phys_addrs != NULL) if (plist->phys_addrs != NULL)
usb_free_mem(plist->phys_addrs); usb_free_mem(plist->phys_addrs);
@ -306,9 +264,7 @@ ERROR_OUT:
} }
VOID VOID
elem_list_destroy_elem_list( elem_list_destroy_elem_list(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
LONG i, pages; LONG i, pages;
@ -317,21 +273,14 @@ PEHCI_ELEM_LIST plist
pages = (plist->total_count * plist->elem_size + PAGE_SIZE - 1) / PAGE_SIZE; pages = (plist->total_count * plist->elem_size + PAGE_SIZE - 1) / PAGE_SIZE;
for(i = 0; i < pages; i++) for(i = 0; i < pages; i++)
HalFreeCommonBuffer( HalFreeCommonBuffer(plist->padapter, PAGE_SIZE, plist->phys_addrs[i], plist->phys_bufs[i], FALSE);
plist->padapter,
PAGE_SIZE,
plist->phys_addrs[ i ],
plist->phys_bufs[ i ],
FALSE );
usb_free_mem(plist->phys_addrs); usb_free_mem(plist->phys_addrs);
RtlZeroMemory(plist, sizeof(EHCI_ELEM_LIST)); RtlZeroMemory(plist, sizeof(EHCI_ELEM_LIST));
} }
PLIST_ENTRY PLIST_ENTRY
elem_list_get_list_head( elem_list_get_list_head(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
if (plist == NULL) if (plist == NULL)
return NULL; return NULL;
@ -339,9 +288,7 @@ PEHCI_ELEM_LIST plist
} }
LONG LONG
elem_list_get_total_count( elem_list_get_total_count(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
if (plist == NULL) if (plist == NULL)
return 0; return 0;
@ -349,9 +296,7 @@ PEHCI_ELEM_LIST plist
} }
LONG LONG
elem_list_get_elem_size( elem_list_get_elem_size(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
if (plist == NULL) if (plist == NULL)
return 0; return 0;
@ -359,9 +304,7 @@ PEHCI_ELEM_LIST plist
} }
LONG LONG
elem_list_get_link_offset( elem_list_get_link_offset(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
if (plist == NULL) if (plist == NULL)
return 0; return 0;
@ -370,27 +313,21 @@ PEHCI_ELEM_LIST plist
} }
LONG LONG
elem_list_add_ref( elem_list_add_ref(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
plist->reference++; plist->reference++;
return plist->reference; return plist->reference;
} }
LONG LONG
elem_list_release_ref( elem_list_release_ref(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
plist->reference--; plist->reference--;
return plist->reference; return plist->reference;
} }
LONG LONG
elem_list_get_ref( elem_list_get_ref(PEHCI_ELEM_LIST plist)
PEHCI_ELEM_LIST plist
)
{ {
return plist->reference; return plist->reference;
} }
@ -400,11 +337,7 @@ PEHCI_ELEM_LIST plist
// //
BOOL BOOL
elem_pool_init_pool( elem_pool_init_pool(PEHCI_ELEM_POOL pool, LONG flags, PVOID context)
PEHCI_ELEM_POOL pool,
LONG flags,
PVOID context
)
{ {
PADAPTER_OBJECT padapter; PADAPTER_OBJECT padapter;
INIT_ELEM_LIST_CONTEXT init_ctx; INIT_ELEM_LIST_CONTEXT init_ctx;
@ -436,25 +369,19 @@ PVOID context
} }
LONG LONG
elem_pool_get_link_offset( elem_pool_get_link_offset(PEHCI_ELEM_POOL elem_pool)
PEHCI_ELEM_POOL elem_pool
)
{ {
return elem_pool->link_offset; return elem_pool->link_offset;
} }
LONG LONG
elem_pool_get_total_count( elem_pool_get_total_count(PEHCI_ELEM_POOL elem_pool)
PEHCI_ELEM_POOL elem_pool
)
{ {
return elem_pool->elem_lists[0]->get_total_count(elem_pool->elem_lists[0]) * elem_pool->list_count; return elem_pool->elem_lists[0]->get_total_count(elem_pool->elem_lists[0]) * elem_pool->list_count;
} }
VOID VOID
elem_pool_destroy_pool( elem_pool_destroy_pool(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
LONG i; LONG i;
if (pool == NULL) if (pool == NULL)
@ -470,9 +397,7 @@ PEHCI_ELEM_POOL pool
} }
PEHCI_ELEM_LINKS PEHCI_ELEM_LINKS
elem_pool_alloc_elem( elem_pool_alloc_elem(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
LONG i; LONG i;
PEHCI_ELEM_LIST pel; PEHCI_ELEM_LIST pel;
@ -508,9 +433,7 @@ PEHCI_ELEM_POOL pool
} }
VOID VOID
elem_pool_free_elem( elem_pool_free_elem(PEHCI_ELEM_LINKS elem_link)
PEHCI_ELEM_LINKS elem_link
)
{ {
PLIST_HEAD lh; PLIST_HEAD lh;
LONG ref; LONG ref;
@ -530,9 +453,7 @@ PEHCI_ELEM_LINKS elem_link
} }
BOOL BOOL
elem_pool_is_empty( elem_pool_is_empty(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
PEHCI_ELEM_LIST pel; PEHCI_ELEM_LIST pel;
@ -543,9 +464,7 @@ PEHCI_ELEM_POOL pool
} }
LONG LONG
elem_pool_get_free_count( elem_pool_get_free_count(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
if (pool == NULL) if (pool == NULL)
return 0; return 0;
@ -553,10 +472,7 @@ PEHCI_ELEM_POOL pool
} }
PEHCI_ELEM_LINKS PEHCI_ELEM_LINKS
elem_pool_alloc_elems( elem_pool_alloc_elems(PEHCI_ELEM_POOL pool, LONG count)
PEHCI_ELEM_POOL pool,
LONG count
)
{ {
LIST_HEAD lh; LIST_HEAD lh;
PLIST_ENTRY pthis; PLIST_ENTRY pthis;
@ -601,9 +517,7 @@ LONG count
} }
BOOL BOOL
elem_pool_free_elems( elem_pool_free_elems(PEHCI_ELEM_LINKS elem_chains)
PEHCI_ELEM_LINKS elem_chains
)
{ {
// note: no list head exists. // note: no list head exists.
LIST_HEAD lh; LIST_HEAD lh;
@ -617,10 +531,9 @@ PEHCI_ELEM_LINKS elem_chains
} }
return TRUE; return TRUE;
} }
LONG LONG
elem_pool_get_type( elem_pool_get_type(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
if (pool == NULL) if (pool == NULL)
return -1; return -1;
@ -628,10 +541,7 @@ PEHCI_ELEM_POOL pool
} }
BOOL BOOL
elem_pool_expand_pool( elem_pool_expand_pool(PEHCI_ELEM_POOL pool, LONG elem_count)
PEHCI_ELEM_POOL pool,
LONG elem_count
)
{ {
LONG elem_cnt_list, list_count, i, j; LONG elem_cnt_list, list_count, i, j;
INIT_ELEM_LIST_CONTEXT init_ctx; INIT_ELEM_LIST_CONTEXT init_ctx;
@ -675,9 +585,7 @@ LONG elem_count
} }
BOOL BOOL
elem_pool_collect_garbage( elem_pool_collect_garbage(PEHCI_ELEM_POOL pool)
PEHCI_ELEM_POOL pool
)
{ {
LONG i, j, k, fl; LONG i, j, k, fl;
LONG free_elem_lists[EHCI_MAX_LISTS_POOL - 1]; LONG free_elem_lists[EHCI_MAX_LISTS_POOL - 1];
@ -713,21 +621,16 @@ PEHCI_ELEM_POOL pool
} }
BOOL BOOL
elem_pool_can_transfer( elem_pool_can_transfer(PEHCI_ELEM_POOL pool, LONG td_count)
PEHCI_ELEM_POOL pool,
LONG td_count
)
{ {
LONG i; LONG i;
if (pool == NULL || td_count <= 0) if (pool == NULL || td_count <= 0)
return FALSE; return FALSE;
get_max_lists_count(pool, i); get_max_lists_count(pool, i);
if ((i - pool->list_count) if ((i - pool->list_count)
* pool->elem_lists[ 0 ]->get_total_count( pool->elem_lists[ 0 ] ) * pool->elem_lists[0]->get_total_count(pool->elem_lists[0]) + pool->free_count < td_count)
+ pool->free_count < td_count )
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
//---------------------------------------------------------- //----------------------------------------------------------

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

@ -59,181 +59,73 @@
extern POBJECT_TYPE NTSYSAPI IoDriverObjectType; extern POBJECT_TYPE NTSYSAPI IoDriverObjectType;
extern VOID extern VOID disp_urb_completion(PURB purb, PVOID context);
disp_urb_completion(
PURB purb,
PVOID context
);
VOID VOID disp_noio_urb_completion(PURB purb, PVOID context);
disp_noio_urb_completion(
PURB purb, NTSYSAPI NTSTATUS NTAPI ZwLoadDriver(IN PUNICODE_STRING DriverServiceName);
PVOID context
); NTSYSAPI NTSTATUS NTAPI ZwClose(IN HANDLE Handle);
NTSYSAPI NTSYSAPI
NTSTATUS NTSTATUS
NTAPI NTAPI
ZwLoadDriver( ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PUNICODE_STRING DriverServiceName
);
NTSYSAPI
NTSTATUS
NTAPI
ZwClose(
IN HANDLE Handle
);
NTSYSAPI
NTSTATUS
NTAPI
ObOpenObjectByName(
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN POBJECT_TYPE ObjectType OPTIONAL, IN POBJECT_TYPE ObjectType OPTIONAL,
IN KPROCESSOR_MODE AccessMode, IN KPROCESSOR_MODE AccessMode,
IN OUT PACCESS_STATE AccessState OPTIONAL, IN OUT PACCESS_STATE AccessState OPTIONAL,
IN ACCESS_MASK DesiredAccess OPTIONAL, IN ACCESS_MASK DesiredAccess OPTIONAL,
IN OUT PVOID ParseContext OPTIONAL, IN OUT PVOID ParseContext OPTIONAL, OUT PHANDLE Handle);
OUT PHANDLE Handle
);
BOOL 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
);
VOID VOID gendrv_set_cfg_completion(PURB purb, PVOID context);
gendrv_set_cfg_completion(
PURB purb,
PVOID context
);
BOOL BOOL gendrv_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle);
gendrv_connect(
PCONNECT_DATA param,
DEV_HANDLE dev_handle
);
BOOL BOOL gendrv_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
gendrv_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL BOOL gendrv_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
gendrv_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
VOID VOID gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
gendrv_startio(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
);
VOID VOID gendrv_cancel_queued_irp(PDEVICE_OBJECT pdev_obj, PIRP pirp);
gendrv_cancel_queued_irp(
PDEVICE_OBJECT pdev_obj,
PIRP pirp
);
VOID 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
);
VOID VOID gendrv_clean_up_queued_irps(PDEVICE_OBJECT dev_obj);
gendrv_clean_up_queued_irps(
PDEVICE_OBJECT dev_obj
);
PGENDRV_EXT_DRVR_ENTRY PGENDRV_EXT_DRVR_ENTRY gendrv_alloc_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext);
gendrv_alloc_ext_drvr_entry(
PGENDRV_DRVR_EXTENSION pdrvr_ext
);
PDRIVER_OBJECT PDRIVER_OBJECT gendrv_open_ext_driver(PUNICODE_STRING unicode_string);
gendrv_open_ext_driver(
PUNICODE_STRING unicode_string
);
NTSTATUS NTSTATUS
gendrv_get_key_value( gendrv_get_key_value(IN HANDLE KeyHandle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION * Information);
IN HANDLE KeyHandle,
IN PWSTR ValueName,
OUT PKEY_VALUE_FULL_INFORMATION *Information
);
NTSTATUS NTSTATUS
gendrv_open_reg_key( gendrv_open_reg_key(OUT PHANDLE handle,
OUT PHANDLE handle,
IN HANDLE base_handle OPTIONAL, IN HANDLE base_handle OPTIONAL,
IN PUNICODE_STRING keyname, IN PUNICODE_STRING keyname, IN ACCESS_MASK desired_access, IN BOOLEAN create);
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 BOOL
gendrv_do_disconnect( gendrv_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
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
)
{ {
PGENDRV_DRVR_EXTENSION pdrvr_ext; PGENDRV_DRVR_EXTENSION pdrvr_ext;
@ -277,19 +169,13 @@ PUSB_DRIVER pdriver
} }
BOOL BOOL
gendrv_driver_destroy( gendrv_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
return gendrv_if_driver_destroy(dev_mgr, pdriver); return gendrv_if_driver_destroy(dev_mgr, pdriver);
} }
BOOL BOOL
gendrv_connect( gendrv_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle)
PCONNECT_DATA param,
DEV_HANDLE dev_handle
)
{ {
PURB purb; PURB purb;
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
@ -387,12 +273,8 @@ DEV_HANDLE dev_handle
} }
BOOL BOOL
gendrv_event_select_driver( gendrv_event_select_driver(PUSB_DEV pdev, //always null. we do not use this param
PUSB_DEV pdev, //always null. we do not use this param ULONG event, ULONG context, ULONG param)
ULONG event,
ULONG context,
ULONG param
)
{ {
// //
// try to search the registry to find one driver. // try to search the registry to find one driver.
@ -499,10 +381,7 @@ ERROR_OUT:
} }
VOID VOID
gendrv_set_cfg_completion( gendrv_set_cfg_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
DEV_HANDLE dev_handle; DEV_HANDLE dev_handle;
PUSB_DEV_MANAGER dev_mgr; PUSB_DEV_MANAGER dev_mgr;
@ -585,10 +464,7 @@ PVOID context
BOOL BOOL
gendrv_stop( gendrv_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
{ {
if (dev_mgr == NULL) if (dev_mgr == NULL)
return FALSE; return FALSE;
@ -596,10 +472,7 @@ DEV_HANDLE dev_handle
} }
BOOL BOOL
gendrv_disconnect( gendrv_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
{ {
if (dev_mgr == NULL) if (dev_mgr == NULL)
return FALSE; return FALSE;
@ -607,10 +480,7 @@ DEV_HANDLE dev_handle
} }
BOOL BOOL
gendrv_build_reg_string( gendrv_build_reg_string(PUSB_DESC_HEADER pdesc, PUNICODE_STRING pus)
PUSB_DESC_HEADER pdesc,
PUNICODE_STRING pus
)
{ {
CHAR desc_str[128]; CHAR desc_str[128];
@ -625,8 +495,7 @@ PUNICODE_STRING pus
pdev_desc = (PUSB_DEVICE_DESC) pdesc; pdev_desc = (PUSB_DEVICE_DESC) pdesc;
sprintf(desc_str, "%sv_%04x&p_%04x", sprintf(desc_str, "%sv_%04x&p_%04x",
"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\device\\", "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\device\\",
pdev_desc->idVendor, pdev_desc->idVendor, pdev_desc->idProduct);
pdev_desc->idProduct );
} }
else if (pdesc->bDescriptorType == USB_DT_INTERFACE) else if (pdesc->bDescriptorType == USB_DT_INTERFACE)
{ {
@ -634,9 +503,7 @@ PUNICODE_STRING pus
pif_desc = (PUSB_INTERFACE_DESC) pdesc; pif_desc = (PUSB_INTERFACE_DESC) pdesc;
sprintf(desc_str, "%sc_%04x&s_%04x&p_%04x", sprintf(desc_str, "%sc_%04x&s_%04x&p_%04x",
"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\interface\\", "\\Registry\\Machine\\System\\CurrentControlSet\\Services\\ehci\\interface\\",
pif_desc->bInterfaceClass, pif_desc->bInterfaceClass, pif_desc->bInterfaceSubClass, pif_desc->bInterfaceProtocol);
pif_desc->bInterfaceSubClass,
pif_desc->bInterfaceProtocol );
} }
else else
return FALSE; return FALSE;
@ -647,9 +514,7 @@ PUNICODE_STRING pus
} }
ULONG ULONG
gendrv_make_key( gendrv_make_key(PUSB_DESC_HEADER pdesc)
PUSB_DESC_HEADER pdesc
)
{ {
PUSB_DEVICE_DESC pdev_desc; PUSB_DEVICE_DESC pdev_desc;
PUSB_INTERFACE_DESC pif_desc; PUSB_INTERFACE_DESC pif_desc;
@ -664,18 +529,14 @@ PUSB_DESC_HEADER pdesc
else if (pdesc->bDescriptorType == USB_DT_INTERFACE) else if (pdesc->bDescriptorType == USB_DT_INTERFACE)
{ {
pif_desc = (PUSB_INTERFACE_DESC) pdesc; pif_desc = (PUSB_INTERFACE_DESC) pdesc;
return ( ( ( ( ULONG )pif_desc->bInterfaceClass ) << 16 ) | \ return ((((ULONG) pif_desc->bInterfaceClass) << 16) |
( ( ( ULONG )pif_desc->bInterfaceSubClass ) << 8 ) | \ (((ULONG) pif_desc->bInterfaceSubClass) << 8) | ((ULONG) pif_desc->bInterfaceProtocol));
( ( ULONG )pif_desc->bInterfaceProtocol ) );
} }
return (ULONG) - 1; return (ULONG) - 1;
} }
PDRIVER_OBJECT PDRIVER_OBJECT
gendrv_find_drvr_by_key( gendrv_find_drvr_by_key(PGENDRV_DRVR_EXTENSION pdrvr_ext, ULONG key)
PGENDRV_DRVR_EXTENSION pdrvr_ext,
ULONG key
)
{ {
PGENDRV_EXT_DRVR_ENTRY pentry; PGENDRV_EXT_DRVR_ENTRY pentry;
PLIST_ENTRY pthis, pnext; PLIST_ENTRY pthis, pnext;
@ -701,10 +562,7 @@ ULONG key
} }
PDRIVER_OBJECT PDRIVER_OBJECT
gendrv_load_ext_drvr( gendrv_load_ext_drvr(PGENDRV_DRVR_EXTENSION pdrvr_ext, PUSB_DESC_HEADER pdesc)
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PUSB_DESC_HEADER pdesc
)
{ {
PDRIVER_OBJECT pdrvr_obj; PDRIVER_OBJECT pdrvr_obj;
PGENDRV_EXT_DRVR_ENTRY pentry; PGENDRV_EXT_DRVR_ENTRY pentry;
@ -790,10 +648,7 @@ ERROR_OUT:
} }
VOID VOID
gendrv_release_drvr( gendrv_release_drvr(PGENDRV_DRVR_EXTENSION pdrvr_ext, PDRIVER_OBJECT pdrvr_obj)
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PDRIVER_OBJECT pdrvr_obj
)
{ {
PLIST_ENTRY pthis, pnext; PLIST_ENTRY pthis, pnext;
PGENDRV_EXT_DRVR_ENTRY pentry; PGENDRV_EXT_DRVR_ENTRY pentry;
@ -818,11 +673,7 @@ PDRIVER_OBJECT pdrvr_obj
} }
NTSTATUS NTSTATUS
gendrv_send_pnp_msg( gendrv_send_pnp_msg(ULONG msg, PDEVICE_OBJECT pdev_obj, PVOID pctx)
ULONG msg,
PDEVICE_OBJECT pdev_obj,
PVOID pctx
)
{ {
if (pdev_obj == NULL) if (pdev_obj == NULL)
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
@ -868,10 +719,7 @@ PVOID pctx
BOOL BOOL
gendrv_if_connect( gendrv_if_connect(PCONNECT_DATA params, DEV_HANDLE if_handle)
PCONNECT_DATA params,
DEV_HANDLE if_handle
)
{ {
// //
// try to search the registry to find one driver. // 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 = (PGENDRV_DEVICE_EXTENSION) pdev_obj->DeviceExtension;
pdev_ext->desc_buf = usb_alloc_mem(NonPagedPool, 512); pdev_ext->desc_buf = usb_alloc_mem(NonPagedPool, 512);
RtlCopyMemory(pdev_ext->desc_buf, pconfig_desc, 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 // insert the device to the dev_list
ExAcquireFastMutex(&pdrvr_ext->drvr_ext_mutex); ExAcquireFastMutex(&pdrvr_ext->drvr_ext_mutex);
@ -1003,11 +852,7 @@ ERROR_OUT:
} }
BOOL BOOL
gendrv_do_stop( gendrv_do_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle, BOOL is_if)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle,
BOOL is_if
)
{ {
PUSB_DEV pdev; PUSB_DEV pdev;
PDEVICE_OBJECT pdev_obj; PDEVICE_OBJECT pdev_obj;
@ -1037,10 +882,7 @@ BOOL is_if
} }
BOOL BOOL
gendrv_if_stop( gendrv_if_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
{ {
if (dev_mgr == NULL) if (dev_mgr == NULL)
return FALSE; return FALSE;
@ -1049,11 +891,7 @@ DEV_HANDLE dev_handle
} }
BOOL BOOL
gendrv_do_disconnect( gendrv_do_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle, BOOL is_if)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle,
BOOL is_if
)
{ {
PUSB_DEV pdev; PUSB_DEV pdev;
PDEVICE_OBJECT dev_obj = NULL; PDEVICE_OBJECT dev_obj = NULL;
@ -1107,19 +945,13 @@ BOOL is_if
} }
BOOL BOOL
gendrv_if_disconnect( gendrv_if_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
{ {
return gendrv_do_disconnect(dev_mgr, if_handle, TRUE); return gendrv_do_disconnect(dev_mgr, if_handle, TRUE);
} }
BOOL BOOL
gendrv_if_driver_init( gendrv_if_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
PGENDRV_DRVR_EXTENSION pdrvr_ext; PGENDRV_DRVR_EXTENSION pdrvr_ext;
if (dev_mgr == NULL || pdriver == NULL) if (dev_mgr == NULL || pdriver == NULL)
@ -1164,10 +996,7 @@ PUSB_DRIVER pdriver
} }
BOOL BOOL
gendrv_if_driver_destroy( gendrv_if_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
PGENDRV_DRVR_EXTENSION pdrvr_ext; PGENDRV_DRVR_EXTENSION pdrvr_ext;
PLIST_ENTRY pthis; PLIST_ENTRY pthis;
@ -1208,9 +1037,7 @@ PUSB_DRIVER pdriver
} }
PDRIVER_OBJECT PDRIVER_OBJECT
gendrv_open_ext_driver( gendrv_open_ext_driver(PUNICODE_STRING unicode_string)
PUNICODE_STRING unicode_string
)
{ {
NTSTATUS status; NTSTATUS status;
OBJECT_ATTRIBUTES oa; OBJECT_ATTRIBUTES oa;
@ -1225,8 +1052,7 @@ PUNICODE_STRING unicode_string
RtlInitUnicodeString(&oname, L""); RtlInitUnicodeString(&oname, L"");
RtlAppendUnicodeStringToString(&oname, unicode_string); RtlAppendUnicodeStringToString(&oname, unicode_string);
status = ObOpenObjectByName( &oa, status = ObOpenObjectByName(&oa, IoDriverObjectType, // object type
IoDriverObjectType, // object type
KernelMode, // access mode KernelMode, // access mode
NULL, // access state NULL, // access state
FILE_READ_DATA, // STANDARD_RIGHTS_READ, access right FILE_READ_DATA, // STANDARD_RIGHTS_READ, access right
@ -1242,8 +1068,8 @@ PUNICODE_STRING unicode_string
IoDriverObjectType, IoDriverObjectType,
KernelMode, KernelMode,
(PVOID)&pdrvr, (PVOID)&pdrvr,
NULL // OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL NULL); // OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL
);
ZwClose(drvr_handle); ZwClose(drvr_handle);
return pdrvr; return pdrvr;
} }
@ -1258,10 +1084,7 @@ gendrv_close_ext_driver( PDRIVER_OBJECT pdrvr )
} }
NTSTATUS NTSTATUS
gendrv_dispatch( gendrv_dispatch(PDEVICE_OBJECT dev_obj, PIRP irp)
PDEVICE_OBJECT dev_obj,
PIRP irp
)
{ {
IO_STACK_LOCATION *irpstack; IO_STACK_LOCATION *irpstack;
PUSB_DEV_MANAGER dev_mgr; PUSB_DEV_MANAGER dev_mgr;
@ -1311,8 +1134,7 @@ PIRP irp
if (!default_endp_handle(endp_handle)) if (!default_endp_handle(endp_handle))
{ {
//no permit to other interface if interface dev //no permit to other interface if interface dev
if( if_dev( dev_obj ) && if (if_dev(dev_obj) && if_idx_from_handle(endp_handle) != pdev_ext->if_ctx.if_idx)
if_idx_from_handle( endp_handle ) != pdev_ext->if_ctx.if_idx )
GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp); GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp);
} }
@ -1358,8 +1180,7 @@ PIRP irp
if (!default_endp_handle(endp_handle)) if (!default_endp_handle(endp_handle))
{ {
//no permit to other interface if interface dev //no permit to other interface if interface dev
if( if_dev( dev_obj ) && if (if_dev(dev_obj) && if_idx_from_handle(endp_handle) != pdev_ext->if_ctx.if_idx)
if_idx_from_handle( endp_handle ) != pdev_ext->if_ctx.if_idx )
GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp); GENDRV_EXIT_DISPATCH(dev_obj, STATUS_INVALID_PARAMETER, irp);
} }
@ -1390,11 +1211,9 @@ PIRP irp
return STATUS_NOT_SUPPORTED; return STATUS_NOT_SUPPORTED;
} }
BOOL BOOL
gendrv_init_dev_ext_hdr( gendrv_init_dev_ext_hdr(PDEVICE_OBJECT dev_obj, PUSB_DEV_MANAGER dev_mgr)
PDEVICE_OBJECT dev_obj,
PUSB_DEV_MANAGER dev_mgr
)
{ {
PDEVEXT_HEADER dev_hdr = NULL; PDEVEXT_HEADER dev_hdr = NULL;
if (dev_obj == NULL || dev_mgr == NULL) if (dev_obj == NULL || dev_mgr == NULL)
@ -1408,11 +1227,7 @@ PUSB_DEV_MANAGER dev_mgr
} }
PDEVICE_OBJECT PDEVICE_OBJECT
gendrv_create_device( gendrv_create_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER gen_drvr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER gen_drvr,
DEV_HANDLE dev_handle
)
{ {
BOOL is_if; BOOL is_if;
PDEVICE_OBJECT pdev; PDEVICE_OBJECT pdev;
@ -1441,14 +1256,8 @@ DEV_HANDLE dev_handle
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE); RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL; pdev = NULL;
status = IoCreateDevice( status = IoCreateDevice(dev_mgr->usb_driver_obj,
dev_mgr->usb_driver_obj, sizeof(GENDRV_DEVICE_EXTENSION), &name_string, FILE_USB_DEV_TYPE, 0, TRUE, &pdev);
sizeof( GENDRV_DEVICE_EXTENSION ),
&name_string,
FILE_USB_DEV_TYPE,
0,
TRUE,
&pdev);
if (status == STATUS_SUCCESS) if (status == STATUS_SUCCESS)
{ {
@ -1492,9 +1301,7 @@ DEV_HANDLE dev_handle
VOID VOID
gendrv_deferred_delete_device( gendrv_deferred_delete_device(PVOID context)
PVOID context
)
{ {
PDEVICE_OBJECT dev_obj; PDEVICE_OBJECT dev_obj;
PGENDRV_DEVICE_EXTENSION pdev_ext; PGENDRV_DEVICE_EXTENSION pdev_ext;
@ -1533,10 +1340,7 @@ PVOID context
} }
BOOL BOOL
gendrv_delete_device( gendrv_delete_device(PUSB_DEV_MANAGER dev_mgr, PDEVICE_OBJECT dev_obj)
PUSB_DEV_MANAGER dev_mgr,
PDEVICE_OBJECT dev_obj
)
{ {
BOOL is_if; BOOL is_if;
PUSB_DRIVER pdrvr; PUSB_DRIVER pdrvr;
@ -1588,9 +1392,7 @@ PDEVICE_OBJECT dev_obj
// must have the drvr_ext_mutex acquired. // must have the drvr_ext_mutex acquired.
PGENDRV_EXT_DRVR_ENTRY PGENDRV_EXT_DRVR_ENTRY
gendrv_alloc_ext_drvr_entry( gendrv_alloc_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext)
PGENDRV_DRVR_EXTENSION pdrvr_ext
)
{ {
LONG i; LONG i;
if (pdrvr_ext == NULL) if (pdrvr_ext == NULL)
@ -1610,10 +1412,7 @@ PGENDRV_DRVR_EXTENSION pdrvr_ext
// must have the drvr_ext_mutex acquired. // must have the drvr_ext_mutex acquired.
VOID VOID
gendrv_release_ext_drvr_entry( gendrv_release_ext_drvr_entry(PGENDRV_DRVR_EXTENSION pdrvr_ext, PGENDRV_EXT_DRVR_ENTRY pentry)
PGENDRV_DRVR_EXTENSION pdrvr_ext,
PGENDRV_EXT_DRVR_ENTRY pentry
)
{ {
if (pdrvr_ext == NULL || pentry == NULL) if (pdrvr_ext == NULL || pentry == NULL)
return; return;
@ -1623,14 +1422,9 @@ PGENDRV_EXT_DRVR_ENTRY pentry
} }
NTSTATUS NTSTATUS
gendrv_open_reg_key( gendrv_open_reg_key(OUT PHANDLE handle,
OUT PHANDLE handle,
IN HANDLE base_handle OPTIONAL, IN HANDLE base_handle OPTIONAL,
IN PUNICODE_STRING keyname, IN PUNICODE_STRING keyname, IN ACCESS_MASK desired_access, IN BOOLEAN create)
IN ACCESS_MASK desired_access,
IN BOOLEAN create
)
/*++ /*++
Routine Description: Routine Description:
@ -1657,7 +1451,6 @@ Return Value:
The function value is the final status of the operation. The function value is the final status of the operation.
--*/ --*/
{ {
OBJECT_ATTRIBUTES object_attr; OBJECT_ATTRIBUTES object_attr;
ULONG disposition; ULONG disposition;
@ -1667,10 +1460,7 @@ Return Value:
// //
InitializeObjectAttributes(&object_attr, InitializeObjectAttributes(&object_attr,
keyname, keyname, OBJ_CASE_INSENSITIVE, base_handle, (PSECURITY_DESCRIPTOR) NULL);
OBJ_CASE_INSENSITIVE,
base_handle,
(PSECURITY_DESCRIPTOR) NULL );
// //
// Create the key or open it, as appropriate based on the caller's // Create the key or open it, as appropriate based on the caller's
@ -1681,28 +1471,17 @@ Return Value:
{ {
return ZwCreateKey(handle, return ZwCreateKey(handle,
desired_access, desired_access,
&object_attr, &object_attr, 0, (PUNICODE_STRING) NULL, REG_OPTION_VOLATILE, &disposition);
0,
(PUNICODE_STRING) NULL,
REG_OPTION_VOLATILE,
&disposition );
} }
else else
{ {
return ZwOpenKey( handle, return ZwOpenKey(handle, desired_access, &object_attr);
desired_access,
&object_attr );
} }
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
NTSTATUS NTSTATUS
gendrv_get_key_value( gendrv_get_key_value(IN HANDLE KeyHandle, IN PWSTR ValueName, OUT PKEY_VALUE_FULL_INFORMATION * Information)
IN HANDLE KeyHandle,
IN PWSTR ValueName,
OUT PKEY_VALUE_FULL_INFORMATION *Information
)
/*++ /*++
Routine Description: Routine Description:
@ -1727,7 +1506,6 @@ Return Value:
The function value is the final status of the query operation. The function value is the final status of the query operation.
--*/ --*/
{ {
UNICODE_STRING unicodeString; UNICODE_STRING unicodeString;
NTSTATUS status; NTSTATUS status;
@ -1744,13 +1522,9 @@ Return Value:
// //
status = ZwQueryValueKey(KeyHandle, status = ZwQueryValueKey(KeyHandle,
&unicodeString, &unicodeString, KeyValueFullInformation, (PVOID) NULL, 0, &keyValueLength);
KeyValueFullInformation, if (status != STATUS_BUFFER_OVERFLOW && status != STATUS_BUFFER_TOO_SMALL)
(PVOID) NULL, {
0,
&keyValueLength );
if (status != STATUS_BUFFER_OVERFLOW &&
status != STATUS_BUFFER_TOO_SMALL) {
return status; return status;
} }
@ -1759,7 +1533,8 @@ Return Value:
// //
infoBuffer = usb_alloc_mem(NonPagedPool, keyValueLength); infoBuffer = usb_alloc_mem(NonPagedPool, keyValueLength);
if (!infoBuffer) { if (!infoBuffer)
{
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
} }
@ -1769,11 +1544,9 @@ Return Value:
status = ZwQueryValueKey(KeyHandle, status = ZwQueryValueKey(KeyHandle,
&unicodeString, &unicodeString,
KeyValueFullInformation, KeyValueFullInformation, infoBuffer, keyValueLength, &keyValueLength);
infoBuffer, if (!NT_SUCCESS(status))
keyValueLength, {
&keyValueLength );
if (!NT_SUCCESS( status )) {
usb_free_mem(infoBuffer); usb_free_mem(infoBuffer);
return status; return status;
} }
@ -1788,10 +1561,7 @@ Return Value:
} }
VOID VOID
gendrv_startio( gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp)
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
)
{ {
PIO_STACK_LOCATION irp_stack; PIO_STACK_LOCATION irp_stack;
ULONG ctrl_code; ULONG ctrl_code;
@ -1875,16 +1645,14 @@ IN PIRP irp
} }
lock_dev(pdev, FALSE); lock_dev(pdev, FALSE);
if( dev_state( pdev ) == USB_DEV_STATE_ZOMB \ if (dev_state(pdev) == USB_DEV_STATE_ZOMB || (dev_state(pdev) < USB_DEV_STATE_ADDRESSED))
|| ( dev_state( pdev ) < USB_DEV_STATE_ADDRESSED ) )
{ {
status = STATUS_INVALID_DEVICE_STATE; status = STATUS_INVALID_DEVICE_STATE;
goto ERROR_OUT1; goto ERROR_OUT1;
} }
if( dev_state( pdev ) == USB_DEV_STATE_ADDRESSED if (dev_state(pdev) == USB_DEV_STATE_ADDRESSED && !default_endp_handle(endp_handle))
&& !default_endp_handle( endp_handle ) )
{ {
status = STATUS_DEVICE_NOT_READY; status = STATUS_DEVICE_NOT_READY;
goto ERROR_OUT1; goto ERROR_OUT1;
@ -1979,9 +1747,7 @@ ERROR_OUT1:
} }
VOID VOID
gendrv_clean_up_queued_irps( gendrv_clean_up_queued_irps(PDEVICE_OBJECT dev_obj)
PDEVICE_OBJECT dev_obj
)
{ {
// called when device may not function or about to be removed, need cleanup // called when device may not function or about to be removed, need cleanup
KIRQL cancelIrql; KIRQL cancelIrql;
@ -2024,10 +1790,7 @@ PDEVICE_OBJECT dev_obj
} }
VOID VOID
gendrv_cancel_queued_irp( gendrv_cancel_queued_irp(PDEVICE_OBJECT dev_obj, PIRP pirp)
PDEVICE_OBJECT dev_obj,
PIRP pirp
)
{ {
// cancel routine for irps queued in the device queue // cancel routine for irps queued in the device queue
PUSB_DEV_MANAGER dev_mgr; PUSB_DEV_MANAGER dev_mgr;
@ -2054,4 +1817,3 @@ PIRP pirp
// the device queue is moved on, no need to call IoStartNextPacket // the device queue is moved on, no need to call IoStartNextPacket
return; 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 #define UHCI_MIN_TD_POOLS 4
BOOL 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
); //add tds till pnext == NULL
PUHCI_QH PUHCI_QH alloc_qh(PUHCI_QH_POOL pqh_pool); //null if failed
alloc_qh(
PUHCI_QH_POOL pqh_pool
); //null if failed
BOOL BOOL
init_td_pool( init_td_pool(PUHCI_TD_POOL ptd_pool)
PUHCI_TD_POOL ptd_pool
)
{ {
int i, pages; int i, pages;
PTD_EXTENSION ptde; PTD_EXTENSION ptde;
@ -58,17 +49,12 @@ PUHCI_TD_POOL ptd_pool
for(i = 0; i < pages; i++) for(i = 0; i < pages; i++)
{ {
ptd_pool->td_array[i] = ptd_pool->td_array[i] =
HalAllocateCommonBuffer( HalAllocateCommonBuffer(ptd_pool->padapter, PAGE_SIZE, &ptd_pool->logic_addr[i], FALSE);
ptd_pool->padapter,
PAGE_SIZE,
&ptd_pool->logic_addr[ i ],
FALSE);
if (ptd_pool->td_array[i] == NULL) if (ptd_pool->td_array[i] == NULL)
goto failed; goto failed;
} }
ptd_pool->tde_array = ( PTD_EXTENSION )usb_alloc_mem( ptd_pool->tde_array = (PTD_EXTENSION) usb_alloc_mem(NonPagedPool,
NonPagedPool,
sizeof(TD_EXTENSION) * UHCI_MAX_POOL_TDS); sizeof(TD_EXTENSION) * UHCI_MAX_POOL_TDS);
if (ptd_pool->tde_array == NULL) 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->td_array[i], PAGE_SIZE);
} }
RtlZeroMemory( RtlZeroMemory(ptd_pool->tde_array, sizeof(TD_EXTENSION) * UHCI_MAX_POOL_TDS);
ptd_pool->tde_array,
sizeof( TD_EXTENSION ) * UHCI_MAX_POOL_TDS );
ptde = ptd_pool->tde_array; ptde = ptd_pool->tde_array;
ptd_pool->free_count = 0; 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]; ptd_pool->td_array[i >> 7][i & 0x7f].ptde = &ptde[i];
ptde[i].ptd = &ptd_pool->td_array[i >> 7][i & 0x7f]; ptde[i].ptd = &ptd_pool->td_array[i >> 7][i & 0x7f];
ptde[i].flags = UHCI_ITEM_FLAG_TD; 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].pool = ptd_pool;
ptd_pool->td_array[i >> 7][i & 0x7f].purb = NULL; ptd_pool->td_array[i >> 7][i & 0x7f].purb = NULL;
free_td_to_pool(ptd_pool, &ptd_pool->td_array[i >> 7][i & 0x7f]); 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]) if (ptd_pool->td_array[i])
{ {
HalFreeCommonBuffer(ptd_pool->padapter, HalFreeCommonBuffer(ptd_pool->padapter,
PAGE_SIZE, PAGE_SIZE, ptd_pool->logic_addr[i], ptd_pool->td_array[i], FALSE);
ptd_pool->logic_addr[ i ],
ptd_pool->td_array[ i ],
FALSE);
ptd_pool->td_array[i] = NULL; ptd_pool->td_array[i] = NULL;
ptd_pool->logic_addr[i].QuadPart = 0; ptd_pool->logic_addr[i].QuadPart = 0;
} }
@ -127,11 +109,9 @@ PUHCI_TD_POOL ptd_pool
return FALSE; return FALSE;
} }
//add tds till pnext == NULL
BOOL BOOL
free_td_to_pool( free_td_to_pool(PUHCI_TD_POOL ptd_pool, PUHCI_TD ptd)
PUHCI_TD_POOL ptd_pool,
PUHCI_TD ptd
) //add tds till pnext == NULL
{ {
if (ptd_pool == NULL || ptd == NULL) if (ptd_pool == NULL || ptd == NULL)
{ {
@ -147,11 +127,12 @@ PUHCI_TD ptd
return TRUE; return TRUE;
} }
// qh routines // qh routines
//null if failed
PUHCI_TD PUHCI_TD
alloc_td_from_pool( alloc_td_from_pool(PUHCI_TD_POOL ptd_pool)
PUHCI_TD_POOL ptd_pool
) //null if failed
{ {
PTD_EXTENSION ptde; PTD_EXTENSION ptde;
PLIST_ENTRY temp; PLIST_ENTRY temp;
@ -178,10 +159,9 @@ PUHCI_TD_POOL ptd_pool
} }
//test whether the pool is all free
BOOL BOOL
is_pool_free( is_pool_free(PUHCI_TD_POOL pool)
PUHCI_TD_POOL pool
) //test whether the pool is all free
{ {
if (pool == NULL) if (pool == NULL)
return FALSE; return FALSE;
@ -193,9 +173,7 @@ PUHCI_TD_POOL pool
} }
BOOL BOOL
is_pool_empty( is_pool_empty(PUHCI_TD_POOL pool)
PUHCI_TD_POOL pool
)
{ {
if (pool == NULL) if (pool == NULL)
return FALSE; return FALSE;
@ -204,9 +182,7 @@ PUHCI_TD_POOL pool
} }
BOOL BOOL
destroy_td_pool( destroy_td_pool(PUHCI_TD_POOL ptd_pool)
PUHCI_TD_POOL ptd_pool
)
{ {
int i, pages; int i, pages;
PADAPTER_OBJECT padapter; //we need this garbage for allocation PADAPTER_OBJECT padapter; //we need this garbage for allocation
@ -223,10 +199,7 @@ PUHCI_TD_POOL ptd_pool
if (ptd_pool->td_array[i]) if (ptd_pool->td_array[i])
{ {
HalFreeCommonBuffer(ptd_pool->padapter, HalFreeCommonBuffer(ptd_pool->padapter,
PAGE_SIZE, PAGE_SIZE, ptd_pool->logic_addr[i], ptd_pool->td_array[i], FALSE);
ptd_pool->logic_addr[ i ],
ptd_pool->td_array[ i ],
FALSE);
ptd_pool->td_array[i] = NULL; ptd_pool->td_array[i] = NULL;
ptd_pool->logic_addr[i].QuadPart = 0; ptd_pool->logic_addr[i].QuadPart = 0;
} }
@ -242,10 +215,7 @@ PUHCI_TD_POOL ptd_pool
} }
BOOL BOOL
init_td_pool_list( init_td_pool_list(PUHCI_TD_POOL_LIST pool_list, PADAPTER_OBJECT padapter)
PUHCI_TD_POOL_LIST pool_list,
PADAPTER_OBJECT padapter
)
{ {
int i; int i;
RtlZeroMemory(pool_list, sizeof(UHCI_TD_POOL_LIST)); RtlZeroMemory(pool_list, sizeof(UHCI_TD_POOL_LIST));
@ -266,9 +236,7 @@ PADAPTER_OBJECT padapter
} }
BOOL BOOL
destroy_td_pool_list( destroy_td_pool_list(PUHCI_TD_POOL_LIST pool_list)
PUHCI_TD_POOL_LIST pool_list
)
{ {
PUHCI_TD_POOL pool; PUHCI_TD_POOL pool;
while (IsListEmpty(&pool_list->busy_pools) == FALSE) while (IsListEmpty(&pool_list->busy_pools) == FALSE)
@ -282,10 +250,7 @@ PUHCI_TD_POOL_LIST pool_list
} }
BOOL BOOL
expand_pool_list( expand_pool_list(PUHCI_TD_POOL_LIST pool_list, LONG pool_count) //private
PUHCI_TD_POOL_LIST pool_list,
LONG pool_count
) //private
{ {
PUHCI_TD_POOL pool; PUHCI_TD_POOL pool;
int i; int i;
@ -316,9 +281,7 @@ LONG pool_count
} }
BOOL BOOL
collect_garbage( collect_garbage(PUHCI_TD_POOL_LIST pool_list)
PUHCI_TD_POOL_LIST pool_list
)
{ {
PLIST_ENTRY prev, next; PLIST_ENTRY prev, next;
@ -354,27 +317,21 @@ PUHCI_TD_POOL_LIST pool_list
//private //private
LONG LONG
get_num_free_tds( get_num_free_tds(PUHCI_TD_POOL_LIST pool_list)
PUHCI_TD_POOL_LIST pool_list
)
{ {
return pool_list->free_tds; return pool_list->free_tds;
} }
//private //private
LONG LONG
get_max_free_tds( get_max_free_tds(PUHCI_TD_POOL_LIST pool_list)
PUHCI_TD_POOL_LIST pool_list
)
{ {
return pool_list->free_tds + pool_list->free_count * UHCI_MAX_POOL_TDS; return pool_list->free_tds + pool_list->free_count * UHCI_MAX_POOL_TDS;
} }
//add tds till pnext == NULL
BOOL BOOL
free_td( free_td(PUHCI_TD_POOL_LIST pool_list, PUHCI_TD ptd)
PUHCI_TD_POOL_LIST pool_list,
PUHCI_TD ptd
) //add tds till pnext == NULL
{ {
if (pool_list == NULL || ptd == NULL) if (pool_list == NULL || ptd == NULL)
return FALSE; return FALSE;
@ -391,10 +348,9 @@ PUHCI_TD ptd
return TRUE; return TRUE;
} }
//null if failed
PUHCI_TD PUHCI_TD
alloc_td( alloc_td(PUHCI_TD_POOL_LIST pool_list)
PUHCI_TD_POOL_LIST pool_list
) //null if failed
{ {
PLIST_ENTRY prev, next; PLIST_ENTRY prev, next;
PUHCI_TD new_td; PUHCI_TD new_td;
@ -432,10 +388,7 @@ PUHCI_TD_POOL_LIST pool_list
} }
PUHCI_TD PUHCI_TD
alloc_tds( alloc_tds(PUHCI_TD_POOL_LIST pool_list, LONG count)
PUHCI_TD_POOL_LIST pool_list,
LONG count
)
{ {
//return value is a list of tds, vert_link chain. //return value is a list of tds, vert_link chain.
@ -462,19 +415,15 @@ LONG count
TRAP(); TRAP();
} }
uhci_dbg_print( DBGLVL_MEDIUM, ("alloc_tds(): td pool-list free_tds=0x%x, free pools=0x%x\n", \ 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_tds, pool_list->free_count));
pool_list->free_count ) );
return ptd; return ptd;
} }
VOID VOID
free_tds( free_tds(PUHCI_TD_POOL_LIST pool_list, PUHCI_TD ptd)
PUHCI_TD_POOL_LIST pool_list,
PUHCI_TD ptd
)
{ {
PUHCI_TD ptofree; PUHCI_TD ptofree;
PLIST_ENTRY pthis; PLIST_ENTRY pthis;
@ -496,10 +445,7 @@ PUHCI_TD ptd
BOOL BOOL
can_transfer( can_transfer(PUHCI_TD_POOL_LIST pool_list, LONG td_count)
PUHCI_TD_POOL_LIST pool_list,
LONG td_count
)
{ {
if (td_count > get_max_free_tds(pool_list)) if (td_count > get_max_free_tds(pool_list))
return FALSE; return FALSE;
@ -508,10 +454,7 @@ LONG td_count
} }
VOID VOID
lock_td_pool( lock_td_pool(PUHCI_TD_POOL_LIST pool_list, BOOL at_dpc)
PUHCI_TD_POOL_LIST pool_list,
BOOL at_dpc
)
{ {
//if( !at_dpc ) //if( !at_dpc )
// KeAcquireSpinLock( &pool_list->pool_lock ); // KeAcquireSpinLock( &pool_list->pool_lock );
@ -520,10 +463,7 @@ BOOL at_dpc
} }
VOID VOID
unlock_td_pool( unlock_td_pool(PUHCI_TD_POOL_LIST pool_list, BOOL at_dpc)
PUHCI_TD_POOL_LIST pool_list,
BOOL at_dpc
)
{ {
//if( !at_dpc ) //if( !at_dpc )
// KeReleaseSpinLock( &pool_list->pool_lock ); // KeReleaseSpinLock( &pool_list->pool_lock );
@ -532,10 +472,7 @@ BOOL at_dpc
} }
BOOL BOOL
init_qh_pool( init_qh_pool(PUHCI_QH_POOL pqh_pool, PADAPTER_OBJECT padapter)
PUHCI_QH_POOL pqh_pool,
PADAPTER_OBJECT padapter
)
{ {
PQH_EXTENSION pqhe; PQH_EXTENSION pqhe;
LONG i; LONG i;
@ -545,19 +482,15 @@ PADAPTER_OBJECT padapter
pqh_pool->padapter = padapter; pqh_pool->padapter = padapter;
pqh_pool->qhe_array = (PQH_EXTENSION)usb_alloc_mem( pqh_pool->qhe_array = (PQH_EXTENSION) usb_alloc_mem(NonPagedPool,
NonPagedPool,
sizeof(QH_EXTENSION) * UHCI_MAX_POOL_QHS); sizeof(QH_EXTENSION) * UHCI_MAX_POOL_QHS);
if (pqh_pool->qhe_array == NULL) if (pqh_pool->qhe_array == NULL)
return FALSE; return FALSE;
pqh_pool->qh_array = \ pqh_pool->qh_array =
(PUHCI_QH)HalAllocateCommonBuffer( (PUHCI_QH) HalAllocateCommonBuffer(padapter,
padapter, sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS, &pqh_pool->logic_addr, FALSE);
sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS,
&pqh_pool->logic_addr,
FALSE);
if (pqh_pool->qh_array == NULL) if (pqh_pool->qh_array == NULL)
{ {
@ -593,11 +526,9 @@ PADAPTER_OBJECT padapter
} }
//add qhs till pnext == NULL
BOOL BOOL
free_qh( free_qh(PUHCI_QH_POOL pqh_pool, PUHCI_QH pqh)
PUHCI_QH_POOL pqh_pool,
PUHCI_QH pqh
) //add qhs till pnext == NULL
{ {
if (pqh_pool == NULL || pqh == NULL) if (pqh_pool == NULL || pqh == NULL)
return FALSE; return FALSE;
@ -610,10 +541,9 @@ PUHCI_QH pqh
return TRUE; return TRUE;
} }
//null if failed
PUHCI_QH PUHCI_QH
alloc_qh( alloc_qh(PUHCI_QH_POOL pqh_pool)
PUHCI_QH_POOL pqh_pool
) //null if failed
{ {
PQH_EXTENSION pqhe; PQH_EXTENSION pqhe;
@ -636,9 +566,7 @@ PUHCI_QH_POOL pqh_pool
} }
BOOL BOOL
destroy_qh_pool( destroy_qh_pool(PUHCI_QH_POOL pqh_pool)
PUHCI_QH_POOL pqh_pool
)
{ {
int i; int i;
@ -648,9 +576,7 @@ PUHCI_QH_POOL pqh_pool
HalFreeCommonBuffer(pqh_pool->padapter, HalFreeCommonBuffer(pqh_pool->padapter,
sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS, sizeof(UHCI_QH) * UHCI_MAX_POOL_QHS,
pqh_pool->logic_addr, pqh_pool->logic_addr, pqh_pool->qh_array, FALSE);
pqh_pool->qh_array,
FALSE);
RtlZeroMemory(pqh_pool, sizeof(UHCI_QH_POOL)); RtlZeroMemory(pqh_pool, sizeof(UHCI_QH_POOL));
@ -662,10 +588,7 @@ PUHCI_QH_POOL pqh_pool
} }
VOID VOID
lock_qh_pool( lock_qh_pool(PUHCI_QH_POOL pool, BOOL at_dpc)
PUHCI_QH_POOL pool,
BOOL at_dpc
)
{ {
//if( !at_dpc ) //if( !at_dpc )
// KeAcquireSpinLock( &pool->pool_lock ); // KeAcquireSpinLock( &pool->pool_lock );
@ -674,14 +597,10 @@ BOOL at_dpc
} }
VOID VOID
unlock_qh_pool( unlock_qh_pool(PUHCI_QH_POOL pool, BOOL at_dpc)
PUHCI_QH_POOL pool,
BOOL at_dpc
)
{ {
//if( !at_dpc ) //if( !at_dpc )
// KeReleaseSpinLock( &pool->pool_lock ); // KeReleaseSpinLock( &pool->pool_lock );
//else //else
// KeReleaseSpinLockFromDpcLevel( &pool->pool_lock ); // 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;\ return;\
} }
extern VOID extern VOID gendrv_startio(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
gendrv_startio(
IN PDEVICE_OBJECT dev_obj, NTSYSAPI NTSTATUS NTAPI ZwLoadDriver(IN PUNICODE_STRING DriverServiceName);
IN PIRP irp
);
NTSYSAPI NTSYSAPI
NTSTATUS NTSTATUS
NTAPI NTAPI
ZwLoadDriver( ObOpenObjectByName(IN POBJECT_ATTRIBUTES ObjectAttributes,
IN PUNICODE_STRING DriverServiceName
);
NTSYSAPI
NTSTATUS
NTAPI
ObOpenObjectByName(
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN POBJECT_TYPE ObjectType OPTIONAL, IN POBJECT_TYPE ObjectType OPTIONAL,
IN KPROCESSOR_MODE AccessMode, IN KPROCESSOR_MODE AccessMode,
IN OUT PACCESS_STATE AccessState OPTIONAL, IN OUT PACCESS_STATE AccessState OPTIONAL,
IN ACCESS_MASK DesiredAccess OPTIONAL, IN ACCESS_MASK DesiredAccess OPTIONAL,
IN OUT PVOID ParseContext OPTIONAL, IN OUT PVOID ParseContext OPTIONAL, OUT PHANDLE Handle);
OUT PHANDLE Handle
);
VOID VOID umss_start_io(IN PDEVICE_OBJECT dev_obj, IN PIRP irp);
umss_start_io(
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
);
NTSTATUS NTSTATUS umss_port_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp);
umss_port_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
);
BOOL BOOL umss_connect(PCONNECT_DATA dev_mgr, DEV_HANDLE dev_handle);
umss_connect(
PCONNECT_DATA dev_mgr,
DEV_HANDLE dev_handle
);
BOOL BOOL umss_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
umss_disconnect(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
BOOL BOOL umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
umss_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
NTSTATUS NTSTATUS umss_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp);
umss_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
);
VOID VOID umss_set_cfg_completion(PURB purb, PVOID pcontext);
umss_set_cfg_completion(
PURB purb,
PVOID pcontext
);
VOID VOID umss_start_create_device(IN PVOID Parameter);
umss_start_create_device(
IN PVOID Parameter
);
BOOL 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
);
BOOL BOOL umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle);
umss_stop(
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
);
NTSTATUS NTSTATUS umss_process_srb(PDEVICE_OBJECT dev_obj, PIRP irp);
umss_process_srb(
PDEVICE_OBJECT dev_obj,
PIRP irp );
VOID VOID umss_load_class_driver(PVOID context);
umss_load_class_driver(
PVOID context
);
BOOL BOOL umss_tsc_to_sff(PIO_PACKET io_packet);
umss_tsc_to_sff(
PIO_PACKET io_packet
);
VOID 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
);
PDEVICE_OBJECT PDEVICE_OBJECT
umss_create_port_device( umss_create_port_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
// currently a port device is a connection point // currently a port device is a connection point
@ -195,14 +126,8 @@ PUSB_DRIVER pdriver
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE); RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL; pdev = NULL;
status = IoCreateDevice( status = IoCreateDevice(dev_mgr->usb_driver_obj,
dev_mgr->usb_driver_obj, sizeof(UMSS_PORT_DEV_EXT), &name_string, FILE_USB_DEV_TYPE, 0, TRUE, &pdev);
sizeof( UMSS_PORT_DEV_EXT ),
&name_string,
FILE_USB_DEV_TYPE,
0,
TRUE,
&pdev);
if (status == STATUS_SUCCESS) if (status == STATUS_SUCCESS)
{ {
@ -236,9 +161,7 @@ PUSB_DRIVER pdriver
} }
BOOL BOOL
umss_delete_port_device( umss_delete_port_device(PDEVICE_OBJECT dev_obj)
PDEVICE_OBJECT dev_obj
)
{ {
UCHAR dev_name[64]; UCHAR dev_name[64];
STRING string; STRING string;
@ -262,15 +185,12 @@ PDEVICE_OBJECT dev_obj
return TRUE; return TRUE;
} }
NTSTATUS
umss_port_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
)
// FIXME!!! there can not be sent IOCTL_SUBMIT_URB_XXX while // FIXME!!! there can not be sent IOCTL_SUBMIT_URB_XXX while
// the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device. // the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device.
// not resolved yet. // not resolved yet.
// 2004-03-22 23:12:26 // 2004-03-22 23:12:26
NTSTATUS
umss_port_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp)
{ {
KIRQL irql; KIRQL irql;
ULONG ctrl_code; ULONG ctrl_code;
@ -335,10 +255,7 @@ PIRP irp
} }
BOOL BOOL
umss_driver_init( umss_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
PUMSS_DRVR_EXTENSION pdrvr_ext; PUMSS_DRVR_EXTENSION pdrvr_ext;
UNICODE_STRING unicode_string; UNICODE_STRING unicode_string;
@ -398,10 +315,7 @@ PUSB_DRIVER pdriver
} }
BOOL BOOL
umss_driver_destroy( umss_driver_destroy(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
PUMSS_DRVR_EXTENSION pdrvr_ext; PUMSS_DRVR_EXTENSION pdrvr_ext;
if (dev_mgr == NULL || pdriver == NULL) if (dev_mgr == NULL || pdriver == NULL)
@ -420,12 +334,7 @@ PUSB_DRIVER pdriver
} }
PDEVICE_OBJECT PDEVICE_OBJECT
umss_create_device( umss_create_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER umss_drvr, DEV_HANDLE dev_handle, BOOL is_if)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER umss_drvr,
DEV_HANDLE dev_handle,
BOOL is_if
)
{ {
UCHAR dev_name[64], dev_id; UCHAR dev_name[64], dev_id;
@ -449,8 +358,7 @@ BOOL is_if
RtlAnsiStringToUnicodeString(&name_string, &string, TRUE); RtlAnsiStringToUnicodeString(&name_string, &string, TRUE);
pdev = NULL; pdev = NULL;
status = IoCreateDevice( status = IoCreateDevice(dev_mgr->usb_driver_obj,
dev_mgr->usb_driver_obj,
sizeof(UMSS_DEVICE_EXTENSION), sizeof(UMSS_DEVICE_EXTENSION),
&name_string, &name_string,
FILE_USB_DEV_TYPE, FILE_USB_DEV_TYPE,
@ -508,10 +416,7 @@ BOOL is_if
} }
BOOL BOOL
umss_connect( umss_connect(PCONNECT_DATA param, DEV_HANDLE dev_handle)
PCONNECT_DATA param,
DEV_HANDLE dev_handle
)
{ {
PURB purb; PURB purb;
NTSTATUS status; NTSTATUS status;
@ -554,10 +459,7 @@ DEV_HANDLE dev_handle
} }
VOID VOID
umss_set_cfg_completion( umss_set_cfg_completion(PURB purb, PVOID pcontext)
PURB purb,
PVOID pcontext
)
{ {
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
PUCHAR buf; PUCHAR buf;
@ -636,9 +538,7 @@ PVOID pcontext
} }
VOID VOID
umss_start_create_device( umss_start_create_device(IN PVOID Parameter)
IN PVOID Parameter
)
{ {
LONG i; LONG i;
PUCHAR desc_buf; PUCHAR desc_buf;
@ -677,8 +577,8 @@ IN PVOID Parameter
pdev_obj = umss_create_device(dev_mgr, pdrvr, dev_handle, FALSE); pdev_obj = umss_create_device(dev_mgr, pdrvr, dev_handle, FALSE);
lock_dev(pdev, FALSE); lock_dev(pdev, FALSE);
if( pdev_obj == NULL || \ if (pdev_obj == NULL ||
dev_state( pdev ) == USB_DEV_STATE_ZOMB || \ dev_state(pdev) == USB_DEV_STATE_ZOMB ||
dev_mgr_set_driver(dev_mgr, dev_handle, pdrvr, pdev) == FALSE) dev_mgr_set_driver(dev_mgr, dev_handle, pdrvr, pdev) == FALSE)
{ {
usb_free_mem(desc_buf); usb_free_mem(desc_buf);
@ -703,8 +603,7 @@ IN PVOID Parameter
//search for our if //search for our if
for(i = 0; ((UCHAR) i) < pconfig_desc->bNumInterfaces; i++) for(i = 0; ((UCHAR) i) < pconfig_desc->bNumInterfaces; i++)
{ {
if( pif_desc->bLength == sizeof( USB_INTERFACE_DESC ) \ if (pif_desc->bLength == sizeof(USB_INTERFACE_DESC) && pif_desc->bDescriptorType == USB_DT_INTERFACE)
&& pif_desc->bDescriptorType == USB_DT_INTERFACE )
{ {
if (pif_desc->bInterfaceClass == USB_CLASS_MASS_STORAGE) if (pif_desc->bInterfaceClass == USB_CLASS_MASS_STORAGE)
{ {
@ -729,17 +628,15 @@ IN PVOID Parameter
pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1]; pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1];
for(i = 0; ((UCHAR) i) < pif_desc->bNumEndpoints; i++) 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)) && pendp_desc->bLength == sizeof(USB_ENDPOINT_DESC))
{ {
if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \ if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
== USB_ENDPOINT_XFER_INT )
{ {
pdev_ext->pint_endp_desc = pendp_desc; pdev_ext->pint_endp_desc = pendp_desc;
pdev_ext->int_endp_idx = (UCHAR) i; pdev_ext->int_endp_idx = (UCHAR) i;
} }
else if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \ else if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
== USB_ENDPOINT_XFER_BULK )
{ {
if (pendp_desc->bEndpointAddress & USB_DIR_IN) if (pendp_desc->bEndpointAddress & USB_DIR_IN)
{ {
@ -763,19 +660,13 @@ IN PVOID Parameter
} }
BOOL BOOL
umss_stop( umss_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
{ {
return TRUE; return TRUE;
} }
BOOL BOOL
umss_disconnect( umss_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE dev_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE dev_handle
)
{ {
PDEVICE_OBJECT dev_obj; PDEVICE_OBJECT dev_obj;
NTSTATUS status; NTSTATUS status;
@ -806,9 +697,7 @@ DEV_HANDLE dev_handle
} }
VOID VOID
umss_deferred_delete_device( umss_deferred_delete_device(PVOID context)
PVOID context
)
{ {
PDEVICE_OBJECT dev_obj; PDEVICE_OBJECT dev_obj;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -847,12 +736,7 @@ PVOID context
} }
BOOL BOOL
umss_delete_device( umss_delete_device(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdrvr, PDEVICE_OBJECT dev_obj, BOOL is_if)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdrvr,
PDEVICE_OBJECT dev_obj,
BOOL is_if
)
{ {
UCHAR dev_name[64]; UCHAR dev_name[64];
STRING string; STRING string;
@ -916,10 +800,7 @@ BOOL is_if
} }
VOID VOID
umss_submit_io_packet( umss_submit_io_packet(PDEVICE_OBJECT dev_obj, PIO_PACKET io_packet)
PDEVICE_OBJECT dev_obj,
PIO_PACKET io_packet
)
{ {
NTSTATUS status; NTSTATUS status;
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
@ -928,8 +809,7 @@ PIO_PACKET io_packet
pdev_ext = dev_obj->DeviceExtension; pdev_ext = dev_obj->DeviceExtension;
// lock the dev, the pdev_ext->pif_desc won't go away. // 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 ) ) if ((status = usb_query_and_lock_dev(pdev_ext->dev_mgr, pdev_ext->dev_handle, &pdev)) != STATUS_SUCCESS)
!= STATUS_SUCCESS )
{ {
usb_dbg_print(DBGLVL_MAXIMUM, ("umss_start_io(): error, device is not valid\n")); usb_dbg_print(DBGLVL_MAXIMUM, ("umss_start_io(): error, device is not valid\n"));
UMSS_COMPLETE_START_IO(dev_obj, status, io_packet->pirp); UMSS_COMPLETE_START_IO(dev_obj, status, io_packet->pirp);
@ -955,10 +835,7 @@ PIO_PACKET io_packet
} }
VOID VOID
umss_start_io( umss_start_io(IN PDEVICE_OBJECT dev_obj, IN PIRP irp)
IN PDEVICE_OBJECT dev_obj,
IN PIRP irp
)
{ {
KIRQL irql; KIRQL irql;
ULONG ctrl_code; ULONG ctrl_code;
@ -1060,8 +937,7 @@ IN PIRP irp
if (irp_stack->Parameters.DeviceIoControl.InputBufferLength < if (irp_stack->Parameters.DeviceIoControl.InputBufferLength <
(sizeof(SCSI_PASS_THROUGH) + (sizeof(SCSI_PASS_THROUGH) +
pass_through->SenseInfoLength + pass_through->SenseInfoLength + pass_through->DataTransferLength))
pass_through->DataTransferLength ) )
UMSS_COMPLETE_START_IO(dev_obj, STATUS_BUFFER_TOO_SMALL, irp); UMSS_COMPLETE_START_IO(dev_obj, STATUS_BUFFER_TOO_SMALL, irp);
RtlZeroMemory(&io_packet, sizeof(io_packet)); RtlZeroMemory(&io_packet, sizeof(io_packet));
@ -1138,14 +1014,11 @@ IN PIRP irp
return; return;
} }
NTSTATUS
umss_dispatch_routine(
PDEVICE_OBJECT pdev_obj,
PIRP irp
)
// bugbug!!! there can not be sent IOCTL_SUBMIT_URB_XXX while // bugbug!!! there can not be sent IOCTL_SUBMIT_URB_XXX while
// the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device. // the IOCTL_SUBMIT_CDB_XXX are active. may confuse the device.
// not resolved yet. // not resolved yet.
NTSTATUS
umss_dispatch_routine(PDEVICE_OBJECT pdev_obj, PIRP irp)
{ {
KIRQL irql; KIRQL irql;
ULONG ctrl_code; ULONG ctrl_code;
@ -1186,7 +1059,8 @@ PIRP irp
PUSB_DEV pdev; PUSB_DEV pdev;
USE_IRQL; 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); 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 // 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); EXIT_DISPATCH(STATUS_DEVICE_DOES_NOT_EXIST, irp);
lock_dev(pdev, FALSE); lock_dev(pdev, FALSE);
if( dev_state( pdev ) >= USB_DEV_STATE_BEFORE_ZOMB || if (dev_state(pdev) >= USB_DEV_STATE_BEFORE_ZOMB || dev_state(pdev) == USB_DEV_STATE_ZOMB)
dev_state( pdev ) == USB_DEV_STATE_ZOMB )
{ {
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
usb_unlock_dev(pdev); usb_unlock_dev(pdev);
@ -1293,9 +1167,7 @@ PIRP irp
ULONG required_size; ULONG required_size;
required_size = sizeof(SCSI_ADAPTER_BUS_INFO) required_size = sizeof(SCSI_ADAPTER_BUS_INFO)
+ sizeof( SCSI_BUS_DATA ) + sizeof(SCSI_BUS_DATA) + sizeof(SCSI_INQUIRY_DATA) + INQUIRYDATABUFFERSIZE;
+ sizeof( SCSI_INQUIRY_DATA )
+ INQUIRYDATABUFFERSIZE;
if (irp_stack->Parameters.DeviceIoControl.OutputBufferLength < required_size) if (irp_stack->Parameters.DeviceIoControl.OutputBufferLength < required_size)
UMSS_EXIT_DISPATCH(pdev_obj, STATUS_BUFFER_TOO_SMALL, irp); UMSS_EXIT_DISPATCH(pdev_obj, STATUS_BUFFER_TOO_SMALL, irp);
@ -1355,7 +1227,8 @@ PIRP irp
{ {
PIO_SCSI_CAPABILITIES port_cap; 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); EXIT_DISPATCH(STATUS_INVALID_PARAMETER, irp);
port_cap = (PIO_SCSI_CAPABILITIES) irp->AssociatedIrp.SystemBuffer; port_cap = (PIO_SCSI_CAPABILITIES) irp->AssociatedIrp.SystemBuffer;
@ -1402,10 +1275,7 @@ PIRP irp
} }
VOID VOID
umss_reset_pipe_completion( umss_reset_pipe_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUMSS_DEVICE_EXTENSION pdev_ext; PUMSS_DEVICE_EXTENSION pdev_ext;
if (context == NULL) if (context == NULL)
@ -1417,12 +1287,9 @@ PVOID context
return; return;
} }
NTSTATUS
umss_reset_pipe(
PUMSS_DEVICE_EXTENSION pdev_ext,
DEV_HANDLE endp_handle
)
//can only be called at passive level //can only be called at passive level
NTSTATUS
umss_reset_pipe(PUMSS_DEVICE_EXTENSION pdev_ext, DEV_HANDLE endp_handle)
{ {
NTSTATUS status; NTSTATUS status;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -1436,20 +1303,11 @@ DEV_HANDLE endp_handle
if (status != STATUS_SUCCESS) if (status != STATUS_SUCCESS)
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
status = usb_reset_pipe_ex( status = usb_reset_pipe_ex(pdev_ext->dev_mgr, endp_handle, umss_reset_pipe_completion, pdev_ext);
pdev_ext->dev_mgr,
endp_handle,
umss_reset_pipe_completion,
pdev_ext );
if (status == STATUS_PENDING) if (status == STATUS_PENDING)
{ {
KeWaitForSingleObject( KeWaitForSingleObject(&pdev_ext->sync_event, Executive, KernelMode, TRUE, NULL);
&pdev_ext->sync_event,
Executive,
KernelMode,
TRUE,
NULL );
status = pdev_ext->reset_pipe_status; status = pdev_ext->reset_pipe_status;
} }
usb_unlock_dev(pdev); usb_unlock_dev(pdev);
@ -1457,11 +1315,7 @@ DEV_HANDLE endp_handle
} }
BOOL BOOL
umss_gen_result_srb( umss_gen_result_srb(PIO_PACKET io_packet, PSCSI_REQUEST_BLOCK srb, NTSTATUS status)
PIO_PACKET io_packet,
PSCSI_REQUEST_BLOCK srb,
NTSTATUS status
)
{ {
if (srb == NULL || io_packet == NULL) if (srb == NULL || io_packet == NULL)
@ -1537,7 +1391,8 @@ NTSTATUS status
srb->SrbStatus = SRB_STATUS_ERROR; 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) if (io_packet->data_buffer)
{ {
@ -1549,11 +1404,7 @@ NTSTATUS status
} }
BOOL BOOL
umss_gen_result_ctrl( umss_gen_result_ctrl(PDEVICE_OBJECT dev_obj, PIRP irp, NTSTATUS status)
PDEVICE_OBJECT dev_obj,
PIRP irp,
NTSTATUS status
)
{ {
PIO_STACK_LOCATION irp_stack; PIO_STACK_LOCATION irp_stack;
ULONG ctrl_code; ULONG ctrl_code;
@ -1598,7 +1449,8 @@ NTSTATUS status
// pass_through_direct->SenseInfoLength = pdev_ext->io_packet.sense_data_length; // pass_through_direct->SenseInfoLength = pdev_ext->io_packet.sense_data_length;
if (status == STATUS_SUCCESS) 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 else
pass_through_direct->ScsiStatus = SCSISTAT_CHECK_CONDITION; pass_through_direct->ScsiStatus = SCSISTAT_CHECK_CONDITION;
@ -1610,10 +1462,7 @@ NTSTATUS status
VOID VOID
umss_complete_request( umss_complete_request(PUMSS_DEVICE_EXTENSION pdev_ext, NTSTATUS status)
PUMSS_DEVICE_EXTENSION pdev_ext,
NTSTATUS status
)
{ {
PIRP pirp; PIRP pirp;
KIRQL old_irql; KIRQL old_irql;
@ -1668,10 +1517,7 @@ NTSTATUS status
} }
BOOL BOOL
umss_if_connect( umss_if_connect(PCONNECT_DATA params, DEV_HANDLE if_handle)
PCONNECT_DATA params,
DEV_HANDLE if_handle
)
{ {
PURB purb; PURB purb;
LONG if_idx, i; LONG if_idx, i;
@ -1813,17 +1659,15 @@ DEV_HANDLE if_handle
pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1]; pendp_desc = (PUSB_ENDPOINT_DESC) & pif_desc[1];
for(i = 0; ((UCHAR) i) < pif_desc->bNumEndpoints; i++) 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)) && pendp_desc->bLength == sizeof(USB_ENDPOINT_DESC))
{ {
if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \ if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
== USB_ENDPOINT_XFER_INT )
{ {
pdev_ext->pint_endp_desc = pendp_desc; pdev_ext->pint_endp_desc = pendp_desc;
pdev_ext->int_endp_idx = (UCHAR) i; pdev_ext->int_endp_idx = (UCHAR) i;
} }
else if( ( pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK ) \ else if ((pendp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_BULK)
== USB_ENDPOINT_XFER_BULK )
{ {
if (pendp_desc->bEndpointAddress & USB_DIR_IN) if (pendp_desc->bEndpointAddress & USB_DIR_IN)
{ {
@ -1845,16 +1689,13 @@ DEV_HANDLE if_handle
// notify the class driver, some device comes // notify the class driver, some device comes
pdrvr_ext = (PUMSS_DRVR_EXTENSION) pdrvr->driver_ext; pdrvr_ext = (PUMSS_DRVR_EXTENSION) pdrvr->driver_ext;
if( pdrvr_ext && 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 )
pdrvr_ext->class_driver_info.add_device(pdrvr_ext->class_driver_info.fdo_driver, pdev_obj); pdrvr_ext->class_driver_info.add_device(pdrvr_ext->class_driver_info.fdo_driver, pdev_obj);
usb_unlock_dev(pdev); usb_unlock_dev(pdev);
return TRUE; return TRUE;
ERROR_OUT: ERROR_OUT:
if (desc_buf) if (desc_buf)
usb_free_mem(desc_buf); usb_free_mem(desc_buf);
@ -1870,10 +1711,7 @@ ERROR_OUT:
} }
BOOL BOOL
umss_if_disconnect( umss_if_disconnect(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
{ {
LONG if_idx; LONG if_idx;
NTSTATUS status; NTSTATUS status;
@ -1919,10 +1757,7 @@ DEV_HANDLE if_handle
} }
BOOL BOOL
umss_if_stop( umss_if_stop(PUSB_DEV_MANAGER dev_mgr, DEV_HANDLE if_handle)
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE if_handle
)
{ {
LONG if_idx; LONG if_idx;
NTSTATUS status; NTSTATUS status;
@ -1971,9 +1806,7 @@ DEV_HANDLE if_handle
} }
VOID VOID
umss_load_class_driver( umss_load_class_driver(PVOID context)
PVOID context
)
{ {
NTSTATUS status; NTSTATUS status;
UNICODE_STRING unicode_string; UNICODE_STRING unicode_string;
@ -1981,15 +1814,15 @@ PVOID context
// //
// let's load the class driver // 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); 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 BOOL
umss_if_driver_init( umss_if_driver_init(PUSB_DEV_MANAGER dev_mgr, PUSB_DRIVER pdriver)
PUSB_DEV_MANAGER dev_mgr,
PUSB_DRIVER pdriver
)
{ {
PUMSS_DRVR_EXTENSION pdrvr_ext; PUMSS_DRVR_EXTENSION pdrvr_ext;
UNICODE_STRING unicode_string; UNICODE_STRING unicode_string;
@ -2046,7 +1879,6 @@ PUSB_DRIVER pdriver
// //
// let's load the class driver // let's load the class driver
// //
umss_load_class_driver(NULL); umss_load_class_driver(NULL);
// umss_schedule_workitem( NULL, umss_load_class_driver, NULL, 0 ); // umss_schedule_workitem( NULL, umss_load_class_driver, NULL, 0 );
@ -2055,18 +1887,14 @@ PUSB_DRIVER pdriver
return TRUE; 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 // get the driver reg information for pnp notification to class
// driver. // driver.
// bug??? how if the driver info is returned while the driver // bug??? how if the driver info is returned while the driver
// is being unloaded. // is being unloaded.
// So the routine must be called when usb_query_and_lock_dev is // So the routine must be called when usb_query_and_lock_dev is
// called. // 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; PUMSS_DRVR_EXTENSION drvr_ext;
ULONG if_idx; ULONG if_idx;
@ -2104,9 +1932,7 @@ DEV_HANDLE if_handle
} }
VOID VOID
umss_worker( umss_worker(IN PVOID reference)
IN PVOID reference
)
{ {
PUMSS_WORKER_PACKET worker_packet; PUMSS_WORKER_PACKET worker_packet;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -2124,13 +1950,6 @@ IN PVOID reference
usb_dbg_print(DBGLVL_MAXIMUM, ("umss_worker(): exit\n")); 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: Routine Description:
@ -2151,7 +1970,9 @@ Return Value:
FALSE if work item not queued 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; BOOL ret_val = TRUE;
PWORK_QUEUE_ITEM workitem; PWORK_QUEUE_ITEM workitem;
@ -2182,17 +2003,10 @@ Return Value:
} }
} }
// Initialize the work-item // Initialize the work-item
ExInitializeWorkItem( ExInitializeWorkItem(workitem, umss_worker, worker_packet);
workitem,
umss_worker,
worker_packet
);
// Schedule the work-item // Schedule the work-item
ExQueueWorkItem( ExQueueWorkItem(workitem, DelayedWorkQueue);
workitem,
DelayedWorkQueue
);
usb_dbg_print(DBGLVL_MINIMUM, ("umss_schedule_workitem(): work-item queued\n")); usb_dbg_print(DBGLVL_MINIMUM, ("umss_schedule_workitem(): work-item queued\n"));
} }
@ -2206,10 +2020,7 @@ Return Value:
} }
NTSTATUS NTSTATUS
umss_process_srb( umss_process_srb(PDEVICE_OBJECT dev_obj, PIRP irp)
PDEVICE_OBJECT dev_obj,
PIRP irp
)
{ {
NTSTATUS status; NTSTATUS status;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -2242,7 +2053,6 @@ PIRP irp
// //
// let's build the srb status for class driver // let's build the srb status for class driver
// //
srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID; srb->SrbStatus |= SRB_STATUS_AUTOSENSE_VALID;
RtlZeroMemory(srb->SenseInfoBuffer, srb->SenseInfoBufferLength); RtlZeroMemory(srb->SenseInfoBuffer, srb->SenseInfoBufferLength);
if (!(srb->SrbFlags & SRB_FLAGS_DISABLE_AUTOSENSE)) if (!(srb->SrbFlags & SRB_FLAGS_DISABLE_AUTOSENSE))
@ -2281,7 +2091,8 @@ PIRP irp
} }
else 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 // since these operations does not allign the buffer on page boundary
@ -2326,8 +2137,8 @@ PIRP irp
{ {
status = STATUS_DEVICE_PROTOCOL_ERROR; status = STATUS_DEVICE_PROTOCOL_ERROR;
usb_dbg_print( DBGLVL_MAXIMUM, ( "umss_process_srb(): error converting to sff proto, 0x%x\n", usb_dbg_print(DBGLVL_MAXIMUM,
status ) ); ("umss_process_srb(): error converting to sff proto, 0x%x\n", status));
srb->SrbStatus = SRB_STATUS_ERROR; srb->SrbStatus = SRB_STATUS_ERROR;
break; break;
} }
@ -2338,7 +2149,7 @@ PIRP irp
// //
// currently we support only transparent scsi command set // 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) pdev_ext->pif_desc->bInterfaceSubClass == UMSS_SUBCLASS_SFF8070I)
status = umss_bulkonly_startio(pdev_ext, &io_packet); status = umss_bulkonly_startio(pdev_ext, &io_packet);
else else
@ -2357,8 +2168,7 @@ PIRP irp
if (status != STATUS_PENDING && status != STATUS_SUCCESS) if (status != STATUS_PENDING && status != STATUS_SUCCESS)
{ {
// error occured // error occured
usb_dbg_print( DBGLVL_MAXIMUM, ( "umss_process_srb(): error sending request, 0x%x\n", usb_dbg_print(DBGLVL_MAXIMUM, ("umss_process_srb(): error sending request, 0x%x\n", status));
status ) );
srb->SrbStatus = SRB_STATUS_ERROR; srb->SrbStatus = SRB_STATUS_ERROR;
} }
break; break;
@ -2390,13 +2200,13 @@ PIRP irp
pdev = NULL; pdev = NULL;
ERROR_OUT: ERROR_OUT:
irp->IoStatus.Status = status; irp->IoStatus.Status = status;
if (status != STATUS_PENDING) if (status != STATUS_PENDING)
{ {
IoStartNextPacket(dev_obj, FALSE); IoStartNextPacket(dev_obj, FALSE);
IoCompleteRequest(irp, IO_NO_INCREMENT); IoCompleteRequest(irp, IO_NO_INCREMENT);
} }
// //
// UMSS_COMPLETE_START_IO( dev_obj, status, irp ); // UMSS_COMPLETE_START_IO( dev_obj, status, irp );
// //
@ -2404,9 +2214,7 @@ ERROR_OUT:
} }
BOOL BOOL
umss_tsc_to_sff( umss_tsc_to_sff(PIO_PACKET io_packet)
PIO_PACKET io_packet
)
{ {
if (io_packet == NULL) if (io_packet == NULL)
return FALSE; return FALSE;
@ -2423,17 +2231,15 @@ PIO_PACKET io_packet
io_packet->data_length = 8; io_packet->data_length = 8;
return TRUE; return TRUE;
} }
if( io_packet->cdb[ 0 ] == SCSIOP_REASSIGN_BLOCKS || \ if (io_packet->cdb[0] == SCSIOP_REASSIGN_BLOCKS ||
io_packet->cdb[ 0 ] == SCSIOP_RESERVE_UNIT || \ io_packet->cdb[0] == SCSIOP_RESERVE_UNIT || io_packet->cdb[0] == SCSIOP_RELEASE_UNIT)
io_packet->cdb[ 0 ] == SCSIOP_RELEASE_UNIT )
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
VOID VOID
umss_fix_sff_result( umss_fix_sff_result(PIO_PACKET io_packet, SCSI_REQUEST_BLOCK *srb)
PIO_PACKET io_packet,
SCSI_REQUEST_BLOCK *srb )
{ {
PBYTE buf; PBYTE buf;
if (io_packet->cdb[0] != 0x5a) 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; LONG g_alloc_cnt = 0;
ULONG cpu_clock_freq = 0; ULONG cpu_clock_freq = 0;
NTSTATUS NTSTATUS usb_get_descriptor(PUSB_DEV pdev, PURB purb);
usb_get_descriptor(
PUSB_DEV pdev,
PURB purb
);
VOID VOID usb_set_interface_completion(PURB purb, PVOID context);
usb_set_interface_completion(
PURB purb,
PVOID context
);
NTSTATUS NTSTATUS usb_set_interface(PURB purb);
usb_set_interface(
PURB purb
);
PVOID PVOID
usb_alloc_mem( usb_alloc_mem(POOL_TYPE pool_type, LONG size)
POOL_TYPE pool_type,
LONG size
)
{ {
PVOID ret; PVOID ret;
g_alloc_cnt++; g_alloc_cnt++;
@ -58,29 +44,18 @@ LONG size
} }
VOID VOID
usb_free_mem( usb_free_mem(PVOID pbuf)
PVOID pbuf
)
{ {
g_alloc_cnt--; g_alloc_cnt--;
usb_dbg_print(DBGLVL_MAXIMUM, ("usb_free_mem(): alloced=0x%x\n", g_alloc_cnt)); usb_dbg_print(DBGLVL_MAXIMUM, ("usb_free_mem(): alloced=0x%x\n", g_alloc_cnt));
ExFreePool(pbuf); ExFreePool(pbuf);
} }
VOID VOID usb_config_dev_completion(PURB purb, PVOID context);
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 //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; LONG tmp;
@ -134,18 +109,14 @@ LONG byte_count
return 125001; 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 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 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. // 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 // 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; int i;
PLIST_ENTRY pthis, pnext; PLIST_ENTRY pthis, pnext;
@ -208,9 +179,7 @@ PUSB_DEV* ppdev
} }
NTSTATUS NTSTATUS
usb_unlock_dev( usb_unlock_dev(PUSB_DEV dev)
PUSB_DEV dev
)
{ {
USE_BASIC_NON_PENDING_IRQL; USE_BASIC_NON_PENDING_IRQL;
@ -226,12 +195,10 @@ PUSB_DEV dev
} }
NTSTATUS NTSTATUS
usb_reset_pipe_ex( usb_reset_pipe_ex(PUSB_DEV_MANAGER dev_mgr,
PUSB_DEV_MANAGER dev_mgr,
DEV_HANDLE endp_handle, //endp handle to reset 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 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; NTSTATUS status;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -269,8 +236,7 @@ PVOID param
} }
pendp = &pdev->usb_config->interf[if_idx].endp[endp_idx]; pendp = &pdev->usb_config->interf[if_idx].endp[endp_idx];
unlock_dev( pdev, FALSE ) unlock_dev(pdev, FALSE) status = usb_reset_pipe(pdev, pendp, reset_completion, param);
status = usb_reset_pipe( pdev, pendp, reset_completion, param );
usb_unlock_dev(pdev); usb_unlock_dev(pdev);
return status; return status;
@ -281,14 +247,9 @@ LBL_OUT:
return status; 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 // 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; PHCD hcd;
@ -337,10 +298,7 @@ PVOID param
} }
VOID VOID
usb_reset_pipe_completion( usb_reset_pipe_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUSB_DEV pdev; PUSB_DEV pdev;
PUSB_ENDPOINT pendp; PUSB_ENDPOINT pendp;
@ -367,7 +325,7 @@ PVOID context
pendp->flags &= ~USB_ENDP_FLAG_STAT_MASK; pendp->flags &= ~USB_ENDP_FLAG_STAT_MASK;
//reset toggle endp_type //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->pusb_endp_desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
{ {
pendp->flags &= ~USB_ENDP_FLAG_DATATOGGLE; pendp->flags &= ~USB_ENDP_FLAG_DATATOGGLE;
@ -386,12 +344,8 @@ LBL_OUT:
} }
void void
usb_reset_pipe_from_dispatch_completion( usb_reset_pipe_from_dispatch_completion(PURB purb, PVOID param)
PURB purb,
PVOID param
)
{ {
PURB pclient_urb; PURB pclient_urb;
if (purb == NULL || param == NULL) if (purb == NULL || param == NULL)
TRAP(); TRAP();
@ -407,11 +361,9 @@ PVOID param
return; return;
} }
//used to check descriptor validity
BOOL BOOL
is_header_match( is_header_match(PBYTE pbuf, ULONG type)
PBYTE pbuf,
ULONG type
) //used to check descriptor validity
{ {
BOOL ret; BOOL ret;
PUSB_DESC_HEADER phdr; PUSB_DESC_HEADER phdr;
@ -421,26 +373,22 @@ ULONG type
{ {
case USB_DT_DEVICE: case USB_DT_DEVICE:
{ {
ret = ( phdr->bLength == sizeof( USB_DEVICE_DESC ) ret = (phdr->bLength == sizeof(USB_DEVICE_DESC) && phdr->bDescriptorType == USB_DT_DEVICE);
&& phdr->bDescriptorType == USB_DT_DEVICE );
break; break;
} }
case USB_DT_CONFIG: case USB_DT_CONFIG:
{ {
ret = ( phdr->bLength == sizeof( USB_CONFIGURATION_DESC ) ret = (phdr->bLength == sizeof(USB_CONFIGURATION_DESC) && phdr->bDescriptorType == USB_DT_CONFIG);
&& phdr->bDescriptorType == USB_DT_CONFIG );
break; break;
} }
case USB_DT_INTERFACE: case USB_DT_INTERFACE:
{ {
ret = ( phdr->bLength == sizeof( USB_INTERFACE_DESC ) ret = (phdr->bLength == sizeof(USB_INTERFACE_DESC) && phdr->bDescriptorType == USB_DT_INTERFACE);
&& phdr->bDescriptorType == USB_DT_INTERFACE );
break; break;
} }
case USB_DT_ENDPOINT: case USB_DT_ENDPOINT:
{ {
ret = ( phdr->bLength == sizeof( USB_ENDPOINT_DESC ) ret = (phdr->bLength == sizeof(USB_ENDPOINT_DESC) && phdr->bDescriptorType == USB_DT_ENDPOINT);
&& phdr->bDescriptorType == USB_DT_ENDPOINT );
break; break;
} }
default: default:
@ -450,10 +398,7 @@ ULONG type
} }
BOOL BOOL
usb_skip_endp_desc( usb_skip_endp_desc(PBYTE * pbUF, LONG n)
PBYTE* pbUF,
LONG n
)
{ {
if (is_header_match(*pbUF, USB_DT_ENDPOINT)) if (is_header_match(*pbUF, USB_DT_ENDPOINT))
{ {
@ -464,9 +409,7 @@ LONG n
} }
BOOL BOOL
usb_skip_if_desc( usb_skip_if_desc(PBYTE * pBUF)
PBYTE* pBUF
)
{ {
BOOL ret; BOOL ret;
PUSB_INTERFACE_DESC pif_desc = (PUSB_INTERFACE_DESC) * pBUF; PUSB_INTERFACE_DESC pif_desc = (PUSB_INTERFACE_DESC) * pBUF;
@ -489,9 +432,7 @@ PBYTE* pBUF
} }
BOOL BOOL
usb_skip_if_and_altif( usb_skip_if_and_altif(PUCHAR * pdesc_BUF)
PUCHAR* pdesc_BUF
)
{ {
BOOL ret; BOOL ret;
PUSB_INTERFACE_DESC pif_desc1 = (PUSB_INTERFACE_DESC) * pdesc_BUF; PUSB_INTERFACE_DESC pif_desc1 = (PUSB_INTERFACE_DESC) * pdesc_BUF;
@ -512,10 +453,9 @@ PUCHAR* pdesc_BUF
return ret; return ret;
} }
BOOL BOOL
usb_skip_one_config( usb_skip_one_config(PUCHAR *pconfig_desc_BUF)
PUCHAR* pconfig_desc_BUF
)
{ {
LONG if_count, i; LONG if_count, i;
BOOL ret; BOOL ret;
@ -549,11 +489,7 @@ PUCHAR* pconfig_desc_BUF
} }
PUSB_CONFIGURATION_DESC PUSB_CONFIGURATION_DESC
usb_find_config_desc_by_idx( usb_find_config_desc_by_idx(PUCHAR pbuf, LONG idx, LONG cfg_count)
PUCHAR pbuf,
LONG idx,
LONG cfg_count
)
{ {
LONG i; LONG i;
BOOL ret; BOOL ret;
@ -580,11 +516,7 @@ LONG cfg_count
} }
PUSB_CONFIGURATION_DESC PUSB_CONFIGURATION_DESC
usb_find_config_desc_by_val( usb_find_config_desc_by_val(PBYTE pbuf, LONG val, LONG cfg_count)
PBYTE pbuf,
LONG val,
LONG cfg_count
)
{ {
LONG i; LONG i;
BOOL ret; BOOL ret;
@ -611,9 +543,7 @@ LONG cfg_count
#define if_from_handle( handle ) ( ( handle & 0xff00 ) >> 8 ) #define if_from_handle( handle ) ( ( handle & 0xff00 ) >> 8 )
NTSTATUS NTSTATUS
usb_submit_config_urb( usb_submit_config_urb(PURB purb)
PURB purb
)
{ {
PUSB_DEV pdev; PUSB_DEV pdev;
PUSB_DEV_MANAGER dev_mgr; PUSB_DEV_MANAGER dev_mgr;
@ -642,8 +572,7 @@ PURB purb
goto LBL_OUT; goto LBL_OUT;
} }
if( dev_state( pdev ) == USB_DEV_STATE_FIRST_CONFIG if (dev_state(pdev) == USB_DEV_STATE_FIRST_CONFIG || dev_state(pdev) == USB_DEV_STATE_RECONFIG)
|| dev_state( pdev ) == USB_DEV_STATE_RECONFIG )
{ {
//outstanding request of set configuration exists in process //outstanding request of set configuration exists in process
status = STATUS_UNSUCCESSFUL; status = STATUS_UNSUCCESSFUL;
@ -678,10 +607,7 @@ PURB purb
UsbBuildSelectConfigurationRequest(purb1, UsbBuildSelectConfigurationRequest(purb1,
usb_make_handle(pdev->dev_id, 0, 0) | 0xffff, usb_make_handle(pdev->dev_id, 0, 0) | 0xffff,
psetup->wValue, psetup->wValue, usb_config_dev_completion, 0, ((ULONG) purb));
usb_config_dev_completion,
0,
( ( ULONG )purb ) );
purb1->pdev = pdev; purb1->pdev = pdev;
purb1->pendp = pendp; purb1->pendp = pendp;
@ -706,10 +632,7 @@ PURB purb
NTSTATUS NTSTATUS
usb_submit_urb( usb_submit_urb(PUSB_DEV_MANAGER dev_mgr, PURB purb)
PUSB_DEV_MANAGER dev_mgr,
PURB purb
)
{ {
NTSTATUS status; NTSTATUS status;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -786,26 +709,22 @@ PURB purb
if (default_endp_handle(endp_handle)) if (default_endp_handle(endp_handle))
{ {
psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet; psetup = (PUSB_CTRL_SETUP_PACKET) purb->setup_packet;
if( psetup->bmRequestType == 0 if (psetup->bmRequestType == 0 && psetup->bRequest == USB_REQ_SET_CONFIGURATION)
&& psetup->bRequest == USB_REQ_SET_CONFIGURATION )
{ {
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
status = usb_submit_config_urb(purb); status = usb_submit_config_urb(purb);
goto LBL_OUT; goto LBL_OUT;
} }
else if( psetup->bmRequestType == 1 else if (psetup->bmRequestType == 1 && psetup->bRequest == USB_REQ_SET_INTERFACE)
&& psetup->bRequest == USB_REQ_SET_INTERFACE )
{ {
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
// status = STATUS_NOT_SUPPORTED; // status = STATUS_NOT_SUPPORTED;
status = usb_set_interface(purb); status = usb_set_interface(purb);
goto LBL_OUT; goto LBL_OUT;
} }
else if( psetup->bmRequestType == 0x80 else if (psetup->bmRequestType == 0x80 && psetup->bRequest == USB_REQ_GET_DESCRIPTOR)
&& psetup->bRequest == USB_REQ_GET_DESCRIPTOR )
{ {
if( ( psetup->wValue >> 8 ) == USB_DT_CONFIG if ((psetup->wValue >> 8) == USB_DT_CONFIG || (psetup->wValue >> 8) == USB_DT_DEVICE)
|| ( psetup->wValue >> 8 ) == USB_DT_DEVICE )
{ {
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
status = usb_get_descriptor(pdev, purb); status = usb_get_descriptor(pdev, purb);
@ -816,9 +735,7 @@ PURB purb
//goto LBL_OUT; //goto LBL_OUT;
} }
} }
else if( psetup->bmRequestType == 0x02 else if (psetup->bmRequestType == 0x02 && psetup->bRequest == USB_REQ_CLEAR_FEATURE && psetup->wValue == 0) //reset pipe
&& psetup->bRequest == USB_REQ_CLEAR_FEATURE
&& psetup->wValue == 0 ) //reset pipe
{ {
ULONG endp_addr; ULONG endp_addr;
BOOL found; BOOL found;
@ -855,11 +772,7 @@ PURB purb
goto LBL_OUT; goto LBL_OUT;
} }
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
status = usb_reset_pipe_ex( status = usb_reset_pipe_ex(dev_mgr, endp_handle, usb_reset_pipe_from_dispatch_completion, purb);
dev_mgr,
endp_handle,
usb_reset_pipe_from_dispatch_completion,
purb );
goto LBL_OUT; goto LBL_OUT;
} }
@ -875,10 +788,7 @@ PURB purb
void void
usb_config_dev_completion( usb_config_dev_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PURB puser_urb; PURB puser_urb;
PUSB_DEV pdev; PUSB_DEV pdev;
@ -936,8 +846,7 @@ PVOID context
config_val = psetup->wValue; config_val = psetup->wValue;
status = dev_mgr_build_usb_config(pdev, status = dev_mgr_build_usb_config(pdev,
&pdev->desc_buf[sizeof(USB_DEVICE_DESC)], &pdev->desc_buf[sizeof(USB_DEVICE_DESC)],
config_val, config_val, pdev->pusb_dev_desc->bNumConfigurations);
pdev->pusb_dev_desc->bNumConfigurations );
if (status != STATUS_SUCCESS) if (status != STATUS_SUCCESS)
{ {
pdev->flags &= ~USB_DEV_STATE_MASK; pdev->flags &= ~USB_DEV_STATE_MASK;
@ -947,8 +856,7 @@ PVOID context
pdev->flags &= ~USB_DEV_STATE_MASK; pdev->flags &= ~USB_DEV_STATE_MASK;
pdev->flags |= USB_DEV_STATE_CONFIGURED; pdev->flags |= USB_DEV_STATE_CONFIGURED;
//this usb dev represents physical dev //this usb dev represents physical dev
if( pdev->pusb_dev_desc->bDeviceClass == USB_CLASS_HUB if (pdev->pusb_dev_desc->bDeviceClass == USB_CLASS_HUB && pdev->pusb_dev_desc->bDeviceSubClass == 0)
&& pdev->pusb_dev_desc->bDeviceSubClass == 0 )
{ {
pdev->flags &= ~USB_DEV_CLASS_MASK; pdev->flags &= ~USB_DEV_CLASS_MASK;
pdev->flags |= USB_DEV_CLASS_HUB; pdev->flags |= USB_DEV_CLASS_HUB;
@ -972,6 +880,7 @@ PVOID context
pdev->flags &= ~USB_DEV_STATE_MASK; pdev->flags &= ~USB_DEV_STATE_MASK;
pdev->flags |= USB_DEV_STATE_CONFIGURED; pdev->flags |= USB_DEV_STATE_CONFIGURED;
} }
LBL_OUT: LBL_OUT:
unlock_dev(pdev, TRUE); unlock_dev(pdev, TRUE);
usb_free_mem(purb); usb_free_mem(purb);
@ -982,10 +891,7 @@ PVOID context
} }
NTSTATUS NTSTATUS
usb_get_descriptor( usb_get_descriptor(PUSB_DEV pdev, PURB purb)
PUSB_DEV pdev,
PURB purb
)
{ {
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
LONG idx, size, count, i; LONG idx, size, count, i;
@ -1041,9 +947,7 @@ PURB purb
} }
else if ((psetup->wValue >> 8) == USB_DT_DEVICE) else if ((psetup->wValue >> 8) == USB_DT_DEVICE)
{ {
size = purb->data_length > sizeof( USB_DEVICE_DESC ) size = purb->data_length > sizeof(USB_DEVICE_DESC) ? sizeof(USB_DEVICE_DESC) : purb->data_length;
? sizeof( USB_DEVICE_DESC )
: purb->data_length;
for(i = 0; i < size; i++) for(i = 0; i < size; i++)
{ {
@ -1051,12 +955,14 @@ PURB purb
} }
purb->status = STATUS_SUCCESS; purb->status = STATUS_SUCCESS;
} }
LBL_OUT: LBL_OUT:
unlock_dev(pdev, FALSE); unlock_dev(pdev, FALSE);
return purb->status; return purb->status;
} }
LONG usb_count_list( PLIST_HEAD list_head ) LONG
usb_count_list(PLIST_HEAD list_head)
{ {
LONG count; LONG count;
PLIST_ENTRY pthis, pnext; PLIST_ENTRY pthis, pnext;
@ -1078,9 +984,7 @@ LONG usb_count_list( PLIST_HEAD list_head )
// checks if processor supports Time Stamp Counter // checks if processor supports Time Stamp Counter
__inline BOOL __inline BOOL
usb_query_clicks( usb_query_clicks(PLARGE_INTEGER clicks)
PLARGE_INTEGER clicks
)
{ {
BOOL ret_val; BOOL ret_val;
//so we have to use intel's cpu??? //so we have to use intel's cpu???
@ -1112,9 +1016,7 @@ LBL_OUT:
} }
VOID VOID
usb_wait_ms_dpc( usb_wait_ms_dpc(ULONG ms)
ULONG ms
)
{ {
LARGE_INTEGER start; LARGE_INTEGER start;
LARGE_INTEGER ticker; LARGE_INTEGER ticker;
@ -1154,9 +1056,7 @@ ULONG ms
VOID VOID
usb_wait_us_dpc( usb_wait_us_dpc(ULONG us)
ULONG us
)
{ {
LARGE_INTEGER start; LARGE_INTEGER start;
LARGE_INTEGER ticker; LARGE_INTEGER ticker;
@ -1219,9 +1119,7 @@ usb_cal_cpu_freq()
} }
NTSTATUS NTSTATUS
usb_set_interface( usb_set_interface(PURB purb)
PURB purb
)
{ {
ULONG u; ULONG u;
PURB purb1; PURB purb1;
@ -1354,10 +1252,7 @@ LBL_SEND_URB:
} }
VOID VOID
usb_set_interface_completion( usb_set_interface_completion(PURB purb, PVOID context)
PURB purb,
PVOID context
)
{ {
PUSB_CTRL_SETUP_PACKET psetup; PUSB_CTRL_SETUP_PACKET psetup;
PUSB_INTERFACE pif, palt_if; PUSB_INTERFACE pif, palt_if;
@ -1445,13 +1340,11 @@ PVOID context
usb_complete_and_free_ctrl_urb(purb); 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 // can only be called when current completion finished and called only in
// urb completion. And this func may be called recursively, if this routine // urb completion. And this func may be called recursively, if this routine
// is called, the urb must be treated as released. // is called, the urb must be treated as released.
VOID
usb_call_ctrl_completion(PURB purb)
{ {
PURB parent_urb; PURB parent_urb;
PCTRL_REQ_STACK pstack; PCTRL_REQ_STACK pstack;
@ -1520,4 +1413,3 @@ PURB purb
else else
return; return;
} }