GP0 Transfer and Other Commands

Frame buffer fill, copy and transfer commands and the other GP0 commands.

This is an old revision of this page, as edited by RemmyLee at 02:43, 23 October 2026. Edit this revision | Latest revision

Summary

The transfer commands of GP0 make the GPU move image data between main memory and the frame buffer and within the frame buffer. Sony lists three image transfers among the GPU drawing functions: CPU to frame buffer, frame buffer to CPU and frame buffer to frame buffer.¹ These are command groups 4, 5 and 6. The fill and cache commands belong to group 0, and GP0 Drawing Commands lists all the groups. For groups 4 to 6 the GPU ignores the lower 29 bits of the command word, so any value may be placed there.²

The libgpu functions in the table are those that access the frame buffer directly.³ ClearImage() sets a rectangle of the frame buffer to one RGB color and is not affected by the clip and offset of the drawing environment. In interlace mode ClearImage() clears only one field, so ClearImage2() must be used to clear both.⁴

Frame Buffer Transfers in libgpu

LoadImage(), StoreImage() and MoveImage() are non-blocking functions. Each returns before the transfer is complete, and the transfer proceeds in the background; consequently, the end of the transfer must be detected with DrawSync(). Up to 64 non-blocking requests may wait in the queue, and a 65th request blocks until a place in the queue is free.³⁵

The rectangle given to these functions is in frame buffer coordinates of 16-bit pixels. For a 4-bit texture the width in texels must therefore be divided by 4, and for an 8-bit texture by 2; a 4-bit texture must be a multiple of 4 pixels wide and an 8-bit texture a multiple of 2.⁶

GP0(01h) - Clear Cache

GP0(01h) flushes the texture cache. It is used after the frame buffer is changed, in the same way that the CPU instruction cache must be flushed after new code is written. psx-spx reports that demos can make the GPU draw stale cached texels by changing VRAM without this command, but that games do not do this.⁷

GP0(02h) - Fill Rectangle in VRAM

GP0(02h) fills a rectangle of the frame buffer with one color. It is faster than an equivalent rectangle drawing command and is therefore used to clear the screen. The command is 3 words:⁸

The GPU converts the 24-bit color to 15 bits by dropping the lower 3 bits of each component, and it writes bit 15 (the mask bit) as 0. The fill ignores the GP0(E6h) mask setting and behaves as if both of its bits were 0. Horizontally the fill works in units of 16 pixels (32 bytes), so the parameters are rounded as follows:⁸⁹

No fill takes place when Xsiz or Ysiz is 0. Because of the masking a parameter of 400h becomes a width of 0. A parameter from 3F1h to 3FFh, however, rounds up to a width of 400h. A single fill command therefore covers at most 511 lines, and a fill with the full height of 512 lines does nothing because its height is masked to 0.⁹

The v0 GPU has a defect in this command. When bits 0 to 3 of the X coordinate are all set, it writes every second pixel to the wrong address; the v2 GPU ignores these bits as intended. Software should therefore always set them to 0.¹⁰

GP0(80h) - Copy Rectangle VRAM to VRAM

GP0(80h) copies a rectangle within the frame buffer. The command is 4 words:¹¹

The copy is affected by the mask setting of GP0(E6h).¹¹

GP0(A0h) - Copy Rectangle CPU to VRAM

GP0(A0h) transfers image data from the CPU to the frame buffer. After the 3 command words the data follows as 32-bit words, which are normally sent by DMA:¹²

Because the data is sent in 32-bit words, an odd number of halfwords is padded with one extra halfword. The transfer is affected by the mask setting of GP0(E6h).¹²

GP0(C0h) - Copy Rectangle VRAM to CPU

GP0(C0h) transfers image data from the frame buffer to the CPU. The CPU writes the 3 command words to GP0 and then reads the data from the GP0 port, or by DMA:¹³

The CPU must wait until bit 27 of GPUSTAT is set before it reads the data. As with GP0(A0h), an odd number of halfwords ends with one extra halfword.¹³

Copy Parameters

The copy commands clip their parameters to 10 and 9 bits. The only special case is a size of 0, which means the maximum size:¹⁴

The coordinates of all transfer commands are absolute frame buffer addresses. The drawing offset is not added and the drawing area does not clip them. When a source or destination rectangle extends past the 1024 x 512 frame buffer, the copy or fill wraps to the opposite edge. There is no carry from X into Y or from Y into X.¹⁵¹⁶

A transfer command differs from a textured rectangle in three ways: it is not clipped to the drawing area, it does not treat any texel as transparent or semi-transparent, and it does not convert color depth. A 4-bit texture copied with GP0(80h) is therefore not expanded to 16-bit pixels.¹⁷

psx-spx reports that a continuous DMA transfer to or from VRAM works only during vertical blanking on the GPU it tested, and that parts of the data are skipped at other times. Transfers by the CPU are not affected, and neither is the DMA list mode that sends an ordering table.¹⁵

GP0(1Fh) - Interrupt Request

GP0(1Fh) requests interrupt IRQ1 and sets bit 24 of GPUSTAT. The interrupt is acknowledged with GP1(02h). psx-spx describes the command as rarely used.¹⁸

GP0(00h) - NOP

GP0(00h) does not take up space in the command FIFO. Dozens of GP0(00h) words can be sent while a VRAM-to-VRAM copy is still busy without filling the FIFO. Consequently the command is either ignored or executed at once.¹⁹

GP0(04h) to GP0(1Eh), GP0(E0h) and GP0(E7h) to GP0(EFh) behave the same way. However, the drawing area and offset commands also take no FIFO space, so this alone does not prove that these commands have no function. GP0(03h), by contrast, does take a FIFO entry, and its purpose is unknown.²⁰²¹

References