usb_pipe_close(9f) 맨 페이지 - 윈디하나의 솔라나라

개요

섹션
맨 페이지 이름
검색(S)

usb_pipe_close(9f)

usb_pipe_close(9F)             Kernel Functions             usb_pipe_close(9F)

NAME
       usb_pipe_close - Close and cleanup a USB device pipe

SYNOPSIS
       #include <sys/usb/usba.h>

       void usb_pipe_close(dev_info_t *dip, usb_pipe_handle_t pipe_handle,
            usb_flags_t flags,
            void (*callback)(usb_pipe_handle_t pipe_handle,
            usb_opaque_t arg, int rval,
            usb_cb_flags_t flags), usb_opaque_t callback_arg);

INTERFACE LEVEL
       Solaris DDI specific (Solaris DDI)

PARAMETERS
       dip             Pointer to the device's dev_info structure.


       pipe_handle     Handle  of pipe to close. Cannot be a handle to the de‐
                       fault control pipe.


       flags           USB_FLAGS_SLEEP is the only flag recognized. Set it  to
                       wait  for  resources,  for pipe to become free, and for
                       all pending request callbacks to complete.


       callback        This  function  is  called   on   completion   if   the
                       USB_FLAGS_SLEEP flag is not specified. Mandatory if the
                       USB_FLAGS_SLEEP flag has not been specified.


       callback_arg    Second argument to callback function.


DESCRIPTION
       The  usb_pipe_close()  function closes the pipe pointed to by pipe_han‐
       dle, releases all related resources and then  frees  the  pipe  handle.
       This function stops polling if the pipe to be closed is an interrupt-IN
       or isochronous-IN pipe. The default control pipe cannot be closed.


       Pipe  cleanup includes waiting for the all pending requests in the pipe
       to finish, and then flushing residual requests remaining after  waiting
       for  several seconds. Exception handlers of flushed requests are called
       with a completion reason of USB_CR_FLUSHED.


       If USB_FLAGS_SLEEP is specified in flags, wait for all  cleanup  opera‐
       tions to complete before calling the callback handler and returning.


       If USB_FLAGS_SLEEP is not specified in flags, an asynchronous close (to
       be  done  in  a  separate thread) is requested. Return immediately. The
       callback handler is called after all pending operations are completed.


       The callback parameter is the callback handler and takes the  following
       arguments:

       usb_pipe_handle_t pipe_handle

           Handle of the pipe to close.


       usb_opaque_t callback_arg

           Callback_arg specified to usb_pipe_close().


       int rval

           Return value of close operation


       usb_cb_flags_t callback_flags

           Status of queueing operation. Can be:

           USB_CB_NO_INFO             Callback was uneventful.


           USB_CB_ASYNC_REQ_FAILED    Error starting asynchronous request.



RETURN VALUES
       Status  is returned to the caller via the callback handler's rval argu‐
       ment. Possible callback handler rval argument values are:

       USB_INVALID_PIPE       Pipe handle specifies a pipe which is closed  or
                              closing.


       USB_INVALID_ARGS       dip or pipe_handle arguments are NULL.


       USB_INVALID_CONTEXT    Called from interrupt context.


       USB_INVALID_PERM       Pipe handle specifies the default control pipe.


       USB_FAILURE            Asynchronous  resources are unavailable. In this
                              case, USB_CB_ASYNC_REQ_FAILED is  passed  in  as
                              the callback_flags arg to the callback handler.



       Exception handlers of any queued requests which were flushed are called
       with a completion reason of USB_CR_FLUSHED. Exception handlers of peri‐
       odic   pipe   requests   which   were   terminated   are   called  with
       USB_CR_PIPE_CLOSING.


       Note that messages mirroring the above errors are logged to the console
       logfile on error. (This provides status for calls which otherwise could
       provide status).

CONTEXT
       May be called from user or kernel context regardless of arguments.  May
       not  be  called  from a callback executing in interrupt context. Please
       see usb_callback_flags(9S) for more information on callbacks.


       If the USB_CB_ASYNC_REQ_FAILED bit  is  clear  in  usb_cb_flags_t,  the
       callback, if supplied, can block because it is executing in kernel con‐
       text.  Otherwise  the  callback  cannot  block.  Please  see  usb_call‐
       back_flags(9S) for more information on callbacks.

EXAMPLES
         /* Synchronous close of pipe. */
         usb_pipe_close(dip, pipe, USB_FLAGS_SLEEP, NULL, NULL);

             --------

         /* Template callback. */
         void close_callback(usb_pipe_handle_t, usb_opaque_t, usb_cb_flags_t);

         /* Asynchronous close of pipe. */
         usb_pipe_close(dip, pipe, 0, close_callback, callback_arg);



ATTRIBUTES
       See attributes(7) for descriptions of the following attributes:

       tab() box; cw(2.75i) |cw(2.75i) lw(2.75i) |lw(2.75i) ATTRIBUTE  TYPEAT‐
       TRIBUTE  VALUE  _  ArchitecturePCI-based systems _ Interface Stability‐
       Committed _ Availabilitysystem/io/usb


SEE ALSO
       attributes(7),       usb_get_status(9F),       usb_pipe_drain_reqs(9F),
       usb_pipe_get_state(9F),      usb_pipe_open(9F),     usb_pipe_reset(9F),
       usb_callback_flags(9S)

Oracle Solaris 11.4               13 Nov 2020               usb_pipe_close(9F)
맨 페이지 내용의 저작권은 맨 페이지 작성자에게 있습니다.
RSS ATOM XHTML 5 CSS3