Changeset eb1a2f4 in mainline for uspace/drv/vhc


Ignore:
Timestamp:
2011-02-22T23:30:56Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3b5d1535, a9c674e0
Parents:
dbe25f1 (diff), 664af708 (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 mainline changes (DDF refactoring)

This merge includes DDF refactoring that brought multifunctional devices
(i.e. ddf_dev_t and ddf_fun_t). Please, see ticket #295 at HelenOS
upstream Trac.

The conflicts themselves were easy to solve (merely several renamings).

Changes to USB subsystem:

  • drivers uses ddf_dev_t and ddf_fun_t
  • different signatures of many library functions
  • several hacks around communication with parent device (now the communication is clearer and somehow what we have now is hack about other hacks)
    • will repair and clean later
  • maybe added some extra debugging messages (the diff has about 240K, and I admit I have no energy to double check that)

WARNING:

  • the diff is VERY long, recommended is viewing partial diffs of the merge (i.e. merges in mainline branch that lead to the parent one)
  • merging with your branches might involve huge renamings, sorry, no other way is possible

BUGS:

  • hub driver will not work (no function created)

GOOD NEWS:

  • QEMU keyboard seems to work with QEMU 0.13 and 0.14
  • we are up-to-date with mainline again
Location:
uspace/drv/vhc
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/vhc/conn.h

    rdbe25f1 reb1a2f4  
    4646extern usbhc_iface_t vhc_iface;
    4747extern usb_iface_t vhc_usb_iface;
     48extern usb_iface_t rh_usb_iface;
    4849
    4950void address_init(void);
    5051
    5152
    52 void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
    53 void on_client_close(device_t *);
     53void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
     54void on_client_close(ddf_fun_t *);
    5455
    5556

  • uspace/drv/vhc/conndev.c

    rdbe25f1 reb1a2f4  
    7676/** Default handler for IPC methods not handled by DDF.
    7777 *
    78  * @param dev Device handling the call.
     78 * @param fun Device handling the call.
    7979 * @param icallid Call id.
    8080 * @param icall Call data.
    8181 */
    82 void default_connection_handler(device_t *dev,
     82void default_connection_handler(ddf_fun_t *fun,
    8383    ipc_callid_t icallid, ipc_call_t *icall)
    8484{
    … …  
    112112 * @param d Device the client was connected to.
    113113 */
    114 void on_client_close(device_t *d)
     114void on_client_close(ddf_fun_t *fun)
    115115{
    116116        /*

  • uspace/drv/vhc/connhost.c

    rdbe25f1 reb1a2f4  
    4848        usbhc_iface_transfer_out_callback_t out_callback;
    4949        usbhc_iface_transfer_in_callback_t in_callback;
    50         device_t *dev;
     50        ddf_fun_t *fun;
    5151        size_t reported_size;
    5252        void *arg;
    … …  
    5858        usbhc_iface_transfer_out_callback_t out_callback;
    5959        usbhc_iface_transfer_in_callback_t in_callback;
    60         device_t *dev;
     60        ddf_fun_t *fun;
    6161        void *arg;
    6262        void *data_buffer;
    … …  
    7575        switch (transfer->direction) {
    7676                case USB_DIRECTION_IN:
    77                         transfer->in_callback(transfer->dev,
     77                        transfer->in_callback(transfer->fun,
    7878                            outcome, size,
    7979                            transfer->arg);
    8080                        break;
    8181                case USB_DIRECTION_OUT:
    82                         transfer->out_callback(transfer->dev,
     82                        transfer->out_callback(transfer->fun,
    8383                            outcome,
    8484                            transfer->arg);
    … …  
    9292}
    9393
    94 static transfer_info_t *create_transfer_info(device_t *dev,
     94static transfer_info_t *create_transfer_info(ddf_fun_t *fun,
    9595    usb_direction_t direction, void *arg)
    9696{
    … …  
    101101        transfer->out_callback = NULL;
    102102        transfer->arg = arg;
    103         transfer->dev = dev;
     103        transfer->fun = fun;
    104104        transfer->reported_size = (size_t) -1;
    105105
    … …  
    112112        switch (transfer->direction) {
    113113                case USB_DIRECTION_IN:
    114                         transfer->in_callback(transfer->dev,
     114                        transfer->in_callback(transfer->fun,
    115115                            outcome, size,
    116116                            transfer->arg);
    117117                        break;
    118118                case USB_DIRECTION_OUT:
    119                         transfer->out_callback(transfer->dev,
     119                        transfer->out_callback(transfer->fun,
    120120                            outcome,
    121121                            transfer->arg);
    … …  
    138138        }
    139139
    140         transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->dev,
     140        transfer_info_t *transfer  = create_transfer_info(ctrl_transfer->fun,
    141141            ctrl_transfer->direction, ctrl_transfer->arg);
    142142        transfer->out_callback = ctrl_transfer->out_callback;
    … …  
    195195}
    196196
    197 static control_transfer_info_t *create_control_transfer_info(device_t *dev,
     197static control_transfer_info_t *create_control_transfer_info(ddf_fun_t *fun,
    198198    usb_direction_t direction, usb_target_t target,
    199199    void *data_buffer, size_t data_buffer_size,
    … …  
    208208        transfer->out_callback = NULL;
    209209        transfer->arg = arg;
    210         transfer->dev = dev;
     210        transfer->fun = fun;
    211211        transfer->data_buffer = data_buffer;
    212212        transfer->data_buffer_size = data_buffer_size;
    … …  
    215215}
    216216
    217 static int enqueue_transfer_out(device_t *dev,
     217static int enqueue_transfer_out(ddf_fun_t *fun,
    218218    usb_target_t target, usb_transfer_type_t transfer_type,
    219219    void *buffer, size_t size,
    … …  
    226226
    227227        transfer_info_t *transfer
    228             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     228            = create_transfer_info(fun, USB_DIRECTION_OUT, arg);
    229229        transfer->out_callback = callback;
    230230
    … …  
    235235}
    236236
    237 static int enqueue_transfer_in(device_t *dev,
     237static int enqueue_transfer_in(ddf_fun_t *fun,
    238238    usb_target_t target, usb_transfer_type_t transfer_type,
    239239    void *buffer, size_t size,
    … …  
    246246
    247247        transfer_info_t *transfer
    248             = create_transfer_info(dev, USB_DIRECTION_IN, arg);
     248            = create_transfer_info(fun, USB_DIRECTION_IN, arg);
    249249        transfer->in_callback = callback;
    250250
    … …  
    256256
    257257
    258 static int interrupt_out(device_t *dev, usb_target_t target,
     258static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
    259259    size_t max_packet_size,
    260260    void *data, size_t size,
    261261    usbhc_iface_transfer_out_callback_t callback, void *arg)
    262262{
    263         return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
     263        return enqueue_transfer_out(fun, target, USB_TRANSFER_INTERRUPT,
    264264            data, size,
    265265            callback, arg);
    266266}
    267267
    268 static int interrupt_in(device_t *dev, usb_target_t target,
     268static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
    269269    size_t max_packet_size,
    270270    void *data, size_t size,
    271271    usbhc_iface_transfer_in_callback_t callback, void *arg)
    272272{
    273         return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
     273        return enqueue_transfer_in(fun, target, USB_TRANSFER_INTERRUPT,
    274274            data, size,
    275275            callback, arg);
    276276}
    277277
    278 static int control_write(device_t *dev, usb_target_t target,
     278static int control_write(ddf_fun_t *fun, usb_target_t target,
    279279    size_t max_packet_size,
    280280    void *setup_packet, size_t setup_packet_size,
    … …  
    283283{
    284284        control_transfer_info_t *transfer
    285             = create_control_transfer_info(dev, USB_DIRECTION_OUT, target,
     285            = create_control_transfer_info(fun, USB_DIRECTION_OUT, target,
    286286            data, data_size, arg);
    287287        transfer->out_callback = callback;
    … …  
    294294}
    295295
    296 static int control_read(device_t *dev, usb_target_t target,
     296static int control_read(ddf_fun_t *fun, usb_target_t target,
    297297    size_t max_packet_size,
    298298    void *setup_packet, size_t setup_packet_size,
    … …  
    301301{
    302302        control_transfer_info_t *transfer
    303             = create_control_transfer_info(dev, USB_DIRECTION_IN, target,
     303            = create_control_transfer_info(fun, USB_DIRECTION_IN, target,
    304304            data, data_size, arg);
    305305        transfer->in_callback = callback;
    … …  
    314314static usb_address_keeping_t addresses;
    315315
    316 static int tell_address(device_t *dev, devman_handle_t handle,
     316static int tell_address(ddf_fun_t *fun, devman_handle_t handle,
    317317    usb_address_t *address)
    318318{
     319        usb_log_debug("tell_address(fun \"%s\", handle %zu)\n",
     320            fun->name, (size_t) fun->handle);
    319321        usb_address_t addr = usb_address_keeping_find(&addresses, handle);
    320322        if (addr < 0) {
    … …  
    326328}
    327329
    328 static int reserve_default_address(device_t *dev, usb_speed_t ignored)
     330static int reserve_default_address(ddf_fun_t *fun, usb_speed_t ignored)
    329331{
    330332        usb_address_keeping_reserve_default(&addresses);
    … …  
    332334}
    333335
    334 static int release_default_address(device_t *dev)
     336static int release_default_address(ddf_fun_t *fun)
    335337{
    336338        usb_address_keeping_release_default(&addresses);
    … …  
    338340}
    339341
    340 static int request_address(device_t *dev, usb_speed_t ignored,
     342static int request_address(ddf_fun_t *fun, usb_speed_t ignored,
    341343    usb_address_t *address)
    342344{
    … …  
    350352}
    351353
    352 static int release_address(device_t *dev, usb_address_t address)
     354static int release_address(ddf_fun_t *fun, usb_address_t address)
    353355{
    354356        return usb_address_keeping_release(&addresses, address);
    355357}
    356358
    357 static int bind_address(device_t *dev, usb_address_t address,
     359static int bind_address(ddf_fun_t *fun, usb_address_t address,
    358360    devman_handle_t handle)
    359361{
    360362        usb_address_keeping_devman_bind(&addresses, address, handle);
    361363        return EOK;
     364}
     365
     366static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
     367    devman_handle_t *handle)
     368{
     369        ddf_fun_t *hc_fun = root_hub_fun->driver_data;
     370        assert(hc_fun != NULL);
     371
     372        *handle = hc_fun->handle;
     373
     374        usb_log_debug("usb_iface_get_hc_handle_rh_impl returns %zu\n", *handle);
     375
     376        return EOK;
     377}
     378
     379static int tell_address_rh(ddf_fun_t *root_hub_fun, devman_handle_t handle,
     380    usb_address_t *address)
     381{
     382        ddf_fun_t *hc_fun = root_hub_fun->driver_data;
     383        assert(hc_fun != NULL);
     384
     385        return tell_address(hc_fun, root_hub_fun->handle, address);
    362386}
    363387
    … …  
    386410};
    387411
     412usb_iface_t rh_usb_iface = {
     413        .get_hc_handle = usb_iface_get_hc_handle_rh_impl,
     414        .get_address = tell_address_rh
     415};
     416
    388417
    389418/**

  • uspace/drv/vhc/hcd.c

    rdbe25f1 reb1a2f4  
    4242#include <errno.h>
    4343#include <str_error.h>
    44 #include <driver.h>
     44#include <ddf/driver.h>
    4545
    4646#include <usb/usb.h>
    … …  
    5353#include "conn.h"
    5454
    55 static device_ops_t vhc_ops = {
     55static ddf_dev_ops_t vhc_ops = {
    5656        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
    5757        .interfaces[USB_DEV_IFACE] = &vhc_usb_iface,
    … …  
    6060};
    6161
    62 static int vhc_count = 0;
    63 static int vhc_add_device(device_t *dev)
     62static int vhc_add_device(ddf_dev_t *dev)
    6463{
     64        static int vhc_count = 0;
     65        int rc;
     66
    6567        /*
    6668         * Currently, we know how to simulate only single HC.
    … …  
    7072        }
    7173
    72         vhc_count++;
     74        /*
     75         * Create exposed function representing the host controller
     76         * itself.
     77         */
     78        ddf_fun_t *hc = ddf_fun_create(dev, fun_exposed, "hc");
     79        if (hc == NULL) {
     80                usb_log_fatal("Failed to create device function.\n");
     81                return ENOMEM;
     82        }
    7383
    74         dev->ops = &vhc_ops;
     84        hc->ops = &vhc_ops;
    7585
    76         devman_add_device_to_class(dev->handle, "usbhc");
     86        rc = ddf_fun_bind(hc);
     87        if (rc != EOK) {
     88                usb_log_fatal("Failed to bind HC function: %s.\n",
     89                    str_error(rc));
     90                return rc;
     91        }
     92
     93        ddf_fun_add_to_class(hc, "usbhc");
    7794
    7895        /*
    7996         * Initialize our hub and announce its presence.
    8097         */
    81         virtual_hub_device_init(dev);
     98        virtual_hub_device_init(hc);
    8299
    83         usb_log_info("Virtual USB host controller ready (id = %zu).\n",
    84             (size_t) dev->handle);
     100        usb_log_info("Virtual USB host controller ready (dev %zu, hc %zu).\n",
     101            (size_t) dev->handle, (size_t) hc->handle);
    85102
    86103        return EOK;
    … …  
    103120         * in devman output.
    104121         */
    105         sleep(5);
     122        //sleep(5);
    106123
    107         usb_log_enable(USB_LOG_LEVEL_INFO, NAME);
     124        usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
    108125
    109126        printf(NAME ": virtual USB host controller driver.\n");
    … …  
    122139         * We are also a driver within devman framework.
    123140         */
    124         return driver_main(&vhc_driver);
     141        return ddf_driver_main(&vhc_driver);
    125142}
    126143

  • uspace/drv/vhc/hub.c

    rdbe25f1 reb1a2f4  
    3939#include <str_error.h>
    4040#include <stdlib.h>
    41 #include <driver.h>
     41#include <ddf/driver.h>
     42#include <devman.h>
    4243#include <usb/hub.h>
    4344#include <usb/recognise.h>
    … …  
    4647#include "hub/virthub.h"
    4748#include "vhcd.h"
     49#include "conn.h"
    4850
    4951usbvirt_device_t virtual_hub_device;
     52static ddf_dev_ops_t rh_ops = {
     53        .interfaces[USB_DEV_IFACE] = &rh_usb_iface,
     54};
    5055
    5156static int hub_register_in_devman_fibril(void *arg);
    5257
    53 void virtual_hub_device_init(device_t *hc_dev)
     58void virtual_hub_device_init(ddf_fun_t *hc_dev)
    5459{
    5560        virthub_init(&virtual_hub_device);
    … …  
    8388int hub_register_in_devman_fibril(void *arg)
    8489{
    85         device_t *hc_dev = (device_t *) arg;
     90        ddf_fun_t *hc_dev = (ddf_fun_t *) arg;
    8691
    8792        /*
    … …  
    9499        async_hangup(phone);
    95100
     101        int rc;
     102
    96103        usb_hc_connection_t hc_conn;
    97         usb_hc_connection_initialize(&hc_conn, hc_dev->handle);
     104        rc = usb_hc_connection_initialize(&hc_conn, hc_dev->handle);
     105        assert(rc == EOK);
    98106
    99         usb_hc_connection_open(&hc_conn);
     107        rc = usb_hc_connection_open(&hc_conn);
     108        assert(rc == EOK);
    100109
    101         int rc = usb_hc_new_device_wrapper(hc_dev, &hc_conn, USB_SPEED_FULL,
     110        ddf_fun_t *hub_dev;
     111        rc = usb_hc_new_device_wrapper(hc_dev->dev, &hc_conn,
     112            USB_SPEED_FULL,
    102113            pretend_port_rest, 0, NULL,
    103             NULL, NULL);
     114            NULL, NULL, &rh_ops, hc_dev, &hub_dev);
    104115        if (rc != EOK) {
    105116                usb_log_fatal("Failed to create root hub: %s.\n",
    … …  
    108119
    109120        usb_hc_connection_close(&hc_conn);
     121
     122        usb_log_info("Created root hub function (handle %zu).\n",
     123            (size_t) hub_dev->handle);
    110124
    111125        return 0;

  • uspace/drv/vhc/hub.h

    rdbe25f1 reb1a2f4  
    3737
    3838#include <usbvirt/device.h>
    39 #include <driver.h>
     39#include <ddf/driver.h>
    4040
    4141#include "devices.h"
    … …  
    4545extern usbvirt_device_t virtual_hub_device;
    4646
    47 void virtual_hub_device_init(device_t *);
     47void virtual_hub_device_init(ddf_fun_t *);
    4848
    4949#endif

  • uspace/drv/vhc/hub/hub.c

    rdbe25f1 reb1a2f4  
    3838#include <errno.h>
    3939#include <str_error.h>
     40#include <assert.h>
    4041#include <stdlib.h>
    41 #include <driver.h>
     42#include <ddf/driver.h>
    4243
    4344#include "hub.h"

  • uspace/drv/vhc/hub/virthub.c

    rdbe25f1 reb1a2f4  
    3939#include <errno.h>
    4040#include <str_error.h>
     41#include <assert.h>
    4142#include <stdlib.h>
    42 #include <driver.h>
     43#include <ddf/driver.h>
    4344
    4445#include "virthub.h"
Note: See TracChangeset for help on using the changeset viewer.