Changeset 4d0c40b in mainline

Timestamp:

2011-03-22T22:30:55Z (13 years ago)

Author:

Matus Dekanek <smekideki@…>

Branches:

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

Children:

d8421c4

Parents:

41ef5b9

Message:

ohci root hub implementation basis, missing descriptors and interrupt transfer

Location:

uspace/drv

Files:

• ohci/root_hub.c (modified) (2 diffs)
• ohci/root_hub.h (modified) (1 diff)
• usbhub/port_status.h (modified) (2 diffs)
• usbhub/usbhub.c (modified) (1 diff)

uspace/drv/ohci/root_hub.c

@@ -39 +39 @@
 
 #include "root_hub.h"
+#include <usb/request.h>
+#include <usb/classes/hub.h>
+
 
 /** Root hub initialization
@@ -50 +53 @@
         instance->device = dev;
 
+
         usb_log_info("OHCI root hub with %d ports.\n", regs->rh_desc_a & 0xff);
 
+        //start generic usb hub driver
+        
         /* TODO: implement */
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+
+
+static int process_get_port_status_request(rh_t *instance, uint16_t port,
+                char * buffer){
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        uint32_t * uint32_buffer = (uint32_t*)buffer;
+        uint32_buffer[0] = instance->registers->rh_port_status[port -1];
+        return EOK;
+}
+
+static int process_get_hub_status_request(rh_t *instance,char * buffer){
+        uint32_t * uint32_buffer = (uint32_t*)buffer;
+        //bits, 0,1,16,17
+        uint32_t mask = 1 & (1<<1) & (1<<16) & (1<<17);
+        uint32_buffer[0] = mask & instance->registers->rh_status;
+        return EOK;
+
+}
+
+
+static int process_get_status_request(rh_t *instance,char * buffer,
+                size_t buffer_size, usb_device_request_setup_packet_t * request){
+
+        usb_hub_bm_request_type_t request_type = request->request_type;
+        if(buffer_size!=4) return EINVAL;
+        if(request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS)
+                return process_get_hub_status_request(instance, buffer);
+        if(request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS)
+                return process_get_port_status_request(instance, request->index,
+                                buffer);
+        return ENOTSUP;
+}
+
+static int process_get_descriptor_request(rh_t *instance,
+                usb_transfer_batch_t *request){
+        /// \TODO
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->value == USB_DESCTYPE_HUB){
+                //create hub descriptor
+        }else if(setup_request->value == USB_DESCTYPE_HUB){
+                //create std device descriptor
+        }else{
+                return EINVAL;
+        }
+        return EOK;
+}
+
+static int process_get_configuration_request(rh_t *instance, char * buffer,
+        size_t buffer_size
+){
+        //set and get configuration requests do not have any meaning, only dummy
+        //values are returned
+        if(buffer_size != 1)
+                return EINVAL;
+        buffer[0] = 1;
+        return EOK;
+}
+
+static int process_hub_feature_set_request(rh_t *instance,
+                uint16_t feature, bool enable){
+        if(feature > USB_HUB_FEATURE_C_HUB_OVER_CURRENT)
+                return EINVAL;
+        instance->registers->rh_status =
+                        enable ?
+                        (instance->registers->rh_status | (1<<feature))
+                        :
+                        (instance->registers->rh_status & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+}
+
+static int process_port_feature_set_request(rh_t *instance,
+                uint16_t feature, uint16_t port, bool enable){
+        if(feature > USB_HUB_FEATURE_C_PORT_RESET)
+                return EINVAL;
+        if(port<1 || port>instance->port_count)
+                return EINVAL;
+        instance->registers->rh_port_status[port - 1] =
+                        enable ?
+                        (instance->registers->rh_port_status[port - 1] | (1<<feature))
+                        :
+                        (instance->registers->rh_port_status[port - 1] & (~(1<<feature)));
+        /// \TODO any error?
+        return EOK;
+
+}
+
+static int process_request_with_output(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request == USB_DEVREQ_GET_STATUS){
+                return process_get_status_request(instance, request->buffer,
+                                request->buffer_size,
+                                setup_request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_DESCRIPTOR){
+                return process_get_descriptor_request(instance, request);
+        }
+        if(setup_request->request == USB_DEVREQ_GET_CONFIGURATION){
+                return process_get_configuration_request(instance, request->buffer,
+                                request->buffer_size);
+        }
+        return ENOTSUP;
+}
+
+static int process_request_with_input(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR){
+                return ENOTSUP;
+        }
+        if(setup_request->request == USB_DEVREQ_SET_CONFIGURATION){
+                //set and get configuration requests do not have any meaning,
+                //only dummy values are returned
+                return EOK;
+        }
+        return ENOTSUP;
+}
+
+
+static int process_request_without_data(rh_t *instance,
+                usb_transfer_batch_t *request){
+        usb_device_request_setup_packet_t * setup_request =
+                        (usb_device_request_setup_packet_t*)request->setup_buffer;
+        if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_HUB_FEATURE){
+                return process_hub_feature_set_request(instance, setup_request->value,
+                                setup_request->request == USB_DEVREQ_SET_FEATURE);
+        }
+        if(setup_request->request_type == USB_HUB_REQ_TYPE_SET_PORT_FEATURE){
+                return process_port_feature_set_request(instance, setup_request->value,
+                                setup_request->index,
+                                setup_request->request == USB_DEVREQ_SET_FEATURE);
+        }
+        return ENOTSUP;
+}
+
+
+/**
+ *
+ * @param instance
+ * @param request
+ * @return
+ */
 int rh_request(rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
         assert(request);
-        /* TODO: implement */
+        int opResult;
         if (request->setup_buffer) {
                 usb_log_info("Root hub got SETUP packet: %s.\n",
                     usb_debug_str_buffer((const uint8_t *)request->setup_buffer, 8, 8));
-        }
-        usb_log_error("Root hub request processing not implemented.\n");
-        usb_transfer_batch_finish(request, ENOTSUP);
+                if(sizeof(usb_device_request_setup_packet_t)>request->setup_size){
+                        usb_log_error("setup packet too small\n");
+                        return EINVAL;
+                }
+                usb_device_request_setup_packet_t * setup_request =
+                                (usb_device_request_setup_packet_t*)request->setup_buffer;
+                if(
+                        setup_request->request == USB_DEVREQ_GET_STATUS
+                        || setup_request->request == USB_DEVREQ_GET_DESCRIPTOR
+                        || setup_request->request == USB_DEVREQ_GET_CONFIGURATION
+                ){
+                        usb_log_debug("processing request with output\n");
+                        opResult = process_request_with_output(instance,request);
+                }else if(
+                        setup_request->request == USB_DEVREQ_CLEAR_FEATURE
+                        || setup_request->request == USB_DEVREQ_SET_FEATURE
+                ){
+                        usb_log_debug("processing request without additional data\n");
+                        opResult = process_request_without_data(instance,request);
+                }else if(setup_request->request == USB_DEVREQ_SET_DESCRIPTOR
+                                || setup_request->request == USB_DEVREQ_SET_CONFIGURATION
+                ){
+                        usb_log_debug("processing request with input\n");
+                        opResult = process_request_with_input(instance,request);
+                }else{
+                        usb_log_warning("received unsuported request: %d\n",
+                                        setup_request->request
+                                        );
+                        opResult = ENOTSUP;
+                }
+        }else{
+                usb_log_error("root hub received empty transaction?");
+                opResult = EINVAL;
+        }
+        usb_transfer_batch_finish(request, opResult);
         return EOK;
 }
 /*----------------------------------------------------------------------------*/
+//is this status change?
 void rh_interrupt(rh_t *instance)
 {

uspace/drv/ohci/root_hub.h

@@ -45 +45 @@
         usb_address_t address;
         ddf_dev_t *device;
+        int port_count;
 } rh_t;
 

uspace/drv/usbhub/port_status.h

@@ -30 +30 @@
  */
 
-#ifndef PORT_STATUS_H
-#define PORT_STATUS_H
+#ifndef HUB_PORT_STATUS_H
+#define HUB_PORT_STATUS_H
 
 #include <bool.h>
@@ -335 +335 @@
 
 
-#endif  /* PORT_STATUS_H */
+#endif  /* HUB_PORT_STATUS_H */
 
 /**

uspace/drv/usbhub/usbhub.c

@@ -162 +162 @@
             std_descriptor->configuration_count);
         if(std_descriptor->configuration_count<1){
-                usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE\n");
-                //shouldn`t I return?
-                //definitely
+                usb_log_error("there are no configurations available\n");
                 return EINVAL;
         }