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

File:

• uspace/drv/ohci/root_hub.c (modified) (17 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 bool is_zeros(void * buffer, size_t size);
+
 
 
@@ -204 +205 @@
  * @return Error code.
  */
-int rh_init(rh_t *instance, ohci_regs_t *regs) {
+int rh_init(rh_t *instance, ddf_dev_t *dev, ohci_regs_t *regs) {
         assert(instance);
+        //instance->address = -1;
         instance->registers = regs;
-        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;
-        }
+        instance->device = dev;
+        instance->port_count = instance->registers->rh_desc_a & 0xff;
+        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;
-        
+        instance->registers->rh_desc_a =
+                instance->registers->rh_desc_a | (1<<9);
 
         usb_log_info("OHCI root hub with %d ports.\n", instance->port_count);
+
+        //start generic usb hub driver
+
+        /* TODO: implement */
         return EOK;
 }
@@ -238 +236 @@
         assert(request);
         int opResult;
-        if (request->ep->transfer_type == USB_TRANSFER_CONTROL) {
+        if (request->transfer_type == USB_TRANSFER_CONTROL) {
                 usb_log_info("Root hub got CONTROL packet\n");
                 opResult = process_ctrl_request(instance, request);
-                usb_transfer_batch_finish_error(request, opResult);
-        } else if (request->ep->transfer_type == USB_TRANSFER_INTERRUPT) {
+        } else if (request->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;
-                        //will be finished later
-                }else{
-                        usb_log_debug("processing changes..\n");
-                        process_interrupt_mask_in_instance(instance, request);
-                }
+                void * buffer;
+                create_interrupt_mask(instance, &buffer,
+                        &(request->transfered_size));
+                memcpy(request->transport_buffer, buffer,
+                        request->transfered_size);
                 opResult = EOK;
         } else {
                 opResult = EINVAL;
-                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
- */
+        }
+        usb_transfer_batch_finish_error(request, opResult);
+        return EOK;
+}
+
+/*----------------------------------------------------------------------------*/
+
+
 void rh_interrupt(rh_t *instance) {
-        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);
+        usb_log_info("Whoa whoa wait, I`m not supposed to receive any "
+                "interrupts, am I?\n");
+        /* TODO: implement? */
 }
 /*----------------------------------------------------------------------------*/
@@ -288 +271 @@
  *
  * @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 +312 @@
                 result[7 + var_size + i] = 255;
         }
-        instance->hub_descriptor = result;
-        instance->descriptor_size = size;
-        return EOK;
+        (*out_result) = result;
+        (*out_size) = size;
 }
 /*----------------------------------------------------------------------------*/
@@ -336 +322 @@
  * 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 +330 @@
         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 +352 @@
                 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;
 }
 /*----------------------------------------------------------------------------*/
@@ -392 +373 @@
         if (port < 1 || port > instance->port_count)
                 return EINVAL;
-        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
         request->transfered_size = 4;
         uint32_buffer[0] = instance->registers->rh_port_status[port - 1];
@@ -418 +399 @@
 static int process_get_hub_status_request(rh_t *instance,
         usb_transfer_batch_t * request) {
-        uint32_t * uint32_buffer = (uint32_t*) request->data_buffer;
+        uint32_t * uint32_buffer = (uint32_t*) request->transport_buffer;
         request->transfered_size = 4;
         //bits, 0,1,16,17
@@ -465 +446 @@
  * 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 +491 @@
         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;
                 }
@@ -559 +549 @@
         }
         request->transfered_size = size;
-        memcpy(request->data_buffer, result_descriptor, size);
+        memcpy(request->transport_buffer, result_descriptor, size);
+        if (del)
+                free(result_descriptor);
         return EOK;
 }
@@ -578 +570 @@
         if (request->buffer_size != 1)
                 return EINVAL;
-        request->data_buffer[0] = 1;
+        request->transport_buffer[0] = 1;
         request->transfered_size = 1;
         return EOK;
@@ -873 +865 @@
         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;
-}
 
 /**