MCF5253CVM140J Freescale Semiconductor, MCF5253CVM140J Datasheet - Page 544

• Manufacturer Part Number: MCF5253CVM140J
• Description: IC MCU 2.1MIPS 140MHZ 225MAPBGA
• Manufacturer: Freescale Semiconductor
• Series: MCF525xr

Specifications of MCF5253CVM140J

• Core Processor: Coldfire V2
• Core Size: 32-Bit
• Speed: 140MHz
• Connectivity: CAN, EBI/EMI, I²C, QSPI, UART/USART, USB OTG
• Peripherals: DMA, WDT
• Program Memory Type: ROMless
• Ram Size: 128K x 8
• Voltage - Supply (vcc/vdd): 1.08 V ~ 1.32 V
• Data Converters: A/D 6x12b
• Oscillator Type: External
• Operating Temperature: -40°C ~ 85°C
• Package / Case: 225-MAPBGA
• Processor Series: MCF525x
• Core: ColdFire V2
• 3rd Party Development Tools: JLINK-CF-BDM26, EWCF
• Lead Free Status / RoHS Status: Lead free / RoHS Compliant
• Number Of I /o: -
• Eeprom Size: -
• Program Memory Size: -
• Lead Free Status / Rohs Status: Details

Universal Serial Bus Interface
If the software removes the queue head with the H-bit set, it must select another queue head still linked
into the schedule and set its H-bit. This should be completed before removing the queue head. The
requirement is that the software keep one queue head in the asynchronous schedule, with its H-bit set. At
the point the software has removed one or more queue heads from the asynchronous schedule, it is
unknown whether the host controller has a cached pointer to them. Similarly, it is unknown how long the
host controller might retain the cached information, as it is implementation dependent and may be affected
by the actual dynamics of the schedule load. Therefore, once the software has removed a queue head from
the asynchronous list, it must retain the coherency of the queue head (link pointers). It cannot disturb the
removed queue heads until it knows that the host controller does not have a local copy of a pointer to any
of the removed data structures.
The method the software uses to determine when it is safe to modify a removed queue head is to handshake
with the host controller. The handshake mechanism allows the software to remove items from the
asynchronous schedule, then execute a simple, lightweight handshake that is used by the software as a key
that it can free (or reuse) the memory associated the data structures it has removed from the asynchronous
schedule.
The handshake is implemented with three bits in the host controller. The first bit is a command bit
(Interrupt on Async Advance Doorbell bit in the USBCMD register) that allows the software to inform the
host controller that something has been removed from its asynchronous schedule. The second bit is a status
bit (Interrupt on Async Advance bit in the USBSTS register) that the host controller sets after it has
released all on-chip state that may potentially reference one of the data structures just removed. When the
host controller sets this status bit, it also clears the command bit. The third bit is an interrupt enable
(Interrupt on Async Advance bit in the USBINTR register) that is matched with the status bit. If the status
bit is set and the interrupt enable bit is set, then the host controller asserts a hardware interrupt.
Figure 24-49
the schedule using the algorithm above. Before the unlink operation, the host controller has a copy of
queue head A.
The unlink algorithm requires that as the software unlinks each queue head, the unlinked queue head is
loaded with the address of a queue head that will remain in the asynchronous schedule.
When the host controller observes that doorbell bit being set, it makes a note of the local reachable
schedule information. In this example, the local reachable schedule information includes both queue heads
(A & B). It is sufficient that the host controller can set the status bit (and clear the doorbell bit) as soon as
it has traversed beyond current reachable schedule information (that is, traversed beyond queue head (B)
in this example).
24-82
End UnlinkQueueHead
-- software is unlinking a consecutive series of
-- queue heads, QHeadNext must be set by software to
-- the queue head remaining in the schedule.
--
-- This algorithm unlinks a queue head from a circular list
--
pQueueHeadPrevious.HorizontalPointer = pQueueHeadToUnlink.HorizontalPointer
pQueueHeadToUnlink.HorizontalPointer = pQHeadNext
illustrates a general example where consecutive queue heads (B and C) are unlinked from
MCF5253 Reference Manual, Rev. 1
Freescale Semiconductor