Changeset a333b7f in mainline for uspace/drv/audio/hdaudio/hdactl.c

Timestamp:

2014-08-25T09:28:39Z (10 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

932e2f5

Parents:

1412a184

Message:

Interrupt handling - RIRB interrupts.

File:

• uspace/drv/audio/hdaudio/hdactl.c (modified) (10 diffs)

uspace/drv/audio/hdaudio/hdactl.c

@@ -39 +39 @@
 #include <ddi.h>
 #include <errno.h>
+#include <fibril_synch.h>
 #include <macros.h>
 #include <stdint.h>
@@ -222 +223 @@
 
         /* Set RINTCNT - Qemu won't read from CORB if this is zero */
-        hda_reg16_write(&hda->regs->rintcnt, 128);
+        hda_reg16_write(&hda->regs->rintcnt, hda->ctl->rirb_entries / 2);
 
         hda->ctl->rirb_rp = 0;
 
-        /* Start RIRB */
+        /* Start RIRB and enable RIRB interrupt */
         ctl = hda_reg8_read(&hda->regs->rirbctl);
         ddf_msg(LVL_NOTE, "RIRBctl (0x%x) = 0x%x",
             (unsigned)((void *)&hda->regs->rirbctl - (void *)hda->regs), ctl | BIT_V(uint8_t, rirbctl_run));
-        hda_reg8_write(&hda->regs->rirbctl, ctl | BIT_V(uint8_t, rirbctl_run));
+        hda_reg8_write(&hda->regs->rirbctl, ctl | BIT_V(uint8_t, rirbctl_run) |
+            BIT_V(uint8_t, rirbctl_int));
 
         ddf_msg(LVL_NOTE, "RIRB initialized");
@@ -327 +329 @@
 }
 
-static int hda_rirb_read(hda_t *hda, hda_rirb_entry_t *data, size_t count)
+static int hda_rirb_read(hda_t *hda, hda_rirb_entry_t *data)
 {
         size_t wp;
         hda_rirb_entry_t resp;
         hda_rirb_entry_t *rirb;
+
+        rirb = (hda_rirb_entry_t *)hda->ctl->rirb_virt;
+
+        wp = hda_get_rirbwp(hda);
+        ddf_msg(LVL_DEBUG2, "hda_rirb_read: wp=%d", wp);
+        if (hda->ctl->rirb_rp == wp)
+                return ENOENT;
+
+        ++hda->ctl->rirb_rp;
+        resp = rirb[hda->ctl->rirb_rp];
+
+        ddf_msg(LVL_DEBUG2, "RESPONSE resp=0x%x respex=0x%x",
+            resp.resp, resp.respex);
+        *data = resp;
+        return EOK;
+}
+
+static int hda_solrb_read(hda_t *hda, hda_rirb_entry_t *data, size_t count)
+{
+        hda_rirb_entry_t resp;
         int wcnt;
 
-        rirb = (hda_rirb_entry_t *)hda->ctl->rirb_virt;
+        wcnt = 10;
+
+        fibril_mutex_lock(&hda->ctl->solrb_lock);
 
         while (count > 0) {
-                wp = hda_get_rirbwp(hda);
-                ddf_msg(LVL_DEBUG2, "hda_rirb_read: wp=%d", wp);
-                while (count > 0 && hda->ctl->rirb_rp != wp) {
-                        ++hda->ctl->rirb_rp;
-                        resp = rirb[hda->ctl->rirb_rp];
-
-                        ddf_msg(LVL_DEBUG2, "RESPONSE resp=0x%x respex=0x%x",
+                while (count > 0 && hda->ctl->solrb_rp != hda->ctl->solrb_wp) {
+                        ++hda->ctl->solrb_rp;
+                        resp = hda->ctl->solrb[hda->ctl->solrb_rp];
+
+                        ddf_msg(LVL_DEBUG2, "solrb RESPONSE resp=0x%x respex=0x%x",
                             resp.resp, resp.respex);
                         if ((resp.respex & BIT_V(uint32_t, respex_unsol)) == 0) {
@@ -353 +375 @@
 
                 if (count > 0) {
-                        wcnt = rirb_wait_max;
-                        while (wcnt > 0 && hda_get_rirbwp(hda) == hda->ctl->rirb_rp) {
+                        while (wcnt > 0 && hda->ctl->solrb_wp == hda->ctl->solrb_rp) {
+                                fibril_mutex_unlock(&hda->ctl->solrb_lock);
                                 async_usleep(100);
+                                fibril_mutex_lock(&hda->ctl->solrb_lock);
                                 --wcnt;
                         }
 
-                        if (hda_get_rirbwp(hda) == hda->ctl->rirb_rp)
+                        if (hda->ctl->solrb_wp == hda->ctl->solrb_rp) {
+                                ddf_msg(LVL_NOTE, "hda_solrb_read() time out");
+                                fibril_mutex_unlock(&hda->ctl->solrb_lock);
                                 return ETIMEOUT;
-                }
-        }
-
+                        }
+                }
+        }
+
+        fibril_mutex_unlock(&hda->ctl->solrb_lock);
         return EOK;
 }
@@ -371 +398 @@
         hda_ctl_t *ctl;
         uint32_t gctl;
+        uint32_t intctl;
         int cnt;
         int rc;
@@ -378 +406 @@
                 return NULL;
 
+        fibril_mutex_initialize(&ctl->solrb_lock);
+        fibril_condvar_initialize(&ctl->solrb_cv);
+
         hda->ctl = ctl;
+        ctl->hda = hda;
 
         uint8_t vmaj = hda_reg8_read(&hda->regs->vmaj);
@@ -391 +423 @@
 
         ddf_msg(LVL_NOTE, "reg 0x%zx STATESTS = 0x%x",
-            (void *)&hda->regs->statests - (void *)hda->regs, hda_reg16_read(&hda->regs->statests));
+            (void *)&hda->regs->statests - (void *)hda->regs,
+                hda_reg16_read(&hda->regs->statests));
+        /**
+          * Clear STATESTS bits so they don't generate an interrupt later
+          * when we enable interrupts.
+          */
+        hda_reg16_write(&hda->regs->statests, 0x7f);
+
+        ddf_msg(LVL_NOTE, "after clearing reg 0x%zx STATESTS = 0x%x",
+            (void *)&hda->regs->statests - (void *)hda->regs,
+                hda_reg16_read(&hda->regs->statests));
 
         gctl = hda_reg32_read(&hda->regs->gctl);
@@ -437 +479 @@
             hda_reg16_read(&hda->regs->statests));
 
+        async_usleep(1000*1000);
+
+        /* Enable interrupts */
+        intctl = hda_reg32_read(&hda->regs->intctl);
+        ddf_msg(LVL_NOTE, "intctl (0x%x) := 0x%x",
+            (unsigned)((void *)&hda->regs->intctl - (void *)hda->regs),
+            intctl | BIT_V(uint32_t, intctl_gie) | BIT_V(uint32_t, intctl_cie));
+        hda_reg32_write(&hda->regs->intctl, intctl |
+            BIT_V(uint32_t, intctl_gie) | BIT_V(uint32_t, intctl_cie));
+
+        async_usleep(1000*1000);
+
         rc = hda_corb_init(hda);
         if (rc != EOK)
                 goto error;
 
+
+        async_usleep(1000*1000);
+
         rc = hda_rirb_init(hda);
         if (rc != EOK)
                 goto error;
 
+        async_usleep(1000*1000);
+
+        ddf_msg(LVL_NOTE, "call hda_codec_init()");
         hda->ctl->codec = hda_codec_init(hda, 0);
-        if (hda->ctl->codec == NULL)
-                goto error;
+        if (hda->ctl->codec == NULL) {
+                ddf_msg(LVL_NOTE, "hda_codec_init() failed");
+                goto error;
+        }
 
         return ctl;
@@ -466 +528 @@
 
         if (resp != NULL) {
-                rc = hda_rirb_read(hda, &rentry, 1);
+                rc = hda_solrb_read(hda, &rentry, 1);
                 if (rc != EOK)
                         return rc;
@@ -483 +545 @@
 }
 
+void hda_ctl_interrupt(hda_ctl_t *ctl)
+{
+        hda_rirb_entry_t resp;
+        int rc;
+
+        while (true) {
+                rc = hda_rirb_read(ctl->hda, &resp);
+                if (rc != EOK) {
+//                      ddf_msg(LVL_NOTE, "nothing in rirb");
+                        break;
+                }
+
+                ddf_msg(LVL_NOTE, "writing to solrb");
+                fibril_mutex_lock(&ctl->solrb_lock);
+                ctl->solrb_wp = (ctl->solrb_wp + 1) % softrb_entries;
+                ctl->solrb[ctl->solrb_wp] = resp;
+                fibril_mutex_unlock(&ctl->solrb_lock);
+                fibril_condvar_broadcast(&ctl->solrb_cv);
+        }
+}
+
 /** @}
  */