Changes in / [4fa05a32:bf58895] in mainline


Ignore:
Location:
uspace/drv
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/batch.c

    r4fa05a32 rbf58895  
    153153}
    154154/*----------------------------------------------------------------------------*/
    155 /** Mark batch as failed and continue with next step.
    156  *
    157  * @param[in] instance Batch structure to use.
    158  *
    159  */
    160 void batch_abort(batch_t *instance)
    161 {
    162         assert(instance);
    163         instance->error = EIO;
    164         instance->next_step(instance);
    165 }
    166 /*----------------------------------------------------------------------------*/
    167155/** Check batch TDs for activity.
    168156 *
    … …  
    263251        assert(instance);
    264252        /* We are data out, we are supposed to provide data */
    265         memcpy(instance->transport_buffer, instance->buffer,
    266             instance->buffer_size);
     253        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
    267254        batch_data(instance, USB_PID_OUT);
    268255        instance->next_step = batch_call_out_and_dispose;
    … …  
    294281        assert(instance);
    295282        /* We are data out, we are supposed to provide data */
    296         memcpy(instance->transport_buffer, instance->buffer,
    297             instance->buffer_size);
     283        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
    298284        batch_data(instance, USB_PID_OUT);
    299285        instance->next_step = batch_call_out_and_dispose;

  • uspace/drv/uhci-hcd/batch.h

    r4fa05a32 rbf58895  
    6969} batch_t;
    7070
    71 batch_t * batch_get(
    72     ddf_fun_t *fun,
    73                 usb_target_t target,
    74     usb_transfer_type_t transfer_type,
    75                 size_t max_packet_size,
    76     usb_speed_t speed,
    77                 char *buffer,
    78                 size_t size,
    79                 char *setup_buffer,
    80                 size_t setup_size,
     71batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     72    usb_transfer_type_t transfer_type, size_t max_packet_size,
     73    usb_speed_t speed, char *buffer, size_t size,
     74                char *setup_buffer, size_t setup_size,
    8175    usbhc_iface_transfer_in_callback_t func_in,
    82     usbhc_iface_transfer_out_callback_t func_out,
    83                 void *arg,
     76    usbhc_iface_transfer_out_callback_t func_out, void *arg,
    8477                device_keeper_t *manager
    8578                );
    8679
    8780void batch_dispose(batch_t *instance);
    88 
    89 void batch_abort(batch_t *instance);
    9081
    9182bool batch_is_complete(batch_t *instance);

  • uspace/drv/uhci-hcd/transfer_list.c

    r4fa05a32 rbf58895  
    129129}
    130130/*----------------------------------------------------------------------------*/
    131 /** Check list for finished batches.
    132  *
    133  * @param[in] instance List to use.
    134  * @return Error code
    135  *
    136  * Creates a local list of finished batches and calls next_step on each and
    137  * every one. This is safer because next_step may theoretically access
    138  * this transfer list leading to the deadlock if its done inline.
    139  */
    140 void transfer_list_remove_finished(transfer_list_t *instance)
    141 {
    142         assert(instance);
    143 
    144         LIST_INITIALIZE(done);
    145 
    146         fibril_mutex_lock(&instance->guard);
    147         link_t *current = instance->batch_list.next;
    148         while (current != &instance->batch_list) {
    149                 link_t *next = current->next;
    150                 batch_t *batch = list_get_instance(current, batch_t, link);
    151 
    152                 if (batch_is_complete(batch)) {
    153                         /* Save for post-processing */
    154                         transfer_list_remove_batch(instance, batch);
    155                         list_append(current, &done);
    156                 }
    157                 current = next;
    158         }
    159         fibril_mutex_unlock(&instance->guard);
    160 
    161         while (!list_empty(&done)) {
    162                 link_t *item = done.next;
    163                 list_remove(item);
    164                 batch_t *batch = list_get_instance(item, batch_t, link);
    165                 batch->next_step(batch);
    166         }
    167 }
    168 /*----------------------------------------------------------------------------*/
    169 /** Walk the list and abort all batches.
    170  *
    171  * @param[in] instance List to use.
    172  */
    173 void transfer_list_abort_all(transfer_list_t *instance)
    174 {
    175         fibril_mutex_lock(&instance->guard);
    176         while (list_empty(&instance->batch_list)) {
    177                 link_t *current = instance->batch_list.next;
    178                 batch_t *batch = list_get_instance(current, batch_t, link);
    179                 transfer_list_remove_batch(instance, batch);
    180                 batch_abort(batch);
    181         }
    182         fibril_mutex_unlock(&instance->guard);
    183 }
    184 /*----------------------------------------------------------------------------*/
    185131/** Remove a transfer batch from the list and queue.
    186132 *
    … …  
    217163            batch, pos, instance->name, batch->qh->next);
    218164}
     165/*----------------------------------------------------------------------------*/
     166/** Check list for finished batches.
     167 *
     168 * @param[in] instance List to use.
     169 * @return Error code
     170 *
     171 * Creates a local list of finished batches and calls next_step on each and
     172 * every one. This is safer because next_step may theoretically access
     173 * this transfer list leading to the deadlock if its done inline.
     174 */
     175void transfer_list_remove_finished(transfer_list_t *instance)
     176{
     177        assert(instance);
     178
     179        LIST_INITIALIZE(done);
     180
     181        fibril_mutex_lock(&instance->guard);
     182        link_t *current = instance->batch_list.next;
     183        while (current != &instance->batch_list) {
     184                link_t *next = current->next;
     185                batch_t *batch = list_get_instance(current, batch_t, link);
     186
     187                if (batch_is_complete(batch)) {
     188                        /* Save for post-processing */
     189                        transfer_list_remove_batch(instance, batch);
     190                        list_append(current, &done);
     191                }
     192                current = next;
     193        }
     194        fibril_mutex_unlock(&instance->guard);
     195
     196        while (!list_empty(&done)) {
     197                link_t *item = done.next;
     198                list_remove(item);
     199                batch_t *batch = list_get_instance(item, batch_t, link);
     200                batch->next_step(batch);
     201        }
     202}
    219203/**
    220204 * @}

  • uspace/drv/uhci-hcd/transfer_list.h

    r4fa05a32 rbf58895  
    6666void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
    6767
    68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
    69 
    7068void transfer_list_remove_finished(transfer_list_t *instance);
    7169
    72 void transfer_list_abort_all(transfer_list_t *instance);
     70void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
    7371#endif
    7472/**

  • uspace/drv/uhci-hcd/uhci_hc.c

    r4fa05a32 rbf58895  
    9797
    9898        instance->hw_interrupts = interrupts;
    99         instance->hw_failures = 0;
    100 
    10199        /* Setup UHCI function. */
    102100        instance->ddf_instance = fun;
    … …  
    151149        while ((pio_read_16(&registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
    152150
    153         /* Set frame to exactly 1ms */
    154         pio_write_8(&registers->sofmod, 64);
    155 
    156         /* Set frame list pointer */
     151        /* Set framelist pointer */
    157152        const uint32_t pa = addr_to_phys(instance->frame_list);
    158153        pio_write_32(&registers->flbaseadd, pa);
    … …  
    352347{
    353348        assert(instance);
    354         /* TODO: Resume interrupts are not supported */
     349        /* TODO: Check interrupt cause here */
    355350        /* Lower 2 bits are transaction error and transaction complete */
    356351        if (status & 0x3) {
    … …  
    359354                transfer_list_remove_finished(&instance->transfers_control_full);
    360355                transfer_list_remove_finished(&instance->transfers_bulk_full);
    361         }
    362         /* bits 4 and 5 indicate hc error */
    363         if (status & 0x18) {
    364                 usb_log_error("UHCI hardware failure!.\n");
    365                 ++instance->hw_failures;
    366                 transfer_list_abort_all(&instance->transfers_interrupt);
    367                 transfer_list_abort_all(&instance->transfers_control_slow);
    368                 transfer_list_abort_all(&instance->transfers_control_full);
    369                 transfer_list_abort_all(&instance->transfers_bulk_full);
    370 
    371                 if (instance->hw_failures < UHCI_ALLOWED_HW_FAIL) {
    372                         /* reinitialize hw, this triggers virtual disconnect*/
    373                         uhci_hc_init_hw(instance);
    374                 } else {
    375                         usb_log_fatal("Too many UHCI hardware failures!.\n");
    376                         uhci_hc_fini(instance);
    377                 }
    378356        }
    379357}

  • uspace/drv/uhci-hcd/uhci_hc.h

    r4fa05a32 rbf58895  
    8080#define UHCI_CLEANER_TIMEOUT 10000
    8181#define UHCI_DEBUGER_TIMEOUT 5000000
    82 #define UHCI_ALLOWED_HW_FAIL 5
    8382
    8483typedef struct uhci_hc {
    … …  
    101100        fid_t debug_checker;
    102101        bool hw_interrupts;
    103         unsigned hw_failures;
    104102
    105103        ddf_fun_t *ddf_instance;

  • uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c

    r4fa05a32 rbf58895  
    159159            (s & TD_STATUS_ERROR_BIT_STUFF) ? " BIT_STUFF," : "",
    160160            (s & TD_STATUS_ERROR_RESERVED) ? " RESERVED," : "",
    161             td_act_size(instance)
     161            (s >> TD_STATUS_ACTLEN_POS) & TD_STATUS_ACTLEN_MASK
    162162        );
    163163}

  • uspace/drv/usbhub/usbhub.c

    r4fa05a32 rbf58895  
    7272int usb_hub_control_loop(void * hub_info_param){
    7373        usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
    74         int errorCode = EOK;
    75 
    76         while(errorCode == EOK){
    77                 errorCode = usb_hub_check_hub_changes(hub_info);
     74        while(true){
     75                usb_hub_check_hub_changes(hub_info);
    7876                async_usleep(1000 * 1000 );/// \TODO proper number once
    7977        }
    80         dprintf(USB_LOG_LEVEL_ERROR,
    81                                 "something in ctrl loop went wrong, errno %d",errorCode);
    8278        return 0;
    8379}
    … …  
    384380 * @param target
    385381 */
    386 static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port,
    387                 bool isLowSpeed) {
     382static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port) {
    388383        usb_device_request_setup_packet_t request;
    389384        int opResult;
    … …  
    391386        assert(hub->endpoints.control.hc_phone);
    392387        //get default address
    393         usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
    394         opResult = usb_hc_reserve_default_address(&hub->connection, speed);
     388        //opResult = usb_drv_reserve_default_address(hc);
     389        opResult = usb_hc_reserve_default_address(&hub->connection, USB_SPEED_LOW);
    395390       
    396391        if (opResult != EOK) {
    … …  
    451446        usb_address_t new_device_address = usb_hc_request_address(
    452447                        &hub->connection,
    453                         speed
     448                        speed/// \TODO fullspeed??
    454449                        );
    455450        if (new_device_address < 0) {
    … …  
    515510static void usb_hub_removed_device(
    516511    usb_hub_info_t * hub,uint16_t port) {
    517                
     512        //usb_device_request_setup_packet_t request;
     513        int opResult;
     514       
    518515        /** \TODO remove device from device manager - not yet implemented in
    519516         * devide manager
    … …  
    522519        //close address
    523520        if(hub->attached_devs[port].address!=0){
    524                 /*uncomment this code to use it when DDF allows device removal
     521                //opResult = usb_drv_release_address(hc,hub->attached_devs[port].address);
    525522                opResult = usb_hc_unregister_device(
    526523                                &hub->connection, hub->attached_devs[port].address);
    … …  
    531528                hub->attached_devs[port].address = 0;
    532529                hub->attached_devs[port].handle = 0;
    533                  */
    534530        }else{
    535531                dprintf(USB_LOG_LEVEL_WARNING, "this is strange, disconnected device had no address");
    … …  
    601597                if (usb_port_dev_connected(&status)) {
    602598                        dprintf(USB_LOG_LEVEL_INFO, "some connection changed");
    603                         usb_hub_init_add_device(hub, port, usb_port_low_speed(&status));
     599                        usb_hub_init_add_device(hub, port);
    604600                } else {
    605601                        usb_hub_removed_device(hub, port);
    … …  
    639635/**
    640636 * Check changes on particular hub
    641  * @param hub_info_param pointer to usb_hub_info_t structure
    642  * @return error code if there is problem when initializing communication with
    643  * hub, EOK otherwise
    644  */
    645 int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
     637 * @param hub_info_param
     638 */
     639void usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
    646640        int opResult;
    647641        opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
    … …  
    649643                dprintf(USB_LOG_LEVEL_ERROR,
    650644                                "could not initialize communication for hub; %d", opResult);
    651                 return opResult;
     645                return;
    652646        }
    653647
    … …  
    671665                dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
    672666                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    673                 return opResult;
     667                return;
    674668        }
    675669        unsigned int port;
    … …  
    679673                                opResult);
    680674                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    681                 return opResult;
     675                return;
    682676        }
    683677        opResult = usb_hc_connection_open(&hub_info->connection);
    … …  
    687681                usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
    688682                usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    689                 return opResult;
     683                return;
    690684        }
    691685
    … …  
    703697        usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
    704698        free(change_bitmap);
    705         return EOK;
    706699}
    707700

  • uspace/drv/usbhub/usbhub.h

    r4fa05a32 rbf58895  
    8787
    8888/**
    89  * Check changes on specified hub
     89 * check changes on specified hub
    9090 * @param hub_info_param pointer to usb_hub_info_t structure
    91  * @return error code if there is problem when initializing communication with
    92  * hub, EOK otherwise
    9391 */
    94 int usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
     92void usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
    9593
    9694
Note: See TracChangeset for help on using the changeset viewer.