kolibrios-fun/drivers/devman/pci_irq.c

#include <ddk.h>
#include <linux/errno.h>
#include <mutex.h>
#include <linux/spinlock.h>
#include <pci.h>
#include <syscall.h>

#include "acpi.h"
#include "acpi_bus.h"

#define PREFIX "ACPI: "

struct acpi_prt_entry
{
    struct list_head    list;
    ACPI_PCI_ID         id;
    u8                  pin;
    ACPI_HANDLE         link;
    u32                 index;      /* GSI, or link _CRS index */
};

static LIST_HEAD(acpi_prt_list);
static DEFINE_SPINLOCK(acpi_prt_lock);

static inline char pin_name(int pin)
{
    return 'A' + pin - 1;
}


/* --------------------------------------------------------------------------
                         PCI IRQ Routing Table (PRT) Support
   -------------------------------------------------------------------------- */

static struct acpi_prt_entry *acpi_pci_irq_find_prt_entry(struct pci_dev *dev,
                              int pin)
{
    struct acpi_prt_entry *entry;
    int segment = pci_domain_nr(dev->bus);
    int bus = dev->bus->number;
    int device = PCI_SLOT(dev->devfn);

    spin_lock(&acpi_prt_lock);
    list_for_each_entry(entry, &acpi_prt_list, list) {
        if ((segment == entry->id.Segment)
            && (bus == entry->id.Bus)
            && (device == entry->id.Device)
            && (pin == entry->pin)) {
            spin_unlock(&acpi_prt_lock);
            return entry;
        }
    }
    spin_unlock(&acpi_prt_lock);
    return NULL;
}

static int acpi_pci_irq_add_entry(ACPI_HANDLE handle, struct pci_bus *bus,
                  struct acpi_pci_routing_table *prt)
{
    struct acpi_prt_entry *entry;

    entry = kzalloc(sizeof(struct acpi_prt_entry), GFP_KERNEL);
    if (!entry)
        return -ENOMEM;

    /*
     * Note that the _PRT uses 0=INTA, 1=INTB, etc, while PCI uses
     * 1=INTA, 2=INTB.  We use the PCI encoding throughout, so convert
     * it here.
     */
    entry->id.Segment = pci_domain_nr(bus);
    entry->id.Bus = bus->number;
    entry->id.Device = (prt->Address >> 16) & 0xFFFF;
    entry->pin = prt->Pin + 1;

//    do_prt_fixups(entry, prt);

    entry->index = prt->SourceIndex;

    /*
     * Type 1: Dynamic
     * ---------------
     * The 'source' field specifies the PCI interrupt link device used to
     * configure the IRQ assigned to this slot|dev|pin.  The 'source_index'
     * indicates which resource descriptor in the resource template (of
     * the link device) this interrupt is allocated from.
     *
     * NOTE: Don't query the Link Device for IRQ information at this time
     *       because Link Device enumeration may not have occurred yet
     *       (e.g. exists somewhere 'below' this _PRT entry in the ACPI
     *       namespace).
     */
    if (prt->Source[0])
        AcpiGetHandle(handle, prt->Source, &entry->link);

    /*
     * Type 2: Static
     * --------------
     * The 'source' field is NULL, and the 'source_index' field specifies
     * the IRQ value, which is hardwired to specific interrupt inputs on
     * the interrupt controller.
     */

    dbgprintf(PREFIX "      %04x:%02x:%02x[%c] -> %s[%d]\n",
                  entry->id.Segment, entry->id.Bus,
                  entry->id.Device, pin_name(entry->pin),
                  prt->Source, entry->index);

    spin_lock(&acpi_prt_lock);
    list_add_tail(&entry->list, &acpi_prt_list);
    spin_unlock(&acpi_prt_lock);

    return 0;
}



int acpi_pci_irq_add_prt(ACPI_HANDLE handle, struct pci_bus *bus)
{
    ACPI_STATUS status;
    struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
    struct acpi_pci_routing_table *entry;

    /* 'handle' is the _PRT's parent (root bridge or PCI-PCI bridge) */
    status = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buffer);
    if (ACPI_FAILURE(status))
        return -ENODEV;

    printk(KERN_DEBUG "ACPI: PCI Interrupt Routing Table [%s._PRT]\n",
           (char *) buffer.Pointer);

    kfree(buffer.Pointer);

    buffer.Length = ACPI_ALLOCATE_BUFFER;
    buffer.Pointer = NULL;

    status = AcpiGetIrqRoutingTable(handle, &buffer);
    if (ACPI_FAILURE(status))
    {
        dbgprintf("AcpiGetIrqRoutingTable failed "
                  "evaluating _PRT [%s]\n",AcpiFormatException(status));
        kfree(buffer.Pointer);
        return -ENODEV;
    }

    entry = buffer.Pointer;
    while (entry && (entry->Length > 0)) {
        acpi_pci_irq_add_entry(handle, bus, entry);
        entry = (struct acpi_pci_routing_table *)
            ((unsigned long)entry + entry->Length);
    }

    kfree(buffer.Pointer);
    return 0;
}

static struct acpi_prt_entry *acpi_pci_irq_lookup(struct pci_dev *dev, int pin)
{
    struct acpi_prt_entry *entry;
    struct pci_dev *bridge;
    u8 bridge_pin, orig_pin = pin;

    entry = acpi_pci_irq_find_prt_entry(dev, pin);
    if (entry) {
        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %s[%c] _PRT entry\n",
                  pci_name(dev), pin_name(pin)));
        return entry;
    }

    /*
     * Attempt to derive an IRQ for this device from a parent bridge's
     * PCI interrupt routing entry (eg. yenta bridge and add-in card bridge).
     */
    bridge = dev->bus->self;
    while (bridge)
    {
        pin = pci_swizzle_interrupt_pin(dev, pin);

        if ((bridge->class >> 8) == PCI_CLASS_BRIDGE_CARDBUS) {
            /* PC card has the same IRQ as its cardbridge */
            bridge_pin = bridge->pin;
            if (!bridge_pin) {
                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                          "No interrupt pin configured for device %s\n",
                          pci_name(bridge)));
                return NULL;
            }
            pin = bridge_pin;
        }

        entry = acpi_pci_irq_find_prt_entry(bridge, pin);
        if (entry) {
            ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                     "Derived GSI for %s INT %c from %s\n",
                     pci_name(dev), pin_name(orig_pin),
                     pci_name(bridge)));
            return entry;
        }

        dev = bridge;
        bridge = dev->bus->self;
    }

    dbgprintf("can't derive routing for PCI INT %c\n",
         pin_name(orig_pin));
    return NULL;
}


int acpi_get_irq(struct pci_dev *dev)
{
    struct acpi_prt_entry *entry;
    int gsi = -1;
    u8 pin;

    int triggering = ACPI_LEVEL_SENSITIVE;
    int polarity = ACPI_ACTIVE_LOW;

    char *link = NULL;
    char link_desc[16];
    int rc;

    pin = dev->pin;
    if (!pin) {
        dbgprintf(("No interrupt pin configured for device %s\n",
                  pci_name(dev)));
        return 0;
    }

    entry = acpi_pci_irq_lookup(dev, pin);
    if (!entry) {
        /*
         * IDE legacy mode controller IRQs are magic. Why do compat
         * extensions always make such a nasty mess.
         */
        if (dev->class >> 8 == PCI_CLASS_STORAGE_IDE &&
                (dev->class & 0x05) == 0)
            return 0;
    }

    if (entry)
    {
        if (entry->link)
        {
            gsi = acpi_pci_link_allocate_irq(entry->link,
                             entry->index,
                             &triggering, &polarity,
                             &link);
//            dbgprintf("link not implemen\n");
        }
        else
            gsi = entry->index;
    } else
        gsi = -1;

#if 0

    /*
     * No IRQ known to the ACPI subsystem - maybe the BIOS /
     * driver reported one, then use it. Exit in any case.
     */
    if (gsi < 0) {
        u32 dev_gsi;
        dev_warn(&dev->dev, "PCI INT %c: no GSI", pin_name(pin));
        /* Interrupt Line values above 0xF are forbidden */
        if (dev->irq > 0 && (dev->irq <= 0xF) &&
            (acpi_isa_irq_to_gsi(dev->irq, &dev_gsi) == 0)) {
            printk(" - using ISA IRQ %d\n", dev->irq);
            acpi_register_gsi(&dev->dev, dev_gsi,
                      ACPI_LEVEL_SENSITIVE,
                      ACPI_ACTIVE_LOW);
            return 0;
        } else {
            printk("\n");
            return 0;
        }
    }

    rc = acpi_register_gsi(&dev->dev, gsi, triggering, polarity);
    if (rc < 0) {
        dev_warn(&dev->dev, "PCI INT %c: failed to register GSI\n",
             pin_name(pin));
        return rc;
    }
    dev->irq = rc;

    if (link)
        snprintf(link_desc, sizeof(link_desc), " -> Link[%s]", link);
    else
        link_desc[0] = '\0';

    dev_info(&dev->dev, "PCI INT %c%s -> GSI %u (%s, %s) -> IRQ %d\n",
         pin_name(pin), link_desc, gsi,
         (triggering == ACPI_LEVEL_SENSITIVE) ? "level" : "edge",
         (polarity == ACPI_ACTIVE_LOW) ? "low" : "high", dev->irq);
#endif

    return gsi;
}


#define ACPI_PCI_LINK_MAX_POSSIBLE  16

/*
 * If a link is initialized, we never change its active and initialized
 * later even the link is disable. Instead, we just repick the active irq
 */
struct acpi_pci_link_irq {
    u8 active;      /* Current IRQ */
    u8 triggering;      /* All IRQs */
    u8 polarity;        /* All IRQs */
    u8 resource_type;
    u8 possible_count;
    u8 possible[ACPI_PCI_LINK_MAX_POSSIBLE];
    u8 initialized:1;
    u8 reserved:7;
};

struct acpi_pci_link {
    struct list_head        list;
    struct acpi_device      *device;
    struct acpi_pci_link_irq    irq;
    int             refcnt;
};

static LIST_HEAD(acpi_link_list);
static DEFINE_MUTEX(acpi_link_lock);


static int acpi_pci_link_set(struct acpi_pci_link *link, int irq)
{
    int result;
    ACPI_STATUS status;
    struct {
        struct acpi_resource res;
        struct acpi_resource end;
    } *resource;

    ACPI_BUFFER buffer = { 0, NULL };

    if (!irq)
        return -EINVAL;

    resource = kzalloc(sizeof(*resource) + 1, GFP_KERNEL);
    if (!resource)
        return -ENOMEM;

    buffer.Length = sizeof(*resource) + 1;
    buffer.Pointer = resource;

    switch (link->irq.resource_type) {
    case ACPI_RESOURCE_TYPE_IRQ:
        resource->res.Type = ACPI_RESOURCE_TYPE_IRQ;
        resource->res.Length = sizeof(struct acpi_resource);
        resource->res.Data.Irq.Triggering = link->irq.triggering;
        resource->res.Data.Irq.Polarity =
            link->irq.polarity;
        if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
            resource->res.Data.Irq.Sharable =
                ACPI_EXCLUSIVE;
        else
            resource->res.Data.Irq.Sharable = ACPI_SHARED;
        resource->res.Data.Irq.InterruptCount = 1;
        resource->res.Data.Irq.Interrupts[0] = irq;
        break;

    case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
        resource->res.Type = ACPI_RESOURCE_TYPE_EXTENDED_IRQ;
        resource->res.Length = sizeof(struct acpi_resource);
        resource->res.Data.ExtendedIrq.ProducerConsumer =
            ACPI_CONSUMER;
        resource->res.Data.ExtendedIrq.Triggering =
            link->irq.triggering;
        resource->res.Data.ExtendedIrq.Polarity =
            link->irq.polarity;
        if (link->irq.triggering == ACPI_EDGE_SENSITIVE)
            resource->res.Data.Irq.Sharable =
                ACPI_EXCLUSIVE;
        else
            resource->res.Data.Irq.Sharable = ACPI_SHARED;
        resource->res.Data.ExtendedIrq.InterruptCount = 1;
        resource->res.Data.ExtendedIrq.Interrupts[0] = irq;
        /* ignore resource_source, it's optional */
        break;
    default:
        printk(KERN_ERR PREFIX "Invalid Resource_type %d\n", link->irq.resource_type);
        result = -EINVAL;
        goto end;

    }
    resource->end.Type = ACPI_RESOURCE_TYPE_END_TAG;

#if 0
    /* Attempt to set the resource */
    status = acpi_set_current_resources(link->device->handle, &buffer);

    /* check for total failure */
    if (ACPI_FAILURE(status)) {
        dbgprintf("%s failure Evaluating _SRS", __FUNCTION__);
        result = -ENODEV;
        goto end;
    }

    /* Query _STA, set device->status */
    result = acpi_bus_get_status(link->device);
    if (result) {
        printk(KERN_ERR PREFIX "Unable to read status\n");
        goto end;
    }
    if (!link->device->status.enabled) {
        printk(KERN_WARNING PREFIX
                  "%s [%s] disabled and referenced, BIOS bug\n",
                  acpi_device_name(link->device),
                  acpi_device_bid(link->device));
    }

    /* Query _CRS, set link->irq.active */
    result = acpi_pci_link_get_current(link);
    if (result) {
        goto end;
    }

    /*
     * Is current setting not what we set?
     * set link->irq.active
     */
    if (link->irq.active != irq) {
        /*
         * policy: when _CRS doesn't return what we just _SRS
         * assume _SRS worked and override _CRS value.
         */
        printk(KERN_WARNING PREFIX
                  "%s [%s] BIOS reported IRQ %d, using IRQ %d\n",
                  acpi_device_name(link->device),
                  acpi_device_bid(link->device), link->irq.active, irq);
        link->irq.active = irq;
    }
#endif

    ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Set IRQ %d\n", link->irq.active));

end:
    kfree(resource);
    return result;
}



#define ACPI_MAX_IRQS       256
#define ACPI_MAX_ISA_IRQ    16

#define PIRQ_PENALTY_PCI_AVAILABLE  (0)
#define PIRQ_PENALTY_PCI_POSSIBLE   (16*16)
#define PIRQ_PENALTY_PCI_USING      (16*16*16)
#define PIRQ_PENALTY_ISA_TYPICAL    (16*16*16*16)
#define PIRQ_PENALTY_ISA_USED       (16*16*16*16*16)
#define PIRQ_PENALTY_ISA_ALWAYS     (16*16*16*16*16*16)

static int acpi_irq_penalty[ACPI_MAX_IRQS] = {
    PIRQ_PENALTY_ISA_ALWAYS,    /* IRQ0 timer */
    PIRQ_PENALTY_ISA_ALWAYS,    /* IRQ1 keyboard */
    PIRQ_PENALTY_ISA_ALWAYS,    /* IRQ2 cascade */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ3 serial */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ4 serial */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ5 sometimes SoundBlaster */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ6 */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ7 parallel, spurious */
    PIRQ_PENALTY_ISA_TYPICAL,   /* IRQ8 rtc, sometimes */
    PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ9  PCI, often acpi */
    PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ10 PCI */
    PIRQ_PENALTY_PCI_AVAILABLE, /* IRQ11 PCI */
    PIRQ_PENALTY_ISA_USED,      /* IRQ12 mouse */
    PIRQ_PENALTY_ISA_USED,      /* IRQ13 fpe, sometimes */
    PIRQ_PENALTY_ISA_USED,      /* IRQ14 ide0 */
    PIRQ_PENALTY_ISA_USED,      /* IRQ15 ide1 */
    /* >IRQ15 */
};




static int acpi_irq_balance = 0;

static int acpi_pci_link_allocate(struct acpi_pci_link *link)
{
    int irq;
    int i;

    if (link->irq.initialized) {
        if (link->refcnt == 0)
            /* This means the link is disabled but initialized */
            acpi_pci_link_set(link, link->irq.active);
        return 0;
    }

    /*
     * search for active IRQ in list of possible IRQs.
     */
    for (i = 0; i < link->irq.possible_count; ++i) {
        if (link->irq.active == link->irq.possible[i])
            break;
    }
    /*
     * forget active IRQ that is not in possible list
     */
    if (i == link->irq.possible_count) {
        printk(KERN_WARNING PREFIX "_CRS %d not found"
                      " in _PRS\n", link->irq.active);
        link->irq.active = 0;
    }

    /*
     * if active found, use it; else pick entry from end of possible list.
     */
    if (link->irq.active)
        irq = link->irq.active;
    else
        irq = link->irq.possible[link->irq.possible_count - 1];

    if (acpi_irq_balance || !link->irq.active) {
        /*
         * Select the best IRQ.  This is done in reverse to promote
         * the use of IRQs 9, 10, 11, and >15.
         */
        for (i = (link->irq.possible_count - 1); i >= 0; i--) {
            if (acpi_irq_penalty[irq] >
                acpi_irq_penalty[link->irq.possible[i]])
                irq = link->irq.possible[i];
        }
    }

    /* Attempt to enable the link device at this IRQ. */
    if (acpi_pci_link_set(link, irq)) {
        printk(KERN_ERR PREFIX "Unable to set IRQ for %s [%s]. "
                "Try pci=noacpi or acpi=off\n",
                acpi_device_name(link->device),
                acpi_device_bid(link->device));
        return -ENODEV;
    } else {
        acpi_irq_penalty[link->irq.active] += PIRQ_PENALTY_PCI_USING;
        printk(KERN_WARNING PREFIX "%s [%s] enabled at IRQ %d\n",
               acpi_device_name(link->device),
               acpi_device_bid(link->device), link->irq.active);
    }

    link->irq.initialized = 1;
    return 0;
}


/*
 * acpi_pci_link_allocate_irq
 * success: return IRQ >= 0
 * failure: return -1
 */
int acpi_pci_link_allocate_irq(ACPI_HANDLE handle, int index,
                               int *triggering, int *polarity, char **name)
{
    int result;
    struct acpi_device *device;
    struct acpi_pci_link *link;

    result = acpi_bus_get_device(handle, &device);
    if (result) {
        printk(KERN_ERR PREFIX "Invalid link device\n");
        return -1;
    }

    link = acpi_driver_data(device);
    if (!link) {
        printk(KERN_ERR PREFIX "Invalid link context\n");
        return -1;
    }

    /* TBD: Support multiple index (IRQ) entries per Link Device */
    if (index) {
        printk(KERN_ERR PREFIX "Invalid index %d\n", index);
        return -1;
    }

    mutex_lock(&acpi_link_lock);
    if (acpi_pci_link_allocate(link)) {
        mutex_unlock(&acpi_link_lock);
        return -1;
    }

    if (!link->irq.active) {
        mutex_unlock(&acpi_link_lock);
        printk(KERN_ERR PREFIX "Link active IRQ is 0!\n");
        return -1;
    }
    link->refcnt++;
    mutex_unlock(&acpi_link_lock);

    if (triggering)
        *triggering = link->irq.triggering;
    if (polarity)
        *polarity = link->irq.polarity;
    if (name)
        *name = acpi_device_bid(link->device);
    ACPI_DEBUG_PRINT((ACPI_DB_INFO,
              "Link %s is referenced\n",
              acpi_device_bid(link->device)));
    return (link->irq.active);
}