umka/umka_gen_devices_dat.c

193 lines
5.7 KiB
C
Raw Normal View History

2021-11-04 03:52:50 +01:00
/*
2022-06-27 19:36:56 +02:00
SPDX-License-Identifier: GPL-2.0-or-later
2021-11-04 03:52:50 +01:00
UMKa - User-Mode KolibriOS developer tools
umka_gen_devices_dat - generate devices.dat file with IRQ information
2022-06-27 19:36:56 +02:00
Copyright (C) 2021 Ivan Baravy <dunkaist@gmail.com>
2021-11-04 03:52:50 +01:00
*/
#include <dirent.h>
#include <errno.h>
#include <limits.h>
2022-06-27 19:36:56 +02:00
#include <stdint.h>
2021-11-04 03:52:50 +01:00
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include "umka.h"
#include "util.h"
2021-11-04 03:52:50 +01:00
#include <pci.h>
#define UMKA_DEFAULT_DISPLAY_WIDTH 400
#define UMKA_DEFAULT_DISPLAY_HEIGHT 300
#define ACPI_CALL_DEV "/proc/acpi/call"
#define PCI_BASE_DIR "/sys/bus/pci/devices"
#define ACPI_BUF_SIZE 0x1000
#define STR2UINT32(s) ((s[3] << 24) | (s[2] << 16) | (s[1] << 8) | s[0])
char acpi_path_file[PATH_MAX];
char acpi_path[PATH_MAX];
char acpi_value[ACPI_BUF_SIZE];
amlctx_t *ctx;
size_t strcnt(const char *s, char c) {
size_t count = 0;
while (*s) {
if (*s == c) {
count += 1;
}
s++;
}
return count;
}
uint64_t acpi_get_next_number(char **str) {
char *s = *str;
while (*s == '[' || *s == ']' || *s == ' ' || *s == ',') {
s++;
}
uint64_t result = strtoull(s, str, 16);
return result;
}
acpi_node_t *acpi_get(const char *path) {
FILE *f;
f = fopen(ACPI_CALL_DEV, "w");
if (!f) {
perror("Can't open file");
exit(1);
}
fwrite(path, strlen(path), 1, f);
fclose(f);
f = fopen(ACPI_CALL_DEV, "r");
if (!f) {
perror("Can't open file");
exit(1);
}
size_t len = fread(acpi_value, 1, ACPI_BUF_SIZE, f);
acpi_value[len-1] = '\0';
fclose(f);
2021-12-12 23:07:42 +01:00
acpi_node_t *n = NULL;
2021-11-04 03:52:50 +01:00
char *str = acpi_value;
if (acpi_value[0] == '0') {
kos_node_integer_t *aint = (kos_node_integer_t*)kos_aml_constructor_integer();
aint->value = strtoull(acpi_value, NULL, 16);
n = (acpi_node_t*)aint;
} else if (acpi_value[0] == '[') {
size_t open_cnt = strcnt(acpi_value, '[');
size_t close_cnt = strcnt(acpi_value, ']');
if (open_cnt != close_cnt) {
printf("acpi_call buffer is too short!\n");
exit(1);
}
size_t el_cnt = open_cnt - 1;
kos_node_package_t *apkg = (kos_node_package_t*)kos_aml_constructor_package(el_cnt);
n = (acpi_node_t *)apkg;
for (size_t i = 0; i < el_cnt; i++) {
kos_node_package_t *p4 = (kos_node_package_t*)kos_aml_constructor_package(4);
p4->list[0] = kos_aml_constructor_integer();
((kos_node_integer_t*)(p4->list[0]))->value = acpi_get_next_number(&str);
p4->list[1] = kos_aml_constructor_integer();
((kos_node_integer_t*)(p4->list[1]))->value = acpi_get_next_number(&str);
p4->list[2] = kos_aml_constructor_integer();
((kos_node_integer_t*)(p4->list[2]))->value = acpi_get_next_number(&str);
p4->list[3] = kos_aml_constructor_integer();
((kos_node_integer_t*)(p4->list[3]))->value = acpi_get_next_number(&str);
apkg->list[i] = (acpi_node_t*)p4;
}
}
return n;
}
acpi_node_t *acpi_get_at(acpi_node_t *node, uint32_t name) {
char path[PATH_MAX];
path[PATH_MAX-1] = '\0';
*(uint32_t*)(path + PATH_MAX - 5) = name;
path[PATH_MAX-6] = '.';
char *cur;
for (cur = path + PATH_MAX - 6; node->parent; node = node->parent) {
cur -= 5;
cur[0] = '.';
*(uint32_t*)(cur+1) = node->name;
}
cur[0] = '\\';
acpi_node_t *n = acpi_get(cur);
n->name = name;
return n;
}
void acpi_process_dev(char *path) {
size_t dir_name_len = strlen(path) - 1;
acpi_node_t *parent = kos_acpi_root;
acpi_node_t *new_parent;
for (char *name = path + 1; name < path + dir_name_len; name += 5) {
name[4] = '\0';
if (!(new_parent = kos_acpi_lookup_node(parent, name))) {
new_parent = kos_aml_alloc_node(KOS_ACPI_NODE_Device);
new_parent->name = *(uint32_t*)name;
kos_aml_attach(parent, new_parent);
acpi_node_t *adr = acpi_get_at(new_parent, STR2UINT32("_ADR"));
kos_aml_attach(new_parent, adr);
if (name < path + dir_name_len - 5) {
acpi_node_t *prt = acpi_get_at(new_parent, STR2UINT32("_PRT"));
kos_aml_attach(new_parent, prt);
}
}
parent = new_parent;
}
}
int
main () {
kos_boot.bpp = 32;
kos_boot.x_res = UMKA_DEFAULT_DISPLAY_WIDTH;
kos_boot.y_res = UMKA_DEFAULT_DISPLAY_HEIGHT;
kos_boot.pitch = UMKA_DEFAULT_DISPLAY_WIDTH*4; // 32bpp
strcpy(pci_path, PCI_BASE_DIR);
2021-11-04 03:52:50 +01:00
umka_init(UMKA_GEN_DEVICES_DAT);
2021-11-04 03:52:50 +01:00
kos_acpi_aml_init();
ctx = kos_acpi_aml_new_thread();
kos_acpi_dev_size = MAX_PCI_DEVICES*16;
kos_acpi_dev_data = kos_kernel_alloc(kos_acpi_dev_size);
kos_acpi_dev_next = kos_acpi_dev_data;
DIR *pci_base_dir = opendir(PCI_BASE_DIR);
if (!pci_base_dir) {
perror("Can't open dir");
exit(1);
}
struct dirent *d;
while ((d = readdir(pci_base_dir))) {
if (d->d_name[0] == '.') {
continue;
}
sprintf(acpi_path_file, "%s/%s/%s", PCI_BASE_DIR, d->d_name,
"firmware_node/path");
FILE *f = fopen(acpi_path_file, "r");
if (!f) {
if (errno == ENOENT) {
continue;
} else {
perror("Can't open file");
}
}
size_t len = fread(acpi_path, 1, PATH_MAX, f);
acpi_path[len-1] = '\0';
fclose(f);
acpi_process_dev(acpi_path);
}
closedir(pci_base_dir);
kos_acpi_print_tree(ctx);
kos_acpi_fill_pci_irqs(ctx);
dump_devices_dat("devices.dat");
2021-11-04 03:52:50 +01:00
return 0;
}