Mouse operation and data packet

Mouse Operation

• Detects presses, releases, and movement events.
• Uses two 9-bit 2's complement counters for X and Y directions, reset after communication.
• Some touchpads communicate absolute positions
• Informs the KBC of events by sending a 3-byte data packet via a serial line.
• Each byte of the packet is placed in the KBC's OUT_BUF.
• The KBC triggers IRQ12 (which is IRQ4 on PIC 2) for each received byte.

Data Packet Structure

• Byte 1: Contains overflow flags for X and Y deltas and button states.
  • Includes the MSB of the Y delta.
  • Includes the MSB of the X delta.
  • Indicates middle, right, and left button states (1 if pressed).
  • Bit 3 is always set to 1.
• Byte 2: Contains the 8 LSB of the X-axis relative displacement (delta X).
  • Combined with the X MSB from Byte 1, forms a 9-bit 2's complement integer.
• Byte 3: Contains the 8 LSB of the Y-axis relative displacement (delta Y).
  • Combined with the Y MSB from Byte 1, forms a 9-bit 2's complement integer.

Mouse Operation Modes

• Stream Mode (Default): Continuously sends data packets to the KBC at a fixed rate whenever mouse events occur.
• Remote Mode: Sends data packets only when explicitly requested by the KBC.

Mouse Commands

• Sent to the mouse via the KBC using the "Write Byte to Mouse" command (0xD4), written to the KBC's command port (0x64).
• The byte to be sent (command or argument) is written to the KBC's data port (0x60).
• 0xFF: Resets the mouse.
• 0xF6: Sets default values.
• 0xF5: Disables data reporting (used in stream mode before other commands).
• 0xF4: Enables data reporting (stream mode only).
• 0xF3: Sets the sample rate.
• 0xF0: Sets remote mode.
• 0xEB: Reads data (requests a data packet in remote mode).
• 0xEA: Sets stream mode.
• 0xE9: Requests status (mouse configuration).
• 0xE8: Sets the resolution.
• 0xE7/0xE6: Sets the scale (2:1 or 1:1).
• The mouse sends an acknowledgment byte (0xFA for ACK, 0xFE for NACK, 0xFC for ERROR) in response to most received bytes.
• The ACK byte is placed in the KBC's OUT_BUF and must be read from port 0x60.
• For commands that trigger a data response, the mouse sends the response after acknowledging the last byte of the command.
• The mouse must be first disabled using the command 0xF5 before sending other commands in stream mode after enabling data report.

Mouse Implementation Details

• Interacting with the mouse requires interfacing with the KBC (i8042) using I/O ports 0x60 (data) and 0x64 (status/command).
• Mouse interrupts (IRQ12) are subscribed using sys_irqsetpolicy().
  • IRQ_EXCLUSIVE is important to prevent interference from Minix's default mouse handler.
• The interrupt handler does not need to explicitly check OBF or AUX bits, as the KBC uses different IRQ lines for the keyboard and mouse.
• Since the mouse data packet has 3 bytes, these bytes must be assembled in the driver.
  • A buffer and counter are used. The 1st byte has bit 3 set, as a hint for synchronization. All 3 bytes must belong to the same package, requiring checking.

Event Driven Design

• Programs wait for events to occur and react to them, instead of executing top-down.
• They wait for clients to signal an event and then act.
• Events: Signals that something interesting has happened, such as mouse clicks, timer triggers, or data arrival from the network.
• Event handler: Specific code sections that handle each event type.
• Dispatchers: Manage event handlers by listening for events and calling the correct handler.

State Machines

• State machines can function with event driven design.
• The program can be in different "modes". How it responds to an event may change based on the current "mode" or state.
• Useful when the event handler depends on input event and process state (Mealy machine), or when it depends only on process state (Moore machine).
• Example states: INIT, DRAW, COMP with events like RDOWN (right button pressed), RUP (right button released).

Event Processing

• Application Dependent: IH performs more processing and may decide what the event means for the program.
• Application Independent: IH only gets raw data from the hardware, and other parts of the program decide what to do with it.
• Device drivers in Minix 3 generally use an application-independent approach, processing interrupt notifications.

Function Pointers

• Store the address of a function in memory, treating functions as data.
• Allow assigning functions to variables.
• Allow storing functions in arrays, structs, or unions.
• Functions can be passed as arguments to other functions.
• Functions can be returned from other functions.
• Example: int (*fp)(int); declares a pointer to a function that takes an int and returns an int.

Function Pointers in Events

• Useful for linking events to their handlers.
• Events
  • Switch Statement: Selects the event handler based on event type.
  • Table of Function Pointers: An array where each index corresponds to an event type and stores the pointer to the handler.
• State Machines: The event handler depends on the current state and the event.
  • Two-Dimensional Table: Indexed by state and event.
• Menus: Each menu item executes a specific action.
  • Each menu entry stores a pointer to the function.
• Device Drivers
  • Generic Operations: Defines a common interface for different devices.
  • Flexibility: allows replacing operations to adapt to different hardware

Video Card

• Interfaces between the computer and the monitor.
• GPU: Controls the screen hardware and performs rendering, reducing CPU usage.
• VRAM: Memory storing data to be rendered on the screen.
• BIOS ROM/Flash: Non-volatile memory containing firmware and code for basic video I/O operations, such as VBE.

x86 Registers

Video Modes

• Text Mode: Grid of characters (e.g., 80x25).
• Graphic Mode: Matrix of pixels, each with a color stored in VRAM.
• Direct-color mode: the color of each pixel is stored directly in VRAM, using 3 intensity values (Red, Green, Blue - RGB)
  • 8 bits / color / pixel
• Indexed mode: stores an index of a table (palette) of colors in VRAM. The palette contains the definition (RGB intensities) of each color.
  • 8 bit index -> 256 colors

Memory Model

• Determines how video memory is organized.
• Linear Mode: Pixels are stored contiguously in memory in a linear framebuffer.
  • Requires knowing the framebuffer base address (vbe_get_mode_info()), pixel coordinates, and number of bytes used to encode the color.

Video Card Configuration

• Minix 3 typically starts in text mode.
• The GPU is configured using standardized interfaces through BIOS and VBE.
  • BIOS services are provided through interrupts (INT xx).
  • VBE (Video BIOS Extension): Supports higher resolutions using INT 0x10, differentiated by the AH register value.
• Calls to real-mode BIOS can be made from user level in Minix 3 using the sys_int86 kernel call, which temporarily switches from 32-bit protected mode to 16-bit real mode.
• Arguments for BIOS calls are passed through CPU registers represented by the reg86_t struct.

VRAM Access

• Images can be drawn on the screen from graphic mode. Obtain the physical memory address of the framebuffer using vbe_get_mode_info() (or implement your own using VBE function 0x01). The vbe_mode_info_t struct contains:
  • Screen dimensions.
  • Color depth.
  • Physical base address of the framebuffer (PhysBasePtr).
• Mapping the region of physical memory into the process's virtual address space using kernel calls. Process user-level cannot directly access the physical memory, hence sys_privtcl (using SYS_PRIV_ADD_MEM) and vm_map_phys are used for mapping. Returns virtual address (void *video_mem).
• After mapping VRAM, it is accessed using pointers. The pointer type dictates the number of bytes per pixel.
  • 3 bytes per pixel: Use memcpy or a struct. Pointer arithmetic automatically handles pixel traversal based on the pointer type.
• reg86_t struct: is the union of anonymous structs that allow the access of IA32 registers: uint32_t *, uint16_t *, uint8_t *

Image Display (XPM)

• Images represented as a pixmap (array of pixel color values).
• X Pixmap (XPM): Format where pixel colors are represented by strings in a C file.
• xpm_load(): Converts XPM to raw pixmap, reads the XPM, then creates a pixel with the specified color. The image (img.bytes) is then copied to VRAM.

Raster Graphics

• Image stored directly in a framebuffer
• Simple Hardware
• Constant time to redraw
• Images often have jagged edges

Vector Graphics

• Allow to draw smooth lines
• Complex Harware
• Update rate depends on number of paths in the image
• May flicker if image becomes to large

Sprites

• Sprites are separate overlay images that do not alter the background with position, dimensions, speed, and a pointer to its pixmap.
• The pixmap includes a transparent color which should not be copied to the VRAM, allowing background to be visible.
• A collision can be detected is a non-transparent pixel overlaps a non-background pixel.
• create_sprite() and destroy_sprite() manages allocated and the deallocation of the sprite.

Moving Sprites

• Sprite movement is obtained by changing a sprite in an order to make different pixmaps.
• Pixels have to be redefined to there original starting point so that the Sprite appears to move correctly.

Vertical Sync

• To solve screen tearing sync screen refreseh swaps during the interval vetween frames to ensure they do not tear.

Double Buffering

• Draw the back frame, write everything on the background from the back buffer and transfer write the result back to VRAM. This reduces time and is faster, but may cause tearing.

Page Flipping

• instant background swap to another one to save on performance issues.

Animating Sprites

• Involves changing the image of the sprite over time.
• Animation speed is measured by the number of frames each image is shown for before changing the next.
• An animated sprite can be created using create_animSprite(), which takes an array of XPMs as input.