[Puto]

Right, I've got a small problem. I'm trying to make jman's Sonic 1 sound driver to load without kosinski compression. This works if I manually copy every byte into Z80 RAM, like this:

	 move.b (Kos_Z80+$000),($A00000+$000).l   
	 move.b (Kos_Z80+$001),($A00000+$001).l
	 move.b (Kos_Z80+$002),($A00000+$002).l
	 move.b (Kos_Z80+$003),($A00000+$003).l
	 move.b (Kos_Z80+$004),($A00000+$004).l
	 move.b (Kos_Z80+$005),($A00000+$005).l
	 move.b (Kos_Z80+$006),($A00000+$006).l
	 move.b (Kos_Z80+$007),($A00000+$007).l
	 move.b (Kos_Z80+$008),($A00000+$008).l
	 move.b (Kos_Z80+$009),($A00000+$009).l
	 ...

But this is horribly ugly, it takes a shitload of ROM space, and it's not very extensible. Unfortunately, I seem to not get along with address registers and the like, so could someone help me get this in a proper loop plz?

EDIT: Oh, and the size of the driver can be obtained by doing (Kos_Z80_End-Kos_Z80).

This post has been edited by Puto: 10 June 2007 - 06:07 AM

[Quickman]

lea (Kos_Z80),a0
lea ($A00000).l,a1
move.w ((Kos_Z80_End-Kos_Z80)/4),d1

$$loop:
move.l (a0)+,(a1)+
dbf d1,$$loop

EDIT: Just noticed your own edit, made the extra code I added redundant. Be sure to change the label - I've assumed $$ as a prefix for a local label. If you were using AS I'd use a nameless temporary symbol.

This post has been edited by Quickman: 10 June 2007 - 06:24 AM

[Puto]

Thanks, it worked

[Puto]

OK, continuation of problem. Apparently, access to Z80 RAM, aka $A00000-$A1FFFF, can only be done in bytes. How do I increment an address register by only one byte, instead of 4?

[JoseTB]

That's defined by the size of the instruction if I'm not mistaken, therefore use move.b instead of move.l, and change the rest of the loop accordingly.

[Puto]

This code doesn't seem to work:

move.w (Z80_Driver_End-Z80_Driver),d1
@loop:
move.b (a0)+,(a1)+
dbf d1,@loop

So what am I doing wrong?

EDIT: Wait a minute...

How did this work:

move.w (Z80_Driver_End-Z80_Driver)/4,d1
@loop:
move.b (a0)+,(a1)+
dbf d1,@loop
move.w (Z80_Driver_End-Z80_Driver)/4,d1
@loop2:
move.b (a0)+,(a1)+
dbf d1,@loop2
move.w (Z80_Driver_End-Z80_Driver)/4,d1
@loop3:
move.b (a0)+,(a1)+
dbf d1,@loop3
move.w (Z80_Driver_End-Z80_Driver)/4,d1
@loop4:
move.b (a0)+,(a1)+
dbf d1,@loop4

But one loop without a /4 didn't?

This post has been edited by Puto: 12 June 2007 - 11:54 AM

[Aurochs]

DBcc operates on a 16-bit counter. If your driver is longer than 65535 ($FFFF) bytes, the loop will terminate prematurely.

This post has been edited by Aurochs: 13 June 2007 - 01:47 PM
Reason for edit: lol can't edit a non-html post to include html elements

[drx]

Seeing as you Z80 RAM is limited to $2000 (or $4000, I don't remember which) bytes, the scenario you provided is impossible anyway ($2000 < $FFFF). I still can't quite understand why this occurs... What Puto posted seems pretty much impossible, as the code is pretty much identical, so I must be blind and not seeing something.

[Aurochs]

Indeed. I can't see any other problems with this... Try running both of them through your assembler, then disassembling it again (68kd works for this), or just read back the listing file. It may not be generating code as expected.

[Quickman]

The Z80 can access 64KB ($A00000 - $A01000) but the high 32KB of that are bank-switched to look at a 32KB chunk of 68k memory.

[drx]

Quickman, on Jun 13 2007, 10:12 PM, said:

The Z80 can access 64KB ($A00000 - $A01000) but the high 32KB of that are bank-switched to look at a 32KB chunk of 68k memory.

Wow, that is so wrong that I don't know where to start.

First of all 64KB is $10000, not $1000, second, we're not talking about what the Z80 can access, but rather what the 68000 can access. And yea... stuff.

[Tweaker]

IIRC, the 68k can only access Z80 at a byte level.

EDIT: Oh cool, we've established that. So what exactly IS the problem?

[JoseTB]

I can't see where is the problem either. Do you clean D1 before using it? Judging by the code it shouldn't really matter, but who knows.

Also, what happens with the non-working loop? Does it crash in a never-ending loop, or does the loop actually end, but before all data has been sent?

This post has been edited by JoseTB: 13 June 2007 - 10:02 PM

[drx]

Quote

I can't see where is the problem either. Do you clean D1 before using it? Judging by the code it shouldn't really matter, but who knows.

Yea, as the DBcc instruction never even touches the higher register word.

A good idea would be to run your debugging tools of choice and trace what is happening byte by byte.

[Puto]

Eventually I just ended up doing this:

<tt>move.w (Z80_Driver_End-Z80_Driver)/4,d1
@loop:
move.b (a0)+,(a1)+
move.b (a0)+,(a1)+
move.b (a0)+,(a1)+
move.b (a0)+,(a1)+
dbf d1,@loop</tt>

Which seems to work perfectly. I still don't understand why taking out the /4 and putting in just one move.b doesn't work though.