PERFORCE change 129488 for review
Hans Petter Selasky
hselasky at FreeBSD.org
Sun Nov 25 01:45:53 PST 2007
http://perforce.freebsd.org/chv.cgi?CH=129488
Change 129488 by hselasky at hselasky_laptop001 on 2007/11/25 09:45:05
Style change. Make all function comment boxes 75 chars wide so
that they fit on a single line when printed.
Scripted by:
[ -f src/$F ] && (cat src/$F |
sed -e "s/[*]----*----[*]/*--------
-----------------------------------
-----------------------------*/g" > temp
) && ((diff temp src/$F > /dev/null) || (cat temp > src/$F))
Affected files ...
.. //depot/projects/usb/src/sys/dev/usb/ehci.c#51 edit
.. //depot/projects/usb/src/sys/dev/usb/ohci.c#41 edit
.. //depot/projects/usb/src/sys/dev/usb/uhci.c#43 edit
.. //depot/projects/usb/src/sys/dev/usb/usb.h#20 edit
.. //depot/projects/usb/src/sys/dev/usb/usb_subr.c#53 edit
.. //depot/projects/usb/src/sys/dev/usb/usb_subr.h#58 edit
.. //depot/projects/usb/src/sys/dev/usb/usb_transfer.c#47 edit
Differences ...
==== //depot/projects/usb/src/sys/dev/usb/ehci.c#51 (text+ko) ====
@@ -2224,9 +2224,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci bulk support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_device_bulk_open(struct usbd_xfer *xfer)
{
@@ -2274,9 +2274,9 @@
.start = ehci_device_bulk_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci control support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_device_ctrl_open(struct usbd_xfer *xfer)
{
@@ -2324,9 +2324,9 @@
.start = ehci_device_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_device_intr_open(struct usbd_xfer *xfer)
{
@@ -2430,9 +2430,9 @@
.start = ehci_device_intr_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci full speed isochronous support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_device_isoc_fs_open(struct usbd_xfer *xfer)
{
@@ -2700,9 +2700,9 @@
.start = ehci_device_isoc_fs_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci high speed isochronous support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_device_isoc_hs_open(struct usbd_xfer *xfer)
{
@@ -2981,12 +2981,12 @@
.start = ehci_device_isoc_hs_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci root control support
- *---------------------------------------------------------------------------*
+ *------------------------------------------------------------------------*
* simulate a hardware hub by handling
* all the necessary requests
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_root_ctrl_open(struct usbd_xfer *xfer)
@@ -3542,9 +3542,9 @@
.start = ehci_root_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ehci root interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ehci_root_intr_open(struct usbd_xfer *xfer)
{
==== //depot/projects/usb/src/sys/dev/usb/ohci.c#41 (text+ko) ====
@@ -1758,9 +1758,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci bulk support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_device_bulk_open(struct usbd_xfer *xfer)
{
@@ -1808,9 +1808,9 @@
.start = ohci_device_bulk_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci control support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_device_ctrl_open(struct usbd_xfer *xfer)
{
@@ -1858,9 +1858,9 @@
.start = ohci_device_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_device_intr_open(struct usbd_xfer *xfer)
{
@@ -1940,9 +1940,9 @@
.start = ohci_device_intr_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci isochronous support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_device_isoc_open(struct usbd_xfer *xfer)
{
@@ -2155,12 +2155,12 @@
.start = ohci_device_isoc_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci root control support
- *---------------------------------------------------------------------------*
+ *------------------------------------------------------------------------*
* simulate a hardware hub by handling
* all the necessary requests
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_root_ctrl_open(struct usbd_xfer *xfer)
@@ -2597,9 +2597,9 @@
.start = ohci_root_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ohci root interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
ohci_root_intr_open(struct usbd_xfer *xfer)
{
==== //depot/projects/usb/src/sys/dev/usb/uhci.c#43 (text+ko) ====
@@ -1989,9 +1989,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci bulk support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_device_bulk_open(struct usbd_xfer *xfer)
{
@@ -2048,9 +2048,9 @@
.start = uhci_device_bulk_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci control support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_device_ctrl_open(struct usbd_xfer *xfer)
{
@@ -2113,9 +2113,9 @@
.start = uhci_device_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_device_intr_open(struct usbd_xfer *xfer)
{
@@ -2203,9 +2203,9 @@
.start = uhci_device_intr_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci isochronous support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_device_isoc_open(struct usbd_xfer *xfer)
{
@@ -2407,12 +2407,12 @@
.start = uhci_device_isoc_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci root control support
- *---------------------------------------------------------------------------*
+ *------------------------------------------------------------------------*
* simulate a hardware hub by handling
* all the necessary requests
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_root_ctrl_open(struct usbd_xfer *xfer)
@@ -2964,9 +2964,9 @@
.start = uhci_root_ctrl_start,
};
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* uhci root interrupt support
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
uhci_root_intr_open(struct usbd_xfer *xfer)
{
==== //depot/projects/usb/src/sys/dev/usb/usb.h#20 (text+ko) ====
@@ -550,9 +550,9 @@
#define USB_UNCONFIG_NO 0
#define USB_UNCONFIG_INDEX 0xFF
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* ioctl() related stuff
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
struct usb_ctl_request {
int ucr_addr;
usb_device_request_t ucr_request;
==== //depot/projects/usb/src/sys/dev/usb/usb_subr.c#53 (text+ko) ====
@@ -1727,11 +1727,11 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* allocate mbufs to an usbd interface queue
*
* returns a pointer that eventually should be passed to "free()"
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void *
usbd_alloc_mbufs(struct malloc_type *type, struct usbd_ifqueue *ifq,
uint32_t block_size, uint16_t block_number)
@@ -1774,9 +1774,9 @@
return (free_ptr);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_get_page - lookup DMA-able memory for the given offset
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_get_page(struct usbd_page_cache *pc, uint32_t offset,
struct usbd_page_search *res)
@@ -1811,9 +1811,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_copy_in - copy directly to DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_copy_in(struct usbd_page_cache *cache, uint32_t offset,
const void *ptr, uint32_t len)
@@ -1844,9 +1844,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_m_copy_in - copy a mbuf chain directly into DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
struct usbd_m_copy_in_arg {
struct usbd_page_cache *cache;
uint32_t dst_offset;
@@ -1917,9 +1917,9 @@
return (error);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_copy_out - copy directly from DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_copy_out(struct usbd_page_cache *cache, uint32_t offset,
void *ptr, uint32_t len)
@@ -1950,9 +1950,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_bzero - zero DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_bzero(struct usbd_page_cache *cache, uint32_t offset, uint32_t len)
{
@@ -1981,13 +1981,13 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_page_alloc - allocate multiple DMA-able memory pages
*
* Returns:
* 1: failure
* 0: success
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint8_t
usbd_page_alloc(bus_dma_tag_t tag, struct usbd_page *page,
uint32_t npages)
@@ -2026,9 +2026,9 @@
return (0); /* success */
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_page_free - free multiple DMA-able memory pages
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_page_free(struct usbd_page *page, uint32_t npages)
{
@@ -2038,9 +2038,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_page_cache_init
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_page_cache_init(struct usbd_page_cache *pc, struct usbd_page *page_ptr,
uint32_t offset, uint32_t size)
@@ -2051,9 +2051,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_page_fit_obj - fit object function
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint32_t
usbd_page_fit_obj(uint32_t size, uint32_t obj_len)
{
@@ -2077,9 +2077,9 @@
return (adj);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_mem_alloc - allocate DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void *
usbd_mem_alloc(bus_dma_tag_t parent, struct usbd_page *page, uint32_t size,
uint8_t align_power)
@@ -2102,9 +2102,9 @@
return (ptr);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_mem_free - free DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_mem_free(struct usbd_page *page)
{
@@ -2120,9 +2120,9 @@
}
#ifdef __FreeBSD__
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* bus_dmamap_load_callback
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
bus_dmamap_load_callback(void *arg, bus_dma_segment_t *segs,
int nseg, int error)
@@ -2136,9 +2136,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_dma_tag_alloc - allocate a bus-DMA tag
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
bus_dma_tag_t
usbd_dma_tag_alloc(bus_dma_tag_t parent, uint32_t seg_size,
uint32_t alignment, uint32_t max_size)
@@ -2165,9 +2165,9 @@
return (tag);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_dma_tag_free - free a bus-DMA tag
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_dma_tag_free(bus_dma_tag_t tag)
{
@@ -2175,9 +2175,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_mem_alloc_sub - allocate DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void *
usbd_mem_alloc_sub(bus_dma_tag_t tag, struct usbd_page *page,
uint32_t size, uint32_t alignment)
@@ -2216,9 +2216,9 @@
return (ptr);
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_mem_free_sub - free DMA-able memory
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_mem_free_sub(struct usbd_page *page)
{
@@ -2265,9 +2265,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_dma_load_mem_callback - internal callback
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
usbd_dma_load_mem_callback(void *arg, bus_dma_segment_t *segs, int nseg, int error)
{
@@ -2313,9 +2313,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_dma_load_mem - load DMA memory if any
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_dma_load_mem(struct usbd_xfer *xfer, struct usbd_dma_load_mem_info *info)
{
@@ -2500,9 +2500,9 @@
#endif
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_pio_load_mem - load virtual memory if any
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_pio_load_mem(struct usbd_xfer *xfer, struct usbd_dma_load_mem_info *info)
{
@@ -2553,9 +2553,9 @@
return;
}
-/*------------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_make_str_desc - convert an ASCII string into a UNICODE string
- *------------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint8_t
usbd_make_str_desc(void *ptr, uint16_t max_len, const char *s)
{
@@ -2591,9 +2591,9 @@
return (totlen);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* mtx_drop_recurse - drop mutex recurse level
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint32_t
mtx_drop_recurse(struct mtx *mtx)
{
@@ -2609,9 +2609,9 @@
return (recurse_level);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* mtx_pickup_recurse - pickup mutex recurse level
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
mtx_pickup_recurse(struct mtx *mtx, uint32_t recurse_level)
{
@@ -2624,9 +2624,9 @@
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_thread
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
usbd_config_td_thread(void *arg)
{
@@ -2723,7 +2723,7 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_setup
*
* NOTE: the structure pointed to by "ctd" must be zeroed before calling
@@ -2732,7 +2732,7 @@
* Return values:
* 0: success
* else: failure
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint8_t
usbd_config_td_setup(struct usbd_config_td *ctd, void *priv_sc,
struct mtx *priv_mtx,
@@ -2771,9 +2771,9 @@
return (1);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_dummy_cmd
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
usbd_config_td_dummy_cmd(struct usbd_config_td_softc *sc,
struct usbd_config_td_cc *cc,
@@ -2782,12 +2782,12 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_stop
*
* NOTE: If the structure pointed to by "ctd" is all zero,
* this function does nothing.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_config_td_stop(struct usbd_config_td *ctd)
{
@@ -2826,12 +2826,12 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_unsetup
*
* NOTE: If the structure pointed to by "ctd" is all zero,
* this function does nothing.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_config_td_unsetup(struct usbd_config_td *ctd)
{
@@ -2844,9 +2844,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_queue_command
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_config_td_queue_command(struct usbd_config_td *ctd,
usbd_config_td_command_t *command_pre_func,
@@ -2933,13 +2933,13 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_is_gone
*
* Return values:
* 0: config thread is running
* else: config thread is gone
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint8_t
usbd_config_td_is_gone(struct usbd_config_td *ctd)
{
@@ -2948,7 +2948,7 @@
return (ctd->flag_config_td_gone ? 1 : 0);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_config_td_sleep
*
* NOTE: this function can only be called from the config thread
@@ -2956,7 +2956,7 @@
* Return values:
* 0: normal delay
* else: config thread is gone
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint8_t
usbd_config_td_sleep(struct usbd_config_td *ctd, uint32_t timeout)
{
@@ -2985,9 +2985,9 @@
return (is_gone);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_ether_get_mbuf - get a new ethernet mbuf
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
struct mbuf *
usbd_ether_get_mbuf(void)
{
@@ -3001,9 +3001,9 @@
return (m_new);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* device_delete_all_children - delete all children of a device
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
int32_t
device_delete_all_children(device_t dev)
{
@@ -3024,9 +3024,9 @@
return (error);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_isoc_time_expand - expand time counter from 7-bit to 16-bit
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
uint16_t
usbd_isoc_time_expand(struct usbd_bus *bus, uint16_t isoc_time_curr)
{
==== //depot/projects/usb/src/sys/dev/usb/usb_subr.h#58 (text+ko) ====
@@ -573,9 +573,9 @@
(m)->last_packet = 0; \
} while (0)
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* structures used by the usbd config thread system
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
struct usbd_config_td_softc;
struct usbd_config_td_cc;
@@ -604,9 +604,9 @@
uint16_t command_ref;
} __aligned(USB_HOST_ALIGN);
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* structures used by probe and attach
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
struct usb_devno {
uint16_t ud_vendor;
uint16_t ud_product;
@@ -653,9 +653,9 @@
#define UMATCH_GENERIC (-140)
#define UMATCH_NONE (ENXIO)
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* prototypes
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
/* prototypes from usb_subr.c */
==== //depot/projects/usb/src/sys/dev/usb/usb_transfer.c#47 (text+ko) ====
@@ -666,7 +666,7 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_setup - setup an array of USB transfers
*
* NOTE: must always call unsetup after setup
@@ -675,7 +675,7 @@
*
* The idea is that the USB device driver should pre-allocate all
* its transfers by one call to this function.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
usbd_status
usbd_transfer_setup(struct usbd_device *udev,
uint8_t iface_index,
@@ -874,12 +874,12 @@
return (parm.err);
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_drop_refcount
*
* This function is called from various places, and its job is to
* wakeup "usbd_transfer_unsetup", when is safe to free the memory.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
usbd_drop_refcount(struct usbd_memory_info *info)
{
@@ -896,13 +896,13 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_unsetup - unsetup/free an array of USB transfers
*
* NOTE: if the transfer was in progress, the callback will
* called with "xfer->error=USBD_CANCELLED", before this
* function returns
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_transfer_unsetup(struct usbd_xfer **pxfer, uint16_t n_setup)
{
@@ -1270,9 +1270,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_start_hardware - start USB hardware for the given transfer
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_start_hardware(struct usbd_xfer *xfer)
{
@@ -1384,9 +1384,9 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_pipe_enter_wrapper - factored out code
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
static void
usbd_pipe_enter_wrapper(struct usbd_xfer *xfer)
{
@@ -1543,7 +1543,7 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_start - start an USB transfer
*
* NOTE: Calling this function more than one time will only
@@ -1551,7 +1551,7 @@
* completes.
* NOTE: if USBD_USE_POLLING is set in "xfer->flags", then this
* function will spin until transfer is completed
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_transfer_start(struct usbd_xfer *xfer)
{
@@ -1605,12 +1605,12 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_stop - stop an USB transfer
*
* NOTE: Calling this function more than one time will only
* result in a single transfer stop.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_transfer_stop(struct usbd_xfer *xfer)
{
@@ -1674,13 +1674,13 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_drain
*
* This function will stop the USB transfer and wait for any
* additional BUS-DMA operations to complete. Buffers that are loaded
* into DMA can safely be freed after that this function has returned.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_transfer_drain(struct usbd_xfer *xfer)
{
@@ -1754,12 +1754,12 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_callback_wrapper
*
* This is a wrapper for USB callbacks, which handles
* recursation, which can happen during boot.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_callback_wrapper(struct usbd_xfer *xfer)
{
@@ -1798,11 +1798,11 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_do_callback
*
* This function is used to call back a list of USB callbacks.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_do_callback(struct usbd_xfer **pp_xfer, struct thread *td)
{
@@ -1853,11 +1853,11 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_enqueue
*
* This function is used to add an USB transfer to the pipe transfer list.
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
void
usbd_transfer_enqueue(struct usbd_xfer *xfer)
{
@@ -1910,7 +1910,7 @@
return;
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_transfer_dequeue
*
* This function:
@@ -1922,7 +1922,7 @@
* NOTE: In some special cases the USB transfer will not be removed from
* the pipe queue, but remain first. To enforce USB transfer removal call
* this function passing the error code "USBD_CANCELLED".
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
#undef LIST_PREV
#define LIST_PREV(head,elm,field) \
(((elm) == LIST_FIRST(head)) ? ((__typeof(elm))0) : \
@@ -2054,9 +2054,9 @@
}
}
-/*---------------------------------------------------------------------------*
+/*------------------------------------------------------------------------*
* usbd_do_request_flags and usbd_do_request
- *---------------------------------------------------------------------------*/
+ *------------------------------------------------------------------------*/
usbd_status
usbd_do_request_flags(struct usbd_device *udev, struct mtx *mtx,
usb_device_request_t *req, void *data,
More information about the p4-projects
mailing list