Changeset 733a9a8 in mainline

Timestamp:

2011-02-19T19:45:18Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

7e7f0f5

Parents:

e221ca0

Message:

Use hardware interrupts

Location:

uspace/drv/uhci-hcd

Files:

• main.c (modified) (4 diffs)
• uhci.c (modified) (6 diffs)
• uhci.h (modified) (1 diff)

uspace/drv/uhci-hcd/main.c

@@ -34 +34 @@
 #include <driver.h>
 #include <usb_iface.h>
+#include <ipc/irc.h>
+#include <ipc/ns.h>
+#include <ipc/services.h>
+#include <sysinfo.h>
 
 #include <errno.h>
@@ -76 +80 @@
 };
 /*----------------------------------------------------------------------------*/
+static irq_cmd_t uhci_cmds[] = {
+        {
+                .cmd = CMD_PIO_READ_16,
+                .addr = (void*)0xc022,
+                .dstarg = 1
+        },
+        {
+                .cmd = CMD_PIO_WRITE_16,
+                .addr = (void*)0xc022,
+                .value = 0x1f
+        },
+        {
+                .cmd = CMD_ACCEPT
+        }
+};
+/*----------------------------------------------------------------------------*/
+static irq_code_t uhci_code = {
+        sizeof(uhci_cmds) / sizeof(irq_cmd_t),
+        uhci_cmds
+};
+/*----------------------------------------------------------------------------*/
 static void irq_handler(device_t *device, ipc_callid_t iid, ipc_call_t *call)
 {
@@ -81 +106 @@
         uhci_t *hc = dev_to_uhci(device);
         usb_log_info("LOL HARDWARE INTERRUPT: %p.\n", hc);
+        uint16_t status = IPC_GET_ARG1(*call);
         assert(hc);
-        uhci_interrupt(hc);
+        uhci_interrupt(hc, status);
 }
 /*----------------------------------------------------------------------------*/
@@ -109 +135 @@
             io_reg_base, io_reg_size, irq);
 
-        ret = register_interrupt_handler(device, irq, irq_handler, NULL);
+
+  sysarg_t apic;
+  sysarg_t i8259;
+        int irc_phone = -1;
+        int irc_service = 0;
+
+  if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
+    irc_service = SERVICE_APIC;
+                usb_log_debug("SERVICE_APIC\n");
+        } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
+    irc_service = SERVICE_I8259;
+                usb_log_debug("SERVICE_I8259\n");
+        }
+
+  if (irc_service) {
+    while (irc_phone < 0)
+      irc_phone = service_connect_blocking(irc_service, 0, 0);
+  }
+        usb_log_debug("Interrupt conttroller phone: %d\n", irc_phone);
+
+        async_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, irq);
+//      async_hangup(irc_phone);
+
+        ret = register_interrupt_handler(device, irq, irq_handler, &uhci_code);
         usb_log_debug("Registered interrupt handler %d.\n", ret);
 

uspace/drv/uhci-hcd/uhci.c

@@ -58 +58 @@
 int uhci_init(uhci_t *instance, void *regs, size_t reg_size)
 {
-        int ret = uhci_init_mem_structures(instance);
-        CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
+        assert(reg_size >= sizeof(regs_t));
 
         /* allow access to hc control registers */
         regs_t *io;
-        assert(reg_size >= sizeof(regs_t));
-        ret = pio_enable(regs, reg_size, (void**)&io);
+        int ret = pio_enable(regs, reg_size, (void**)&io);
         CHECK_RET_RETURN(ret, "Failed to gain access to registers at %p.\n", io);
         instance->registers = io;
         usb_log_debug("Device registers accessible.\n");
 
+        ret = uhci_init_mem_structures(instance);
+        CHECK_RET_RETURN(ret, "Failed to initialize memory structures.\n");
+
+        uhci_init_hw(instance);
+
         instance->cleaner = fibril_create(uhci_interrupt_emulator, instance);
-        fibril_add_ready(instance->cleaner);
+//      fibril_add_ready(instance->cleaner);
 
         instance->debug_checker = fibril_create(uhci_debug_checker, instance);
         fibril_add_ready(instance->debug_checker);
 
-        uhci_init_hw(instance);
-
         return EOK;
 }
@@ -82 +83 @@
 void uhci_init_hw(uhci_t *instance)
 {
+
+        /* set framelist pointer */
         const uint32_t pa = addr_to_phys(instance->frame_list);
         pio_write_32(&instance->registers->flbaseadd, pa);
 
-        /* enable all interrupts */
+        /* enable all interrupts, but resume interrupt */
         pio_write_16(&instance->registers->usbintr,
                   UHCI_INTR_CRC | UHCI_INTR_COMPLETE | UHCI_INTR_SHORT_PACKET);
@@ -91 +94 @@
         /* Start the hc with large(64B) packet FSBR */
         pio_write_16(&instance->registers->usbcmd,
-            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET);
+            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
         usb_log_debug("Started UHCI HC.\n");
 }
@@ -189 +192 @@
 }
 /*----------------------------------------------------------------------------*/
-void uhci_interrupt(uhci_t *instance)
-{
-        assert(instance);
-        const uint16_t sts = pio_read_16(&instance->registers->usbsts);
-        if ((sts & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
+void uhci_interrupt(uhci_t *instance, uint16_t status)
+{
+        assert(instance);
+        if ((status & (UHCI_STATUS_INTERRUPT | UHCI_STATUS_ERROR_INTERRUPT)) == 0)
                 return;
-        usb_log_debug("UHCI interrupt: %X.\n", sts);
+        usb_log_debug("UHCI interrupt: %X.\n", status);
         transfer_list_check(&instance->transfers_interrupt);
         transfer_list_check(&instance->transfers_control_slow);
         transfer_list_check(&instance->transfers_control_full);
         transfer_list_check(&instance->transfers_bulk_full);
-        pio_write_16(&instance->registers->usbsts, 0xf);
 }
 /*----------------------------------------------------------------------------*/
 int uhci_interrupt_emulator(void* arg)
 {
-        return EOK;
         usb_log_debug("Started interrupt emulator.\n");
         uhci_t *instance = (uhci_t*)arg;
@@ -211 +211 @@
 
         while(1) {
-                uhci_interrupt(instance);
+                uint16_t status = pio_read_16(&instance->registers->usbsts);
+                uhci_interrupt(instance, status);
                 async_usleep(UHCI_CLEANER_TIMEOUT);
         }
@@ -229 +230 @@
 
                 uintptr_t frame_list = pio_read_32(&instance->registers->flbaseadd);
-                if (frame_list != (uintptr_t)addr_to_phys(instance->frame_list)) {
+                if (frame_list != addr_to_phys(instance->frame_list)) {
                         usb_log_debug("Framelist address: %p vs. %p.\n",
                                 frame_list, addr_to_phys(instance->frame_list));

uspace/drv/uhci-hcd/uhci.h

@@ -117 +117 @@
 int uhci_schedule(uhci_t *instance, batch_t *batch);
 
-void uhci_interrupt(uhci_t *instance);
+void uhci_interrupt(uhci_t *instance, uint16_t status);
 
 static inline uhci_t * dev_to_uhci(device_t *dev)