Changeset 832cbe7 in mainline for uspace/drv/bus

Timestamp:

2025-02-05T12:30:20Z (13 months ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

master

Children:

accdf882

Parents:

0dab4850

git-author:

Jiri Svoboda <jiri@…> (2025-02-04 21:30:06)

git-committer:

Jiri Svoboda <jiri@…> (2025-02-05 12:30:20)

Message:

Add proper IDE PCI to ISA fallback mechanism.

To determine if legacy IDE I/O ports are free, isa-ide asks isa,
who asks pciintel. pciintel waits for bus enumeration to complete,
then waits for all functions except the one who is asking
(which is ISA bus) to stabilize. During attach pci-ide will claim
the legacy IDE ports. Thus, if at this point legacy IDE ports
are unclaimed, pciintel tells ISA they are free, which tells isa-ide,
which continues to attach. If they are not free, isa-ide will not
attach.

This works for all use cases, including system without PCI bus,
system with PCI bus, but no (or disabled) PCI IDE, system with PCI
IDE with unrecognized VID/PID (which we will handle in legacy ISA mode).

Location:

uspace/drv/bus

Files:

• isa/isa.c (modified) (3 diffs)
• pci/pciintel/pci.c (modified) (5 diffs)
• pci/pciintel/pci.h (modified) (4 diffs)

uspace/drv/bus/isa/isa.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2024 Jiri Svoboda
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * Copyright (c) 2011 Jan Vesely
@@ -206 +206 @@
 }
 
-static errno_t isa_fun_get_flags(ddf_fun_t *fnode, hw_res_flags_t *rflags)
+/** Handle legacy IO availability query from function.
+ *
+ * @param fnode Function performing the query
+ * @param rclaims Place to store the legacy IO claims bitmask
+ * @return EOK on success or an error code
+ */
+static errno_t isa_fun_query_legacy_io(ddf_fun_t *fnode,
+    hw_res_claims_t *rclaims)
 {
         isa_fun_t *fun = isa_fun(fnode);
-        hw_res_flags_t flags;
-
-        flags = 0;
-        if (fun->bus->pci_isa_bridge)
-                flags |= hwf_isa_bridge;
-
-        ddf_msg(LVL_NOTE, "isa_fun_get_flags: returning 0x%x", flags);
-        *rflags = flags;
+        hw_res_claims_t claims;
+        async_sess_t *sess;
+        errno_t rc;
+
+        ddf_msg(LVL_DEBUG, "isa_fun_query_legacy_io()");
+
+        sess = ddf_dev_parent_sess_get(fun->bus->dev);
+        if (sess == NULL) {
+                ddf_msg(LVL_ERROR, "isa_dev_add failed to connect to the "
+                    "parent driver.");
+                return ENOENT;
+        }
+
+        if (!fun->bus->pci_isa_bridge) {
+                ddf_msg(LVL_NOTE, "isa_fun_query_legacy_io: classic ISA - "
+                    "legacy IDE range is available");
+                /* Classic ISA, we can be sure IDE is unclaimed by PCI */
+                claims = 0;
+        } else {
+                ddf_msg(LVL_NOTE, "isa_fun_query_legacy_io: ISA bridge - "
+                    "determine legacy IDE availability from PCI bus driver");
+                rc = hw_res_query_legacy_io(sess, &claims);
+                if (rc != EOK) {
+                        ddf_msg(LVL_NOTE, "Error querying legacy IO claims.");
+                        return rc;
+                }
+        }
+
+        ddf_msg(LVL_DEBUG, "isa_fun_query_legacy_io: returning 0x%x", claims);
+        *rclaims = claims;
         return EOK;
 }
@@ -227 +256 @@
         .dma_channel_setup = isa_fun_setup_dma,
         .dma_channel_remain = isa_fun_remain_dma,
-        .get_flags = isa_fun_get_flags
+        .query_legacy_io = isa_fun_query_legacy_io
 };
 

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

@@ -1 +1 @@
 /*
- * Copyright (c) 2019 Jiri Svoboda
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * All rights reserved.
@@ -143 +143 @@
 }
 
+/** Handle legacy IO availability query from function.
+ *
+ * @param fnode Function performing the query
+ * @param rclaims Place to store the legacy IO claims bitmask
+ * @return EOK on success or an error code
+ */
+static errno_t pciintel_query_legacy_io(ddf_fun_t *fnode,
+    hw_res_claims_t *rclaims)
+{
+        pci_fun_t *fun = pci_fun(fnode);
+        pci_bus_t *bus = fun->busptr;
+        pci_fun_t *f;
+        hw_res_claims_t claims;
+
+        /*
+         * We need to wait for enumeration to complete so that we give
+         * the PCI IDE driver a chance to claim the legacy ISA IDE
+         * ranges.
+         */
+        ddf_msg(LVL_DEBUG, "pciintel_query_legacy_io");
+
+        fun->querying = true;
+
+        fibril_mutex_lock(&bus->enum_done_lock);
+        while (!bus->enum_done)
+                fibril_condvar_wait(&bus->enum_done_cv, &bus->enum_done_lock);
+        fibril_mutex_unlock(&bus->enum_done_lock);
+
+        ddf_msg(LVL_DEBUG, "Wait for PCI devices to stabilize");
+
+        f = pci_fun_first(bus);
+        while (f != NULL) {
+                if (!f->querying)
+                        ddf_fun_wait_stable(f->fnode);
+                f = pci_fun_next(f);
+        }
+
+        /* Devices are stable. Now we can determine if ISA IDE was claimed. */
+
+        claims = 0;
+
+        ddf_msg(LVL_DEBUG, "PCI devices stabilized, leg_ide_claimed=%d\n",
+            (int)bus->leg_ide_claimed);
+        if (bus->leg_ide_claimed != false) {
+                ddf_msg(LVL_NOTE, "Legacy IDE I/O ports claimed by PCI driver.");
+                claims |= hwc_isa_ide;
+        }
+
+        fun->querying = false;
+        *rclaims = claims;
+        return EOK;
+}
+
+/** Handle legacy IO claim from function.
+ *
+ * @param fnode Function claiming the legacy I/O ports
+ * @param claims Bitmask of claimed I/O
+ * @return EOK on success or an error code
+ */
+static errno_t pciintel_claim_legacy_io(ddf_fun_t *fnode,
+    hw_res_claims_t claims)
+{
+        pci_fun_t *fun = pci_fun(fnode);
+        pci_bus_t *bus = fun->busptr;
+
+        ddf_msg(LVL_DEBUG, "pciintel_claim_legacy_io() claims=%x", claims);
+        if ((claims & hwc_isa_ide) != 0)
+                bus->leg_ide_claimed = true;
+
+        return EOK;
+}
+
 static pio_window_t *pciintel_get_pio_window(ddf_fun_t *fnode)
 {
@@ -211 +283 @@
         .disable_interrupt = &pciintel_disable_interrupt,
         .clear_interrupt = &pciintel_clear_interrupt,
+        .query_legacy_io = &pciintel_query_legacy_io,
+        .claim_legacy_io = &pciintel_claim_legacy_io
 };
 
@@ -755 +829 @@
         list_initialize(&bus->funs);
         fibril_mutex_initialize(&bus->conf_mutex);
+        fibril_mutex_initialize(&bus->enum_done_lock);
+        fibril_condvar_initialize(&bus->enum_done_cv);
 
         bus->dnode = dnode;
@@ -863 +939 @@
         hw_res_clean_resource_list(&hw_resources);
 
+        ddf_msg(LVL_DEBUG, "Bus enumeration done.");
+
+        fibril_mutex_lock(&bus->enum_done_lock);
+        bus->enum_done = true;
+        fibril_mutex_unlock(&bus->enum_done_lock);
+        fibril_condvar_broadcast(&bus->enum_done_cv);
+
         return EOK;
-
 fail:
         if (got_res)

uspace/drv/bus/pci/pciintel/pci.h

@@ -1 +1 @@
 /*
+ * Copyright (c) 2025 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
- * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +41 @@
 #include <ddf/driver.h>
 #include <fibril_synch.h>
+#include <stdbool.h>
 
 #define PCI_MAX_HW_RES 10
@@ -54 +55 @@
         /** List of functions (of pci_fun_t) */
         list_t funs;
+        /** Enumeration is done */
+        bool enum_done;
+        /** Synchronize enum_done */
+        fibril_mutex_t enum_done_lock;
+        /** Signal change to enum_done */
+        fibril_condvar_t enum_done_cv;
+        /** @c true iff legacy IDE range is claimed by PCI IDE driver */
+        bool leg_ide_claimed;
 } pci_bus_t;
 
@@ -72 +81 @@
         uint8_t prog_if;
         uint8_t revision;
+        bool querying;
         hw_resource_list_t hw_resources;
         hw_resource_t resources[PCI_MAX_HW_RES];