Changes in / [fa2f79d:47c573a] in mainline


Ignore:
Location:
uspace
Files:
4 deleted
16 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-rhd/port.c

    rfa2f79d r47c573a  
    3636
    3737#include <usb/usb.h>    /* usb_address_t */
    38 #include <usb/usbdevice.h>
    39 #include <usb/hub.h>
    40 #include <usb/request.h>
     38#include <usb/usbdrv.h> /* usb_drv_*     */
    4139#include <usb/debug.h>
    4240#include <usb/recognise.h>
    … …  
    6058        port->attached_device = 0;
    6159        port->rh = rh;
    62         int rc = usb_hc_connection_initialize_from_device(
    63             &port->hc_connection, rh);
    64         if (rc != EOK) {
    65                 usb_log_error("Failed to initialize connection to HC.");
    66                 return rc;
    67         }
     60        port->hc_phone = parent_phone;
    6861
    6962        port->checker = fibril_create(uhci_port_check, port);
    … …  
    10598
    10699                if (port_status & STATUS_CONNECTED_CHANGED) {
    107                         int rc = usb_hc_connection_open(
    108                             &port_instance->hc_connection);
    109                         if (rc != EOK) {
    110                                 usb_log_error("Failed to connect to HC.");
    111                                 goto next;
    112                         }
    113 
    114100                        if (port_status & STATUS_CONNECTED) {
    115101                                /* new device */
    … …  
    118104                                uhci_port_remove_device(port_instance);
    119105                        }
    120 
    121                         rc = usb_hc_connection_close(
    122                             &port_instance->hc_connection);
    123                         if (rc != EOK) {
    124                                 usb_log_error("Failed to disconnect from HC.");
    125                                 goto next;
    126                         }
    127106                }
    128         next:
    129107                async_usleep(port_instance->wait_period_usec);
    130108        }
    … …  
    135113{
    136114        assert(port);
    137         assert(usb_hc_connection_is_opened(&port->hc_connection));
     115        assert(port->hc_phone);
    138116
    139117        usb_log_info("Adding new device on port %d.\n", port->number);
    140118
    141119        /* get address of the future device */
    142         const usb_address_t usb_address = usb_hc_request_address(&port->hc_connection);
     120        const usb_address_t usb_address = usb_drv_request_address(port->hc_phone);
    143121
    144122        if (usb_address <= 0) {
    … …  
    150128
    151129        /* get default address */
    152         int ret = usb_hc_reserve_default_address(&port->hc_connection);
     130        int ret = usb_drv_reserve_default_address(port->hc_phone);
    153131        if (ret != EOK) {
    154132                usb_log_error("Failed to reserve default address on port %d.\n",
    155133                    port->number);
    156                 int ret2 = usb_hc_unregister_device(&port->hc_connection,
    157                     usb_address);
     134                int ret2 =
     135                  usb_drv_release_address(port->hc_phone, usb_address);
    158136                if (ret2 != EOK) {
    159137                        usb_log_fatal("Failed to return requested address on port %d.\n",
    … …  
    196174        }
    197175
    198         /*
    199          * Initialize connection to the device.
    200          */
    201         /* FIXME: check for errors. */
    202         usb_device_connection_t new_dev_connection;
    203         usb_endpoint_pipe_t new_dev_ctrl_pipe;
    204         usb_device_connection_initialize_on_default_address(
    205             &new_dev_connection, &port->hc_connection);
    206         usb_endpoint_pipe_initialize_default_control(&new_dev_ctrl_pipe,
    207             &new_dev_connection);
    208 
    209         /*
    210          * Assign new address to the device. This function updates
    211          * the backing connection to still point to the same device.
    212          */
    213         /* FIXME: check for errors. */
    214         usb_endpoint_pipe_start_session(&new_dev_ctrl_pipe);
    215         ret = usb_request_set_address(&new_dev_ctrl_pipe, usb_address);
    216         usb_endpoint_pipe_end_session(&new_dev_ctrl_pipe);
     176        /* assign address to device */
     177        ret = usb_drv_req_set_address(port->hc_phone, 0, usb_address);
    217178
    218179        if (ret != EOK) { /* address assigning went wrong */
    219180                usb_log_error("Failed(%d) to assign address to the device.\n", ret);
    220181                uhci_port_set_enabled(port, false);
    221                 int release = usb_hc_release_default_address(&port->hc_connection);
     182                int release = usb_drv_release_default_address(port->hc_phone);
    222183                if (release != EOK) {
    223184                        usb_log_error("Failed to release default address on port %d.\n",
    … …  
    233194
    234195        /* release default address */
    235         ret = usb_hc_release_default_address(&port->hc_connection);
     196        ret = usb_drv_release_default_address(port->hc_phone);
    236197        if (ret != EOK) {
    237198                usb_log_error("Failed to release default address on port %d.\n",
    … …  
    245206        assert(port->attached_device == 0);
    246207
    247         ret = usb_device_register_child_in_devman(new_dev_connection.address,
    248             new_dev_connection.hc_handle, port->rh, &port->attached_device);
    249 
     208        devman_handle_t hc_handle;
     209        ret = usb_drv_find_hc(port->rh, &hc_handle);
     210        if (ret != EOK) {
     211                usb_log_error("Failed to get handle of host controller: %s.\n",
     212                    str_error(ret));
     213                uhci_port_set_enabled(port, false);
     214                return ENOMEM;
     215        }
     216
     217        ret = usb_device_register_child_in_devman(usb_address, hc_handle,
     218            port->rh, &port->attached_device);
    250219        if (ret != EOK) { /* something went wrong */
    251220                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
    … …  
    256225                port->number, usb_address, port->attached_device);
    257226
    258         /*
    259          * Register the device in the host controller.
    260          */
    261         usb_hc_attached_device_t new_device = {
    262                 .address = new_dev_connection.address,
    263                 .handle = port->attached_device
    264         };
    265 
    266         ret = usb_hc_register_device(&port->hc_connection, &new_device);
     227        ret =
     228          usb_drv_bind_address(port->hc_phone, usb_address, port->attached_device);
    267229        // TODO: proper error check here
    268230        assert(ret == EOK);

  • uspace/drv/uhci-rhd/port.h

    rfa2f79d r47c573a  
    3838#include <driver.h> /* device_t */
    3939#include <stdint.h>
    40 #include <usb/usbdevice.h>
    4140
    4241#include "port_status.h"
    … …  
    4746        unsigned number;
    4847        unsigned wait_period_usec;
    49         usb_hc_connection_t hc_connection;
     48        int hc_phone;
    5049        device_t *rh;
    5150        devman_handle_t attached_device;

  • uspace/drv/vhc/connhost.c

    rfa2f79d r47c573a  
    6464
    6565static void universal_callback(void *buffer, size_t size,
    66     int outcome, void *arg)
     66    usb_transaction_outcome_t outcome, void *arg)
    6767{
    6868        transfer_info_t *transfer = (transfer_info_t *) arg;
    … …  
    107107
    108108static void control_abort_prematurely(control_transfer_info_t *transfer,
    109     size_t size, int outcome)
     109    size_t size, usb_transaction_outcome_t outcome)
    110110{
    111111        switch (transfer->direction) {
    … …  
    127127
    128128static void control_callback_two(void *buffer, size_t size,
    129     int outcome, void *arg)
     129    usb_transaction_outcome_t outcome, void *arg)
    130130{
    131131        control_transfer_info_t *ctrl_transfer = (control_transfer_info_t *) arg;
    132132
    133         if (outcome != EOK) {
     133        if (outcome != USB_OUTCOME_OK) {
    134134                control_abort_prematurely(ctrl_transfer, outcome, size);
    135135                free(ctrl_transfer);
    … …  
    165165
    166166static void control_callback_one(void *buffer, size_t size,
    167     int outcome, void *arg)
     167    usb_transaction_outcome_t outcome, void *arg)
    168168{
    169169        control_transfer_info_t *transfer = (control_transfer_info_t *) arg;
    170170
    171         if (outcome != EOK) {
     171        if (outcome != USB_OUTCOME_OK) {
    172172                control_abort_prematurely(transfer, outcome, size);
    173173                free(transfer);

  • uspace/drv/vhc/devices.c

    rfa2f79d r47c573a  
    112112 * @param transaction Transaction to be sent over the bus.
    113113 */
    114 int virtdev_send_to_all(transaction_t *transaction)
     114usb_transaction_outcome_t virtdev_send_to_all(transaction_t *transaction)
    115115{
    116116        /* For easier debugging. */
    … …  
    126126                        assert(false && "unreachable branch in switch()");
    127127        }
    128         int outcome = EBADCHECKSUM;
     128        usb_transaction_outcome_t outcome = USB_OUTCOME_BABBLE;
    129129
    130130        link_t *pos;
    … …  
    185185                 */
    186186                if (rc == EOK) {
    187                         outcome = EOK;
     187                        outcome = USB_OUTCOME_OK;
    188188                }
    189189        }
    … …  
    221221                                break;
    222222                }
    223                 outcome = EOK;
     223                outcome = USB_OUTCOME_OK;
    224224        }
    225225       

  • uspace/drv/vhc/devices.h

    rfa2f79d r47c573a  
    5454virtdev_connection_t *virtdev_find(sysarg_t);
    5555void virtdev_destroy_device(virtdev_connection_t *);
    56 int virtdev_send_to_all(transaction_t *);
     56usb_transaction_outcome_t virtdev_send_to_all(transaction_t *);
    5757
    5858#endif

  • uspace/drv/vhc/hc.c

    rfa2f79d r47c573a  
    8989 */
    9090static void process_transaction_with_outcome(transaction_t * transaction,
    91     int outcome)
     91    usb_transaction_outcome_t outcome)
    9292{
    9393        usb_log_debug2("Transaction " TRANSACTION_FORMAT " done: %s.\n",
    9494            TRANSACTION_PRINTF(*transaction),
    95             str_error(outcome));
     95            usb_str_transaction_outcome(outcome));
    9696       
    9797        transaction->callback(transaction->buffer, transaction->actual_len,
    … …  
    127127                    TRANSACTION_PRINTF(*transaction), ports);
    128128
    129                 int outcome;
     129                usb_transaction_outcome_t outcome;
    130130                outcome = virtdev_send_to_all(transaction);
    131131               

  • uspace/drv/vhc/hc.h

    rfa2f79d r47c573a  
    4747 */
    4848typedef void (*hc_transaction_done_callback_t)(void *buffer, size_t size,
    49     int outcome, void *arg);
     49    usb_transaction_outcome_t outcome, void *arg);
    5050
    5151/** Pending transaction details. */

  • uspace/lib/c/generic/str_error.c

    rfa2f79d r47c573a  
    3333 */
    3434
    35 #include <errno.h>
    3635#include <str_error.h>
    3736#include <stdio.h>
    … …  
    6463static fibril_local char noerr[NOERR_LEN];
    6564
    66 const char *str_error(const int e)
     65const char *str_error(const int errno)
    6766{
    68         if ((e <= 0) && (e >= MIN_ERRNO))
    69                 return err_desc[-e];
     67        if ((errno <= 0) && (errno >= MIN_ERRNO))
     68                return err_desc[-errno];
    7069       
    71         /* Ad hoc descriptions of error codes interesting for USB. */
    72         switch (e) {
    73                 case EBADCHECKSUM:
    74                         return "Bad checksum";
    75                 case EAGAIN:
    76                         return "Resource temporarily unavailable";
    77                 default:
    78                         break;
    79         }
    80 
    81         snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
     70        snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
    8271        return noerr;
    8372}

  • uspace/lib/c/include/errno.h

    rfa2f79d r47c573a  
    5656#define EMLINK        (-266)
    5757
    58 /** Bad checksum. */
    59 #define EBADCHECKSUM  (-300)
    60 
    6158/** An API function is called while another blocking function is in progress. */
    6259#define EINPROGRESS  (-10036)

  • uspace/lib/drv/generic/remote_usbhc.c

    rfa2f79d r47c573a  
    240240
    241241static void callback_out(device_t *device,
    242     int outcome, void *arg)
     242    usb_transaction_outcome_t outcome, void *arg)
    243243{
    244244        async_transaction_t *trans = (async_transaction_t *)arg;
    … …  
    250250
    251251static void callback_in(device_t *device,
    252     int outcome, size_t actual_size, void *arg)
     252    usb_transaction_outcome_t outcome, size_t actual_size, void *arg)
    253253{
    254254        async_transaction_t *trans = (async_transaction_t *)arg;
    255255
    256         if (outcome != EOK) {
     256        if (outcome != USB_OUTCOME_OK) {
    257257                async_answer_0(trans->caller, outcome);
    258258                if (trans->data_caller) {
    … …  
    270270        }
    271271
    272         async_answer_0(trans->caller, EOK);
     272        async_answer_0(trans->caller, USB_OUTCOME_OK);
    273273
    274274        async_transaction_destroy(trans);

  • uspace/lib/drv/include/usbhc_iface.h

    rfa2f79d r47c573a  
    207207/** Callback for outgoing transfer. */
    208208typedef void (*usbhc_iface_transfer_out_callback_t)(device_t *,
    209     int, void *);
     209    usb_transaction_outcome_t, void *);
    210210
    211211/** Callback for incoming transfer. */
    212212typedef void (*usbhc_iface_transfer_in_callback_t)(device_t *,
    213     int, size_t, void *);
     213    usb_transaction_outcome_t, size_t, void *);
    214214
    215215

  • uspace/lib/usb/Makefile

    rfa2f79d r47c573a  
    4040        src/dump.c \
    4141        src/hidparser.c \
    42         src/hub.c \
    4342        src/pipes.c \
    4443        src/pipesinit.c \
    … …  
    4746        src/request.c \
    4847        src/usb.c \
    49         src/usbdevice.c \
    5048        src/usbdrvreq.c \
    5149        src/usbdrv.c \

  • uspace/lib/usb/include/usb/pipes.h

    rfa2f79d r47c573a  
    3131 */
    3232/** @file
    33  * USB pipes representation.
     33 * Communication between device drivers and host controller driver.
    3434 */
    3535#ifndef LIBUSB_PIPES_H_
    … …  
    3838#include <sys/types.h>
    3939#include <usb/usb.h>
    40 #include <usb/usbdevice.h>
    4140#include <usb/descriptor.h>
    4241#include <ipc/devman.h>
    … …  
    115114} usb_endpoint_mapping_t;
    116115
    117 int usb_device_connection_initialize_on_default_address(
    118     usb_device_connection_t *, usb_hc_connection_t *);
    119116int usb_device_connection_initialize_from_device(usb_device_connection_t *,
    120117    device_t *);

  • uspace/lib/usb/include/usb/usb.h

    rfa2f79d r47c573a  
    8383} usb_request_recipient_t;
    8484
     85/** USB transaction outcome. */
     86typedef enum {
     87        USB_OUTCOME_OK,
     88        USB_OUTCOME_CRCERROR,
     89        USB_OUTCOME_BABBLE
     90} usb_transaction_outcome_t;
     91
     92const char * usb_str_transaction_outcome(usb_transaction_outcome_t o);
     93
    8594/** USB address type.
    8695 * Negative values could be used to indicate error.

  • uspace/lib/usb/src/pipes.c

    rfa2f79d r47c573a  
    102102}
    103103
    104 /** Initialize connection to USB device on default address.
    105  *
    106  * @param dev_connection Device connection structure to be initialized.
    107  * @param hc_connection Initialized connection to host controller.
    108  * @return Error code.
    109  */
    110 int usb_device_connection_initialize_on_default_address(
    111     usb_device_connection_t *dev_connection,
    112     usb_hc_connection_t *hc_connection)
    113 {
    114         assert(dev_connection);
    115 
    116         if (hc_connection == NULL) {
    117                 return EBADMEM;
    118         }
    119 
    120         return usb_device_connection_initialize(dev_connection,
    121             hc_connection->hc_handle, (usb_address_t) 0);
    122 }
    123 
    124104
    125105/** Start a session on the endpoint pipe.

  • uspace/lib/usb/src/usb.c

    rfa2f79d r47c573a  
    5454}
    5555
     56/** String representation of USB transaction outcome. */
     57const char * usb_str_transaction_outcome(usb_transaction_outcome_t o)
     58{
     59        switch (o) {
     60                case USB_OUTCOME_OK:
     61                        return "ok";
     62                case USB_OUTCOME_CRCERROR:
     63                        return "CRC error";
     64                case USB_OUTCOME_BABBLE:
     65                        return "babble";
     66                default:
     67                        return "unknown";
     68        }
     69}
     70
     71
    5672/**
    5773 * @}
Note: See TracChangeset for help on using the changeset viewer.