Date: Sun, 25 Nov 2007 09:45:51 GMT From: Hans Petter Selasky <hselasky@FreeBSD.org> To: Perforce Change Reviews <perforce@FreeBSD.org> Subject: PERFORCE change 129488 for review Message-ID: <200711250945.lAP9jpCI075615@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=129488 Change 129488 by hselasky@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,
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200711250945.lAP9jpCI075615>