schedule.java

来自「纯java操作系统jnode,安装简单和操作简单的个人使用的Java操作系统」· Java 代码 · 共 179 行

/*
 * $Id: Schedule.java,v 1.1 2003/11/25 11:42:17 epr Exp $
 */
package org.jnode.driver.usb.uhci;

import org.jnode.driver.usb.USBConstants;
import org.jnode.system.ResourceManager;

/**
 * Schedule of TransferDescriptors and QueueHeads. This is the class that constructs and maintains
 * the frame schedule.
 * 
 * @author Ewout Prangsma ([e-mail])
 */
public class Schedule implements USBConstants {

	/** The frame list */
	private final FrameList frameList;
	/** Interrupt queues interval 128ms */
	private final QueueHead int128QH;
	/** Interrupt queues interval 64ms */
	private final QueueHead int64QH;
	/** Interrupt queues interval 32ms */
	private final QueueHead int32QH;
	/** Interrupt queues interval 16ms */
	private final QueueHead int16QH;
	/** Interrupt queues interval 8ms */
	private final QueueHead int8QH;
	/** Interrupt queues interval 4ms */
	private final QueueHead int4QH;
	/** Interrupt queues interval 2ms */
	private final QueueHead int2QH;
	/** Interrupt queues interval 1ms */
	private final QueueHead int1QH;
	/** Low speed control queue */
	private final QueueHead lowSpeedControlQH;
	/** High speed control queue */
	private final QueueHead highSpeedControlQH;
	/** Bulk queue */
	private final QueueHead bulkQH;
	/** Termination QH */
	private final QueueHead termQH;
	/** Termination TD */
	private final TransferDescriptor termTD;

	/**
	 * Create a new instance
	 * 
	 * @param rm
	 */
	public Schedule(ResourceManager rm) {
		//this.intQH = new QueueHead[8];
		this.frameList = new FrameList(rm);
		this.int128QH = new QueueHead(rm);
		this.int64QH = new QueueHead(rm);
		this.int32QH = new QueueHead(rm);
		this.int16QH = new QueueHead(rm);
		this.int8QH = new QueueHead(rm);
		this.int4QH = new QueueHead(rm);
		this.int2QH = new QueueHead(rm);
		this.int1QH = new QueueHead(rm);
		this.lowSpeedControlQH = new QueueHead(rm);
		this.highSpeedControlQH = new QueueHead(rm);
		this.bulkQH = new QueueHead(rm);
		this.termQH = new QueueHead(rm);
		this.termTD = new TransferDescriptor(rm, 0x7F, 0, USB_PID_IN, true, null, 0, 0, false, false, false);

		int128QH.setLink(int64QH);
		int64QH.setLink(int32QH);
		int32QH.setLink(int16QH);
		int16QH.setLink(int8QH);
		int8QH.setLink(int4QH);
		int4QH.setLink(int2QH);
		int2QH.setLink(int1QH);
		int1QH.setLink(lowSpeedControlQH);
		lowSpeedControlQH.setLink(highSpeedControlQH);
		highSpeedControlQH.setLink(bulkQH);
		bulkQH.setLink(termQH);
		// Loop back term QH to high speed control queue.
		termQH.setLink(highSpeedControlQH);
		// Maybe this helps, taken from the Linux kernel as a bugfix
		// for some Intel PIIX controllers
		termQH.setElement(termTD);
		termTD.setActive(false);

		// Setup the framelist
		final int max = frameList.getSize();
		for (int i = 0; i < max; i++) {
			QueueHead q = int1QH;
			if ((i & 1) != 0) {
				q = int2QH;
				if ((i & 2) != 0) {
					q = int4QH;
					if ((i & 4) != 0) {
						q = int8QH;
						if ((i & 8) != 0) {
							q = int16QH;
							if ((i & 16) != 0) {
								q = int32QH;
								if ((i & 32) != 0) {
									q = int64QH;
									if ((i & 64) != 0) {
										q = int128QH;
									}
								}
							}
						}
					}
				}
			}
			frameList.setListPointer(i, q, true);
		}
	}

	/**
	 * @return Returns the frameList.
	 */
	public final FrameList getFrameList() {
		return this.frameList;
	}

	/**
	 * Gets the optimal interrupt QH for a specific interval.
	 * 
	 * @param interval
	 */
	public final QueueHead getInterruptQH(int interval) {
		if (interval < 16) {
			if (interval < 4) {
				if (interval < 2) {
					return int1QH; /* int1 for 0-1 ms */
				} else {
					return int2QH; /* int2 for 2-3 ms */
				}
			} else if (interval < 8) {
				return int4QH; /* int4 for 4-7 ms */
			} else {
				return int8QH; /* int8 for 8-15 ms */
			}
		} else if (interval < 64) {
			if (interval < 32) {
				return int16QH; /* int16 for 16-31 ms */
			} else {
				return int32QH; /* int32 for 32-63 ms */
			}
		} else if (interval < 128) {
			return int64QH; /* int64 for 64-127 ms */
		} else {
			return int128QH; /* int128 for 128-255 ms (Max.) */
		}
	}

	public String toString() {
		return "Schedule{lowQH:" + lowSpeedControlQH + ", highQH:" + highSpeedControlQH + "}";
	}
	
	/**
	 * @return Returns the bulkQH.
	 */
	public QueueHead getBulkQH() {
		return this.bulkQH;
	}

	/**
	 * @return Returns the highSpeedControlQH.
	 */
	public QueueHead getHighSpeedControlQH() {
		return this.highSpeedControlQH;
	}

	/**
	 * @return Returns the lowSpeedControlQH.
	 */
	public QueueHead getLowSpeedControlQH() {
		return this.lowSpeedControlQH;
	}

}