Specifications

28 TMS320C6457 Fixed-Point Digital Signal Processor Silicon Errata SPRZ293A—November 2009
Silicon Updates
www.ti.com
Silicon Revisions 1.0, 1.1, 1.2, 1.3, 1.4 Submit Documentation Feedback
To implement this workaround, programmers must write back (and optionally
invalidate) the buffer from L1D cache after Step 3 and before Step 4. There are multiple
mechanisms for doing this, but the most straightforward is to use the L1D block cache
writeback mechanism via L1DWBAR/L1DWWC or the L1D block cache
writeback-invalidate mechanism via L1DWIBAR/L1DWIWC.
The recommended implementation of this workaround requires calling the
l1d_block_wb.asm and l1d_block_wbinv.asm functions (see the L1D Block
Writeback and L1D Writeback-Invalidate Routines in Sections and of Appendix
A—Code Examples). The functions can be invoked as follows:
void l1d_block_wb(void *base, size_t byte_count);
or
void l1d_block_wbinv(void *base, size_t byte_count);
To writeback a C array, one could then do:
char array[SIZE];
/* ... */
l1d_block_wb(&array[0], sizeof(array));
The above example could be used to writeback-invalidate as well by calling the other
function. Programmers should insert such a call whenever the CPU code is done with
a particular DMA buffer, before the DMA controller can refill it. The l1d_block_wb()
and l1d_block_wbinv() functions are non-interruptible. The overhead is proportional
to the size of the buffer.
Note—To ensure complete effectiveness, ensure that the DMA buffers always
start on an L1D cache-line boundary (64-byte boundary) and occupy a
multiple of 64 bytes. This may require increasing the size of some DMA buffers
slightly. This is necessary to prevent accesses to an unrelated buffer or variable
from bringing a portion of the DMA buffer back into the L1D cache.
Workaround 2: Workaround for False Sharing
This bug can occur when the CPU and the DMA both access distinct objects that share
a single L1D cache line. This is often referred to as false sharing. To avoid false sharing,
ensure that the DMA buffers begin on 64-byte boundaries and occupy a multiple of 64
bytes. This may require increasing the size of some DMA buffers. If an application has
many small DMA buffers, consider packing these together to limit the overall growth
in DMA buffer space implied by this workaround.