kamkow1/mop3
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Device IRQs WIP

Browse Source
This commit is contained in:
Kamil Kowalczyk
2026-03-12 19:23:47 +01:00
parent 04b7355a3d
commit 19793e9126
29 changed files with 420 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
kernel/device/debugconsole.c
View File

@@ -6,12 +6,14 @@
#include <status.h>
#include <sys/debug.h>
bool debugconsole_init (struct device* device, void* arg) {
(void)device, (void)arg;
bool debugconsole_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)arg, (void)proc, (void)rctx;
return true;
}
void debugconsole_fini (struct device* device) { (void)device; }
void debugconsole_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
}
int debugconsole_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4) {

4
kernel/device/debugconsole.h
View File

@@ -7,9 +7,9 @@
struct device;
bool debugconsole_init (struct device* device, void* arg);
bool debugconsole_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void debugconsole_fini (struct device* device);
void debugconsole_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int debugconsole_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);

30
kernel/device/device.c
View File

@@ -49,7 +49,8 @@ struct device* device_find (const char* key) {
}
struct device* device_create (const char* key, device_op_func_t* ops, size_t ops_len,
device_init_func_t init, device_fini_func_t fini, void* arg) {
device_init_func_t init, device_fini_func_t fini, void* arg,
struct proc* proc, struct reschedule_ctx* rctx) {
if (ops_len >= fieldlengthof (struct device, ops))
return NULL;
@@ -67,7 +68,7 @@ struct device* device_create (const char* key, device_op_func_t* ops, size_t ops
if (ops != NULL)
memcpy (device->ops, ops, ops_len * sizeof (device_op_func_t));
if (!device->init (device, arg)) {
if (!device->init (device, arg, proc, rctx)) {
free (device);
return NULL;
}
@@ -87,21 +88,30 @@ struct device* device_create (const char* key, device_op_func_t* ops, size_t ops
}
static void debugconsole_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[DEBUGCONSOLE_PUTSTR] = &debugconsole_putstr,
};
device_create ("DEBUGCONSOLE", ops, lengthof (ops), &debugconsole_init, &debugconsole_fini, NULL);
device_create ("DEBUGCONSOLE", ops, lengthof (ops), &debugconsole_init, &debugconsole_fini, NULL, thiscpu->kproc, &rctx);
}
static void terminal_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[TERMINAL_PUTSTR] = &terminal_putstr,
[TERMINAL_DIMENSIONS] = &terminal_dimensions,
};
device_create ("TERMINAL", ops, lengthof (ops), &terminal_init, &terminal_fini, NULL);
device_create ("TERMINAL", ops, lengthof (ops), &terminal_init, &terminal_fini, NULL, thiscpu->kproc, &rctx);
}
static void ramdisk_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[XDRV_GET_SIZE] = &ramdrv_get_size,
[XDRV_GET_SECTOR_SIZE] = &ramdrv_get_sector_size,
@@ -139,12 +149,15 @@ static void ramdisk_device_init (void) {
.sector_size = 512,
.buffer = unpack_buffer,
};
device_create ("RD0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init);
device_create ("RD0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init, thiscpu->kproc, &rctx);
LZ4F_freeDecompressionContext (dctx);
}
static void temp_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[XDRV_GET_SIZE] = &ramdrv_get_size,
[XDRV_GET_SECTOR_SIZE] = &ramdrv_get_sector_size,
@@ -157,15 +170,18 @@ static void temp_device_init (void) {
.total_size = 1024 * 1024 * 20,
.sector_size = 512,
};
device_create ("TEMP0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init);
device_create ("TEMP0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init, thiscpu->kproc, &rctx);
}
#if defined(__x86_64__)
static void ps2kb_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[KB_READ_KEY] = &ps2kb_read_key,
};
device_create ("KB", ops, lengthof (ops), &ps2kb_init, &ps2kb_fini, NULL);
device_create ("KB", ops, lengthof (ops), &ps2kb_init, &ps2kb_fini, NULL, thiscpu->kproc, &rctx);
}
#endif

7
kernel/device/device.h
View File

@@ -22,8 +22,8 @@ struct device;
typedef int (*device_op_func_t) (struct device* device, struct proc*, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);
typedef bool (*device_init_func_t) (struct device* device, void* arg);
typedef void (*device_fini_func_t) (struct device* device);
typedef bool (*device_init_func_t) (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
typedef void (*device_fini_func_t) (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
struct device {
char key[0x100];
@@ -36,7 +36,8 @@ struct device {
};
struct device* device_create (const char* key, device_op_func_t* ops, size_t ops_len,
device_init_func_t init, device_fini_func_t fini, void* arg);
device_init_func_t init, device_fini_func_t fini, void* arg,
struct proc* proc, struct reschedule_ctx* rctx);
struct device* device_find (const char* key);

211
kernel/device/idedrv.c
View File

@@ -1,13 +1,18 @@
#include <amd64/io.h>
#include <amd64/intr_defs.h>
#include <amd64/apic.h>
#include <device/device.h>
#include <device/idedrv.h>
#include <device/partitions.h>
#include <devices.h>
#include <libk/std.h>
#include <libk/list.h>
#include <libk/string.h>
#include <mm/liballoc.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#include <status.h>
#include <irq/irq.h>
#define IDE_REG_DATA 0x00
#define IDE_REG_ERROR 0x01
@@ -78,6 +83,75 @@ static void ide_delay (uint16_t ctrl) {
}
#pragma clang optimize on
static void ide_flush (struct idedrv* idedrv) {
if (idedrv->lba48)
outb (idedrv->io + IDE_REG_CMD, IDE_CMD_FLUSH48);
else
outb (idedrv->io + IDE_REG_CMD, IDE_CMD_FLUSH28);
}
static void ide_irq (void* arg, void* regs, struct reschedule_ctx* rctx) {
struct idedrv* idedrv = arg;
spin_lock (&idedrv->device->lock);
struct list_node_link* node = idedrv->requests;
if (node == NULL) {
(void)inb (idedrv->io + IDE_REG_STATUS);
spin_unlock (&idedrv->device->lock);
return;
}
struct idedrv_request* req = list_entry (node, struct idedrv_request, requests_link);
struct list_node_link* sqlist_node = req->sq.proc_list;
struct proc_sq_entry* sq_entry = list_entry (sqlist_node, struct proc_sq_entry, sq_link);
struct proc* resumed_proc = sq_entry->proc;
uint8_t status = inb (idedrv->io + IDE_REG_STATUS);
if ((status & (IDE_ERR | IDE_DRQ))) {
list_remove (idedrv->requests, &req->requests_link);
spin_unlock (&idedrv->device->lock);
proc_sq_resume (resumed_proc, sq_entry, rctx);
free (req);
return;
}
spin_lock (&resumed_proc->lock);
if (req->rw == 1) {
if ((status & IDE_DRQ)) {
uint16_t* p = req->outbuffer + (req->sector_done_count * (idedrv->sector_size / 2));
insw (idedrv->io + IDE_REG_DATA, p, idedrv->sector_size / 2);
req->sector_done_count++;
}
} else if (req->rw == 2) {
req->sector_done_count++;
if (req->sector_done_count < req->sector_count) {
uint16_t* p = req->outbuffer + (req->sector_done_count * (idedrv->sector_size / 2));
outsw (idedrv->io + IDE_REG_DATA, p, idedrv->sector_size / 2);
}
}
if (req->sector_done_count >= req->sector_count) {
if (req->rw == 2)
ide_flush (idedrv);
list_remove (idedrv->requests, &req->requests_link);
spin_unlock (&resumed_proc->lock);
spin_unlock (&idedrv->device->lock);
free (req);
proc_sq_resume (resumed_proc, sq_entry, rctx);
return;
}
spin_unlock (&resumed_proc->lock);
spin_unlock (&idedrv->device->lock);
}
void ide_probe (uint16_t io, uint16_t ctrl, uint8_t devno, struct ide_probe* probe) {
probe->flags = 0;
probe->sector_count = 0;
@@ -141,7 +215,10 @@ void ide_probe (uint16_t io, uint16_t ctrl, uint8_t devno, struct ide_probe* pro
probe->sector_size = 512;
}
static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_count) {
static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_count, bool clear) {
if (clear)
outb (idedrv->ctrl, 0x00);
if (idedrv->lba48) {
outb (idedrv->io + IDE_REG_DRIVE, 0x40 | (idedrv->devno << 4));
ide_delay (idedrv->ctrl);
@@ -167,7 +244,9 @@ static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_c
}
}
bool idedrv_init (struct device* device, void* arg) {
bool idedrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct idedrv_init* init = arg;
struct idedrv* idedrv = malloc (sizeof (*idedrv));
@@ -175,23 +254,41 @@ bool idedrv_init (struct device* device, void* arg) {
if (idedrv == NULL)
return false;
idedrv->device = device;
idedrv->lba48 = init->lba48;
idedrv->sector_count = init->sector_count;
idedrv->sector_size = init->sector_size;
idedrv->io = init->io;
idedrv->ctrl = init->ctrl;
idedrv->devno = init->devno;
idedrv->primscnd = init->primscnd;
device->udata = idedrv;
device_probe_partitions (device);
if (idedrv->primscnd == 1) {
ioapic_route_irq (IDE_DRIVE_PRIM, 14, 0, thiscpu->lapic_id);
irq_attach (&ide_irq, idedrv, IDE_DRIVE_PRIM);
} else if (idedrv->primscnd == 2) {
ioapic_route_irq (IDE_DRIVE_SCND, 15, 0, thiscpu->lapic_id);
irq_attach (&ide_irq, idedrv, IDE_DRIVE_SCND);
}
return true;
}
void idedrv_fini (struct device* device) {
void idedrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
struct idedrv* idedrv = device->udata;
struct list_node_link* req_link, *tmp_req_link;
list_foreach (idedrv->requests, req_link, tmp_req_link) {
struct idedrv_request* req = list_entry (req_link, struct idedrv_request, requests_link);
list_remove (idedrv->requests, &req->requests_link);
struct proc_sq_entry* sq_entry = list_entry (req->sq.proc_list, struct proc_sq_entry, sq_link);
proc_sq_resume (proc, sq_entry, rctx);
free (req);
}
irq_detach (idedrv->primscnd == 1 ? IDE_DRIVE_PRIM : IDE_DRIVE_SCND);
free (idedrv);
}
@@ -211,20 +308,47 @@ int idedrv_read (struct device* device, struct proc* proc, struct reschedule_ctx
if (sector + sector_count > idedrv->sector_count)
return -ST_OOB_ERROR;
ide_prepare (idedrv, sector, sector_count);
spin_lock (&proc->lock);
bool is_kproc = (proc->flags & PROC_KPROC) != 0;
spin_unlock (&proc->lock);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28;
outb (idedrv->io + IDE_REG_CMD, cmd);
/* /1* polling *1/ */
/* if (is_kproc) { */
ide_prepare (idedrv, sector, sector_count, false);
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_READ_ERROR;
uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28;
outb (idedrv->io + IDE_REG_CMD, cmd);
insw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)),
idedrv->sector_size / 2);
}
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_READ_ERROR;
return ST_OK;
insw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)), (idedrv->sector_size / 2));
}
return ST_OK;
/* } else { /1* IRQ *1/ */
/* struct idedrv_request* req = malloc (sizeof (*req)); */
/* if (req == NULL) */
/* return -ST_OOM_ERROR; */
/* memset (req, 0, sizeof (*req)); */
/* req->outbuffer = buffer; */
/* req->sector_count = sector_count; */
/* req->sector_done_count = 0; */
/* req->rw = 1; */
/* list_append (idedrv->requests, &req->requests_link); */
/* proc_sq_suspend (proc, &req->sq, NULL, rctx); */
/* ide_prepare (idedrv, sector, sector_count, true); */
/* uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28; */
/* outb (idedrv->io + IDE_REG_CMD, cmd); */
/* return ST_OK; */
/* } */
}
int idedrv_write (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
@@ -242,25 +366,58 @@ int idedrv_write (struct device* device, struct proc* proc, struct reschedule_ct
if (sector + sector_count > idedrv->sector_count)
return -ST_OOB_ERROR;
spin_lock (&proc->lock);
bool is_kproc = (proc->flags & PROC_KPROC) != 0;
spin_unlock (&proc->lock);
ide_prepare (idedrv, sector, sector_count);
/* /1* polling *1/ */
/* if (is_kproc) { */
ide_prepare (idedrv, sector, sector_count, false);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28;
outb (idedrv->io + IDE_REG_CMD, cmd);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28;
outb (idedrv->io + IDE_REG_CMD, cmd);
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_WRITE_ERROR;
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_WRITE_ERROR;
outsw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)),
idedrv->sector_size / 2);
}
outsw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)), (idedrv->sector_size / 2));
}
cmd = idedrv->lba48 ? IDE_CMD_FLUSH48 : IDE_CMD_FLUSH28;
outb (idedrv->io + IDE_REG_CMD, cmd);
ide_wait (idedrv->io, 100000, false, true);
return ST_OK;
/* } else { /1* IRQ *1/ */
/* struct idedrv_request* req = malloc (sizeof (*req)); */
return ST_OK;
/* if (req == NULL) */
/* return -ST_OOM_ERROR; */
/* memset (req, 0, sizeof (*req)); */
/* req->outbuffer = buffer; */
/* req->sector_count = sector_count; */
/* req->sector_done_count = 0; */
/* req->rw = 2; */
/* list_append (idedrv->requests, &req->requests_link); */
/* proc_sq_suspend (proc, &req->sq, NULL, rctx); */
/* ide_prepare (idedrv, sector, sector_count, true); */
/* uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28; */
/* outb (idedrv->io + IDE_REG_CMD, cmd); */
/* if (!ide_wait (idedrv->io, 100000, true, true)) { */
/* list_remove (idedrv->requests, &req->requests_link); */
/* struct proc_sq_entry* sq_entry = list_entry (req->sq.proc_list, struct proc_sq_entry, sq_link); */
/* proc_sq_resume (proc, sq_entry, rctx); */
/* free (req); */
/* return -ST_XDRV_WRITE_ERROR; */
/* } */
/* outsw (idedrv->io + IDE_REG_DATA, buffer, idedrv->sector_size / 2); */
/* return ST_OK; */
/* } */
}
int idedrv_get_device_type (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,

22
kernel/device/idedrv.h
View File

@@ -2,8 +2,11 @@
#define _KERNEL_DEVICE_IDEDRV_H
#include <libk/std.h>
#include <libk/list.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#include <proc/suspension_q.h>
#include <sync/spin_lock.h>
#define IDE_PROBE_AVAIL (1 << 0)
#define IDE_PROBE_LBA48 (1 << 1)
@@ -16,14 +19,28 @@ struct idedrv_init {
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
};
struct idedrv_request {
uint16_t* outbuffer;
size_t sector_done_count;
size_t sector_count;
struct list_node_link requests_link;
struct proc_suspension_q sq;
int rw;
};
struct idedrv {
struct device* device;
bool lba48;
size_t sector_count;
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
struct list_node_link* requests;
};
struct ide_probe {
@@ -32,11 +49,12 @@ struct ide_probe {
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
};
bool idedrv_init (struct device* device, void* arg);
bool idedrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void idedrv_fini (struct device* device);
void idedrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int idedrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

13
kernel/device/partdrv.c
View File

@@ -7,7 +7,9 @@
#include <proc/reschedule.h>
#include <status.h>
bool partdrv_init (struct device* device, void* arg) {
bool partdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct partdrv_init* init = arg;
struct partdrv* partdrv = malloc (sizeof (*partdrv));
@@ -24,7 +26,8 @@ bool partdrv_init (struct device* device, void* arg) {
return true;
}
void partdrv_fini (struct device* device) {
void partdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct partdrv* partdrv = device->udata;
free (partdrv);
@@ -45,7 +48,7 @@ int partdrv_read (struct device* device, struct proc* proc, struct reschedule_ct
uint8_t* buffer = a3;
spin_lock (&super->lock);
int ret = device_op (super, XDRV_READ, NULL, NULL, &sector, &sector_count, buffer);
int ret = device_op (super, XDRV_READ, proc, rctx, &sector, &sector_count, buffer);
spin_unlock (&super->lock);
return ret;
@@ -66,7 +69,7 @@ int partdrv_write (struct device* device, struct proc* proc, struct reschedule_c
uint8_t* buffer = a3;
spin_lock (&super->lock);
int ret = device_op (super, XDRV_WRITE, NULL, NULL, &sector, &sector_count, buffer);
int ret = device_op (super, XDRV_WRITE, proc, rctx, &sector, &sector_count, buffer);
spin_unlock (&super->lock);
return ret;
@@ -98,7 +101,7 @@ int partdrv_get_sector_size (struct device* device, struct proc* proc, struct re
struct partdrv* partdrv = device->udata;
spin_lock (&partdrv->super->lock);
device_op (partdrv->super, XDRV_GET_SECTOR_SIZE, NULL, NULL, secsize);
device_op (partdrv->super, XDRV_GET_SECTOR_SIZE, proc, rctx, secsize);
spin_unlock (&partdrv->super->lock);
return ST_OK;

4
kernel/device/partdrv.h
View File

@@ -19,9 +19,9 @@ struct partdrv {
size_t total_size;
};
bool partdrv_init (struct device* device, void* arg);
bool partdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void partdrv_fini (struct device* device);
void partdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int partdrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

12
kernel/device/partitions.c
View File

@@ -9,8 +9,10 @@
#include <libk/string.h>
#include <status.h>
#include <sys/debug.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
static int device_probe_partitions_dos (struct device* device) {
static int device_probe_partitions_dos (struct proc* proc, struct reschedule_ctx* rctx, struct device* device) {
struct dos_mbr mbr;
memset (&mbr, 0, sizeof (mbr));
size_t sector = 0;
@@ -27,9 +29,9 @@ static int device_probe_partitions_dos (struct device* device) {
spin_lock (&device->lock);
device_op (device, XDRV_GET_SECTOR_SIZE, NULL, NULL, &sector_size);
device_op (device, XDRV_GET_SECTOR_SIZE, proc, rctx, &sector_size);
int ret = device_op (device, XDRV_READ, NULL, NULL, &sector, &sector_count, &mbr);
int ret = device_op (device, XDRV_READ, proc, rctx, &sector, &sector_count, &mbr);
if (ret < 0) {
spin_unlock (&device->lock);
@@ -54,7 +56,7 @@ static int device_probe_partitions_dos (struct device* device) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%sp%zu", device->key, i);
device_create (key, ops, lengthof (ops), &partdrv_init, &partdrv_fini, &init);
device_create (key, ops, lengthof (ops), &partdrv_init, &partdrv_fini, &init, proc, rctx);
}
spin_unlock (&device->lock);
@@ -62,4 +64,4 @@ static int device_probe_partitions_dos (struct device* device) {
return ST_OK;
}
int device_probe_partitions (struct device* device) { return device_probe_partitions_dos (device); }
int device_probe_partitions (struct proc* proc, struct reschedule_ctx* rctx, struct device* device) { return device_probe_partitions_dos (proc, rctx, device); }

4
kernel/device/partitions.h
View File

@@ -4,6 +4,8 @@
#include <aux/compiler.h>
#include <device/device.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
struct dos_pte {
uint8_t drive_attrs;
@@ -22,6 +24,6 @@ struct dos_mbr {
uint8_t valid_sign[2];
} PACKED;
int device_probe_partitions (struct device* device);
int device_probe_partitions (struct proc* proc, struct reschedule_ctx* rctx, struct device* device);
#endif // _KERNEL_DEVICE_PARTITIONS_H

37
kernel/device/pci.c
View File

@@ -4,8 +4,10 @@
#include <device/pci_info.h>
#include <libk/lengthof.h>
#include <libk/std.h>
#include <libk/string.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>
#include <sys/smp.h>
static const struct pci_driver_info pci_driver_infos[] = {
{.class = 0x01, .subclass = 0x01, .init = &pci_ide_init},
@@ -91,9 +93,9 @@ void pci_write8 (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset, uint8_
spin_unlock (&pci_lock);
}
static void pci_check_bus (uint8_t bus, pci_cb_func_t cb);
static void pci_check_bus (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, pci_cb_func_t cb);
static void pci_check_func (uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func_t cb) {
static void pci_check_func (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func_t cb) {
uint32_t reg0 = pci_read32 (bus, slot, func, PCI_VENDOR_ID);
uint16_t vendor = (uint16_t)(reg0 & 0xFFFF);
@@ -112,47 +114,47 @@ static void pci_check_func (uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func
.subclass = ((uint8_t)(reg8 >> 16)),
};
cb (pci_info);
cb (proc, rctx, pci_info);
/* PCI 2 PCI bridge */
if (pci_info.class == 0x06 && pci_info.subclass == 0x04) {
uint32_t reg18 = pci_read32 (bus, slot, func, 0x18);
uint8_t secondary = (uint8_t)(reg18 >> 8);
pci_check_bus (secondary, cb);
pci_check_bus (proc, rctx, secondary, cb);
}
}
static void pci_check_device (uint8_t bus, uint8_t slot, pci_cb_func_t cb) {
static void pci_check_device (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, uint8_t slot, pci_cb_func_t cb) {
uint32_t reg0 = pci_read32 (bus, slot, 0, PCI_VENDOR_ID);
if ((uint16_t)(reg0 & 0xFFFF) == 0xFFFF)
return;
pci_check_func (bus, slot, 0, cb);
pci_check_func (proc, rctx, bus, slot, 0, cb);
/* multifunc device */
uint32_t reg0xc = pci_read32 (bus, slot, 0, PCI_CACHELINE);
if ((reg0xc >> 16) & 0x80) {
for (uint8_t func = 1; func < 8; func++)
pci_check_func (bus, slot, func, cb);
pci_check_func (proc, rctx, bus, slot, func, cb);
}
}
static void pci_check_bus (uint8_t bus, pci_cb_func_t cb) {
static void pci_check_bus (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, pci_cb_func_t cb) {
for (uint8_t slot = 0; slot < 32; slot++)
pci_check_device (bus, slot, cb);
pci_check_device (proc, rctx, bus, slot, cb);
}
static void pci_enumerate (pci_cb_func_t cb) {
static void pci_enumerate (struct proc* proc, struct reschedule_ctx* rctx, pci_cb_func_t cb) {
uint32_t reg0xc = pci_read32 (0, 0, 0, PCI_CACHELINE);
bool is_multictrl = (reg0xc >> 16) & 0x80;
if (!is_multictrl)
pci_check_bus (0, cb);
pci_check_bus (proc, rctx, 0, cb);
else {
for (uint8_t func = 0; func < 8; func++) {
if ((pci_read32 (0, 0, func, PCI_VENDOR_ID) & 0xFFFF) != 0xFFFF)
pci_check_bus (func, cb);
pci_check_bus (proc, rctx, func, cb);
}
}
}
@@ -186,7 +188,7 @@ static void pci_string_identifiers (uint16_t vendor_id, uint16_t device_id, uint
}
}
static void pci_discovery_cb (struct pci_info pci_info) {
static void pci_discovery_cb (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info) {
const char *vname, *dname, *cname;
pci_string_identifiers (pci_info.vendor, pci_info.device, pci_info.class, pci_info.subclass,
&vname, &dname, &cname);
@@ -198,9 +200,14 @@ static void pci_discovery_cb (struct pci_info pci_info) {
for (size_t driver = 0; driver < lengthof (pci_driver_infos); driver++) {
if (pci_driver_infos[driver].class == pci_info.class &&
pci_driver_infos[driver].subclass == pci_info.subclass) {
pci_driver_infos[driver].init (pci_info);
pci_driver_infos[driver].init (proc, rctx, pci_info);
}
}
}
void pci_init (void) { pci_enumerate (&pci_discovery_cb); }
void pci_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
pci_enumerate (thiscpu->kproc, &rctx, &pci_discovery_cb);
}

6
kernel/device/pci.h
View File

@@ -3,6 +3,8 @@
#include <device/pci_info.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#define PCI_CONFIG_ADDR 0xCF8
#define PCI_CONFIG_DATA 0xCFC
@@ -53,10 +55,10 @@ struct pci_class {
struct pci_driver_info {
uint8_t class;
uint8_t subclass;
bool (*init) (struct pci_info pci_info);
bool (*init) (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
};
typedef void (*pci_cb_func_t) (struct pci_info pci_info);
typedef void (*pci_cb_func_t) (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
void pci_init (void);

17
kernel/device/pci_ide.c
View File

@@ -3,12 +3,15 @@
#include <device/idedrv.h>
#include <device/pci.h>
#include <device/pci_info.h>
#include <device/partitions.h>
#include <devices.h>
#include <libk/fieldsizeof.h>
#include <libk/lengthof.h>
#include <libk/printf.h>
#include <libk/std.h>
#include <sys/debug.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
static atomic_int ide_counter = 0;
@@ -27,7 +30,7 @@ static const char* progif_msg[] = {
"PCI native mode controller, supports both channels switched to ISA compatibility mode, supports bus mastering",
};
static void ide_make_device (struct ide_probe probe) {
static void ide_make_device (struct proc* proc, struct reschedule_ctx* rctx, struct ide_probe probe) {
DEBUG ("Found IDE drive: io=%x ctrl=%x no=%u sector=%zu count=%zu\n", probe.io, probe.ctrl,
probe.devno, probe.sector_size, probe.sector_count);
@@ -49,14 +52,16 @@ static void ide_make_device (struct ide_probe probe) {
.io = probe.io,
.ctrl = probe.ctrl,
.devno = probe.devno,
.primscnd = probe.primscnd,
};
device_create (device_key, ops, lengthof (ops), &idedrv_init, &idedrv_fini, &init);
struct device* ide = device_create (device_key, ops, lengthof (ops), &idedrv_init, &idedrv_fini, &init, proc, rctx);
device_probe_partitions (proc, rctx, ide);
}
bool pci_ide_init (struct pci_info pci_info) {
bool pci_ide_init (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info) {
uint16_t pci_cmd = pci_read16 (pci_info.bus, pci_info.slot, pci_info.func, PCI_COMMAND);
uint16_t new_cmd = pci_cmd | (1 << 0);
uint16_t new_cmd = (pci_cmd | (1 << 0)) & ~(1 << 10);
if (pci_cmd != new_cmd) {
pci_write16 (pci_info.bus, pci_info.slot, pci_info.func, PCI_COMMAND, new_cmd);
@@ -116,11 +121,13 @@ bool pci_ide_init (struct pci_info pci_info) {
if (cmd == 0)
continue;
probe.primscnd = i + 1;
for (size_t dev = 0; dev < 2; dev++) {
ide_probe (cmd, ctrl, dev, &probe);
if ((probe.flags & IDE_PROBE_AVAIL))
ide_make_device (probe);
ide_make_device (proc, rctx, probe);
}
}

4
kernel/device/pci_ide.h
View File

@@ -3,7 +3,9 @@
#include <device/pci_info.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
bool pci_ide_init (struct pci_info pci_info);
bool pci_ide_init (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
#endif // _KERNEL_DEVICE_PCI_IDE_H

8
kernel/device/ps2_kb.c
View File

@@ -229,8 +229,8 @@ static void ps2kb_set_typematic (uint8_t delay, uint8_t rate) {
outb (KB_DATA, (delay << 5) | (rate & 0x1F));
}
bool ps2kb_init (struct device* device, void* arg) {
(void)device, (void)arg;
bool ps2kb_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)arg, (void)proc, (void)rctx;
ioapic_route_irq (PS2KB, 1, 0, thiscpu->lapic_id);
irq_attach (&ps2kb_irq, NULL, PS2KB);
@@ -255,8 +255,8 @@ bool ps2kb_init (struct device* device, void* arg) {
return true;
}
void ps2kb_fini (struct device* device) {
(void)device;
void ps2kb_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
irq_detach (PS2KB);
ringbuffer_fini (&ps2kb_ringbuffer);

4
kernel/device/ps2_kb.h
View File

@@ -11,8 +11,8 @@ struct device;
int ps2kb_read_key (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);
bool ps2kb_init (struct device* device, void* arg);
bool ps2kb_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void ps2kb_fini (struct device* device);
void ps2kb_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
#endif // _KERNEL_DEVICE_PS2_KB_H

7
kernel/device/ramdrv.c
View File

@@ -9,7 +9,8 @@
#include <status.h>
#include <sys/debug.h>
bool ramdrv_init (struct device* device, void* arg) {
bool ramdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct ramdrv_init* init = arg;
struct ramdrv* ramdrv = malloc (sizeof (*ramdrv));
@@ -37,7 +38,9 @@ bool ramdrv_init (struct device* device, void* arg) {
return true;
}
void ramdrv_fini (struct device* device) {
void ramdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct ramdrv* ramdrv = device->udata;
free (ramdrv->buffer);

4
kernel/device/ramdrv.h
View File

@@ -20,9 +20,9 @@ struct ramdrv {
uint8_t* buffer;
};
bool ramdrv_init (struct device* device, void* arg);
bool ramdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void ramdrv_fini (struct device* device);
void ramdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int ramdrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

8
kernel/device/terminal.c
View File

@@ -19,8 +19,8 @@ void ft_free (void* ptr, size_t size) {
free (ptr);
}
bool terminal_init (struct device* device, void* arg) {
(void)arg, (void)device;
bool terminal_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)arg, (void)device, (void)proc, (void)rctx;
struct limine_framebuffer_response* fb_r = limine_framebuffer_request.response;
struct limine_framebuffer* fb = fb_r->framebuffers[0];
@@ -33,7 +33,9 @@ bool terminal_init (struct device* device, void* arg) {
return true;
}
void terminal_fini (struct device* device) { (void)device; }
void terminal_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
}
int terminal_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4) {

4
kernel/device/terminal.h
View File

@@ -8,9 +8,9 @@
struct device;
bool terminal_init (struct device* device, void* arg);
bool terminal_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void terminal_fini (struct device* device);
void terminal_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int terminal_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);