l4re-base-25.08.0

src/l4/pkg/examples/sys/isr/Makefile

@@ -0,0 +1,9 @@
+PKGDIR		?= ..
+L4DIR		?= $(PKGDIR)/../../..
+
+TARGET		= ex_isr
+SRC_C		= main.c
+REQUIRES_LIBS   = l4re_c-util
+DEPENDS_PKGS    = $(REQUIRES_LIBS)
+
+include $(L4DIR)/mk/prog.mk

src/l4/pkg/examples/sys/isr/main.c

@@ -0,0 +1,147 @@
+/*
+ * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
+ *               Alexander Warg <warg@os.inf.tu-dresden.de>,
+ *               Björn Döbel <doebel@os.inf.tu-dresden.de>
+ *     economic rights: Technische Universität Dresden (Germany)
+ *
+ * This file is part of TUD:OS and distributed under the terms of the
+ * GNU General Public License 2.
+ * Please see the COPYING-GPL-2 file for details.
+ */
+/*
+ * This example shall show how to connect to an interrupt, receive interrupt
+ * events and detach again. As the interrupt source we'll use the virtual
+ * key interrupt -- pin 0 of the log capability.
+ */
+
+#include <l4/re/c/util/cap_alloc.h>
+#include <l4/re/c/namespace.h>
+#include <l4/sys/factory.h>
+#include <l4/sys/icu.h>
+#include <l4/sys/irq.h>
+#include <l4/sys/vcon.h>
+#include <l4/sys/utcb.h>
+
+#include <stdio.h>
+
+int main(void)
+{
+  int const irqno = 0;
+  l4_cap_idx_t irqcap, icucap;
+  l4_vcon_attr_t attr;
+  long err;
+
+  icucap = l4re_env()->log;
+
+  /* Get a free capability slot for the ICU capability. */
+  if (l4_is_invalid_cap(icucap))
+    {
+      printf("Did not find the Vlog ICU.\n");
+      return 1;
+    }
+
+  /* Get another free capability slot for the corresponding IRQ object. */
+  if (l4_is_invalid_cap(irqcap = l4re_util_cap_alloc()))
+    {
+      printf("Cannot allocate capability slot.\n");
+      return 1;
+    }
+
+  /* Create IRQ object. */
+  if ((err = l4_error(l4_factory_create_irq(l4re_env()->factory, irqcap))))
+    {
+      printf("Could not create IRQ object: %ld (%s).\n", err, l4sys_errtostr(err));
+      return 1;
+    }
+
+  /*
+   * Bind the recently allocated IRQ object to the IRQ number irqno as provided
+   * by the ICU.
+   */
+  if ((err = l4_error(l4_icu_bind(icucap, irqno, irqcap))))
+    {
+      printf("Could not bind IRQ%d to ICU: %ld (%s).\n", irqno, err, l4sys_errtostr(err));
+      return 1;
+    }
+
+  if ((err = l4_error(l4_vcon_get_attr(icucap, &attr))))
+    {
+      printf("Could not get Vcon attributes: %ld (%s).\n", err, l4sys_errtostr(err));
+      return 1;
+    }
+
+  /* Disable echo at Vcon console. */
+  attr.l_flags &= ~L4_VCON_ECHO;
+
+  if ((err = l4_error(l4_vcon_set_attr(icucap, &attr))))
+    {
+      printf("Could not set Vcon attributes: %ld (%s).\n", err, l4sys_errtostr(err));
+      return 1;
+    }
+
+  printf("Vcon echo disabled.\n");
+
+  /* Bind ourselves to the IRQ. Define the IPC label which is sent if an IRQ
+   * IPC arrives. */
+  if ((err = l4_error(l4_rcv_ep_bind_thread(irqcap, l4re_env()->main_thread, 0x1234))))
+    {
+      printf("Could not bind to IRQ%d: %ld (%s).\n", irqno, err, l4sys_errtostr(err));
+      return 1;
+    }
+
+  printf("Attached to key IRQ %d.\nPress keys now, Shift-Q to exit.\n", irqno);
+
+  /* IRQ receive loop. */
+  while (1)
+    {
+      /* Wait for the interrupt to happen. If we received an IRQ, the label
+       * return code is set to 0. If we didn't receive an IRQ, the error flag
+       * in the message tag is set and l4_error() reads the IPC error code from
+       * the UTCB. */
+      l4_umword_t label;
+      if ((err = l4_error(l4_irq_wait(irqcap, &label, L4_IPC_NEVER))))
+        printf("Could not receive IRQ: %ld (%s).\n", err, l4sys_errtostr(err));
+      else
+        {
+          char buf[128];
+          int n;
+
+          if (label != 0x1234)
+            {
+              printf("Unexpected label %0lx -- ignoring interrupt.\n", label);
+              continue;
+            }
+
+          /* Process the interrupt -- may do a 'break' */
+          printf("Got IRQ with expected label 0x%lX.\n", label);
+          n = l4_vcon_read(icucap, buf, sizeof(buf));
+          if (n < 0)
+            printf("Could not read from Vcon interface: %d (%s).\n", n, l4sys_errtostr(n));
+          else
+            {
+              unsigned i;
+              int terminate = 0;
+              for (i = 0; i < (unsigned)n && i < sizeof(buf); ++i)
+                {
+                  int c = (unsigned char)buf[i];
+                  if (c >= 32 && c < 128) // Filter UTF-8 encodings.
+                    printf("Got key '%c'.\n", c);
+                  else
+                    printf("Got keycode %d.\n", c);
+                  if (buf[i] == 'Q')
+                    terminate = 1;
+                }
+
+              if (terminate)
+                break;
+            }
+        }
+    }
+
+  /* We're done, detach from the interrupt. */
+  if ((err = l4_error(l4_irq_detach(irqcap))))
+    printf("Could not detach from IRQ: %ld (%s).\n", err, l4sys_errtostr(err));
+
+  printf("Application terminated.\n");
+  return 0;
+}