Changeset fefc27d in mainline

Timestamp:

2011-04-03T10:15:39Z (14 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

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

Children:

6c399765

Parents:

4fbcd2a (diff), b8f7a0d2 (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 with usb/development

Location:

uspace

Files:

• drv/ohci/hc.c (modified) (6 diffs)
• drv/ohci/hc.h (modified) (2 diffs)
• drv/ohci/iface.c (modified) (2 diffs)
• drv/ohci/ohci_regs.h (modified) (2 diffs)
• drv/ohci/root_hub.c (modified) (4 diffs)
• drv/uhci-hcd/hc.c (modified) (1 diff)
• lib/usb/src/host/bandwidth.c (modified) (1 diff)

uspace/drv/ohci/hc.c

@@ -45 +45 @@
 
 static int interrupt_emulator(hc_t *instance);
+static void hc_gain_control(hc_t *instance);
+static void hc_init_hw(hc_t *instance);
 /*----------------------------------------------------------------------------*/
 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun)
@@ -77 +79 @@
         assert(instance);
         int ret = EOK;
+#define CHECK_RET_RETURN(ret, message...) \
+if (ret != EOK) { \
+        usb_log_error(message); \
+        return ret; \
+} else (void)0
 
         ret = pio_enable((void*)regs, reg_size, (void**)&instance->registers);
-        if (ret != EOK) {
-                usb_log_error("Failed to gain access to device registers.\n");
-                return ret;
-        }
+        CHECK_RET_RETURN(ret,
+            "Failed(%d) to gain access to device registers: %s.\n",
+            ret, str_error(ret));
+
         instance->ddf_instance = fun;
         usb_device_keeper_init(&instance->manager);
+        ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
+            bandwidth_count_usb11);
+        CHECK_RET_RETURN(ret, "Failed to initialize bandwidth allocator: %s.\n",
+            ret, str_error(ret));
 
         if (!interrupts) {
@@ -92 +103 @@
         }
 
+        hc_gain_control(instance);
+
         rh_init(&instance->rh, dev, instance->registers);
+
+        hc_init_hw(instance);
 
         /* TODO: implement */
@@ -117 +132 @@
                 rh_interrupt(&instance->rh);
 
+        usb_log_info("OHCI interrupt: %x.\n", status);
+
         /* TODO: Check for further interrupt causes */
         /* TODO: implement */
@@ -126 +143 @@
         usb_log_info("Started interrupt emulator.\n");
         while (1) {
-                uint32_t status = instance->registers->interrupt_status;
+                const uint32_t status = instance->registers->interrupt_status;
                 instance->registers->interrupt_status = status;
                 hc_interrupt(instance, status);
@@ -133 +150 @@
         return EOK;
 }
+/*----------------------------------------------------------------------------*/
+void hc_gain_control(hc_t *instance)
+{
+        assert(instance);
+        /* Interrupt routing enabled => smm driver is active */
+        if (instance->registers->control & C_IR) {
+                usb_log_info("Found SMM driver requesting ownership change.\n");
+                instance->registers->command_status |= CS_OCR;
+                while (instance->registers->control & C_IR) {
+                        async_usleep(1000);
+                }
+                usb_log_info("Ownership taken from SMM driver.\n");
+                return;
+        }
+
+        const unsigned hc_status =
+            (instance->registers->control >> C_HCFS_SHIFT) & C_HCFS_MASK;
+        /* Interrupt routing disabled && status != USB_RESET => BIOS active */
+        if (hc_status != C_HCFS_RESET) {
+                usb_log_info("Found BIOS driver.\n");
+                if (hc_status == C_HCFS_OPERATIONAL) {
+                        usb_log_info("HC operational(BIOS).\n");
+                        return;
+                }
+                /* HC is suspended assert resume for 20ms */
+                instance->registers->control &= (C_HCFS_RESUME << C_HCFS_SHIFT);
+                async_usleep(20000);
+                return;
+        }
+
+        /* HC is in reset (hw startup) => no other driver
+         * maintain reset for at least the time specified in USB spec (50 ms)*/
+        async_usleep(50000);
+}
+/*----------------------------------------------------------------------------*/
+void hc_init_hw(hc_t *instance)
+{
+        assert(instance);
+        const uint32_t fm_interval = instance->registers->fm_interval;
+        instance->registers->command_status = CS_HCR;
+        async_usleep(10);
+        instance->registers->fm_interval = fm_interval;
+        assert((instance->registers->command_status & CS_HCR) == 0);
+        /* hc is now in suspend state */
+        /* TODO: init HCCA block */
+        /* TODO: init queues */
+        /* TODO: enable queues */
+        /* TODO: enable interrupts */
+        /* TODO: set periodic start to 90% */
+
+        instance->registers->control &= (C_HCFS_OPERATIONAL << C_HCFS_SHIFT);
+        usb_log_info("OHCI HC up and running.\n");
+}
 /**
  * @}

uspace/drv/ohci/hc.h

@@ -42 +42 @@
 #include <usb/usb.h>
 #include <usb/host/device_keeper.h>
+#include <usb/host/bandwidth.h>
 #include <usbhc_iface.h>
 
@@ -54 +55 @@
         ddf_fun_t *ddf_instance;
         usb_device_keeper_t manager;
+        bandwidth_t bandwidth;
         fid_t interrupt_emulator;
 } hc_t;

uspace/drv/ohci/iface.c

@@ -151 +151 @@
     size_t max_packet_size, unsigned int interval)
 {
-        UNSUPPORTED("register_endpoint");
-
-        return ENOTSUP;
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        if (address == hc->rh.address)
+                return EOK;
+        const usb_speed_t speed =
+                usb_device_keeper_get_speed(&hc->manager, address);
+        const size_t size = max_packet_size;
+        usb_log_debug("Register endpoint %d:%d %s %s(%d) %zu(%zu) %u.\n",
+            address, endpoint, usb_str_transfer_type(transfer_type),
+            usb_str_speed(speed), direction, size, max_packet_size, interval);
+        return bandwidth_reserve(&hc->bandwidth, address, endpoint, direction,
+            speed, transfer_type, max_packet_size, size, interval);
 }
 /*----------------------------------------------------------------------------*/
@@ -168 +178 @@
     usb_endpoint_t endpoint, usb_direction_t direction)
 {
-        UNSUPPORTED("unregister_endpoint");
+        assert(fun);
+        hc_t *hc = fun_to_hc(fun);
+        assert(hc);
+        usb_log_debug("Unregister endpoint %d:%d %d.\n",
+            address, endpoint, direction);
+        return bandwidth_release(&hc->bandwidth, address, endpoint, direction);
 
         return ENOTSUP;

uspace/drv/ohci/ohci_regs.h

@@ -39 +39 @@
 typedef struct ohci_regs
 {
-        volatile uint32_t revision;
+        const volatile uint32_t revision;
         volatile uint32_t control;
+#define C_CSBR_MASK (0x3)
+#define C_CSBR_SHIFT (0)
+#define C_PLE (1 << 2)
+#define C_IE (1 << 3)
+#define C_CLE (1 << 4)
+#define C_BLE (1 << 5)
+
+#define C_HCFS_MASK (0x3)
+#define C_HCFS_SHIFT (6)
+#define C_HCFS_RESET (0x0)
+#define C_HCFS_OPERATIONAL (0x1)
+#define C_HCFS_RESUME (0x2)
+#define C_HCFS_SUSPEND (0x3)
+
+#define C_IR (1 << 8)
+#define C_RWC (1 << 9)
+#define C_RWE (1 << 10)
+
         volatile uint32_t command_status;
+#define CS_HCR (1 << 0)
+#define CS_CLF (1 << 1)
+#define CS_BLF (1 << 2)
+#define CS_OCR (1 << 3)
+#define CS_SOC_MASK (0x3)
+#define CS_SOC_SHIFT (16)
+
         volatile uint32_t interrupt_status;
 #define IS_SO (1 << 0)
@@ -51 +76 @@
 #define IS_RHSC (1 << 6)
 #define IS_OC (1 << 30)
+
         volatile uint32_t interupt_enable;
 #define IE_SO   (1 << 0)

uspace/drv/ohci/root_hub.c

@@ -252 +252 @@
 
 
-        usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
+        usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
 
         //start generic usb hub driver
@@ -275 +275 @@
         if(port<1 || port>instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
         request->transfered_size = 4;
         uint32_buffer[0] = instance->registers->rh_port_status[port -1];
@@ -292 +292 @@
 static int process_get_hub_status_request(rh_t *instance,
                 usb_transfer_batch_t * request){
-        uint32_t * uint32_buffer = (uint32_t*)request->buffer;
+        uint32_t * uint32_buffer = (uint32_t*)request->transport_buffer;
         //bits, 0,1,16,17
         request->transfered_size = 4;
@@ -457 +457 @@
         if(request->buffer_size != 1)
                 return EINVAL;
-        request->buffer[0] = 1;
+        request->transport_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;

uspace/drv/uhci-hcd/hc.c

@@ -241 +241 @@
         ret = bandwidth_init(&instance->bandwidth, BANDWIDTH_AVAILABLE_USB11,
             bandwidth_count_usb11);
-        assert(ret == true);
+        assert(ret == EOK);
 
         return EOK;

uspace/lib/usb/src/host/bandwidth.c

@@ -127 +127 @@
         instance->free = bandwidth;
         instance->usage_fnc = usage_fnc;
-        return
+        bool ht =
             hash_table_create(&instance->reserved, BUCKET_COUNT, MAX_KEYS, &op);
+        return ht ? EOK : ENOMEM;
 }
 /*----------------------------------------------------------------------------*/