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

File:

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

uspace/drv/ohci/root_hub.c

@@ -149 +149 @@
 
 
-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 create_serialized_hub_descriptor(rh_t *instance);
+
+static int rh_init_descriptors(rh_t *instance);
 
 static int process_get_port_status_request(rh_t *instance, uint16_t port,
@@ -164 +162 @@
         usb_transfer_batch_t * request);
 
-static void create_interrupt_mask(rh_t *instance, void ** buffer,
-        size_t * buffer_size);
+static void create_interrupt_mask_in_instance(rh_t *instance);
 
 static int process_get_descriptor_request(rh_t *instance,
@@ -198 +195 @@
 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 bool is_zeros(void * buffer, size_t size);
 
 
@@ -205 +204 @@
  * @return Error code.
  */
-int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
+int rh_init(rh_t *instance, ohci_regs_t *regs) {
         assert(instance);
-        //instance->address = -1;
         instance->registers = regs;
-        instance->device = dev;
-        instance->port_count = instance->registers->rh_desc_a & 0xff;
-        rh_init_descriptors(instance);
+        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;
+        }
         // set port power mode to no-power-switching
-        instance->registers->rh_desc_a =
-                instance->registers->rh_desc_a | (1<<9);
+        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);
-
-        //start generic usb hub driver
-
-        /* TODO: implement */
         return EOK;
 }
@@ -236 +238 @@
         assert(request);
         int opResult;
-        if (request->transfer_type == USB_TRANSFER_CONTROL) {
+        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
                 usb_log_info("Root hub got CONTROL packet\n");
                 opResult = process_ctrl_request(instance, request);
-        } else if (request->transfer_type == USB_TRANSFER_INTERRUPT) {
+                usb_transfer_batch_finish_error(request, opResult);
+        } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
                 usb_log_info("Root hub got INTERRUPT packet\n");
-                void * buffer;
-                create_interrupt_mask(instance, &buffer,
-                        &(request->transfered_size));
-                memcpy(request->transport_buffer, buffer,
-                        request->transfered_size);
+                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;
+                        //will be finished later
+                }else{
+                        usb_log_debug("processing changes..\n");
+                        process_interrupt_mask_in_instance(instance, request);
+                }
                 opResult = EOK;
         } else {
                 opResult = EINVAL;
-        }
-        usb_transfer_batch_finish_error(request, opResult);
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-
-
+                usb_transfer_batch_finish_error(request, opResult);
+        }
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+/**
+ * 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");
-        /* TODO: implement? */
+        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);
 }
 /*----------------------------------------------------------------------------*/
@@ -271 +288 @@
  *
  * @param instance root hub instance
- * @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;
+ * @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;
         uint8_t * result = (uint8_t*) malloc(size);
+        if(!result) return ENOMEM;
+
         bzero(result, size);
         //size
@@ -312 +325 @@
                 result[7 + var_size + i] = 255;
         }
-        (*out_result) = result;
-        (*out_size) = size;
+        instance->hub_descriptor = result;
+        instance->descriptor_size = size;
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -322 +336 @@
  * be initialized only once per hub.
  * @instance root hub instance
- */
-static void rh_init_descriptors(rh_t *instance) {
+ * @return error code
+ */
+static int rh_init_descriptors(rh_t *instance) {
         memcpy(&instance->descriptors.device, &ohci_rh_device_descriptor,
                 sizeof (ohci_rh_device_descriptor)
@@ -330 +345 @@
         memcpy(&descriptor, &ohci_rh_conf_descriptor,
                 sizeof (ohci_rh_conf_descriptor));
-        uint8_t * hub_descriptor;
-        size_t hub_desc_size;
-        usb_create_serialized_hub_descriptor(instance, &hub_descriptor,
-                &hub_desc_size);
-
+
+        int opResult = create_serialized_hub_descriptor(instance);
+        if(opResult != EOK){
+                return opResult;
+        }
         descriptor.total_length =
                 sizeof (usb_standard_configuration_descriptor_t) +
                 sizeof (usb_standard_endpoint_descriptor_t) +
                 sizeof (usb_standard_interface_descriptor_t) +
-                hub_desc_size;
+                instance->descriptor_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),
@@ -352 +370 @@
                 sizeof (ohci_rh_iface_descriptor) +
                 sizeof (ohci_rh_ep_descriptor),
-                hub_descriptor, hub_desc_size);
-
+                instance->hub_descriptor, instance->descriptor_size);
+        
         instance->descriptors.configuration = full_config_descriptor;
         instance->descriptors.configuration_size = descriptor.total_length;
+        return EOK;
 }
 /*----------------------------------------------------------------------------*/
@@ -373 +392 @@
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
@@ -399 +418 @@
 static int process_get_hub_status_request(rh_t *instance,
         usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
         request->transfered_size = 4;
         //bits, 0,1,16,17
@@ -446 +465 @@
  * 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)
- * @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);
+ * (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);
         uint32_t mask = (1 << (USB_HUB_FEATURE_C_HUB_LOCAL_POWER + 16))
                 | (1 << (USB_HUB_FEATURE_C_HUB_OVER_CURRENT + 16));
-        bzero(bitmap, (*buffer_size));
+        bzero(bitmap, instance->interrupt_mask_size);
         if (instance->registers->rh_status & mask) {
                 bitmap[0] = 1;
@@ -491 +504 @@
         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:
                 {
-                        uint8_t * descriptor;
-                        usb_create_serialized_hub_descriptor(
-                                instance, &descriptor, &size);
-                        result_descriptor = descriptor;
-                        if (result_descriptor) del = true;
+                        usb_log_debug("USB_DESCTYPE_HUB\n");
+                        result_descriptor = instance->hub_descriptor;
+                        size = instance->descriptor_size;
                         break;
                 }
@@ -549 +559 @@
         }
         request->transfered_size = size;
-        memcpy(request->transport_buffer, result_descriptor, size);
-        if (del)
-                free(result_descriptor);
+        memcpy(request->data_buffer, result_descriptor, size);
         return EOK;
 }
@@ -570 +578 @@
         if (request->buffer_size != 1)
                 return EINVAL;
-        request->transport_buffer[0] = 1;
+        request->data_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;
@@ -865 +873 @@
         return opResult;
 }
+/*----------------------------------------------------------------------------*/
+
+/**
+ * process hanging interrupt request
+ *
+ * If an interrupt transfer has been received and there was no change,
+ * the driver stores the transfer information and waits for change to occcur.
+ * This routine is called when that happens and it finalizes the interrupt
+ * transfer.
+ *
+ * @param instance hub instance
+ * @param request batch request to be processed
+ *
+ * @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;
+        instance->unfinished_interrupt_transfer = NULL;
+        usb_transfer_batch_finish_error(request, EOK);
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+/**
+ * return whether the buffer is full of zeros
+ *
+ * Convenience function.
+ * @param buffer
+ * @param size
+ * @return
+ */
+static bool is_zeros(void * buffer, size_t size){
+        if(!buffer) return true;
+        if(!size) return true;
+        size_t i;
+        for(i=0;i<size;++i){
+                if(((char*)buffer)[i])
+                        return false;
+        }
+        return true;
+}
 
 /**