Changeset b0f00a9 in mainline for uspace/drv/bus/pci/pciintel/pci.c

Timestamp:

2011-11-06T22:21:05Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

898e847

Parents:

2bdf8313 (diff), 7b5f4c9 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

File:

• uspace/drv/bus/pci/pciintel/pci.c (moved) (moved from uspace/drv/pciintel/pci.c ) (20 diffs)

uspace/drv/bus/pci/pciintel/pci.c

@@ -52 +52 @@
 #include <ipc/devman.h>
 #include <ipc/dev_iface.h>
+#include <ipc/irc.h>
+#include <ns.h>
+#include <ipc/services.h>
+#include <sysinfo.h>
 #include <ops/hw_res.h>
 #include <device/hw_res.h>
 #include <ddi.h>
 #include <libarch/ddi.h>
+#include <pci_dev_iface.h>
 
 #include "pci.h"
@@ -72 +77 @@
 /** Obtain PCI bus soft-state from function soft-state */
 #define PCI_BUS_FROM_FUN(fun) ((fun)->busptr)
+
+/** Max is 47, align to something nice. */
+#define ID_MAX_STR_LEN 50
 
 static hw_resource_list_t *pciintel_get_resources(ddf_fun_t *fnode)
@@ -84 +92 @@
 static bool pciintel_enable_interrupt(ddf_fun_t *fnode)
 {
-        /* TODO */
-        
-        return false;
+        /* This is an old ugly way, copied from ne2000 driver */
+        assert(fnode);
+        pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
+        
+        sysarg_t apic;
+        sysarg_t i8259;
+        
+        async_sess_t *irc_sess = NULL;
+        
+        if (((sysinfo_get_value("apic", &apic) == EOK) && (apic))
+            || ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259))) {
+                irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
+                    SERVICE_IRC, 0, 0);
+        }
+        
+        if (!irc_sess)
+                return false;
+        
+        size_t i = 0;
+        hw_resource_list_t *res = &dev_data->hw_resources;
+        for (; i < res->count; i++) {
+                if (res->resources[i].type == INTERRUPT) {
+                        const int irq = res->resources[i].res.interrupt.irq;
+                        
+                        async_exch_t *exch = async_exchange_begin(irc_sess);
+                        const int rc =
+                            async_req_1_0(exch, IRC_ENABLE_INTERRUPT, irq);
+                        async_exchange_end(exch);
+                        
+                        if (rc != EOK) {
+                                async_hangup(irc_sess);
+                                return false;
+                        }
+                }
+        }
+        
+        async_hangup(irc_sess);
+        return true;
+}
+
+static int pci_config_space_write_32(ddf_fun_t *fun, uint32_t address,
+    uint32_t data)
+{
+        if (address > 252)
+                return EINVAL;
+        pci_conf_write_32(PCI_FUN(fun), address, data);
+        return EOK;
+}
+
+static int pci_config_space_write_16(
+    ddf_fun_t *fun, uint32_t address, uint16_t data)
+{
+        if (address > 254)
+                return EINVAL;
+        pci_conf_write_16(PCI_FUN(fun), address, data);
+        return EOK;
+}
+
+static int pci_config_space_write_8(
+    ddf_fun_t *fun, uint32_t address, uint8_t data)
+{
+        if (address > 255)
+                return EINVAL;
+        pci_conf_write_8(PCI_FUN(fun), address, data);
+        return EOK;
+}
+
+static int pci_config_space_read_32(
+    ddf_fun_t *fun, uint32_t address, uint32_t *data)
+{
+        if (address > 252)
+                return EINVAL;
+        *data = pci_conf_read_32(PCI_FUN(fun), address);
+        return EOK;
+}
+
+static int pci_config_space_read_16(
+    ddf_fun_t *fun, uint32_t address, uint16_t *data)
+{
+        if (address > 254)
+                return EINVAL;
+        *data = pci_conf_read_16(PCI_FUN(fun), address);
+        return EOK;
+}
+
+static int pci_config_space_read_8(
+    ddf_fun_t *fun, uint32_t address, uint8_t *data)
+{
+        if (address > 255)
+                return EINVAL;
+        *data = pci_conf_read_8(PCI_FUN(fun), address);
+        return EOK;
 }
 
@@ -94 +191 @@
 };
 
-static ddf_dev_ops_t pci_fun_ops;
+static pci_dev_iface_t pci_dev_ops = {
+        .config_space_read_8 = &pci_config_space_read_8,
+        .config_space_read_16 = &pci_config_space_read_16,
+        .config_space_read_32 = &pci_config_space_read_32,
+        .config_space_write_8 = &pci_config_space_write_8,
+        .config_space_write_16 = &pci_config_space_write_16,
+        .config_space_write_32 = &pci_config_space_write_32
+};
+
+static ddf_dev_ops_t pci_fun_ops = {
+        .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
+        .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
+};
 
 static int pci_add_device(ddf_dev_t *);
+static int pci_fun_online(ddf_fun_t *);
+static int pci_fun_offline(ddf_fun_t *);
 
 /** PCI bus driver standard operations */
 static driver_ops_t pci_ops = {
-        .add_device = &pci_add_device
+        .add_device = &pci_add_device,
+        .fun_online = &pci_fun_online,
+        .fun_offline = &pci_fun_offline,
 };
 
@@ -109 +222 @@
 };
 
-static pci_bus_t *pci_bus_new(void)
-{
-        pci_bus_t *bus;
-        
-        bus = (pci_bus_t *) calloc(1, sizeof(pci_bus_t));
-        if (bus == NULL)
-                return NULL;
-        
-        fibril_mutex_initialize(&bus->conf_mutex);
-        return bus;
-}
-
-static void pci_bus_delete(pci_bus_t *bus)
-{
-        assert(bus != NULL);
-        free(bus);
-}
-
 static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
 {
@@ -133 +228 @@
         fibril_mutex_lock(&bus->conf_mutex);
         
-        uint32_t conf_addr;
-        conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         void *addr = bus->conf_data_port + (reg & 3);
         
@@ -219 +313 @@
 void pci_fun_create_match_ids(pci_fun_t *fun)
 {
-        char *match_id_str;
         int rc;
-        
-        asprintf(&match_id_str, "pci/ven=%04x&dev=%04x",
+        char match_id_str[ID_MAX_STR_LEN];
+
+        /* Vendor ID & Device ID, length(incl \0) 22 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN, "pci/ven=%04x&dev=%04x",
             fun->vendor_id, fun->device_id);
-
-        if (match_id_str == NULL) {
-                ddf_msg(LVL_ERROR, "Out of memory creating match ID.");
-                return;
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
         }
 
         rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 90);
         if (rc != EOK) {
-                ddf_msg(LVL_ERROR, "Failed adding match ID: %s",
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, prog IF, revision, length(incl \0) 47 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x&progif=%02x&revision=%02x",
+            fun->class_code, fun->subclass_code, fun->prog_if, fun->revision);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
                     str_error(rc));
         }
-        
-        /* TODO add more ids (with subsys ids, using class id etc.) */
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 70);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, prog IF, length(incl \0) 35 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x&progif=%02x",
+            fun->class_code, fun->subclass_code, fun->prog_if);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 60);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, subclass, length(incl \0) 25 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN,
+            "pci/class=%02x&subclass=%02x",
+            fun->class_code, fun->subclass_code);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 50);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* Class, length(incl \0) 13 */
+        rc = snprintf(match_id_str, ID_MAX_STR_LEN, "pci/class=%02x",
+            fun->class_code);
+        if (rc < 0) {
+                ddf_msg(LVL_ERROR, "Failed creating match ID str: %s",
+                    str_error(rc));
+        }
+
+        rc = ddf_fun_add_match_id(fun->fnode, match_id_str, 40);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "Failed adding match ID: %s", str_error(rc));
+        }
+
+        /* TODO add subsys ids, but those exist only in header type 0 */
 }
 
@@ -288 +436 @@
         /* Get the value of the BAR. */
         val = pci_conf_read_32(fun, addr);
+
+#define IO_MASK  (~0x3)
+#define MEM_MASK (~0xf)
         
         io = (bool) (val & 1);
         if (io) {
                 addrw64 = false;
+                mask = IO_MASK;
         } else {
+                mask = MEM_MASK;
                 switch ((val >> 1) & 3) {
                 case 0:
@@ -308 +461 @@
         /* Get the address mask. */
         pci_conf_write_32(fun, addr, 0xffffffff);
-        mask = pci_conf_read_32(fun, addr);
+        mask &= pci_conf_read_32(fun, addr);
         
         /* Restore the original value. */
@@ -382 +535 @@
                 for (fnum = 0; multi && fnum < 8; fnum++) {
                         pci_fun_init(fun, bus_num, dnum, fnum);
-                        fun->vendor_id = pci_conf_read_16(fun,
-                            PCI_VENDOR_ID);
-                        fun->device_id = pci_conf_read_16(fun,
-                            PCI_DEVICE_ID);
                         if (fun->vendor_id == 0xffff) {
                                 /*
@@ -412 +561 @@
                         
                         fnode = ddf_fun_create(bus->dnode, fun_inner, fun_name);
+                        free(fun_name);
                         if (fnode == NULL) {
                                 ddf_msg(LVL_ERROR, "Failed creating function.");
@@ -417 +567 @@
                         }
                         
-                        free(fun_name);
                         fun->fnode = fnode;
                         
@@ -469 +618 @@
         
         ddf_msg(LVL_DEBUG, "pci_add_device");
-        dnode->parent_phone = -1;
-        
-        bus = pci_bus_new();
+        dnode->parent_sess = NULL;
+        
+        bus = ddf_dev_data_alloc(dnode, sizeof(pci_bus_t));
         if (bus == NULL) {
                 ddf_msg(LVL_ERROR, "pci_add_device allocation failed.");
@@ -477 +626 @@
                 goto fail;
         }
+        fibril_mutex_initialize(&bus->conf_mutex);
+
         bus->dnode = dnode;
         dnode->driver_data = bus;
         
-        dnode->parent_phone = devman_parent_device_connect(dnode->handle,
-            IPC_FLAG_BLOCKING);
-        if (dnode->parent_phone < 0) {
+        dnode->parent_sess = devman_parent_device_connect(EXCHANGE_SERIALIZE,
+            dnode->handle, IPC_FLAG_BLOCKING);
+        if (!dnode->parent_sess) {
                 ddf_msg(LVL_ERROR, "pci_add_device failed to connect to the "
-                    "parent's driver.");
-                rc = dnode->parent_phone;
+                    "parent driver.");
+                rc = ENOENT;
                 goto fail;
         }
@@ -491 +642 @@
         hw_resource_list_t hw_resources;
         
-        rc = hw_res_get_resource_list(dnode->parent_phone, &hw_resources);
+        rc = hw_res_get_resource_list(dnode->parent_sess, &hw_resources);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "pci_add_device failed to get hw resources "
@@ -542 +693 @@
         
 fail:
-        if (bus != NULL)
-                pci_bus_delete(bus);
-        if (dnode->parent_phone >= 0)
-                async_hangup(dnode->parent_phone);
+        if (dnode->parent_sess)
+                async_hangup(dnode->parent_sess);
+        
         if (got_res)
                 hw_res_clean_resource_list(&hw_resources);
+        
         if (ctl != NULL)
                 ddf_fun_destroy(ctl);
-
+        
         return rc;
+}
+
+static int pci_fun_online(ddf_fun_t *fun)
+{
+        ddf_msg(LVL_DEBUG, "pci_fun_online()");
+        return ddf_fun_online(fun);
+}
+
+static int pci_fun_offline(ddf_fun_t *fun)
+{
+        ddf_msg(LVL_DEBUG, "pci_fun_offline()");
+        return ddf_fun_offline(fun);
 }
 
@@ -558 +721 @@
         ddf_log_init(NAME, LVL_ERROR);
         pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
+        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
 }
 
@@ -577 +741 @@
         fun->dev = dev;
         fun->fn = fn;
+        fun->vendor_id = pci_conf_read_16(fun, PCI_VENDOR_ID);
+        fun->device_id = pci_conf_read_16(fun, PCI_DEVICE_ID);
+        fun->class_code = pci_conf_read_8(fun, PCI_BASE_CLASS);
+        fun->subclass_code = pci_conf_read_8(fun, PCI_SUB_CLASS);
+        fun->prog_if = pci_conf_read_8(fun, PCI_PROG_IF);
+        fun->revision = pci_conf_read_8(fun, PCI_REVISION_ID);
 }
 
@@ -597 +767 @@
 bool pci_alloc_resource_list(pci_fun_t *fun)
 {
-        fun->hw_resources.resources =
-            (hw_resource_t *) malloc(PCI_MAX_HW_RES * sizeof(hw_resource_t));
-        return fun->hw_resources.resources != NULL;
+        fun->hw_resources.resources = fun->resources;
+        return true;
 }
 
 void pci_clean_resource_list(pci_fun_t *fun)
 {
-        if (fun->hw_resources.resources != NULL) {
-                free(fun->hw_resources.resources);
-                fun->hw_resources.resources = NULL;
-        }
+        fun->hw_resources.resources = NULL;
 }
 
@@ -629 +795 @@
 size_t pci_bar_mask_to_size(uint32_t mask)
 {
-        return ((mask & 0xfffffff0) ^ 0xffffffff) + 1;
+        size_t size = mask & ~(mask - 1);
+        return size;
 }