Deleted Added
sdiff udiff text old ( 192984 ) new ( 193045 )
full compact
usb_busdma.c (192984) usb_busdma.c (193045)
1/* $FreeBSD: head/sys/dev/usb/usb_busdma.c 192984 2009-05-28 17:36:36Z thompsa $ */
1/* $FreeBSD: head/sys/dev/usb/usb_busdma.c 193045 2009-05-29 18:46:57Z thompsa $ */
2/*-
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.

--- 27 unchanged lines hidden (view full) ---

37#include <dev/usb/usb_device.h>
38#include <dev/usb/usb_util.h>
39#include <dev/usb/usb_debug.h>
40
41#include <dev/usb/usb_controller.h>
42#include <dev/usb/usb_bus.h>
43
44#if USB_HAVE_BUSDMA
2/*-
3 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.

--- 27 unchanged lines hidden (view full) ---

37#include <dev/usb/usb_device.h>
38#include <dev/usb/usb_util.h>
39#include <dev/usb/usb_debug.h>
40
41#include <dev/usb/usb_controller.h>
42#include <dev/usb/usb_bus.h>
43
44#if USB_HAVE_BUSDMA
45static void usb2_dma_tag_create(struct usb_dma_tag *, usb2_size_t, usb2_size_t);
45static void usb2_dma_tag_create(struct usb_dma_tag *, size_t, size_t);
46static void usb2_dma_tag_destroy(struct usb_dma_tag *);
47static void usb2_dma_lock_cb(void *, bus_dma_lock_op_t);
48static void usb2_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);
49static void usb2_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int);
50static void usb2_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int,
51 uint8_t);
52#endif
53
54/*------------------------------------------------------------------------*
55 * usb2_get_page - lookup DMA-able memory for the given offset
56 *
57 * NOTE: Only call this function when the "page_cache" structure has
58 * been properly initialized !
59 *------------------------------------------------------------------------*/
60void
46static void usb2_dma_tag_destroy(struct usb_dma_tag *);
47static void usb2_dma_lock_cb(void *, bus_dma_lock_op_t);
48static void usb2_pc_alloc_mem_cb(void *, bus_dma_segment_t *, int, int);
49static void usb2_pc_load_mem_cb(void *, bus_dma_segment_t *, int, int);
50static void usb2_pc_common_mem_cb(void *, bus_dma_segment_t *, int, int,
51 uint8_t);
52#endif
53
54/*------------------------------------------------------------------------*
55 * usb2_get_page - lookup DMA-able memory for the given offset
56 *
57 * NOTE: Only call this function when the "page_cache" structure has
58 * been properly initialized !
59 *------------------------------------------------------------------------*/
60void
61usb2_get_page(struct usb_page_cache *pc, usb2_frlength_t offset,
61usb2_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
62 struct usb_page_search *res)
63{
64 struct usb_page *page;
65
66#if USB_HAVE_BUSDMA
67 if (pc->page_start) {
68
69 /* Case 1 - something has been loaded into DMA */

--- 39 unchanged lines hidden (view full) ---

109 res->physaddr = 0;
110#endif
111}
112
113/*------------------------------------------------------------------------*
114 * usb2_copy_in - copy directly to DMA-able memory
115 *------------------------------------------------------------------------*/
116void
62 struct usb_page_search *res)
63{
64 struct usb_page *page;
65
66#if USB_HAVE_BUSDMA
67 if (pc->page_start) {
68
69 /* Case 1 - something has been loaded into DMA */

--- 39 unchanged lines hidden (view full) ---

109 res->physaddr = 0;
110#endif
111}
112
113/*------------------------------------------------------------------------*
114 * usb2_copy_in - copy directly to DMA-able memory
115 *------------------------------------------------------------------------*/
116void
117usb2_copy_in(struct usb_page_cache *cache, usb2_frlength_t offset,
118 const void *ptr, usb2_frlength_t len)
117usb2_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
118 const void *ptr, usb_frlength_t len)
119{
120 struct usb_page_search buf_res;
121
122 while (len != 0) {
123
124 usb2_get_page(cache, offset, &buf_res);
125
126 if (buf_res.length > len) {

--- 11 unchanged lines hidden (view full) ---

138 * usb2_copy_in_user - copy directly to DMA-able memory from userland
139 *
140 * Return values:
141 * 0: Success
142 * Else: Failure
143 *------------------------------------------------------------------------*/
144#if USB_HAVE_USER_IO
145int
119{
120 struct usb_page_search buf_res;
121
122 while (len != 0) {
123
124 usb2_get_page(cache, offset, &buf_res);
125
126 if (buf_res.length > len) {

--- 11 unchanged lines hidden (view full) ---

138 * usb2_copy_in_user - copy directly to DMA-able memory from userland
139 *
140 * Return values:
141 * 0: Success
142 * Else: Failure
143 *------------------------------------------------------------------------*/
144#if USB_HAVE_USER_IO
145int
146usb2_copy_in_user(struct usb_page_cache *cache, usb2_frlength_t offset,
147 const void *ptr, usb2_frlength_t len)
146usb2_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
147 const void *ptr, usb_frlength_t len)
148{
149 struct usb_page_search buf_res;
150 int error;
151
152 while (len != 0) {
153
154 usb2_get_page(cache, offset, &buf_res);
155

--- 13 unchanged lines hidden (view full) ---

169#endif
170
171/*------------------------------------------------------------------------*
172 * usb2_m_copy_in - copy a mbuf chain directly into DMA-able memory
173 *------------------------------------------------------------------------*/
174#if USB_HAVE_MBUF
175struct usb2_m_copy_in_arg {
176 struct usb_page_cache *cache;
148{
149 struct usb_page_search buf_res;
150 int error;
151
152 while (len != 0) {
153
154 usb2_get_page(cache, offset, &buf_res);
155

--- 13 unchanged lines hidden (view full) ---

169#endif
170
171/*------------------------------------------------------------------------*
172 * usb2_m_copy_in - copy a mbuf chain directly into DMA-able memory
173 *------------------------------------------------------------------------*/
174#if USB_HAVE_MBUF
175struct usb2_m_copy_in_arg {
176 struct usb_page_cache *cache;
177 usb2_frlength_t dst_offset;
177 usb_frlength_t dst_offset;
178};
179
180static int
181usb2_m_copy_in_cb(void *arg, void *src, uint32_t count)
182{
183 register struct usb2_m_copy_in_arg *ua = arg;
184
185 usb2_copy_in(ua->cache, ua->dst_offset, src, count);
186 ua->dst_offset += count;
187 return (0);
188}
189
190void
178};
179
180static int
181usb2_m_copy_in_cb(void *arg, void *src, uint32_t count)
182{
183 register struct usb2_m_copy_in_arg *ua = arg;
184
185 usb2_copy_in(ua->cache, ua->dst_offset, src, count);
186 ua->dst_offset += count;
187 return (0);
188}
189
190void
191usb2_m_copy_in(struct usb_page_cache *cache, usb2_frlength_t dst_offset,
192 struct mbuf *m, usb2_size_t src_offset, usb2_frlength_t src_len)
191usb2_m_copy_in(struct usb_page_cache *cache, usb_frlength_t dst_offset,
192 struct mbuf *m, size_t src_offset, usb_frlength_t src_len)
193{
194 struct usb2_m_copy_in_arg arg = {cache, dst_offset};
195 int error;
196
197 error = m_apply(m, src_offset, src_len, &usb2_m_copy_in_cb, &arg);
198}
199#endif
200
201/*------------------------------------------------------------------------*
202 * usb2_uiomove - factored out code
203 *------------------------------------------------------------------------*/
204#if USB_HAVE_USER_IO
205int
206usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
193{
194 struct usb2_m_copy_in_arg arg = {cache, dst_offset};
195 int error;
196
197 error = m_apply(m, src_offset, src_len, &usb2_m_copy_in_cb, &arg);
198}
199#endif
200
201/*------------------------------------------------------------------------*
202 * usb2_uiomove - factored out code
203 *------------------------------------------------------------------------*/
204#if USB_HAVE_USER_IO
205int
206usb2_uiomove(struct usb_page_cache *pc, struct uio *uio,
207 usb2_frlength_t pc_offset, usb2_frlength_t len)
207 usb_frlength_t pc_offset, usb_frlength_t len)
208{
209 struct usb_page_search res;
210 int error = 0;
211
212 while (len != 0) {
213
214 usb2_get_page(pc, pc_offset, &res);
215

--- 15 unchanged lines hidden (view full) ---

231 return (error);
232}
233#endif
234
235/*------------------------------------------------------------------------*
236 * usb2_copy_out - copy directly from DMA-able memory
237 *------------------------------------------------------------------------*/
238void
208{
209 struct usb_page_search res;
210 int error = 0;
211
212 while (len != 0) {
213
214 usb2_get_page(pc, pc_offset, &res);
215

--- 15 unchanged lines hidden (view full) ---

231 return (error);
232}
233#endif
234
235/*------------------------------------------------------------------------*
236 * usb2_copy_out - copy directly from DMA-able memory
237 *------------------------------------------------------------------------*/
238void
239usb2_copy_out(struct usb_page_cache *cache, usb2_frlength_t offset,
240 void *ptr, usb2_frlength_t len)
239usb2_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
240 void *ptr, usb_frlength_t len)
241{
242 struct usb_page_search res;
243
244 while (len != 0) {
245
246 usb2_get_page(cache, offset, &res);
247
248 if (res.length > len) {

--- 11 unchanged lines hidden (view full) ---

260 * usb2_copy_out_user - copy directly from DMA-able memory to userland
261 *
262 * Return values:
263 * 0: Success
264 * Else: Failure
265 *------------------------------------------------------------------------*/
266#if USB_HAVE_USER_IO
267int
241{
242 struct usb_page_search res;
243
244 while (len != 0) {
245
246 usb2_get_page(cache, offset, &res);
247
248 if (res.length > len) {

--- 11 unchanged lines hidden (view full) ---

260 * usb2_copy_out_user - copy directly from DMA-able memory to userland
261 *
262 * Return values:
263 * 0: Success
264 * Else: Failure
265 *------------------------------------------------------------------------*/
266#if USB_HAVE_USER_IO
267int
268usb2_copy_out_user(struct usb_page_cache *cache, usb2_frlength_t offset,
269 void *ptr, usb2_frlength_t len)
268usb2_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
269 void *ptr, usb_frlength_t len)
270{
271 struct usb_page_search res;
272 int error;
273
274 while (len != 0) {
275
276 usb2_get_page(cache, offset, &res);
277

--- 11 unchanged lines hidden (view full) ---

289 return (0); /* success */
290}
291#endif
292
293/*------------------------------------------------------------------------*
294 * usb2_bzero - zero DMA-able memory
295 *------------------------------------------------------------------------*/
296void
270{
271 struct usb_page_search res;
272 int error;
273
274 while (len != 0) {
275
276 usb2_get_page(cache, offset, &res);
277

--- 11 unchanged lines hidden (view full) ---

289 return (0); /* success */
290}
291#endif
292
293/*------------------------------------------------------------------------*
294 * usb2_bzero - zero DMA-able memory
295 *------------------------------------------------------------------------*/
296void
297usb2_bzero(struct usb_page_cache *cache, usb2_frlength_t offset,
298 usb2_frlength_t len)
297usb2_bzero(struct usb_page_cache *cache, usb_frlength_t offset,
298 usb_frlength_t len)
299{
300 struct usb_page_search res;
301
302 while (len != 0) {
303
304 usb2_get_page(cache, offset, &res);
305
306 if (res.length > len) {

--- 20 unchanged lines hidden (view full) ---

327/*------------------------------------------------------------------------*
328 * usb2_dma_tag_create - allocate a DMA tag
329 *
330 * NOTE: If the "align" parameter has a value of 1 the DMA-tag will
331 * allow multi-segment mappings. Else all mappings are single-segment.
332 *------------------------------------------------------------------------*/
333static void
334usb2_dma_tag_create(struct usb_dma_tag *udt,
299{
300 struct usb_page_search res;
301
302 while (len != 0) {
303
304 usb2_get_page(cache, offset, &res);
305
306 if (res.length > len) {

--- 20 unchanged lines hidden (view full) ---

327/*------------------------------------------------------------------------*
328 * usb2_dma_tag_create - allocate a DMA tag
329 *
330 * NOTE: If the "align" parameter has a value of 1 the DMA-tag will
331 * allow multi-segment mappings. Else all mappings are single-segment.
332 *------------------------------------------------------------------------*/
333static void
334usb2_dma_tag_create(struct usb_dma_tag *udt,
335 usb2_size_t size, usb2_size_t align)
335 size_t size, size_t align)
336{
337 bus_dma_tag_t tag;
338
339 if (bus_dma_tag_create
340 ( /* parent */ udt->tag_parent->tag,
341 /* alignment */ align,
342 /* boundary */ USB_PAGE_SIZE,
343 /* lowaddr */ (2ULL << (udt->tag_parent->dma_bits - 1)) - 1,

--- 48 unchanged lines hidden (view full) ---

392 *------------------------------------------------------------------------*/
393static void
394usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
395 int nseg, int error, uint8_t isload)
396{
397 struct usb_dma_parent_tag *uptag;
398 struct usb_page_cache *pc;
399 struct usb_page *pg;
336{
337 bus_dma_tag_t tag;
338
339 if (bus_dma_tag_create
340 ( /* parent */ udt->tag_parent->tag,
341 /* alignment */ align,
342 /* boundary */ USB_PAGE_SIZE,
343 /* lowaddr */ (2ULL << (udt->tag_parent->dma_bits - 1)) - 1,

--- 48 unchanged lines hidden (view full) ---

392 *------------------------------------------------------------------------*/
393static void
394usb2_pc_common_mem_cb(void *arg, bus_dma_segment_t *segs,
395 int nseg, int error, uint8_t isload)
396{
397 struct usb_dma_parent_tag *uptag;
398 struct usb_page_cache *pc;
399 struct usb_page *pg;
400 usb2_size_t rem;
400 size_t rem;
401 uint8_t owned;
402
403 pc = arg;
404 uptag = pc->tag_parent;
405
406 /*
407 * XXX There is sometimes recursive locking here.
408 * XXX We should try to find a better solution.

--- 46 unchanged lines hidden (view full) ---

455 * usb2_pc_alloc_mem - allocate DMA'able memory
456 *
457 * Returns:
458 * 0: Success
459 * Else: Failure
460 *------------------------------------------------------------------------*/
461uint8_t
462usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
401 uint8_t owned;
402
403 pc = arg;
404 uptag = pc->tag_parent;
405
406 /*
407 * XXX There is sometimes recursive locking here.
408 * XXX We should try to find a better solution.

--- 46 unchanged lines hidden (view full) ---

455 * usb2_pc_alloc_mem - allocate DMA'able memory
456 *
457 * Returns:
458 * 0: Success
459 * Else: Failure
460 *------------------------------------------------------------------------*/
461uint8_t
462usb2_pc_alloc_mem(struct usb_page_cache *pc, struct usb_page *pg,
463 usb2_size_t size, usb2_size_t align)
463 size_t size, size_t align)
464{
465 struct usb_dma_parent_tag *uptag;
466 struct usb_dma_tag *utag;
467 bus_dmamap_t map;
468 void *ptr;
469 int err;
470
471 uptag = pc->tag_parent;

--- 106 unchanged lines hidden (view full) ---

578/*------------------------------------------------------------------------*
579 * usb2_pc_load_mem - load virtual memory into DMA
580 *
581 * Return values:
582 * 0: Success
583 * Else: Error
584 *------------------------------------------------------------------------*/
585uint8_t
464{
465 struct usb_dma_parent_tag *uptag;
466 struct usb_dma_tag *utag;
467 bus_dmamap_t map;
468 void *ptr;
469 int err;
470
471 uptag = pc->tag_parent;

--- 106 unchanged lines hidden (view full) ---

578/*------------------------------------------------------------------------*
579 * usb2_pc_load_mem - load virtual memory into DMA
580 *
581 * Return values:
582 * 0: Success
583 * Else: Error
584 *------------------------------------------------------------------------*/
585uint8_t
586usb2_pc_load_mem(struct usb_page_cache *pc, usb2_size_t size, uint8_t sync)
586usb2_pc_load_mem(struct usb_page_cache *pc, size_t size, uint8_t sync)
587{
588 /* setup page cache */
589 pc->page_offset_buf = 0;
590 pc->page_offset_end = size;
591 pc->ismultiseg = 1;
592
593 mtx_assert(pc->tag_parent->mtx, MA_OWNED);
594

--- 84 unchanged lines hidden (view full) ---

679/*------------------------------------------------------------------------*
680 * usb2_pc_dmamap_create - create a DMA map
681 *
682 * Returns:
683 * 0: Success
684 * Else: Failure
685 *------------------------------------------------------------------------*/
686uint8_t
587{
588 /* setup page cache */
589 pc->page_offset_buf = 0;
590 pc->page_offset_end = size;
591 pc->ismultiseg = 1;
592
593 mtx_assert(pc->tag_parent->mtx, MA_OWNED);
594

--- 84 unchanged lines hidden (view full) ---

679/*------------------------------------------------------------------------*
680 * usb2_pc_dmamap_create - create a DMA map
681 *
682 * Returns:
683 * 0: Success
684 * Else: Failure
685 *------------------------------------------------------------------------*/
686uint8_t
687usb2_pc_dmamap_create(struct usb_page_cache *pc, usb2_size_t size)
687usb2_pc_dmamap_create(struct usb_page_cache *pc, size_t size)
688{
689 struct usb_xfer_root *info;
690 struct usb_dma_tag *utag;
691
692 /* get info */
693 info = USB_DMATAG_TO_XROOT(pc->tag_parent);
694
695 /* sanity check */

--- 32 unchanged lines hidden (view full) ---

728 }
729}
730
731/*------------------------------------------------------------------------*
732 * usb2_dma_tag_find - factored out code
733 *------------------------------------------------------------------------*/
734struct usb_dma_tag *
735usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
688{
689 struct usb_xfer_root *info;
690 struct usb_dma_tag *utag;
691
692 /* get info */
693 info = USB_DMATAG_TO_XROOT(pc->tag_parent);
694
695 /* sanity check */

--- 32 unchanged lines hidden (view full) ---

728 }
729}
730
731/*------------------------------------------------------------------------*
732 * usb2_dma_tag_find - factored out code
733 *------------------------------------------------------------------------*/
734struct usb_dma_tag *
735usb2_dma_tag_find(struct usb_dma_parent_tag *udpt,
736 usb2_size_t size, usb2_size_t align)
736 size_t size, size_t align)
737{
738 struct usb_dma_tag *udt;
739 uint8_t nudt;
740
741 USB_ASSERT(align > 0, ("Invalid parameter align = 0!\n"));
742 USB_ASSERT(size > 0, ("Invalid parameter size = 0!\n"));
743
744 udt = udpt->utag_first;

--- 19 unchanged lines hidden (view full) ---

764}
765
766/*------------------------------------------------------------------------*
767 * usb2_dma_tag_setup - initialise USB DMA tags
768 *------------------------------------------------------------------------*/
769void
770usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,
771 struct usb_dma_tag *udt, bus_dma_tag_t dmat,
737{
738 struct usb_dma_tag *udt;
739 uint8_t nudt;
740
741 USB_ASSERT(align > 0, ("Invalid parameter align = 0!\n"));
742 USB_ASSERT(size > 0, ("Invalid parameter size = 0!\n"));
743
744 udt = udpt->utag_first;

--- 19 unchanged lines hidden (view full) ---

764}
765
766/*------------------------------------------------------------------------*
767 * usb2_dma_tag_setup - initialise USB DMA tags
768 *------------------------------------------------------------------------*/
769void
770usb2_dma_tag_setup(struct usb_dma_parent_tag *udpt,
771 struct usb_dma_tag *udt, bus_dma_tag_t dmat,
772 struct mtx *mtx, usb2_dma_callback_t *func,
772 struct mtx *mtx, usb_dma_callback_t *func,
773 uint8_t ndmabits, uint8_t nudt)
774{
775 bzero(udpt, sizeof(*udpt));
776
777 /* sanity checking */
778 if ((nudt == 0) ||
779 (ndmabits == 0) ||
780 (mtx == NULL)) {

--- 52 unchanged lines hidden (view full) ---

833 * This function handles loading of virtual buffers into DMA and is
834 * only called when "dma_refcount" is zero.
835 *------------------------------------------------------------------------*/
836void
837usb2_bdma_work_loop(struct usb_xfer_queue *pq)
838{
839 struct usb_xfer_root *info;
840 struct usb_xfer *xfer;
773 uint8_t ndmabits, uint8_t nudt)
774{
775 bzero(udpt, sizeof(*udpt));
776
777 /* sanity checking */
778 if ((nudt == 0) ||
779 (ndmabits == 0) ||
780 (mtx == NULL)) {

--- 52 unchanged lines hidden (view full) ---

833 * This function handles loading of virtual buffers into DMA and is
834 * only called when "dma_refcount" is zero.
835 *------------------------------------------------------------------------*/
836void
837usb2_bdma_work_loop(struct usb_xfer_queue *pq)
838{
839 struct usb_xfer_root *info;
840 struct usb_xfer *xfer;
841 usb2_frcount_t nframes;
841 usb_frcount_t nframes;
842
843 xfer = pq->curr;
844 info = xfer->xroot;
845
846 mtx_assert(info->xfer_mtx, MA_OWNED);
847
848 if (xfer->error) {
849 /* some error happened */
850 USB_BUS_LOCK(info->bus);
851 usb2_transfer_done(xfer, 0);
852 USB_BUS_UNLOCK(info->bus);
853 return;
854 }
855 if (!xfer->flags_int.bdma_setup) {
856 struct usb_page *pg;
842
843 xfer = pq->curr;
844 info = xfer->xroot;
845
846 mtx_assert(info->xfer_mtx, MA_OWNED);
847
848 if (xfer->error) {
849 /* some error happened */
850 USB_BUS_LOCK(info->bus);
851 usb2_transfer_done(xfer, 0);
852 USB_BUS_UNLOCK(info->bus);
853 return;
854 }
855 if (!xfer->flags_int.bdma_setup) {
856 struct usb_page *pg;
857 usb2_frlength_t frlength_0;
857 usb_frlength_t frlength_0;
858 uint8_t isread;
859
860 xfer->flags_int.bdma_setup = 1;
861
862 /* reset BUS-DMA load state */
863
864 info->dma_error = 0;
865

--- 116 unchanged lines hidden (view full) ---

982 *
983 * This function handles DMA synchronisation that must be done before
984 * an USB transfer is started.
985 *------------------------------------------------------------------------*/
986void
987usb2_bdma_pre_sync(struct usb_xfer *xfer)
988{
989 struct usb_page_cache *pc;
858 uint8_t isread;
859
860 xfer->flags_int.bdma_setup = 1;
861
862 /* reset BUS-DMA load state */
863
864 info->dma_error = 0;
865

--- 116 unchanged lines hidden (view full) ---

982 *
983 * This function handles DMA synchronisation that must be done before
984 * an USB transfer is started.
985 *------------------------------------------------------------------------*/
986void
987usb2_bdma_pre_sync(struct usb_xfer *xfer)
988{
989 struct usb_page_cache *pc;
990 usb2_frcount_t nframes;
990 usb_frcount_t nframes;
991
992 if (xfer->flags_int.isochronous_xfr) {
993 /* only one frame buffer */
994 nframes = 1;
995 } else {
996 /* can be multiple frame buffers */
997 nframes = xfer->nframes;
998 }

--- 16 unchanged lines hidden (view full) ---

1015 *
1016 * This function handles DMA synchronisation that must be done after
1017 * an USB transfer is complete.
1018 *------------------------------------------------------------------------*/
1019void
1020usb2_bdma_post_sync(struct usb_xfer *xfer)
1021{
1022 struct usb_page_cache *pc;
991
992 if (xfer->flags_int.isochronous_xfr) {
993 /* only one frame buffer */
994 nframes = 1;
995 } else {
996 /* can be multiple frame buffers */
997 nframes = xfer->nframes;
998 }

--- 16 unchanged lines hidden (view full) ---

1015 *
1016 * This function handles DMA synchronisation that must be done after
1017 * an USB transfer is complete.
1018 *------------------------------------------------------------------------*/
1019void
1020usb2_bdma_post_sync(struct usb_xfer *xfer)
1021{
1022 struct usb_page_cache *pc;
1023 usb2_frcount_t nframes;
1023 usb_frcount_t nframes;
1024
1025 if (xfer->flags_int.isochronous_xfr) {
1026 /* only one frame buffer */
1027 nframes = 1;
1028 } else {
1029 /* can be multiple frame buffers */
1030 nframes = xfer->nframes;
1031 }

--- 12 unchanged lines hidden --- 		1024
1025 if (xfer->flags_int.isochronous_xfr) {
1026 /* only one frame buffer */
1027 nframes = 1;
1028 } else {
1029 /* can be multiple frame buffers */
1030 nframes = xfer->nframes;
1031 }

--- 12 unchanged lines hidden ---