Changes in uspace/drv/ohci/root_hub.c [361fcec:be11749] in mainline

File:

• uspace/drv/ohci/root_hub.c (modified) (15 diffs)

uspace/drv/ohci/root_hub.c

@@ -149 +149 @@
 
 
-static int create_serialized_hub_descriptor(rh_t *instance);
-
-static int rh_init_descriptors(rh_t *instance);
+static void usb_create_serialized_hub_descriptor(rh_t *instance,
+        uint8_t ** out_result,
+        size_t * out_size);
+
+static void rh_init_descriptors(rh_t *instance);
 
 static int process_get_port_status_request(rh_t *instance, uint16_t port,
@@ -162 +164 @@
         usb_transfer_batch_t * request);
 
-static void create_interrupt_mask_in_instance(rh_t *instance);
+static void create_interrupt_mask(rh_t *instance, void ** buffer,
+        size_t * buffer_size);
 
 static int process_get_descriptor_request(rh_t *instance,
@@ -195 +198 @@
 static int process_ctrl_request(rh_t *instance, usb_transfer_batch_t *request);
 
-static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request);
+static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request,
+    void * change_buffer, size_t buffe_size);
 
 static bool is_zeros(void * buffer, size_t size);
@@ -209 +213 @@
         instance->port_count =
             (instance->registers->rh_desc_a >> RHDA_NDS_SHIFT) & RHDA_NDS_MASK;
-        int opResult = rh_init_descriptors(instance);
-        if(opResult != EOK){
-                return opResult;
-        }
+        rh_init_descriptors(instance);
         // set port power mode to no-power-switching
         instance->registers->rh_desc_a |= RHDA_NPS_FLAG;
         instance->unfinished_interrupt_transfer = NULL;
-        instance->interrupt_mask_size = (instance->port_count + 8)/8;
-        instance->interrupt_buffer = malloc(instance->interrupt_mask_size);
-        if(!instance->interrupt_buffer)
-                return ENOMEM;
-        
-
         usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
         return EOK;
@@ -244 +239 @@
         } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
                 usb_log_info("Root hub got INTERRUPT packet\n");
-                create_interrupt_mask_in_instance(instance);
-                if(is_zeros(instance->interrupt_buffer,
-                    instance->interrupt_mask_size)){
-                        usb_log_debug("no changes..\n");
-                        instance->unfinished_interrupt_transfer = request;
+                void * buffer;
+                size_t buffer_size;
+                create_interrupt_mask(instance, &buffer,
+                        &buffer_size);
+                if(is_zeros(buffer,buffer_size)){
+                        usb_log_debug("no changes..");
+                        instance->unfinished_interrupt_transfer=
+                            request;
                         //will be finished later
                 }else{
-                        usb_log_debug("processing changes..\n");
-                        process_interrupt_mask_in_instance(instance, request);
-                }
+                        usb_log_debug("processing changes..");
+                        process_interrupt(instance, request,
+                            buffer, buffer_size);
+                }
+                free(buffer);
                 opResult = EOK;
         } else {
@@ -264 +264 @@
 /*----------------------------------------------------------------------------*/
 
-/**
- * process interrupt on a hub
- *
- * If there is no pending interrupt transfer, nothing happens.
- * @param instance
- */
+
 void rh_interrupt(rh_t *instance) {
+        //usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
+        //      "interrupts, am I?\n");
         if(!instance->unfinished_interrupt_transfer){
                 return;
         }
-        usb_log_debug("finalizing interrupt transfer\n");
-        create_interrupt_mask_in_instance(instance);
-        process_interrupt_mask_in_instance(instance,
-            instance->unfinished_interrupt_transfer);
+        size_t size;
+        void * buffer;
+        create_interrupt_mask(instance, &buffer,
+                        &size);
+        process_interrupt(instance,instance->unfinished_interrupt_transfer,
+            buffer,size);
+        free(buffer);
 }
 /*----------------------------------------------------------------------------*/
@@ -288 +288 @@
  *
  * @param instance root hub instance
- * @return error code
- */
-static int create_serialized_hub_descriptor(rh_t *instance) {
-        size_t size = 7 +
-            ((instance->port_count +7 )/ 8) * 2;
-        size_t var_size = (instance->port_count +7 )/ 8;
+ * @param@out out_result pointer to resultant serialized descriptor
+ * @param@out out_size size of serialized descriptor
+ */
+static void usb_create_serialized_hub_descriptor(rh_t *instance,
+        uint8_t ** out_result,
+        size_t * out_size) {
+        //base size
+        size_t size = 7;
+        //variable size according to port count
+        size_t var_size = instance->port_count / 8 +
+                ((instance->port_count % 8 > 0) ? 1 : 0);
+        size += 2 * var_size;
         uint8_t * result = (uint8_t*) malloc(size);
-        if(!result) return ENOMEM;
-
         bzero(result, size);
         //size
@@ -325 +329 @@
                 result[7 + var_size + i] = 255;
         }
-        instance->hub_descriptor = result;
-        instance->descriptor_size = size;
-        return EOK;
+        (*out_result) = result;
+        (*out_size) = size;
 }
 /*----------------------------------------------------------------------------*/
@@ -336 +339 @@
  * be initialized only once per hub.
  * @instance root hub instance
- * @return error code
- */
-static int rh_init_descriptors(rh_t *instance) {
+ */
+static void rh_init_descriptors(rh_t *instance) {
         memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
                 sizeof (ohci_rh_device_descriptor)
@@ -345 +347 @@
         memcpy(&descriptor, &ohci_rh_conf_descriptor,
                 sizeof (ohci_rh_conf_descriptor));
-
-        int opResult = create_serialized_hub_descriptor(instance);
-        if(opResult != EOK){
-                return opResult;
-        }
+        uint8_t * hub_descriptor;
+        size_t hub_desc_size;
+        usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
+                &hub_desc_size);
+
         descriptor.total_length =
                 sizeof (usb_standard_configuration_descriptor_t) +
                 sizeof (usb_standard_endpoint_descriptor_t) +
                 sizeof (usb_standard_interface_descriptor_t) +
-                instance->descriptor_size;
+                hub_desc_size;
 
         uint8_t * full_config_descriptor =
                 (uint8_t*) malloc(descriptor.total_length);
-        if(!full_config_descriptor){
-                return ENOMEM;
-        }
         memcpy(full_config_descriptor, &descriptor, sizeof (descriptor));
         memcpy(full_config_descriptor + sizeof (descriptor),
@@ -370 +369 @@
                 sizeof (ohci_rh_iface_descriptor) +
                 sizeof (ohci_rh_ep_descriptor),
-                instance->hub_descriptor, instance->descriptor_size);
-        
+                hub_descriptor, hub_desc_size);
+
         instance->descriptors.configuration = full_config_descriptor;
         instance->descriptors.configuration_size = descriptor.total_length;
-        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -465 +463 @@
  * bit i indicates change on i`th port (i>0). For more info see
  * Hub and Port status bitmap specification in USB specification
- * (chapter 11.13.4).
- * Uses instance`s interrupt buffer to store the interrupt information.
- * @param instance root hub instance
- */
-static void create_interrupt_mask_in_instance(rh_t * instance) {
-        uint8_t * bitmap = (uint8_t*) (instance->interrupt_buffer);
+ * (chapter 11.13.4)
+ * @param instance root hub instance
+ * @param@out buffer pointer to created interrupt mas
+ * @param@out buffer_size size of created interrupt mask
+ */
+static void create_interrupt_mask(rh_t *instance, void ** buffer,
+        size_t * buffer_size) {
+        int bit_count = instance->port_count + 1;
+        (*buffer_size) = (bit_count / 8) + ((bit_count % 8 == 0) ? 0 : 1);
+
+        (*buffer) = malloc(*buffer_size);
+        uint8_t * bitmap = (uint8_t*) (*buffer);
         uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
                 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
-        bzero(bitmap, instance->interrupt_mask_size);
+        bzero(bitmap, (*buffer_size));
         if (instance->registers->rh_status & mask) {
                 bitmap[0] = 1;
@@ -504 +508 @@
         const uint16_t setup_request_value = setup_request->value_high;
         //(setup_request->value_low << 8);
+        bool del = false;
         switch (setup_request_value) {
                 case USB_DESCTYPE_HUB:
                 {
-                        usb_log_debug("USB_DESCTYPE_HUB\n");
-                        result_descriptor = instance->hub_descriptor;
-                        size = instance->descriptor_size;
+                        uint8_t * descriptor;
+                        usb_create_serialized_hub_descriptor(
+                                instance, &descriptor, &size);
+                        result_descriptor = descriptor;
+                        if (result_descriptor) del = true;
                         break;
                 }
@@ -560 +567 @@
         request->transfered_size = size;
         memcpy(request->data_buffer, result_descriptor, size);
+        if (del)
+                free(result_descriptor);
         return EOK;
 }
@@ -885 +894 @@
  * @param instance hub instance
  * @param request batch request to be processed
+ * @param change_buffer chages on hub
+ * @param buffer_size size of change buffer
  *
  * @return
  */
-static int process_interrupt_mask_in_instance(rh_t *instance, usb_transfer_batch_t * request){
-        memcpy(request->data_buffer, instance->interrupt_buffer,
-            instance->interrupt_mask_size);
-        request->transfered_size = instance->interrupt_mask_size;
+static int process_interrupt(rh_t *instance, usb_transfer_batch_t * request,
+    void * change_buffer, size_t buffe_size){
+        create_interrupt_mask(instance, &change_buffer,
+            &(request->transfered_size));
+        memcpy(request->data_buffer, change_buffer,request->transfered_size);
         instance->unfinished_interrupt_transfer = NULL;
         usb_transfer_batch_finish_error(request, EOK);