Commit 1fb2e055 authored by Alan Stern's avatar Alan Stern Committed by Greg Kroah-Hartman
Browse files

USB: EHCI: reorganize isochronous scheduler routine 



This patch (as1408) rearranges the scheduling code in ehci-hcd, partly
to improve its structure, but mainly to change the way it works.
Whether or not a transfer exceeds the hardware schedule length will
now be determined by looking at the last frame the transfer would use,
instead of the first available frame following the end of the transfer.

The benefit of this change is that it allows the driver to accept
valid URBs which would otherwise be rejected.  For example, suppose
the schedule length is 1024 frames, the endpoint period is 256 frames,
and a four-packet URB is submitted.  The four transfers would occupy
slots that are 0, 256, 512, and 768 frames past the current frame
(plus an extra slop factor).  These don't exceed the 1024-frame limit,
so the URB should be accepted.  But the current code notices that the
next available slot would be 1024 frames (plus slop) in the future,
which is beyond the limit, and so the URB is rejected unnecessarily.

Signed-off-by: default avatarAlan Stern <stern@rowland.harvard.edu>
CC: David Brownell <david-b@pacbell.net>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent ffda0803

drivers/usb/host/ehci-sched.c

+57 −53
Original line number Diff line number Diff line
@@ -1413,13 +1413,6 @@ iso_stream_schedule ( 
		goto fail;

	}



	if (stream->depth + span > mod) {

		ehci_dbg (ehci, "request %p would overflow (%d+%d>%d)\n",

			urb, stream->depth, span, mod);

		status = -EFBIG;

		goto fail;

	}



	now = ehci_readl(ehci, &ehci->regs->frame_index) & (mod - 1);



	/* Typical case: reuse current schedule, stream is still active.
@@ -1428,7 +1421,7 @@ iso_stream_schedule ( 
	 * slot in the schedule, implicitly assuming URB_ISO_ASAP.

	 */

	if (likely (!list_empty (&stream->td_list))) {

		start = stream->next_uframe;

		u32	excess;



		/* For high speed devices, allow scheduling within the

		 * isochronous scheduling threshold.  For full speed devices
@@ -1440,21 +1433,23 @@ iso_stream_schedule ( 
		else

			next = now;



		/* Fell behind (by up to twice the slop amount)? */

		if (((start - next) & (mod - 1)) >=

				mod - 2 * SCHEDULE_SLOP)

			start += period * DIV_ROUND_UP(

					(next - start) & (mod - 1),

					period);



		/* Tried to schedule too far into the future? */

		if (unlikely(((start - now) & (mod - 1)) + span

					>= mod - 2 * SCHEDULE_SLOP)) {

		/* Fell behind (by up to twice the slop amount)?

		 * We decide based on the time of the last currently-scheduled

		 * slot, not the time of the next available slot.

		 */

		excess = (stream->next_uframe - period - next) & (mod - 1);

		if (excess >= mod - 2 * SCHEDULE_SLOP)

			start = next + excess - mod + period *

					DIV_ROUND_UP(mod - excess, period);

		else

			start = next + excess + period;

		if (start - now >= mod) {

			ehci_dbg(ehci, "request %p would overflow (%d+%d >= %d)\n",

					urb, start - now - period, period,

					mod);

			status = -EFBIG;

			goto fail;

		}

		stream->next_uframe = start;

		goto ready;

	}



	/* need to schedule; when's the next (u)frame we could start?
@@ -1463,51 +1458,60 @@ iso_stream_schedule ( 
	 * can also help high bandwidth if the dma and irq loads don't

	 * jump until after the queue is primed.

	 */

	else {

		start = SCHEDULE_SLOP + (now & ~0x07);

	start &= mod - 1;

	stream->next_uframe = start;



		/* NOTE:  assumes URB_ISO_ASAP, to limit complexity/bugs */



		/* find a uframe slot with enough bandwidth */

	for (; start < (stream->next_uframe + period); start++) {

		int		enough_space;

		next = start + period;

		for (; start < next; start++) {



			/* check schedule: enough space? */

		if (stream->highspeed)

			enough_space = itd_slot_ok (ehci, mod, start,

					stream->usecs, period);

		else {

			if (stream->highspeed) {

				if (itd_slot_ok(ehci, mod, start,

						stream->usecs, period))

					break;

			} else {

				if ((start % 8) >= 6)

					continue;

			enough_space = sitd_slot_ok (ehci, mod, stream,

					start, sched, period);

		}



		/* schedule it here if there's enough bandwidth */

		if (enough_space) {

			stream->next_uframe = start & (mod - 1);

			goto ready;

				if (sitd_slot_ok(ehci, mod, stream,

						start, sched, period))

					break;

			}

		}



		/* no room in the schedule */

	ehci_dbg (ehci, "iso %ssched full %p (now %d max %d)\n",

		list_empty (&stream->td_list) ? "" : "re",

		if (start == next) {

			ehci_dbg(ehci, "iso resched full %p (now %d max %d)\n",

				urb, now, now + mod);

			status = -ENOSPC;

			goto fail;

		}

	}



fail:

	iso_sched_free (stream, sched);

	urb->hcpriv = NULL;

	return status;

	/* Tried to schedule too far into the future? */

	if (unlikely(start - now + span - period

				>= mod - 2 * SCHEDULE_SLOP)) {

		ehci_dbg(ehci, "request %p would overflow (%d+%d >= %d)\n",

				urb, start - now, span - period,

				mod - 2 * SCHEDULE_SLOP);

		status = -EFBIG;

		goto fail;

	}



	stream->next_uframe = start & (mod - 1);



ready:

	/* report high speed start in uframes; full speed, in frames */

	urb->start_frame = stream->next_uframe;

	if (!stream->highspeed)

		urb->start_frame >>= 3;

	return 0;



 fail:

	iso_sched_free(stream, sched);

	urb->hcpriv = NULL;

	return status;

}



/*-------------------------------------------------------------------------*/

CRA Git | Maintained and supported by SUSTech CRA and CCSE