Changeset fa2f79d in mainline


Ignore:
Timestamp:
2011-02-15T21:26:05Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
563fb40
Parents:
47c573a (diff), f294926 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge development/ changes

Location:
uspace
Files:
4 added
16 edited

Legend:

Unmodified
Added
Removed

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

    r47c573a rfa2f79d  
    3636
    3737#include <usb/usb.h>    /* usb_address_t */
    38 #include <usb/usbdrv.h> /* usb_drv_*     */
     38#include <usb/usbdevice.h>
     39#include <usb/hub.h>
     40#include <usb/request.h>
    3941#include <usb/debug.h>
    4042#include <usb/recognise.h>
    … …  
    5860        port->attached_device = 0;
    5961        port->rh = rh;
    60         port->hc_phone = parent_phone;
     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        }
    6168
    6269        port->checker = fibril_create(uhci_port_check, port);
    … …  
    98105
    99106                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
    100114                        if (port_status & STATUS_CONNECTED) {
    101115                                /* new device */
    … …  
    104118                                uhci_port_remove_device(port_instance);
    105119                        }
     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                        }
    106127                }
     128        next:
    107129                async_usleep(port_instance->wait_period_usec);
    108130        }
    … …  
    113135{
    114136        assert(port);
    115         assert(port->hc_phone);
     137        assert(usb_hc_connection_is_opened(&port->hc_connection));
    116138
    117139        usb_log_info("Adding new device on port %d.\n", port->number);
    118140
    119141        /* get address of the future device */
    120         const usb_address_t usb_address = usb_drv_request_address(port->hc_phone);
     142        const usb_address_t usb_address = usb_hc_request_address(&port->hc_connection);
    121143
    122144        if (usb_address <= 0) {
    … …  
    128150
    129151        /* get default address */
    130         int ret = usb_drv_reserve_default_address(port->hc_phone);
     152        int ret = usb_hc_reserve_default_address(&port->hc_connection);
    131153        if (ret != EOK) {
    132154                usb_log_error("Failed to reserve default address on port %d.\n",
    133155                    port->number);
    134                 int ret2 =
    135                   usb_drv_release_address(port->hc_phone, usb_address);
     156                int ret2 = usb_hc_unregister_device(&port->hc_connection,
     157                    usb_address);
    136158                if (ret2 != EOK) {
    137159                        usb_log_fatal("Failed to return requested address on port %d.\n",
    … …  
    174196        }
    175197
    176         /* assign address to device */
    177         ret = usb_drv_req_set_address(port->hc_phone, 0, usb_address);
     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);
    178217
    179218        if (ret != EOK) { /* address assigning went wrong */
    180219                usb_log_error("Failed(%d) to assign address to the device.\n", ret);
    181220                uhci_port_set_enabled(port, false);
    182                 int release = usb_drv_release_default_address(port->hc_phone);
     221                int release = usb_hc_release_default_address(&port->hc_connection);
    183222                if (release != EOK) {
    184223                        usb_log_error("Failed to release default address on port %d.\n",
    … …  
    194233
    195234        /* release default address */
    196         ret = usb_drv_release_default_address(port->hc_phone);
     235        ret = usb_hc_release_default_address(&port->hc_connection);
    197236        if (ret != EOK) {
    198237                usb_log_error("Failed to release default address on port %d.\n",
    … …  
    206245        assert(port->attached_device == 0);
    207246
    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);
     247        ret = usb_device_register_child_in_devman(new_dev_connection.address,
     248            new_dev_connection.hc_handle, port->rh, &port->attached_device);
     249
    219250        if (ret != EOK) { /* something went wrong */
    220251                usb_log_error("Failed(%d) in usb_drv_register_child.\n", ret);
    … …  
    225256                port->number, usb_address, port->attached_device);
    226257
    227         ret =
    228           usb_drv_bind_address(port->hc_phone, usb_address, port->attached_device);
     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);
    229267        // TODO: proper error check here
    230268        assert(ret == EOK);

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

    r47c573a rfa2f79d  
    3838#include <driver.h> /* device_t */
    3939#include <stdint.h>
     40#include <usb/usbdevice.h>
    4041
    4142#include "port_status.h"
    … …  
    4647        unsigned number;
    4748        unsigned wait_period_usec;
    48         int hc_phone;
     49        usb_hc_connection_t hc_connection;
    4950        device_t *rh;
    5051        devman_handle_t attached_device;

  • uspace/drv/vhc/connhost.c

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

  • uspace/drv/vhc/devices.c

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

  • uspace/drv/vhc/devices.h

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

  • uspace/drv/vhc/hc.c

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

  • uspace/drv/vhc/hc.h

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

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

    r47c573a rfa2f79d  
    3333 */
    3434
     35#include <errno.h>
    3536#include <str_error.h>
    3637#include <stdio.h>
    … …  
    6364static fibril_local char noerr[NOERR_LEN];
    6465
    65 const char *str_error(const int errno)
     66const char *str_error(const int e)
    6667{
    67         if ((errno <= 0) && (errno >= MIN_ERRNO))
    68                 return err_desc[-errno];
     68        if ((e <= 0) && (e >= MIN_ERRNO))
     69                return err_desc[-e];
    6970       
    70         snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
     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);
    7182        return noerr;
    7283}

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

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

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

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

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

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

  • uspace/lib/usb/Makefile

    r47c573a rfa2f79d  
    4040        src/dump.c \
    4141        src/hidparser.c \
     42        src/hub.c \
    4243        src/pipes.c \
    4344        src/pipesinit.c \
    … …  
    4647        src/request.c \
    4748        src/usb.c \
     49        src/usbdevice.c \
    4850        src/usbdrvreq.c \
    4951        src/usbdrv.c \

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

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

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

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

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

    r47c573a rfa2f79d  
    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 */
     110int 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
    104124
    105125/** Start a session on the endpoint pipe.

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

    r47c573a rfa2f79d  
    5454}
    5555
    56 /** String representation of USB transaction outcome. */
    57 const 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 
    7256/**
    7357 * @}
Note: See TracChangeset for help on using the changeset viewer.