1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 23:47:45 +00:00

AK: Rename the common integer typedefs to make it obvious what they are.

These types can be picked up by including <AK/Types.h>:

* u8, u16, u32, u64 (unsigned)
* i8, i16, i32, i64 (signed)
This commit is contained in:
Andreas Kling 2019-07-03 21:17:35 +02:00
parent c4c4bbc5ba
commit 27f699ef0c
208 changed files with 1603 additions and 1621 deletions

View file

@ -43,7 +43,7 @@ BXVGADevice::BXVGADevice()
m_framebuffer_address = PhysicalAddress(find_framebuffer_address());
}
void BXVGADevice::set_register(word index, word data)
void BXVGADevice::set_register(u16 index, u16 data)
{
IO::out16(VBE_DISPI_IOPORT_INDEX, index);
IO::out16(VBE_DISPI_IOPORT_DATA, data);
@ -54,10 +54,10 @@ void BXVGADevice::set_resolution(int width, int height)
m_framebuffer_size = { width, height };
set_register(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_DISABLED);
set_register(VBE_DISPI_INDEX_XRES, (word)width);
set_register(VBE_DISPI_INDEX_YRES, (word)height);
set_register(VBE_DISPI_INDEX_VIRT_WIDTH, (word)width);
set_register(VBE_DISPI_INDEX_VIRT_HEIGHT, (word)height * 2);
set_register(VBE_DISPI_INDEX_XRES, (u16)width);
set_register(VBE_DISPI_INDEX_YRES, (u16)height);
set_register(VBE_DISPI_INDEX_VIRT_WIDTH, (u16)width);
set_register(VBE_DISPI_INDEX_VIRT_HEIGHT, (u16)height * 2);
set_register(VBE_DISPI_INDEX_BPP, 32);
set_register(VBE_DISPI_INDEX_ENABLE, VBE_DISPI_ENABLED | VBE_DISPI_LFB_ENABLED);
set_register(VBE_DISPI_INDEX_BANK, 0);
@ -66,15 +66,15 @@ void BXVGADevice::set_resolution(int width, int height)
void BXVGADevice::set_y_offset(int offset)
{
ASSERT(offset <= m_framebuffer_size.height());
set_register(VBE_DISPI_INDEX_Y_OFFSET, (word)offset);
set_register(VBE_DISPI_INDEX_Y_OFFSET, (u16)offset);
}
dword BXVGADevice::find_framebuffer_address()
u32 BXVGADevice::find_framebuffer_address()
{
// NOTE: The QEMU card has the same PCI ID as the Bochs one.
static const PCI::ID bochs_vga_id = { 0x1234, 0x1111 };
static const PCI::ID virtualbox_vga_id = { 0x80ee, 0xbeef };
dword framebuffer_address = 0;
u32 framebuffer_address = 0;
PCI::enumerate_all([&framebuffer_address](const PCI::Address& address, PCI::ID id) {
if (id == bochs_vga_id || id == virtualbox_vga_id) {
framebuffer_address = PCI::get_BAR0(address) & 0xfffffff0;
@ -133,12 +133,12 @@ bool BXVGADevice::can_write(FileDescription&) const
ASSERT_NOT_REACHED();
}
ssize_t BXVGADevice::read(FileDescription&, byte*, ssize_t)
ssize_t BXVGADevice::read(FileDescription&, u8*, ssize_t)
{
ASSERT_NOT_REACHED();
}
ssize_t BXVGADevice::write(FileDescription&, const byte*, ssize_t)
ssize_t BXVGADevice::write(FileDescription&, const u8*, ssize_t)
{
ASSERT_NOT_REACHED();
}

View file

@ -20,18 +20,18 @@ public:
virtual int ioctl(FileDescription&, unsigned request, unsigned arg) override;
virtual KResultOr<Region*> mmap(Process&, FileDescription&, VirtualAddress preferred_vaddr, size_t offset, size_t, int prot) override;
size_t framebuffer_size_in_bytes() const { return m_framebuffer_size.area() * sizeof(dword) * 2; }
size_t framebuffer_size_in_bytes() const { return m_framebuffer_size.area() * sizeof(u32) * 2; }
Size framebuffer_size() const { return m_framebuffer_size; }
private:
virtual const char* class_name() const override { return "BXVGA"; }
virtual bool can_read(FileDescription&) const override;
virtual bool can_write(FileDescription&) const override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
void set_register(word index, word value);
dword find_framebuffer_address();
void set_register(u16 index, u16 value);
u32 find_framebuffer_address();
PhysicalAddress m_framebuffer_address;
Size m_framebuffer_size;

View file

@ -19,7 +19,7 @@ DebugLogDevice::~DebugLogDevice()
{
}
ssize_t DebugLogDevice::write(FileDescription&, const byte* data, ssize_t data_size)
ssize_t DebugLogDevice::write(FileDescription&, const u8* data, ssize_t data_size)
{
for (int i = 0; i < data_size; ++i)
IO::out8(0xe9, data[i]);

View file

@ -9,8 +9,8 @@ public:
private:
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte*, ssize_t) override { return 0; }
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override { return 0; }
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override { return true; }
virtual bool can_read(FileDescription&) const override { return true; }
virtual const char* class_name() const override { return "DebugLogDevice"; }

View file

@ -8,21 +8,21 @@ DiskDevice::~DiskDevice()
{
}
bool DiskDevice::read(DiskOffset offset, unsigned length, byte* out) const
bool DiskDevice::read(DiskOffset offset, unsigned length, u8* out) const
{
ASSERT((offset % block_size()) == 0);
ASSERT((length % block_size()) == 0);
dword first_block = offset / block_size();
dword end_block = (offset + length) / block_size();
u32 first_block = offset / block_size();
u32 end_block = (offset + length) / block_size();
return const_cast<DiskDevice*>(this)->read_blocks(first_block, end_block - first_block, out);
}
bool DiskDevice::write(DiskOffset offset, unsigned length, const byte* in)
bool DiskDevice::write(DiskOffset offset, unsigned length, const u8* in)
{
ASSERT((offset % block_size()) == 0);
ASSERT((length % block_size()) == 0);
dword first_block = offset / block_size();
dword end_block = (offset + length) / block_size();
u32 first_block = offset / block_size();
u32 end_block = (offset + length) / block_size();
ASSERT(first_block <= 0xffffffff);
ASSERT(end_block <= 0xffffffff);
return write_blocks(first_block, end_block - first_block, in);

View file

@ -4,21 +4,21 @@
#include <AK/Types.h>
// FIXME: Support 64-bit DiskOffset
typedef dword DiskOffset;
typedef u32 DiskOffset;
class DiskDevice : public RefCounted<DiskDevice> {
public:
virtual ~DiskDevice();
virtual unsigned block_size() const = 0;
virtual bool read_block(unsigned index, byte*) const = 0;
virtual bool write_block(unsigned index, const byte*) = 0;
virtual bool read_block(unsigned index, u8*) const = 0;
virtual bool write_block(unsigned index, const u8*) = 0;
virtual const char* class_name() const = 0;
bool read(DiskOffset, unsigned length, byte*) const;
bool write(DiskOffset, unsigned length, const byte*);
bool read(DiskOffset, unsigned length, u8*) const;
bool write(DiskOffset, unsigned length, const u8*);
virtual bool read_blocks(unsigned index, word count, byte*) = 0;
virtual bool write_blocks(unsigned index, word count, const byte*) = 0;
virtual bool read_blocks(unsigned index, u16 count, u8*) = 0;
virtual bool write_blocks(unsigned index, u16 count, const u8*) = 0;
protected:
DiskDevice();

View file

@ -22,7 +22,7 @@ unsigned DiskPartition::block_size() const
return m_device->block_size();
}
bool DiskPartition::read_block(unsigned index, byte* out) const
bool DiskPartition::read_block(unsigned index, u8* out) const
{
#ifdef OFFD_DEBUG
kprintf("DiskPartition::read_block %u (really: %u)\n", index, m_block_offset + index);
@ -31,7 +31,7 @@ bool DiskPartition::read_block(unsigned index, byte* out) const
return m_device->read_block(m_block_offset + index, out);
}
bool DiskPartition::write_block(unsigned index, const byte* data)
bool DiskPartition::write_block(unsigned index, const u8* data)
{
#ifdef OFFD_DEBUG
kprintf("DiskPartition::write_block %u (really: %u)\n", index, m_block_offset + index);
@ -40,7 +40,7 @@ bool DiskPartition::write_block(unsigned index, const byte* data)
return m_device->write_block(m_block_offset + index, data);
}
bool DiskPartition::read_blocks(unsigned index, word count, byte* out)
bool DiskPartition::read_blocks(unsigned index, u16 count, u8* out)
{
#ifdef OFFD_DEBUG
kprintf("DiskPartition::read_blocks %u (really: %u) count=%u\n", index, m_block_offset + index, count);
@ -49,7 +49,7 @@ bool DiskPartition::read_blocks(unsigned index, word count, byte* out)
return m_device->read_blocks(m_block_offset + index, count, out);
}
bool DiskPartition::write_blocks(unsigned index, word count, const byte* data)
bool DiskPartition::write_blocks(unsigned index, u16 count, const u8* data)
{
#ifdef OFFD_DEBUG
kprintf("DiskPartition::write_blocks %u (really: %u) count=%u\n", index, m_block_offset + index, count);

View file

@ -9,10 +9,10 @@ public:
virtual ~DiskPartition();
virtual unsigned block_size() const override;
virtual bool read_block(unsigned index, byte* out) const override;
virtual bool write_block(unsigned index, const byte*) override;
virtual bool read_blocks(unsigned index, word count, byte*) override;
virtual bool write_blocks(unsigned index, word count, const byte*) override;
virtual bool read_block(unsigned index, u8* out) const override;
virtual bool write_block(unsigned index, const u8*) override;
virtual bool read_blocks(unsigned index, u16 count, u8*) override;
virtual bool write_blocks(unsigned index, u16 count, const u8*) override;
private:
virtual const char* class_name() const override;

View file

@ -32,19 +32,19 @@ unsigned FileBackedDiskDevice::block_size() const
return m_block_size;
}
bool FileBackedDiskDevice::read_block(unsigned index, byte* out) const
bool FileBackedDiskDevice::read_block(unsigned index, u8* out) const
{
DiskOffset offset = index * m_block_size;
return read_internal(offset, block_size(), out);
}
bool FileBackedDiskDevice::write_block(unsigned index, const byte* data)
bool FileBackedDiskDevice::write_block(unsigned index, const u8* data)
{
DiskOffset offset = index * m_block_size;
return write_internal(offset, block_size(), data);
}
bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, byte* out) const
bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, u8* out) const
{
#ifndef IGNORE_FILE_LENGTH
if (offset + length >= m_file_length)
@ -54,12 +54,12 @@ bool FileBackedDiskDevice::read_internal(DiskOffset offset, unsigned length, byt
printf("[FileBackedDiskDevice] Read device @ offset %llx, length %u\n", offset, length);
#endif
fseeko(m_file, offset, SEEK_SET);
unsigned nread = fread(out, sizeof(byte), length, m_file);
unsigned nread = fread(out, sizeof(u8), length, m_file);
ASSERT(nread == length);
return true;
}
bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, const byte* data)
bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, const u8* data)
{
#ifndef IGNORE_FILE_LENGTH
if (offset + length >= m_file_length)
@ -70,7 +70,7 @@ bool FileBackedDiskDevice::write_internal(DiskOffset offset, unsigned length, co
#endif
fseeko(m_file, offset, SEEK_SET);
// size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);
unsigned nwritten = fwrite(data, sizeof(byte), length, m_file);
unsigned nwritten = fwrite(data, sizeof(u8), length, m_file);
ASSERT(nwritten == length);
return true;
}

View file

@ -14,14 +14,14 @@ public:
bool is_valid() const { return m_file; }
virtual unsigned block_size() const override;
virtual bool read_block(unsigned index, byte* out) const override;
virtual bool write_block(unsigned index, const byte*) override;
virtual bool read_block(unsigned index, u8* out) const override;
virtual bool write_block(unsigned index, const u8*) override;
private:
virtual const char* class_name() const override;
bool read_internal(DiskOffset, unsigned length, byte* out) const;
bool write_internal(DiskOffset, unsigned length, const byte* data);
bool read_internal(DiskOffset, unsigned length, u8* out) const;
bool write_internal(DiskOffset, unsigned length, const u8* data);
FileBackedDiskDevice(String&& imagePath, unsigned block_size);

View file

@ -17,14 +17,14 @@ bool FullDevice::can_read(FileDescription&) const
return true;
}
ssize_t FullDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t FullDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
ssize_t count = min(PAGE_SIZE, size);
memset(buffer, 0, (size_t)count);
return count;
}
ssize_t FullDevice::write(FileDescription&, const byte*, ssize_t size)
ssize_t FullDevice::write(FileDescription&, const u8*, ssize_t size)
{
if (size == 0)
return 0;

View file

@ -10,8 +10,8 @@ public:
private:
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_read(FileDescription&) const override;
virtual bool can_write(FileDescription&) const override { return true; }
virtual const char* class_name() const override { return "FullDevice"; }

View file

@ -106,19 +106,19 @@ unsigned IDEDiskDevice::block_size() const
return 512;
}
bool IDEDiskDevice::read_blocks(unsigned index, word count, byte* out)
bool IDEDiskDevice::read_blocks(unsigned index, u16 count, u8* out)
{
if (m_bus_master_base && m_dma_enabled.resource())
return read_sectors_with_dma(index, count, out);
return read_sectors(index, count, out);
}
bool IDEDiskDevice::read_block(unsigned index, byte* out) const
bool IDEDiskDevice::read_block(unsigned index, u8* out) const
{
return const_cast<IDEDiskDevice*>(this)->read_blocks(index, 1, out);
}
bool IDEDiskDevice::write_blocks(unsigned index, word count, const byte* data)
bool IDEDiskDevice::write_blocks(unsigned index, u16 count, const u8* data)
{
if (m_bus_master_base && m_dma_enabled.resource())
return write_sectors_with_dma(index, count, data);
@ -129,12 +129,12 @@ bool IDEDiskDevice::write_blocks(unsigned index, word count, const byte* data)
return true;
}
bool IDEDiskDevice::write_block(unsigned index, const byte* data)
bool IDEDiskDevice::write_block(unsigned index, const u8* data)
{
return write_blocks(index, 1, data);
}
static void print_ide_status(byte status)
static void print_ide_status(u8 status)
{
kprintf("DRQ=%u BSY=%u DRDY=%u DSC=%u DF=%u CORR=%u IDX=%u ERR=%u\n",
(status & ATA_SR_DRQ) != 0,
@ -166,7 +166,7 @@ bool IDEDiskDevice::wait_for_irq()
void IDEDiskDevice::handle_irq()
{
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
if (status & ATA_SR_ERR) {
print_ide_status(status);
m_device_error = IO::in8(m_io_base + ATA_REG_ERROR);
@ -192,7 +192,7 @@ void IDEDiskDevice::initialize()
});
#ifdef DISK_DEBUG
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
kprintf("initial status: ");
print_ide_status(status);
#endif
@ -213,19 +213,19 @@ void IDEDiskDevice::initialize()
ByteBuffer wbuf = ByteBuffer::create_uninitialized(512);
ByteBuffer bbuf = ByteBuffer::create_uninitialized(512);
byte* b = bbuf.pointer();
word* w = (word*)wbuf.pointer();
const word* wbufbase = (word*)wbuf.pointer();
u8* b = bbuf.pointer();
u16* w = (u16*)wbuf.pointer();
const u16* wbufbase = (u16*)wbuf.pointer();
for (dword i = 0; i < 256; ++i) {
word data = IO::in16(m_io_base + ATA_REG_DATA);
for (u32 i = 0; i < 256; ++i) {
u16 data = IO::in16(m_io_base + ATA_REG_DATA);
*(w++) = data;
*(b++) = MSB(data);
*(b++) = LSB(data);
}
// "Unpad" the device name string.
for (dword i = 93; i > 54 && bbuf[i] == ' '; --i)
for (u32 i = 93; i > 54 && bbuf[i] == ' '; --i)
bbuf[i] = 0;
m_cylinders = wbufbase[1];
@ -249,13 +249,13 @@ void IDEDiskDevice::initialize()
}
}
static void wait_400ns(word io_base)
static void wait_400ns(u16 io_base)
{
for (int i = 0; i < 4; ++i)
IO::in8(io_base + ATA_REG_ALTSTATUS);
}
bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
bool IDEDiskDevice::read_sectors_with_dma(u32 lba, u16 count, u8* outbuf)
{
LOCKER(m_lock);
#ifdef DISK_DEBUG
@ -275,7 +275,7 @@ bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
IO::out8(m_bus_master_base, 0);
// Write the PRDT location
IO::out32(m_bus_master_base + 4, (dword)&m_prdt);
IO::out32(m_bus_master_base + 4, (u32)&m_prdt);
// Turn on "Interrupt" and "Error" flag. The error flag should be cleared by hardware.
IO::out8(m_bus_master_base + 2, IO::in8(m_bus_master_base + 2) | 0x6);
@ -332,7 +332,7 @@ bool IDEDiskDevice::read_sectors_with_dma(dword lba, word count, byte* outbuf)
return true;
}
bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
bool IDEDiskDevice::read_sectors(u32 start_sector, u16 count, u8* outbuf)
{
ASSERT(count <= 256);
LOCKER(m_lock);
@ -369,7 +369,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
if (m_device_error)
return false;
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
ASSERT(status & ATA_SR_DRQ);
#ifdef DISK_DEBUG
kprintf("Retrieving %u bytes (status=%b), outbuf=%p...\n", count * 512, status, outbuf);
@ -379,7 +379,7 @@ bool IDEDiskDevice::read_sectors(dword start_sector, word count, byte* outbuf)
return true;
}
bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* inbuf)
bool IDEDiskDevice::write_sectors_with_dma(u32 lba, u16 count, const u8* inbuf)
{
LOCKER(m_lock);
#ifdef DISK_DEBUG
@ -401,7 +401,7 @@ bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* in
IO::out8(m_bus_master_base, 0);
// Write the PRDT location
IO::out32(m_bus_master_base + 4, (dword)&m_prdt);
IO::out32(m_bus_master_base + 4, (u32)&m_prdt);
// Turn on "Interrupt" and "Error" flag. The error flag should be cleared by hardware.
IO::out8(m_bus_master_base + 2, IO::in8(m_bus_master_base + 2) | 0x6);
@ -453,7 +453,7 @@ bool IDEDiskDevice::write_sectors_with_dma(dword lba, word count, const byte* in
return true;
}
bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* data)
bool IDEDiskDevice::write_sectors(u32 start_sector, u16 count, const u8* data)
{
ASSERT(count <= 256);
LOCKER(m_lock);
@ -484,7 +484,7 @@ bool IDEDiskDevice::write_sectors(dword start_sector, word count, const byte* da
while (!(IO::in8(m_io_base + ATA_REG_STATUS) & ATA_SR_DRQ))
;
byte status = IO::in8(m_io_base + ATA_REG_STATUS);
u8 status = IO::in8(m_io_base + ATA_REG_STATUS);
ASSERT(status & ATA_SR_DRQ);
IO::repeated_out16(m_io_base + ATA_REG_DATA, data, count * 256);

View file

@ -10,8 +10,8 @@
struct PhysicalRegionDescriptor {
PhysicalAddress offset;
word size { 0 };
word end_of_table { 0 };
u16 size { 0 };
u16 end_of_table { 0 };
};
class IDEDiskDevice final : public IRQHandler
@ -23,10 +23,10 @@ public:
// ^DiskDevice
virtual unsigned block_size() const override;
virtual bool read_block(unsigned index, byte*) const override;
virtual bool write_block(unsigned index, const byte*) override;
virtual bool read_blocks(unsigned index, word count, byte*) override;
virtual bool write_blocks(unsigned index, word count, const byte*) override;
virtual bool read_block(unsigned index, u8*) const override;
virtual bool write_block(unsigned index, const u8*) override;
virtual bool read_blocks(unsigned index, u16 count, u8*) override;
virtual bool write_blocks(unsigned index, u16 count, const u8*) override;
protected:
IDEDiskDevice();
@ -40,22 +40,22 @@ private:
void initialize();
bool wait_for_irq();
bool read_sectors_with_dma(dword lba, word count, byte*);
bool write_sectors_with_dma(dword lba, word count, const byte*);
bool read_sectors(dword lba, word count, byte* buffer);
bool write_sectors(dword lba, word count, const byte* data);
bool read_sectors_with_dma(u32 lba, u16 count, u8*);
bool write_sectors_with_dma(u32 lba, u16 count, const u8*);
bool read_sectors(u32 lba, u16 count, u8* buffer);
bool write_sectors(u32 lba, u16 count, const u8* data);
Lock m_lock { "IDEDiskDevice" };
word m_cylinders { 0 };
word m_heads { 0 };
word m_sectors_per_track { 0 };
word m_io_base { 0 };
u16 m_cylinders { 0 };
u16 m_heads { 0 };
u16 m_sectors_per_track { 0 };
u16 m_io_base { 0 };
volatile bool m_interrupted { false };
volatile byte m_device_error { 0 };
volatile u8 m_device_error { 0 };
PCI::Address m_pci_address;
PhysicalRegionDescriptor m_prdt;
RefPtr<PhysicalPage> m_dma_buffer_page;
word m_bus_master_base { 0 };
u16 m_bus_master_base { 0 };
Lockable<bool> m_dma_enabled;
};

View file

@ -223,7 +223,7 @@ static KeyCode shifted_key_map[0x100] = {
Key_Logo,
};
void KeyboardDevice::key_state_changed(byte raw, bool pressed)
void KeyboardDevice::key_state_changed(u8 raw, bool pressed)
{
Event event;
event.key = (m_modifiers & Mod_Shift) ? shifted_key_map[raw] : unshifted_key_map[raw];
@ -239,11 +239,11 @@ void KeyboardDevice::key_state_changed(byte raw, bool pressed)
void KeyboardDevice::handle_irq()
{
for (;;) {
byte status = IO::in8(I8042_STATUS);
u8 status = IO::in8(I8042_STATUS);
if (!(((status & I8042_WHICH_BUFFER) == I8042_KEYBOARD_BUFFER) && (status & I8042_BUFFER_FULL)))
return;
byte raw = IO::in8(I8042_BUFFER);
byte ch = raw & 0x7f;
u8 raw = IO::in8(I8042_BUFFER);
u8 ch = raw & 0x7f;
bool pressed = !(raw & 0x80);
#ifdef KEYBOARD_DEBUG
@ -316,7 +316,7 @@ bool KeyboardDevice::can_read(FileDescription&) const
return !m_queue.is_empty();
}
ssize_t KeyboardDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t KeyboardDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
ssize_t nread = 0;
while (nread < size) {
@ -332,7 +332,7 @@ ssize_t KeyboardDevice::read(FileDescription&, byte* buffer, ssize_t size)
return nread;
}
ssize_t KeyboardDevice::write(FileDescription&, const byte*, ssize_t)
ssize_t KeyboardDevice::write(FileDescription&, const u8*, ssize_t)
{
return 0;
}

View file

@ -23,9 +23,9 @@ public:
void set_client(KeyboardClient* client) { m_client = client; }
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte* buffer, ssize_t) override;
virtual ssize_t read(FileDescription&, u8* buffer, ssize_t) override;
virtual bool can_read(FileDescription&) const override;
virtual ssize_t write(FileDescription&, const byte* buffer, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8* buffer, ssize_t) override;
virtual bool can_write(FileDescription&) const override { return true; }
private:
@ -35,8 +35,8 @@ private:
// ^CharacterDevice
virtual const char* class_name() const override { return "KeyboardDevice"; }
void key_state_changed(byte raw, bool pressed);
void update_modifier(byte modifier, bool state)
void key_state_changed(u8 raw, bool pressed);
void update_modifier(u8 modifier, bool state)
{
if (state)
m_modifiers |= modifier;
@ -46,7 +46,7 @@ private:
KeyboardClient* m_client { nullptr };
CircularQueue<Event, 16> m_queue;
byte m_modifiers { 0 };
u8 m_modifiers { 0 };
};
class KeyboardClient {

View file

@ -8,23 +8,23 @@
#define MBR_SIGNATURE 0xaa55
struct MBRPartitionEntry {
byte status;
byte chs1[3];
byte type;
byte chs2[3];
dword offset;
dword length;
u8 status;
u8 chs1[3];
u8 type;
u8 chs2[3];
u32 offset;
u32 length;
} __attribute__((packed));
struct MBRPartitionHeader {
byte code1[218];
word ts_zero;
byte ts_drive, ts_seconds, ts_minutes, ts_hours;
byte code2[216];
dword disk_signature;
word disk_signature_zero;
u8 code1[218];
u16 ts_zero;
u8 ts_drive, ts_seconds, ts_minutes, ts_hours;
u8 code2[216];
u32 disk_signature;
u16 disk_signature_zero;
MBRPartitionEntry entry[4];
word mbr_signature;
u16 mbr_signature;
} __attribute__((packed));
class MBRPartitionTable {
@ -43,5 +43,5 @@ private:
ByteBuffer read_header() const;
const MBRPartitionHeader& header() const;
byte m_cached_header[512];
u8 m_cached_header[512];
};

View file

@ -25,12 +25,12 @@ bool NullDevice::can_read(FileDescription&) const
return true;
}
ssize_t NullDevice::read(FileDescription&, byte*, ssize_t)
ssize_t NullDevice::read(FileDescription&, u8*, ssize_t)
{
return 0;
}
ssize_t NullDevice::write(FileDescription&, const byte*, ssize_t buffer_size)
ssize_t NullDevice::write(FileDescription&, const u8*, ssize_t buffer_size)
{
return min(PAGE_SIZE, buffer_size);
}

View file

@ -12,8 +12,8 @@ public:
private:
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override { return true; }
virtual bool can_read(FileDescription&) const override;
virtual const char* class_name() const override { return "NullDevice"; }

View file

@ -6,7 +6,7 @@
void PCSpeaker::tone_on(int frequency)
{
IO::out8(PIT_CTL, TIMER2_SELECT | WRITE_WORD | MODE_SQUARE_WAVE);
word timer_reload = BASE_FREQUENCY / frequency;
u16 timer_reload = BASE_FREQUENCY / frequency;
IO::out8(TIMER2_CTL, LSB(timer_reload));
IO::out8(TIMER2_CTL, MSB(timer_reload));

View file

@ -39,11 +39,11 @@ PS2MouseDevice& PS2MouseDevice::the()
void PS2MouseDevice::handle_irq()
{
for (;;) {
byte status = IO::in8(I8042_STATUS);
u8 status = IO::in8(I8042_STATUS);
if (!(((status & I8042_WHICH_BUFFER) == I8042_MOUSE_BUFFER) && (status & I8042_BUFFER_FULL)))
return;
byte data = IO::in8(I8042_BUFFER);
u8 data = IO::in8(I8042_BUFFER);
m_data[m_data_state] = data;
auto commit_packet = [&] {
@ -113,13 +113,13 @@ void PS2MouseDevice::parse_data_packet()
m_queue.enqueue(packet);
}
void PS2MouseDevice::wait_then_write(byte port, byte data)
void PS2MouseDevice::wait_then_write(u8 port, u8 data)
{
prepare_for_output();
IO::out8(port, data);
}
byte PS2MouseDevice::wait_then_read(byte port)
u8 PS2MouseDevice::wait_then_read(u8 port)
{
prepare_for_input();
return IO::in8(port);
@ -135,7 +135,7 @@ void PS2MouseDevice::initialize()
// Enable the PS/2 mouse IRQ (12).
// NOTE: The keyboard uses IRQ 1 (and is enabled by bit 0 in this register).
byte status = wait_then_read(0x60) | 2;
u8 status = wait_then_read(0x60) | 2;
wait_then_write(0x64, 0x60);
wait_then_write(0x60, status);
@ -149,7 +149,7 @@ void PS2MouseDevice::initialize()
mouse_write(PS2MOUSE_GET_DEVICE_ID);
expect_ack();
byte device_id = mouse_read();
u8 device_id = mouse_read();
if (device_id != PS2MOUSE_INTELLIMOUSE_ID) {
// Send magical wheel initiation sequence.
@ -183,7 +183,7 @@ void PS2MouseDevice::initialize()
void PS2MouseDevice::expect_ack()
{
byte data = mouse_read();
u8 data = mouse_read();
ASSERT(data == I8042_ACK);
}
@ -203,7 +203,7 @@ void PS2MouseDevice::prepare_for_output()
}
}
void PS2MouseDevice::mouse_write(byte data)
void PS2MouseDevice::mouse_write(u8 data)
{
prepare_for_output();
IO::out8(0x64, 0xd4);
@ -211,7 +211,7 @@ void PS2MouseDevice::mouse_write(byte data)
IO::out8(0x60, data);
}
byte PS2MouseDevice::mouse_read()
u8 PS2MouseDevice::mouse_read()
{
prepare_for_input();
return IO::in8(0x60);
@ -222,7 +222,7 @@ bool PS2MouseDevice::can_read(FileDescription&) const
return !m_queue.is_empty();
}
ssize_t PS2MouseDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t PS2MouseDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
ssize_t nread = 0;
while (nread < size) {
@ -238,7 +238,7 @@ ssize_t PS2MouseDevice::read(FileDescription&, byte* buffer, ssize_t size)
return nread;
}
ssize_t PS2MouseDevice::write(FileDescription&, const byte*, ssize_t)
ssize_t PS2MouseDevice::write(FileDescription&, const u8*, ssize_t)
{
return 0;
}

View file

@ -15,8 +15,8 @@ public:
// ^CharacterDevice
virtual bool can_read(FileDescription&) const override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override { return true; }
private:
@ -29,15 +29,15 @@ private:
void initialize();
void prepare_for_input();
void prepare_for_output();
void mouse_write(byte);
byte mouse_read();
void wait_then_write(byte port, byte data);
byte wait_then_read(byte port);
void mouse_write(u8);
u8 mouse_read();
void wait_then_write(u8 port, u8 data);
u8 wait_then_read(u8 port);
void parse_data_packet();
void expect_ack();
CircularQueue<MousePacket, 100> m_queue;
byte m_data_state { 0 };
byte m_data[4];
u8 m_data_state { 0 };
u8 m_data[4];
bool m_has_wheel { false };
};

View file

@ -10,10 +10,10 @@ RandomDevice::~RandomDevice()
{
}
static dword next = 1;
static u32 next = 1;
#define MY_RAND_MAX 4294967295U
dword RandomDevice::random_value()
u32 RandomDevice::random_value()
{
next = next * 1103515245 + 12345;
return next;
@ -31,18 +31,18 @@ bool RandomDevice::can_read(FileDescription&) const
return true;
}
ssize_t RandomDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t RandomDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
const int range = 'z' - 'a';
ssize_t nread = min(size, PAGE_SIZE);
for (ssize_t i = 0; i < nread; ++i) {
dword r = random_value() % range;
buffer[i] = (byte)('a' + r);
u32 r = random_value() % range;
buffer[i] = (u8)('a' + r);
}
return nread;
}
ssize_t RandomDevice::write(FileDescription&, const byte*, ssize_t size)
ssize_t RandomDevice::write(FileDescription&, const u8*, ssize_t size)
{
// FIXME: Use input for entropy? I guess that could be a neat feature?
return min(PAGE_SIZE, size);

View file

@ -8,12 +8,12 @@ public:
RandomDevice();
virtual ~RandomDevice() override;
static dword random_value();
static u32 random_value();
private:
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_read(FileDescription&) const override;
virtual bool can_write(FileDescription&) const override { return true; }
virtual const char* class_name() const override { return "RandomDevice"; }

View file

@ -17,7 +17,7 @@ bool SerialDevice::can_read(FileDescription&) const
return (get_line_status() & DataReady) != 0;
}
ssize_t SerialDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t SerialDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
if (!size)
return 0;
@ -35,7 +35,7 @@ bool SerialDevice::can_write(FileDescription&) const
return (get_line_status() & EmptyTransmitterHoldingRegister) != 0;
}
ssize_t SerialDevice::write(FileDescription&, const byte* buffer, ssize_t size)
ssize_t SerialDevice::write(FileDescription&, const u8* buffer, ssize_t size)
{
if (!size)
return 0;

View file

@ -13,9 +13,9 @@ public:
// ^CharacterDevice
virtual bool can_read(FileDescription&) const override;
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual bool can_write(FileDescription&) const override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
enum InterruptEnable {
LowPowerMode = 0x01 << 5,

View file

@ -16,14 +16,14 @@ bool ZeroDevice::can_read(FileDescription&) const
return true;
}
ssize_t ZeroDevice::read(FileDescription&, byte* buffer, ssize_t size)
ssize_t ZeroDevice::read(FileDescription&, u8* buffer, ssize_t size)
{
ssize_t count = min(PAGE_SIZE, size);
memset(buffer, 0, (size_t)count);
return count;
}
ssize_t ZeroDevice::write(FileDescription&, const byte*, ssize_t size)
ssize_t ZeroDevice::write(FileDescription&, const u8*, ssize_t size)
{
return min(PAGE_SIZE, size);
}

View file

@ -10,8 +10,8 @@ public:
private:
// ^CharacterDevice
virtual ssize_t read(FileDescription&, byte*, ssize_t) override;
virtual ssize_t write(FileDescription&, const byte*, ssize_t) override;
virtual ssize_t read(FileDescription&, u8*, ssize_t) override;
virtual ssize_t write(FileDescription&, const u8*, ssize_t) override;
virtual bool can_read(FileDescription&) const override;
virtual bool can_write(FileDescription&) const override { return true; }
virtual const char* class_name() const override { return "ZeroDevice"; }