Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/drv/usbhub/usbhub.c

    ra7528a16 r42a3a57  
    7878                async_usleep(1000 * 1000 );/// \TODO proper number once
    7979        }
    80         usb_log_error("something in ctrl loop went wrong, errno %d",errorCode);
    81 
     80        dprintf(USB_LOG_LEVEL_ERROR,
     81                                "something in ctrl loop went wrong, errno %d",errorCode);
    8282        return 0;
    8383}
     
    104104                        hub->device);
    105105        if(opResult != EOK){
    106                 usb_log_error("could not initialize connection to hc, errno %d",opResult);
     106                dprintf(USB_LOG_LEVEL_ERROR,
     107                                "could not initialize connection to hc, errno %d",opResult);
    107108                return opResult;
    108109        }
     
    111112                        hub->device);
    112113        if(opResult != EOK){
    113                 usb_log_error("could not initialize connection to device, errno %d",
    114                                 opResult);
     114                dprintf(USB_LOG_LEVEL_ERROR,
     115                                "could not initialize connection to device, errno %d",opResult);
    115116                return opResult;
    116117        }
     
    119120            &hub->device_connection);
    120121        if(opResult != EOK){
    121                 usb_log_error("could not initialize connection to device endpoint, errno %d",
    122                                 opResult);
     122                dprintf(USB_LOG_LEVEL_ERROR,
     123                                "could not initialize connection to device endpoint, errno %d",opResult);
    123124                return opResult;
    124125        }
     
    126127        opResult = usb_endpoint_pipe_probe_default_control(&hub->endpoints.control);
    127128        if (opResult != EOK) {
    128                 usb_log_error("failed probing endpoint 0, %d", opResult);
     129                dprintf(USB_LOG_LEVEL_ERROR, "failed probing endpoint 0, %d", opResult);
    129130                return opResult;
    130131        }
     
    150151            &std_descriptor);
    151152        if(opResult!=EOK){
    152                 usb_log_error("could not get device descriptor, %d",opResult);
    153                 return opResult;
    154         }
    155         usb_log_info("hub has %d configurations",
     153                dprintf(USB_LOG_LEVEL_ERROR, "could not get device descriptor, %d",opResult);
     154                return opResult;
     155        }
     156        dprintf(USB_LOG_LEVEL_INFO, "hub has %d configurations",
    156157                        std_descriptor.configuration_count);
    157158        if(std_descriptor.configuration_count<1){
    158                 usb_log_error("THERE ARE NO CONFIGURATIONS AVAILABLE");
     159                dprintf(USB_LOG_LEVEL_ERROR, "THERE ARE NO CONFIGURATIONS AVAILABLE");
    159160                //shouldn`t I return?
    160161        }
     
    183184                return opResult;
    184185        }
    185         usb_log_debug("\tused configuration %d",
     186        dprintf(USB_LOG_LEVEL_DEBUG, "\tused configuration %d",
    186187                        config_descriptor->configuration_number);
    187188
     
    199200            &hub->device_connection);
    200201        if (opResult != EOK) {
    201                 usb_log_error("Failed to initialize status change pipe: %s",
     202                dprintf(USB_LOG_LEVEL_ERROR,
     203                                "Failed to initialize status change pipe: %s",
    202204                    str_error(opResult));
    203205                return opResult;
    204206        }
    205207        if (!endpoint_mapping[0].present) {
    206                 usb_log_error("Not accepting device, " \
     208                dprintf(USB_LOG_LEVEL_ERROR,"Not accepting device, " \
    207209                    "cannot understand what is happenning");
    208210                return EREFUSED;
     
    233235        result->port_count = -1;
    234236        result->device = device;
    235         result->is_default_address_used = false;
    236237
    237238        //result->usb_device = usb_new(usb_hcd_attached_device_info_t);
     
    239240
    240241        // get hub descriptor
    241         usb_log_debug("creating serialized descripton");
     242        dprintf(USB_LOG_LEVEL_DEBUG, "creating serialized descripton");
    242243        void * serialized_descriptor = malloc(USB_HUB_MAX_DESCRIPTOR_SIZE);
    243244        usb_hub_descriptor_t * descriptor;
    244         usb_log_debug("starting control transaction");
     245        dprintf(USB_LOG_LEVEL_DEBUG, "starting control transaction");
    245246        usb_endpoint_pipe_start_session(&result->endpoints.control);
    246247        opResult = usb_request_set_configuration(&result->endpoints.control, 1);
     
    255256
    256257        if (opResult != EOK) {
    257                 usb_log_error("failed when receiving hub descriptor, badcode = %d",
    258                                 opResult);
     258                dprintf(USB_LOG_LEVEL_ERROR, "failed when receiving hub descriptor, badcode = %d",opResult);
    259259                free(serialized_descriptor);
    260260                free(result);
    261261                return NULL;
    262262        }
    263         usb_log_debug2("deserializing descriptor");
     263        dprintf(USB_LOG_LEVEL_DEBUG2, "deserializing descriptor");
    264264        descriptor = usb_deserialize_hub_desriptor(serialized_descriptor);
    265265        if(descriptor==NULL){
    266                 usb_log_warning("could not deserialize descriptor ");
     266                dprintf(USB_LOG_LEVEL_WARNING, "could not deserialize descriptor ");
    267267                free(result);
    268268                return NULL;
    269269        }
    270270
    271         usb_log_info("setting port count to %d",descriptor->ports_count);
     271        dprintf(USB_LOG_LEVEL_INFO, "setting port count to %d",descriptor->ports_count);
    272272        result->port_count = descriptor->ports_count;
    273273        result->attached_devs = (usb_hc_attached_device_t*)
     
    278278                result->attached_devs[i].address=0;
    279279        }
    280         usb_log_debug2("freeing data");
     280        dprintf(USB_LOG_LEVEL_DEBUG2, "freeing data");
    281281        free(serialized_descriptor);
    282282        free(descriptor->devices_removable);
     
    285285        //finish
    286286
    287         usb_log_info("hub info created");
     287        dprintf(USB_LOG_LEVEL_INFO, "hub info created");
    288288
    289289        return result;
     
    296296 */
    297297int usb_add_hub_device(ddf_dev_t *dev) {
    298         usb_log_info("add_hub_device(handle=%d)", (int) dev->handle);
     298        dprintf(USB_LOG_LEVEL_INFO, "add_hub_device(handle=%d)", (int) dev->handle);
    299299
    300300        //dev->ops = &hub_device_ops;
     
    313313        opResult = usb_hub_process_configuration_descriptors(hub_info);
    314314        if(opResult != EOK){
    315                 usb_log_error("could not get configuration descriptors, %d",
     315                dprintf(USB_LOG_LEVEL_ERROR,"could not get configuration descriptors, %d",
    316316                                opResult);
    317317                return opResult;
     
    324324                opResult = usb_endpoint_pipe_control_write(&hub_info->endpoints.control,
    325325                                &request,sizeof(usb_device_request_setup_packet_t), NULL, 0);
    326                 usb_log_info("powering port %d",port);
     326                dprintf(USB_LOG_LEVEL_INFO, "powering port %d",port);
    327327                if (opResult != EOK) {
    328                         usb_log_warning("something went wrong when setting hub`s %dth port", port);
     328                        dprintf(USB_LOG_LEVEL_WARNING, "something went wrong when setting hub`s %dth port", port);
    329329                }
    330330        }
     
    337337        usb_lst_append(&usb_hub_list, hub_info);
    338338        fibril_mutex_unlock(&usb_hub_list_lock);
    339         usb_log_debug("hub info added to list");
    340 
    341         usb_log_debug("adding to ddf");
     339        dprintf(USB_LOG_LEVEL_DEBUG, "hub info added to list");
     340
     341        dprintf(USB_LOG_LEVEL_DEBUG, "adding to ddf");
    342342        ddf_fun_t *hub_fun = ddf_fun_create(dev, fun_exposed, "hub");
    343343        assert(hub_fun != NULL);
     
    351351        fid_t fid = fibril_create(usb_hub_control_loop, hub_info);
    352352        if (fid == 0) {
    353                 usb_log_error("failed to start monitoring fibril for new hub");
     353                dprintf(USB_LOG_LEVEL_ERROR,
     354                                ": failed to start monitoring fibril for new hub");
    354355                return ENOMEM;
    355356        }
    356357        fibril_add_ready(fid);
    357358
    358         usb_log_debug("hub fibril created");
     359        dprintf(USB_LOG_LEVEL_DEBUG, "hub fibril created");
    359360        //(void)hub_info;
    360361        //usb_hub_check_hub_changes();
    361362       
    362         usb_log_info("hub dev added");
     363        dprintf(USB_LOG_LEVEL_INFO, "hub dev added");
    363364        //address is lost...
    364         usb_log_debug("\taddress %d, has %d ports ",
     365        dprintf(USB_LOG_LEVEL_DEBUG, "\taddress %d, has %d ports ",
    365366                        //hub_info->endpoints.control.,
    366367                        hub_info->port_count);
     
    378379
    379380/**
    380  * release default address used by given hub
    381  *
    382  * Also unsets hub->is_default_address_used. Convenience wrapper function.
    383  * @note hub->connection MUST be open for communication
    384  * @param hub hub representation
    385  * @return error code
    386  */
    387 static int usb_hub_release_default_address(usb_hub_info_t * hub){
    388         int opResult = usb_hc_release_default_address(&hub->connection);
    389         if(opResult!=EOK){
    390                 usb_log_error("could not release default address, errno %d",opResult);
    391                 return opResult;
    392         }
    393         hub->is_default_address_used = false;
    394         return EOK;
    395 }
    396 
    397 /**
    398381 * Reset the port with new device and reserve the default address.
    399382 * @param hc
     
    402385 */
    403386static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port,
    404                 usb_speed_t speed) {
    405         //if this hub already uses default address, it cannot request it once more
    406         if(hub->is_default_address_used) return;
    407 
     387                bool isLowSpeed) {
    408388        usb_device_request_setup_packet_t request;
    409389        int opResult;
    410         usb_log_info("some connection changed");
     390        dprintf(USB_LOG_LEVEL_INFO, "some connection changed");
    411391        assert(hub->endpoints.control.hc_phone);
    412392        //get default address
     393        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
    413394        opResult = usb_hc_reserve_default_address(&hub->connection, speed);
    414395       
    415396        if (opResult != EOK) {
    416                 usb_log_warning("cannot assign default address, it is probably used %d",
    417                                 opResult);
    418                 return;
    419         }
    420         hub->is_default_address_used = true;
     397                dprintf(USB_LOG_LEVEL_WARNING,
     398                                "cannot assign default address, it is probably used %d",opResult);
     399                return;
     400        }
    421401        //reset port
    422402        usb_hub_set_reset_port_request(&request, port);
     
    427407                        );
    428408        if (opResult != EOK) {
    429                 usb_log_error("something went wrong when reseting a port %d",opResult);
     409                dprintf(USB_LOG_LEVEL_ERROR,
     410                                "something went wrong when reseting a port %d",opResult);
    430411                //usb_hub_release_default_address(hc);
    431                 usb_hub_release_default_address(hub);
     412                usb_hc_release_default_address(&hub->connection);
    432413        }
    433414}
     
    443424
    444425        int opResult;
    445         usb_log_info("finalizing add device");
     426        dprintf(USB_LOG_LEVEL_INFO, "finalizing add device");
    446427        opResult = usb_hub_clear_port_feature(&hub->endpoints.control,
    447428            port, USB_HUB_FEATURE_C_PORT_RESET);
    448429
    449430        if (opResult != EOK) {
    450                 usb_log_error("failed to clear port reset feature");
    451                 usb_hub_release_default_address(hub);
     431                dprintf(USB_LOG_LEVEL_ERROR, "failed to clear port reset feature");
     432                usb_hc_release_default_address(&hub->connection);
    452433                return;
    453434        }
     
    473454                        );
    474455        if (new_device_address < 0) {
    475                 usb_log_error("failed to get free USB address");
     456                dprintf(USB_LOG_LEVEL_ERROR, "failed to get free USB address");
    476457                opResult = new_device_address;
    477                 usb_hub_release_default_address(hub);
    478                 return;
    479         }
    480         usb_log_info("setting new address %d",new_device_address);
     458                usb_hc_release_default_address(&hub->connection);
     459                return;
     460        }
     461        dprintf(USB_LOG_LEVEL_INFO, "setting new address %d",new_device_address);
    481462        //opResult = usb_drv_req_set_address(hc, USB_ADDRESS_DEFAULT,
    482463        //    new_device_address);
     
    485466        usb_endpoint_pipe_end_session(&new_device_pipe);
    486467        if (opResult != EOK) {
    487                 usb_log_error("could not set address for new device %d",opResult);
    488                 usb_hub_release_default_address(hub);
     468                dprintf(USB_LOG_LEVEL_ERROR,
     469                                "could not set address for new device %d",opResult);
     470                usb_hc_release_default_address(&hub->connection);
    489471                return;
    490472        }
     
    492474
    493475        //opResult = usb_hub_release_default_address(hc);
    494         opResult = usb_hub_release_default_address(hub);
     476        opResult = usb_hc_release_default_address(&hub->connection);
    495477        if(opResult!=EOK){
    496478                return;
     
    504486
    505487        if (opResult != EOK) {
    506                 usb_log_error("could not start driver for new device %d",opResult);
     488                dprintf(USB_LOG_LEVEL_ERROR,
     489                                "could not start driver for new device %d",opResult);
    507490                return;
    508491        }
     
    515498                        &hub->attached_devs[port]);
    516499        if (opResult != EOK) {
    517                 usb_log_error("could not assign address of device in hcd %d",opResult);
    518                 return;
    519         }
    520         usb_log_info("new device address %d, handle %zu",
     500                dprintf(USB_LOG_LEVEL_ERROR,
     501                                "could not assign address of device in hcd %d",opResult);
     502                return;
     503        }
     504        dprintf(USB_LOG_LEVEL_INFO, "new device address %d, handle %zu",
    521505            new_device_address, child_handle);
    522506
     
    549533                 */
    550534        }else{
    551                 usb_log_warning("this is strange, disconnected device had no address");
     535                dprintf(USB_LOG_LEVEL_WARNING, "this is strange, disconnected device had no address");
    552536                //device was disconnected before it`s port was reset - return default address
    553                 usb_hub_release_default_address(hub);
    554         }
    555 }
    556 
    557 
    558 /**
    559  * Process over current condition on port.
     537                //usb_drv_release_default_address(hc);
     538                usb_hc_release_default_address(&hub->connection);
     539        }
     540}
     541
     542
     543/**
     544 *Process over current condition on port.
    560545 *
    561546 * Turn off the power on the port.
     
    570555            port, USB_HUB_FEATURE_PORT_POWER);
    571556        if(opResult!=EOK){
    572                 usb_log_error("cannot power off port %d;  %d",
     557                dprintf(USB_LOG_LEVEL_ERROR, "cannot power off port %d;  %d",
    573558                                port, opResult);
    574559        }
     
    583568static void usb_hub_process_interrupt(usb_hub_info_t * hub,
    584569        uint16_t port) {
    585         usb_log_debug("interrupt at port %d", port);
     570        dprintf(USB_LOG_LEVEL_DEBUG, "interrupt at port %d", port);
    586571        //determine type of change
    587572        usb_endpoint_pipe_t *pipe = &hub->endpoints.control;
     
    602587                        );
    603588        if (opResult != EOK) {
    604                 usb_log_error("could not get port status");
     589                dprintf(USB_LOG_LEVEL_ERROR, "could not get port status");
    605590                return;
    606591        }
    607592        if (rcvd_size != sizeof (usb_port_status_t)) {
    608                 usb_log_error("received status has incorrect size");
     593                dprintf(USB_LOG_LEVEL_ERROR, "received status has incorrect size");
    609594                return;
    610595        }
     
    615600                // TODO: check opResult
    616601                if (usb_port_dev_connected(&status)) {
    617                         usb_log_info("some connection changed");
    618                         usb_hub_init_add_device(hub, port, usb_port_speed(&status));
     602                        dprintf(USB_LOG_LEVEL_INFO, "some connection changed");
     603                        usb_hub_init_add_device(hub, port, usb_port_low_speed(&status));
    619604                } else {
    620605                        usb_hub_removed_device(hub, port);
     
    627612                        usb_hub_over_current(hub,port);
    628613                }else{
    629                         usb_log_info("over current condition was auto-resolved on port %d",
    630                                         port);
     614                        dprintf(USB_LOG_LEVEL_INFO,
     615                                "over current condition was auto-resolved on port %d",port);
    631616                }
    632617        }
    633618        //port reset
    634619        if (usb_port_reset_completed(&status)) {
    635                 usb_log_info("port reset complete");
     620                dprintf(USB_LOG_LEVEL_INFO, "port reset complete");
    636621                if (usb_port_enabled(&status)) {
    637622                        usb_hub_finalize_add_device(hub, port, usb_port_low_speed(&status));
    638623                } else {
    639                         usb_log_warning("port reset, but port still not enabled");
     624                        dprintf(USB_LOG_LEVEL_WARNING, "port reset, but port still not enabled");
    640625                }
    641626        }
     
    646631        usb_port_set_dev_connected(&status, false);
    647632        if (status>>16) {
    648                 usb_log_info("there was some unsupported change on port %d: %X",
    649                                 port,status);
    650 
    651         }
    652         /// \TODO handle other changes - is there any?
     633                dprintf(USB_LOG_LEVEL_INFO, "there was some unsupported change on port %d: %X",port,status);
     634
     635        }
     636        /// \TODO handle other changes
    653637}
    654638
     
    663647        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
    664648        if(opResult != EOK){
    665                 usb_log_error("could not initialize communication for hub; %d",
    666                                 opResult);
     649                dprintf(USB_LOG_LEVEL_ERROR,
     650                                "could not initialize communication for hub; %d", opResult);
    667651                return opResult;
    668652        }
     
    685669        if (opResult != EOK) {
    686670                free(change_bitmap);
    687                 usb_log_warning("something went wrong while getting status of hub");
     671                dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
    688672                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    689673                return opResult;
     
    692676        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.control);
    693677        if(opResult!=EOK){
    694                 usb_log_error("could not start control pipe session %d", opResult);
     678                dprintf(USB_LOG_LEVEL_ERROR, "could not start control pipe session %d",
     679                                opResult);
    695680                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    696681                return opResult;
     
    698683        opResult = usb_hc_connection_open(&hub_info->connection);
    699684        if(opResult!=EOK){
    700                 usb_log_error("could not start host controller session %d",
     685                dprintf(USB_LOG_LEVEL_ERROR, "could not start host controller session %d",
    701686                                opResult);
    702687                usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
Note: See TracChangeset for help on using the changeset viewer.