default_handlers.c File Reference

#include <uacpi/internal/opregion.h>
#include <uacpi/internal/namespace.h>
#include <uacpi/internal/utilities.h>
#include <uacpi/internal/helpers.h>
#include <uacpi/internal/log.h>
#include <uacpi/internal/io.h>
#include <uacpi/kernel_api.h>
#include <uacpi/uacpi.h>
#include <uacpi/osi.h>

Include dependency graph for default_handlers.c:

Go to the source code of this file.

Classes
struct	pci_region_device
struct	pci_region_ctx
struct	memory_region_ctx
struct	io_region_ctx
struct	protected_io_range

Macros
#define	PCI_ROOT_PNP_ID   "PNP0A03"
#define	PCI_EXPRESS_ROOT_PNP_ID   "PNP0A08"
#define	PCI_HEADER_SIZE   0x40
#define	PCI_HEADER_TYPE_REG   0x0E
#define	PCI_HEADER_TYPE_MASK   0x7F
#define	PCI_HEADER_TYPE_NORMAL   0x00
#define	PCI_HEADER_TYPE_PCI_BRIDGE   0x01
#define	PCI_HEADER_TYPE_CARDBUS_BRIDGE   0x02
#define	PCI_HEADER_TYPE_NO_DEVICE   0xFF
#define	PCI_SECONDARY_BUS_REG   0x19
#define	PCI_SUBSYSTEM_VENDOR_ID_REG   0x2C
#define	PCI_EXPANSION_ROM_REG   0x30
#define	PCI_INTERRUPT_LINE_REG   0x3C

Enumerations
enum	pci_region_state { PCI_REGION_STATE_UNKNOWN = 0 , PCI_REGION_STATE_OPEN , PCI_REGION_STATE_NOT_FOUND , PCI_REGION_STATE_UNREACHABLE }
enum	pci_device_kind { PCI_DEVICE_KIND_NONE , PCI_DEVICE_KIND_NORMAL , PCI_DEVICE_KIND_BRIDGE , PCI_DEVICE_KIND_UNCONFIGURED_BRIDGE }
enum	io_protection_kind { IO_PROTECTION_KIND_ALWAYS , IO_PROTECTION_KIND_XP_AND_ABOVE }

Functions
static uacpi_namespace_node *	find_pci_root (uacpi_namespace_node *node)
static uacpi_bool	pci_address_equal (const uacpi_pci_address *lhs, const uacpi_pci_address *rhs)
static void	pci_region_device_close (struct pci_region_device *dev)
static uacpi_bool	pci_region_device_open (struct pci_region_device *dev, const uacpi_pci_address *address)
static enum pci_device_kind	pci_region_device_probe (struct pci_region_device *dev, const uacpi_pci_address *address, uacpi_u8 *out_secondary_bus)
static const uacpi_char *	pci_region_state_to_string (uacpi_u8 state)
static struct pci_region_device *	pci_region_resolve (struct pci_region_ctx *ctx)
static void	pci_region_ctx_free (struct pci_region_ctx *ctx)
static uacpi_size	pci_region_collect_devices (uacpi_namespace_node *pci_root, uacpi_namespace_node *device, struct pci_region_device *out)
static uacpi_status	pci_region_find_devices (struct pci_region_ctx *ctx, uacpi_namespace_node *pci_root, uacpi_namespace_node *device)
static uacpi_status	pci_region_attach (uacpi_region_attach_data *data)
static uacpi_status	pci_region_detach (uacpi_region_detach_data *data)
static uacpi_bool	pci_write_is_protected (struct pci_region_device *dev, uacpi_size offset)
static uacpi_status	pci_region_do_rw (uacpi_region_op op, uacpi_region_rw_data *data)
static uacpi_status	handle_pci_region (uacpi_region_op op, uacpi_handle op_data)
static uacpi_status	memory_region_attach (uacpi_region_attach_data *data)
static uacpi_status	memory_region_detach (uacpi_region_detach_data *data)
static uacpi_status	io_region_attach (uacpi_region_attach_data *data)
static uacpi_status	io_region_detach (uacpi_region_detach_data *data)
static uacpi_status	memory_region_do_rw (uacpi_region_op op, uacpi_region_rw_data *data)
static uacpi_status	handle_memory_region (uacpi_region_op op, uacpi_handle op_data)
static uacpi_status	table_data_region_do_rw (uacpi_region_op op, uacpi_region_rw_data *data)
static uacpi_status	handle_table_data_region (uacpi_region_op op, uacpi_handle op_data)
static uacpi_bool	io_port_is_protected (uacpi_u64 port)
static uacpi_status	io_region_do_rw (uacpi_region_op op, uacpi_region_rw_data *data)
static uacpi_status	handle_io_region (uacpi_region_op op, uacpi_handle op_data)
void	uacpi_install_default_address_space_handlers (void)

Variables
static const struct protected_io_range	protected_io_ranges []

Macro Definition Documentation

PCI_EXPANSION_ROM_REG

#define PCI_EXPANSION_ROM_REG   0x30

Definition at line 25 of file default_handlers.c.

PCI_EXPRESS_ROOT_PNP_ID

#define PCI_EXPRESS_ROOT_PNP_ID   "PNP0A08"

Definition at line 14 of file default_handlers.c.

PCI_HEADER_SIZE

#define PCI_HEADER_SIZE   0x40

Definition at line 16 of file default_handlers.c.

PCI_HEADER_TYPE_CARDBUS_BRIDGE

#define PCI_HEADER_TYPE_CARDBUS_BRIDGE   0x02

Definition at line 21 of file default_handlers.c.

PCI_HEADER_TYPE_MASK

#define PCI_HEADER_TYPE_MASK   0x7F

Definition at line 18 of file default_handlers.c.

PCI_HEADER_TYPE_NO_DEVICE

#define PCI_HEADER_TYPE_NO_DEVICE   0xFF

Definition at line 22 of file default_handlers.c.

PCI_HEADER_TYPE_NORMAL

#define PCI_HEADER_TYPE_NORMAL   0x00

Definition at line 19 of file default_handlers.c.

PCI_HEADER_TYPE_PCI_BRIDGE

#define PCI_HEADER_TYPE_PCI_BRIDGE   0x01

Definition at line 20 of file default_handlers.c.

PCI_HEADER_TYPE_REG

#define PCI_HEADER_TYPE_REG   0x0E

Definition at line 17 of file default_handlers.c.

PCI_INTERRUPT_LINE_REG

#define PCI_INTERRUPT_LINE_REG   0x3C

Definition at line 26 of file default_handlers.c.

PCI_ROOT_PNP_ID

#define PCI_ROOT_PNP_ID   "PNP0A03"

Definition at line 13 of file default_handlers.c.

PCI_SECONDARY_BUS_REG

#define PCI_SECONDARY_BUS_REG   0x19

Definition at line 23 of file default_handlers.c.

PCI_SUBSYSTEM_VENDOR_ID_REG

#define PCI_SUBSYSTEM_VENDOR_ID_REG   0x2C

Definition at line 24 of file default_handlers.c.

Enumeration Type Documentation

io_protection_kind

enum io_protection_kind

Enumerator
IO_PROTECTION_KIND_ALWAYS
IO_PROTECTION_KIND_XP_AND_ABOVE

Definition at line 654 of file default_handlers.c.

                        {
    IO_PROTECTION_KIND_ALWAYS,
 
    // Only after AML has queried _OSI for Windows XP or anything newer
    IO_PROTECTION_KIND_XP_AND_ABOVE,
};

pci_device_kind

enum pci_device_kind

Enumerator
PCI_DEVICE_KIND_NONE
PCI_DEVICE_KIND_NORMAL
PCI_DEVICE_KIND_BRIDGE
PCI_DEVICE_KIND_UNCONFIGURED_BRIDGE

Definition at line 94 of file default_handlers.c.

                     {
    // There's no device at this address
    PCI_DEVICE_KIND_NONE,
 
    PCI_DEVICE_KIND_NORMAL,
    PCI_DEVICE_KIND_BRIDGE,
 
    // A bridge that has no secondary bus assigned
    PCI_DEVICE_KIND_UNCONFIGURED_BRIDGE,
};

pci_region_state

enum pci_region_state

Enumerator
PCI_REGION_STATE_UNKNOWN
PCI_REGION_STATE_OPEN
PCI_REGION_STATE_NOT_FOUND
PCI_REGION_STATE_UNREACHABLE

Definition at line 56 of file default_handlers.c.

                      {
    PCI_REGION_STATE_UNKNOWN = 0,
    PCI_REGION_STATE_OPEN,
    PCI_REGION_STATE_NOT_FOUND,
    PCI_REGION_STATE_UNREACHABLE,
};

Function Documentation

find_pci_root()

static uacpi_namespace_node * find_pci_root ( uacpi_namespace_node *  node )

static

Definition at line 28 of file default_handlers.c.

{
    static const uacpi_char *pci_root_ids[] = {
        PCI_ROOT_PNP_ID,
        PCI_EXPRESS_ROOT_PNP_ID,
        UACPI_NULL
    };
    uacpi_namespace_node *parent = node->parent;
 
    while (parent != uacpi_namespace_root()) {
        if (uacpi_device_matches_pnp_id(parent, pci_root_ids)) {
            uacpi_trace(
                "found a PCI root node %.4s controlling region %.4s",
                parent->name.text, node->name.text
            );
            return parent;
        }
 
        parent = parent->parent;
    }
 
    uacpi_trace_region_error(
        node, "unable to find PCI root controlling",
        UACPI_STATUS_NOT_FOUND
    );
    return node;
}

Referenced by pci_region_attach().

handle_io_region()

static uacpi_status handle_io_region ( uacpi_region_op  op, uacpi_handle  op_data  )

static

Definition at line 763 of file default_handlers.c.

{
    switch (op) {
    case UACPI_REGION_OP_ATTACH:
        return io_region_attach(op_data);
    case UACPI_REGION_OP_DETACH:
        return io_region_detach(op_data);
    case UACPI_REGION_OP_READ:
    case UACPI_REGION_OP_WRITE:
        return io_region_do_rw(op, op_data);
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
}

Referenced by uacpi_install_default_address_space_handlers().

handle_memory_region()

static uacpi_status handle_memory_region ( uacpi_region_op  op, uacpi_handle  op_data  )

static

Definition at line 614 of file default_handlers.c.

{
    switch (op) {
    case UACPI_REGION_OP_ATTACH:
        return memory_region_attach(op_data);
    case UACPI_REGION_OP_DETACH:
        return memory_region_detach(op_data);
    case UACPI_REGION_OP_READ:
    case UACPI_REGION_OP_WRITE:
        return memory_region_do_rw(op, op_data);
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
}

Referenced by uacpi_install_default_address_space_handlers().

handle_pci_region()

static uacpi_status handle_pci_region ( uacpi_region_op  op, uacpi_handle  op_data  )

static

Definition at line 504 of file default_handlers.c.

{
    switch (op) {
    case UACPI_REGION_OP_ATTACH:
        return pci_region_attach(op_data);
    case UACPI_REGION_OP_DETACH:
        return pci_region_detach(op_data);
    case UACPI_REGION_OP_READ:
    case UACPI_REGION_OP_WRITE:
        return pci_region_do_rw(op, op_data);
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
}

Referenced by uacpi_install_default_address_space_handlers().

handle_table_data_region()

static uacpi_status handle_table_data_region ( uacpi_region_op  op, uacpi_handle  op_data  )

static

Definition at line 640 of file default_handlers.c.

{
    switch (op) {
    case UACPI_REGION_OP_ATTACH:
    case UACPI_REGION_OP_DETACH:
        return UACPI_STATUS_OK;
    case UACPI_REGION_OP_READ:
    case UACPI_REGION_OP_WRITE:
        return table_data_region_do_rw(op, op_data);
    default:
        return UACPI_STATUS_INVALID_ARGUMENT;
    }
}

Referenced by uacpi_install_default_address_space_handlers().

io_port_is_protected()

static uacpi_bool io_port_is_protected ( uacpi_u64  port )

static

Definition at line 714 of file default_handlers.c.

{
    const struct protected_io_range *range;
    uacpi_size i;
 
    for (i = 0; i < UACPI_ARRAY_SIZE(protected_io_ranges); ++i) {
        range = &protected_io_ranges[i];
 
        if (port < range->first || port > range->last)
            continue;
        if (range->kind == IO_PROTECTION_KIND_ALWAYS)
            return UACPI_TRUE;
 
        return uacpi_latest_queried_vendor_interface() >=
               UACPI_VENDOR_INTERFACE_WINDOWS_XP;
    }
 
    return UACPI_FALSE;
}

Referenced by io_region_do_rw().

io_region_attach()

static uacpi_status io_region_attach ( uacpi_region_attach_data *  data )

static

Definition at line 566 of file default_handlers.c.

{
    struct io_region_ctx *ctx;
    uacpi_generic_region_info *info = &data->generic_info;
    uacpi_status ret;
 
    ctx = uacpi_kernel_alloc(sizeof(*ctx));
    if (ctx == UACPI_NULL)
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    ctx->base = info->base;
 
    ret = uacpi_kernel_io_map(ctx->base, info->length, &ctx->handle);
    if (uacpi_unlikely_error(ret)) {
        uacpi_trace_region_error(
            data->region_node, "unable to map an IO", ret
        );
        uacpi_free(ctx, sizeof(*ctx));
        return ret;
    }
 
    data->out_region_context = ctx;
    return ret;
}

Referenced by handle_io_region().

io_region_detach()

static uacpi_status io_region_detach ( uacpi_region_detach_data *  data )

static

Definition at line 591 of file default_handlers.c.

{
    struct io_region_ctx *ctx = data->region_context;
 
    uacpi_kernel_io_unmap(ctx->handle);
    uacpi_free(ctx, sizeof(*ctx));
    return UACPI_STATUS_OK;
}

Referenced by handle_io_region().

io_region_do_rw()

static uacpi_status io_region_do_rw ( uacpi_region_op  op, uacpi_region_rw_data *  data  )

static

Definition at line 734 of file default_handlers.c.

{
    struct io_region_ctx *ctx = data->region_context;
    uacpi_u8 width;
    uacpi_size offset;
 
    offset = data->offset - ctx->base;
    width = data->byte_width;
 
    if (io_port_is_protected(data->offset)) {
        uacpi_trace(
            "denied AML %s access to protected port 0x%04"UACPI_PRIX64,
            op == UACPI_REGION_OP_READ ? "read" : "write",
            UACPI_FMT64(data->offset)
        );
 
        if (op == UACPI_REGION_OP_READ)
            data->value = 0;
 
        return UACPI_STATUS_OK;
    }
 
    return op == UACPI_REGION_OP_READ ?
        uacpi_system_io_read(ctx->handle, offset, width, &data->value) :
        uacpi_system_io_write(ctx->handle, offset, width, data->value);
}

Referenced by handle_io_region().

memory_region_attach()

static uacpi_status memory_region_attach ( uacpi_region_attach_data *  data )

static

Definition at line 525 of file default_handlers.c.

{
    struct memory_region_ctx *ctx;
    uacpi_status ret = UACPI_STATUS_OK;
 
    ctx = uacpi_kernel_alloc(sizeof(*ctx));
    if (ctx == UACPI_NULL)
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    ctx->size = data->generic_info.length;
 
    // FIXME: this really shouldn't try to map everything at once
    ctx->phys = data->generic_info.base;
    ctx->virt = uacpi_kernel_map(ctx->phys, ctx->size);
 
    if (uacpi_unlikely(ctx->virt == UACPI_MAP_FAILED)) {
        ret = UACPI_STATUS_MAPPING_FAILED;
        uacpi_trace_region_error(data->region_node, "unable to map", ret);
        uacpi_free(ctx, sizeof(*ctx));
        goto out;
    }
 
    data->out_region_context = ctx;
out:
    return ret;
}

Referenced by handle_memory_region().

memory_region_detach()

static uacpi_status memory_region_detach ( uacpi_region_detach_data *  data )

static

Definition at line 552 of file default_handlers.c.

{
    struct memory_region_ctx *ctx = data->region_context;
 
    uacpi_kernel_unmap(ctx->virt, ctx->size);
    uacpi_free(ctx, sizeof(*ctx));
    return UACPI_STATUS_OK;
}

Referenced by handle_memory_region().

memory_region_do_rw()

static uacpi_status memory_region_do_rw ( uacpi_region_op  op, uacpi_region_rw_data *  data  )

static

Definition at line 600 of file default_handlers.c.

{
    struct memory_region_ctx *ctx = data->region_context;
    uacpi_size offset;
 
    offset = data->address - ctx->phys;
 
    return op == UACPI_REGION_OP_READ ?
        uacpi_system_memory_read(ctx->virt, offset, data->byte_width, &data->value) :
        uacpi_system_memory_write(ctx->virt, offset, data->byte_width, data->value);
}

Referenced by handle_memory_region().

pci_address_equal()

static uacpi_bool pci_address_equal ( const uacpi_pci_address *  lhs, const uacpi_pci_address *  rhs  )

static

Definition at line 105 of file default_handlers.c.

{
    return lhs->segment == rhs->segment && lhs->bus == rhs->bus &&
           lhs->device == rhs->device && lhs->function == rhs->function;
}

Referenced by pci_region_device_open(), and pci_region_resolve().

pci_region_attach()

static uacpi_status pci_region_attach ( uacpi_region_attach_data *  data )

static

Definition at line 372 of file default_handlers.c.

{
    uacpi_namespace_node *node, *pci_root, *device;
    struct pci_region_ctx *ctx;
    uacpi_u64 value;
    uacpi_status ret;
 
    node = data->region_node;
    pci_root = find_pci_root(node);
 
    /*
     * Find the actual device object that is supposed to be controlling
     * this operation region.
     */
    device = node;
    while (device) {
        uacpi_object_type type;
 
        ret = uacpi_namespace_node_type(device, &type);
        if (uacpi_unlikely_error(ret))
            return ret;
 
        if (type == UACPI_OBJECT_DEVICE)
            break;
 
        device = device->parent;
    }
 
    if (uacpi_unlikely(device == UACPI_NULL)) {
        ret = UACPI_STATUS_NOT_FOUND;
        uacpi_trace_region_error(
            node, "unable to find device responsible for", ret
        );
        return ret;
    }
 
    ctx = uacpi_kernel_alloc_zeroed(sizeof(*ctx));
    if (uacpi_unlikely(ctx == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    ctx->node = device;
 
    ret = uacpi_eval_simple_integer(pci_root, "_SEG", &value);
    if (ret == UACPI_STATUS_OK)
        ctx->root_address.segment = value;
 
    ret = uacpi_eval_simple_integer(pci_root, "_BBN", &value);
    if (ret == UACPI_STATUS_OK)
        ctx->root_address.bus = value;
 
    ret = pci_region_find_devices(ctx, pci_root, device);
    if (uacpi_unlikely_error(ret)) {
        uacpi_free(ctx, sizeof(*ctx));
        return ret;
    }
 
    data->out_region_context = ctx;
    return UACPI_STATUS_OK;
}

Referenced by handle_pci_region().

pci_region_collect_devices()

static uacpi_size pci_region_collect_devices ( uacpi_namespace_node *  pci_root, uacpi_namespace_node *  device, struct pci_region_device *  out  )

static

Definition at line 286 of file default_handlers.c.

{
    uacpi_namespace_node *node;
    uacpi_size depth = 0, count = 0, i;
    uacpi_object_type type;
    uacpi_status ret;
    uacpi_u64 adr;
 
    for (node = device; node != UACPI_NULL && node != pci_root;
         node = node->parent)
        depth++;
 
    // There's no root above the device, the best we can do is use its _ADR
    if (node == UACPI_NULL)
        depth = 1;
 
    while (depth-- != 0) {
        node = device;
        for (i = 0; i < depth; ++i)
            node = node->parent;
 
        ret = uacpi_namespace_node_type(node, &type);
        if (ret != UACPI_STATUS_OK || type != UACPI_OBJECT_DEVICE)
            break;
 
        ret = uacpi_eval_simple_integer(node, "_ADR", &adr);
        if (ret != UACPI_STATUS_OK)
            break;
 
        if (out != UACPI_NULL) {
            out[count].function = (adr >> 0)  & 0xFF;
            out[count].device   = (adr >> 16) & 0xFF;
        }
        count++;
    }
 
    return count;
}

Referenced by pci_region_find_devices().

pci_region_ctx_free()

static void pci_region_ctx_free ( struct pci_region_ctx *  ctx )

static

Definition at line 268 of file default_handlers.c.

{
    uacpi_size i;
 
    for (i = 0; i < ctx->num_devices; ++i)
        pci_region_device_close(&ctx->devices[i]);
 
    if (ctx->devices != UACPI_NULL)
        uacpi_free(ctx->devices, ctx->num_devices * sizeof(*ctx->devices));
 
    uacpi_free(ctx, sizeof(*ctx));
}

Referenced by pci_region_detach().

pci_region_detach()

static uacpi_status pci_region_detach ( uacpi_region_detach_data *  data )

static

Definition at line 432 of file default_handlers.c.

{
    pci_region_ctx_free(data->region_context);
    return UACPI_STATUS_OK;
}

Referenced by handle_pci_region().

pci_region_device_close()

static void pci_region_device_close ( struct pci_region_device *  dev )

static

Definition at line 113 of file default_handlers.c.

{
    if (!dev->is_open)
        return;
 
    uacpi_kernel_pci_device_close(dev->handle);
    dev->is_open = UACPI_FALSE;
}

Referenced by pci_region_ctx_free(), pci_region_device_open(), and pci_region_resolve().

pci_region_device_open()

static uacpi_bool pci_region_device_open ( struct pci_region_device *  dev, const uacpi_pci_address *  address  )

static

Definition at line 123 of file default_handlers.c.

{
    uacpi_status ret;
 
    if (dev->is_open) {
        if (pci_address_equal(&dev->address, address))
            return UACPI_TRUE;
 
        pci_region_device_close(dev);
    }
 
    ret = uacpi_kernel_pci_device_open(*address, &dev->handle);
    if (ret != UACPI_STATUS_OK)
        return UACPI_FALSE;
 
    dev->address = *address;
    dev->is_open = UACPI_TRUE;
    return UACPI_TRUE;
}

Referenced by pci_region_device_probe(), and pci_region_resolve().

pci_region_device_probe()

static enum pci_device_kind pci_region_device_probe ( struct pci_region_device *  dev, const uacpi_pci_address *  address, uacpi_u8 *  out_secondary_bus  )

static

Definition at line 146 of file default_handlers.c.

{
    uacpi_status ret;
    uacpi_u8 header_type;
 
    if (!pci_region_device_open(dev, address))
        return PCI_DEVICE_KIND_NONE;
 
    ret = uacpi_kernel_pci_read8(
        dev->handle, PCI_HEADER_TYPE_REG, &header_type
    );
    if (ret != UACPI_STATUS_OK || header_type == PCI_HEADER_TYPE_NO_DEVICE)
        return PCI_DEVICE_KIND_NONE;
 
    switch (header_type & PCI_HEADER_TYPE_MASK) {
    case PCI_HEADER_TYPE_PCI_BRIDGE:
    case PCI_HEADER_TYPE_CARDBUS_BRIDGE:
        break;
    default:
        return PCI_DEVICE_KIND_NORMAL;
    }
 
    ret = uacpi_kernel_pci_read8(
        dev->handle, PCI_SECONDARY_BUS_REG, out_secondary_bus
    );
    if (ret != UACPI_STATUS_OK || *out_secondary_bus == 0)
        return PCI_DEVICE_KIND_UNCONFIGURED_BRIDGE;
 
    return PCI_DEVICE_KIND_BRIDGE;
}

Referenced by pci_region_resolve().

pci_region_do_rw()

static uacpi_status pci_region_do_rw ( uacpi_region_op  op, uacpi_region_rw_data *  data  )

static

Definition at line 463 of file default_handlers.c.

{
    uacpi_u8 width;
    uacpi_size offset;
    struct pci_region_device *dev;
 
    offset = data->offset;
    width = data->byte_width;
 
    dev = pci_region_resolve(data->region_context);
    if (dev == UACPI_NULL) {
        uacpi_trace(
            "faking a PCI device %s access",
            op == UACPI_REGION_OP_READ ? "read" : "write"
        );
 
        if (op == UACPI_REGION_OP_READ) {
            static uacpi_u64 ffs = 0xFFFFFFFFFFFFFFFF;
            uacpi_memcpy(&data->value, &ffs, width);
        }
 
        return UACPI_STATUS_OK;
    }
 
    if (op == UACPI_REGION_OP_READ)
        return uacpi_pci_read(dev->handle, offset, width, &data->value);
 
    if (pci_write_is_protected(dev, offset)) {
        uacpi_trace(
            "denied AML write access to protected offset 0x%02zX of PCI "
            "device %04X:%02X:%02X:%01X", offset, dev->address.segment,
            dev->address.bus, dev->address.device, dev->address.function
        );
        return UACPI_STATUS_OK;
    }
 
    return uacpi_pci_write(dev->handle, offset, width, data->value);
}

Referenced by handle_pci_region().

pci_region_find_devices()

static uacpi_status pci_region_find_devices ( struct pci_region_ctx *  ctx, uacpi_namespace_node *  pci_root, uacpi_namespace_node *  device  )

static

Definition at line 328 of file default_handlers.c.

{
    struct pci_region_device *devices;
    uacpi_size count;
    uacpi_status ret;
    uacpi_u64 adr;
 
    count = pci_region_collect_devices(pci_root, device, UACPI_NULL);
    if (count != 0) {
        devices = uacpi_kernel_alloc_zeroed(count * sizeof(*devices));
        if (uacpi_unlikely(devices == UACPI_NULL))
            return UACPI_STATUS_OUT_OF_MEMORY;
 
        ctx->devices = devices;
        ctx->num_devices = pci_region_collect_devices(
            pci_root, device, devices
        );
        return UACPI_STATUS_OK;
    }
 
    ret = uacpi_eval_simple_integer(pci_root, "_ADR", &adr);
    if (ret != UACPI_STATUS_OK) {
        uacpi_trace(
            "unable to determine the PCI address of %.4s",
            device->name.text
        );
        return UACPI_STATUS_OK;
    }
 
    devices = uacpi_kernel_alloc_zeroed(sizeof(*devices));
    if (uacpi_unlikely(devices == UACPI_NULL))
        return UACPI_STATUS_OUT_OF_MEMORY;
 
    devices->function = (adr >> 0)  & 0xFF;
    devices->device   = (adr >> 16) & 0xFF;
 
    ctx->devices = devices;
    ctx->num_devices = 1;
    return UACPI_STATUS_OK;
}

Referenced by pci_region_attach().

pci_region_resolve()

static struct pci_region_device * pci_region_resolve ( struct pci_region_ctx *  ctx )

static

Definition at line 211 of file default_handlers.c.

{
    struct pci_region_device *dev;
    uacpi_pci_address address = ctx->root_address;
    uacpi_u8 state = PCI_REGION_STATE_OPEN;
    enum pci_device_kind kind;
    uacpi_size i;
    uacpi_u8 bus;
 
    // The region doesn't belong to any device, see pci_region_find_devices()
    if (ctx->num_devices == 0)
        return UACPI_NULL;
 
    for (i = 0;; ++i) {
        dev = &ctx->devices[i];
 
        address.device = dev->device;
        address.function = dev->function;
 
        // Nothing below us, so this is the one
        if ((i + 1) == ctx->num_devices)
            break;
 
        kind = pci_region_device_probe(dev, &address, &bus);
        if (kind == PCI_DEVICE_KIND_BRIDGE) {
            address.bus = bus;
            continue;
        }
 
        // Whatever is below a normal device belongs to it, so we're done
        if (kind != PCI_DEVICE_KIND_NORMAL)
            state = PCI_REGION_STATE_UNREACHABLE;
        break;
    }
 
    // Whatever is below the device we stopped at is of no use anymore
    while (++i < ctx->num_devices)
        pci_region_device_close(&ctx->devices[i]);
 
    if (state == PCI_REGION_STATE_OPEN &&
        !pci_region_device_open(dev, &address))
        state = PCI_REGION_STATE_NOT_FOUND;
 
    if (state != ctx->state || !pci_address_equal(&address, &ctx->address)) {
        uacpi_trace(
            "PCI device %.4s %s at %04X:%02X:%02X:%01X", ctx->node->name.text,
            pci_region_state_to_string(state), address.segment, address.bus,
            address.device, address.function
        );
 
        ctx->address = address;
        ctx->state = state;
    }
 
    return state == PCI_REGION_STATE_OPEN ? dev : UACPI_NULL;
}

Referenced by pci_region_do_rw().

pci_region_state_to_string()

static const uacpi_char * pci_region_state_to_string ( uacpi_u8  state )

static

Definition at line 180 of file default_handlers.c.

{
    switch (state) {
    case PCI_REGION_STATE_OPEN:
        return "detected";
    case PCI_REGION_STATE_NOT_FOUND:
        return "is not present or powered off";
    default:
        return "is unreachable due to a missing or unconfigured bridge";
    }
}

Referenced by pci_region_resolve().

pci_write_is_protected()

static uacpi_bool pci_write_is_protected ( struct pci_region_device *  dev, uacpi_size  offset  )

static

Definition at line 439 of file default_handlers.c.

{
    uacpi_status ret;
    uacpi_u8 header_type;
 
    if (offset >= PCI_HEADER_SIZE)
        return UACPI_FALSE;
 
    if (offset < PCI_SUBSYSTEM_VENDOR_ID_REG)
        return UACPI_TRUE;
    if (offset >= PCI_EXPANSION_ROM_REG && offset < PCI_INTERRUPT_LINE_REG)
        return UACPI_TRUE;
 
    ret = uacpi_kernel_pci_read8(
        dev->handle, PCI_HEADER_TYPE_REG, &header_type
    );
    if (uacpi_unlikely_error(ret))
        return UACPI_TRUE;
 
    return (header_type & PCI_HEADER_TYPE_MASK) != PCI_HEADER_TYPE_NORMAL;
}

Referenced by pci_region_do_rw().

table_data_region_do_rw()

static uacpi_status table_data_region_do_rw ( uacpi_region_op  op, uacpi_region_rw_data *  data  )

static

Definition at line 629 of file default_handlers.c.

{
    void *addr = UACPI_VIRT_ADDR_TO_PTR((uacpi_virt_addr)data->offset);
 
    return op == UACPI_REGION_OP_READ ?
       uacpi_system_memory_read(addr, 0, data->byte_width, &data->value) :
       uacpi_system_memory_write(addr, 0, data->byte_width, data->value);
}

Referenced by handle_table_data_region().

uacpi_install_default_address_space_handlers()

void uacpi_install_default_address_space_handlers

(

void

)

Definition at line 778 of file default_handlers.c.

{
    uacpi_namespace_node *root;
 
    root = uacpi_namespace_root();
 
    uacpi_install_address_space_handler_with_flags(
        root, UACPI_ADDRESS_SPACE_SYSTEM_MEMORY,
        handle_memory_region, UACPI_NULL,
        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
    );
 
    uacpi_install_address_space_handler_with_flags(
        root, UACPI_ADDRESS_SPACE_SYSTEM_IO,
        handle_io_region, UACPI_NULL,
        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
    );
 
    uacpi_install_address_space_handler_with_flags(
        root, UACPI_ADDRESS_SPACE_PCI_CONFIG,
        handle_pci_region, UACPI_NULL,
        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
    );
 
    uacpi_install_address_space_handler_with_flags(
        root, UACPI_ADDRESS_SPACE_TABLE_DATA,
        handle_table_data_region, UACPI_NULL,
        UACPI_ADDRESS_SPACE_HANDLER_DEFAULT
    );
}

Referenced by uacpi_initialize().

Variable Documentation

protected_io_ranges

const struct protected_io_range protected_io_ranges[]

static

Definition at line 672 of file default_handlers.c.

Referenced by io_port_is_protected().