Most of my assembly coding is part of reverse-engineering video game consoles, and a common need is to delay N clocks, where N is a constant or run-time value. I figured I'd share the 6502 routines I use, since I found them fun to write. This is the key routine:

It's somewhat obfuscated because I wanted to reduce the overhead (the +20) as much as possible. In addition to the above, there are routines that delay A*256+10 clocks and A*65536+10 clocks, allowing 16-bit and 24-bit run-time delays by simply calling the three routines with the low, mid, and high bytes of the delay. There will be an overhead of some constant number of clocks, but that's usually not a problem.

For constant delays, I use a macro (ca65 assembler) that selects between several strategies depending on the delay, which can be any expression evaluating to 2 to 16777216 (or zero). For delays of less than 28, it uses either an inline delay made up of short instructions, or a JSR to a bunch of NOPs followed by a return. For 28 and larger, it uses a call to delay_a_clocks, and optional calls to variants of the "delay A*256 clocks" and "delay A*65536 clocks" routines when the mid and high bytes are non-zero. The X and Y registers are preserved by all routines/macros, but A is not, since it's easy enough to save and restore it. At one point I had a version with the full 24-bit delay stored inline after the JSR, which shortened the delay calls a bit, but this made the delay code much more complex, so I went back to the simpler scheme I use now.

Here's the full commented source code I use: 6502_delay.asm

I've added two routines I had sitting around to the wiki at:

http://6502org.wikidot.com/software-delay

One routine delays 25+A cycles (includes the JSR and RTS); the other can be inlined (i.e. you don't need a JSR or RTS) and delays 15+A cycles (it would take 27+A cycles if a JSR and RTS were used). They're a little smaller too.

This does 14+A in the range A=(1,8) or 13 with A=0.

First a reference


The Code


A table of the code fragments by branch offset



Expanding the concept

Simply adjust from cmp $ea to cmp #$c9 cmp $ea etc.

There's a variation for 1..7 that's 15 bytes because you can use eor #7 directly.

Apparently I did some more work on this. See
http://csdb.dk/forums/?roomid=11&topicid=65658

I made a long post in there that's a bit hard to understand, but basically I've worked out every approach to this problem I think.