Changes in / [36c410e:2cb6571] in mainline


Ignore:
Files:
3 added
10 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • .bzrignore

    r36c410e r2cb6571  
    9494./uspace/dist/drv/rootia32/
    9595./uspace/dist/drv/uhci/
    96 ./uspace/dist/drv/usbhub/
    9796./uspace/dist/drv/usbkbd/
    9897./uspace/dist/drv/vhc/
    … …  
    131130./uspace/drv/rootia32/rootia32
    132131./uspace/drv/uhci/uhci
    133 ./uspace/drv/usbhub/usbhub
    134132./uspace/drv/usbkbd/usbkbd
    135133./uspace/drv/vhc/vhc

  • boot/arch/amd64/Makefile.inc

    r36c410e r2cb6571  
    4242        ns8250 \
    4343        uhci \
    44         usbhub \
    4544        usbkbd
    4645       

  • uspace/Makefile

    r36c410e r2cb6571  
    118118        DIRS += drv/ns8250
    119119        DIRS += drv/uhci
    120         DIRS += drv/usbhub
    121120        DIRS += drv/usbkbd
    122121endif

  • uspace/drv/uhci/Makefile

    r36c410e r2cb6571  
    3333
    3434SOURCES = \
    35         main.c \
    36         transfers.c
     35        main.c
    3736
    3837include $(USPACE_PREFIX)/Makefile.common

  • uspace/drv/uhci/main.c

    r36c410e r2cb6571  
    2828#include <usb/hcdhubd.h>
    2929#include <errno.h>
    30 #include "uhci.h"
    3130
    32 static device_ops_t uhci_ops = {
    33         .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
     31static int enqueue_transfer_out(usb_hc_device_t *hc,
     32    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     33    void *buffer, size_t size,
     34    usb_hcd_transfer_callback_out_t callback, void *arg)
     35{
     36        printf("UHCI: transfer OUT [%d.%d (%s); %u]\n",
     37            dev->address, endpoint->endpoint,
     38            usb_str_transfer_type(endpoint->transfer_type),
     39            size);
     40        return ENOTSUP;
     41}
     42
     43static int enqueue_transfer_setup(usb_hc_device_t *hc,
     44    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     45    void *buffer, size_t size,
     46    usb_hcd_transfer_callback_out_t callback, void *arg)
     47{
     48        printf("UHCI: transfer SETUP [%d.%d (%s); %u]\n",
     49            dev->address, endpoint->endpoint,
     50            usb_str_transfer_type(endpoint->transfer_type),
     51            size);
     52        return ENOTSUP;
     53}
     54
     55static int enqueue_transfer_in(usb_hc_device_t *hc,
     56    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     57    void *buffer, size_t size,
     58    usb_hcd_transfer_callback_in_t callback, void *arg)
     59{
     60        printf("UHCI: transfer IN [%d.%d (%s); %u]\n",
     61            dev->address, endpoint->endpoint,
     62            usb_str_transfer_type(endpoint->transfer_type),
     63            size);
     64        return ENOTSUP;
     65}
     66
     67static usb_hcd_transfer_ops_t uhci_transfer_ops = {
     68        .transfer_out = enqueue_transfer_out,
     69        .transfer_in = enqueue_transfer_in,
     70        .transfer_setup = enqueue_transfer_setup
    3471};
    3572
    36 static int uhci_add_device(device_t *device)
     73static int uhci_add_hc(usb_hc_device_t *device)
    3774{
    38         device->ops = &uhci_ops;
     75        device->transfer_ops = &uhci_transfer_ops;
    3976
    4077        /*
    … …  
    4683}
    4784
    48 static driver_ops_t uhci_driver_ops = {
    49         .add_device = uhci_add_device,
    50 };
    51 
    52 static driver_t uhci_driver = {
    53         .name = NAME,
    54         .driver_ops = &uhci_driver_ops
     85usb_hc_driver_t uhci_driver = {
     86        .name = "uhci",
     87        .add_hc = uhci_add_hc
    5588};
    5689
    … …  
    6093         * Do some global initializations.
    6194         */
    62         sleep(5);
    6395
    64         return driver_main(&uhci_driver);
     96        return usb_hcd_main(&uhci_driver);
    6597}

  • uspace/drv/uhci/uhci.ma

    r36c410e r2cb6571  
    1110 pci/ven=8086&dev=7020
    2 
     210 usb&hc=uhci
     310 usb&hc=uhci&hub

  • uspace/drv/vhc/conn.h

    r36c410e r2cb6571  
    3838#include <usb/usb.h>
    3939#include <usb/hcdhubd.h>
    40 #include <usbhc_iface.h>
    4140#include "vhcd.h"
    4241#include "devices.h"
    … …  
    4544
    4645usb_hcd_transfer_ops_t vhc_transfer_ops;
    47 usbhc_iface_t vhc_iface;
    4846
    4947void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);

  • uspace/drv/vhc/connhost.c

    r36c410e r2cb6571  
    4343typedef struct {
    4444        usb_direction_t direction;
    45         usbhc_iface_transfer_out_callback_t out_callback;
    46         usbhc_iface_transfer_in_callback_t in_callback;
    47         device_t *dev;
     45        usb_hcd_transfer_callback_out_t out_callback;
     46        usb_hcd_transfer_callback_in_t in_callback;
     47        usb_hc_device_t *hc;
    4848        void *arg;
    4949} transfer_info_t;
    … …  
    5656        switch (transfer->direction) {
    5757                case USB_DIRECTION_IN:
    58                         transfer->in_callback(transfer->dev,
     58                        transfer->in_callback(transfer->hc,
    5959                            size, outcome,
    6060                            transfer->arg);
    6161                        break;
    6262                case USB_DIRECTION_OUT:
    63                         transfer->out_callback(transfer->dev,
     63                        transfer->out_callback(transfer->hc,
    6464                            outcome,
    6565                            transfer->arg);
    … …  
    7373}
    7474
    75 static transfer_info_t *create_transfer_info(device_t *dev,
     75static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
    7676    usb_direction_t direction, void *arg)
    7777{
    … …  
    8282        transfer->out_callback = NULL;
    8383        transfer->arg = arg;
    84         transfer->dev = dev;
     84        transfer->hc = hc;
    8585
    8686        return transfer;
    8787}
    8888
    89 static int enqueue_transfer_out(device_t *dev,
    90     usb_target_t target, usb_transfer_type_t transfer_type,
     89static int enqueue_transfer_out(usb_hc_device_t *hc,
     90    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    9191    void *buffer, size_t size,
    92     usbhc_iface_transfer_out_callback_t callback, void *arg)
     92    usb_hcd_transfer_callback_out_t callback, void *arg)
    9393{
    9494        printf(NAME ": transfer OUT [%d.%d (%s); %u]\n",
    95             target.address, target.endpoint,
    96             usb_str_transfer_type(transfer_type),
     95            dev->address, endpoint->endpoint,
     96            usb_str_transfer_type(endpoint->transfer_type),
    9797            size);
    9898
    9999        transfer_info_t *transfer
    100             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     100            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    101101        transfer->out_callback = callback;
     102
     103        usb_target_t target = {
     104                .address = dev->address,
     105                .endpoint = endpoint->endpoint
     106        };
    102107
    103108        hc_add_transaction_to_device(false, target, buffer, size,
    … …  
    107112}
    108113
    109 static int enqueue_transfer_setup(device_t *dev,
    110     usb_target_t target, usb_transfer_type_t transfer_type,
     114static int enqueue_transfer_setup(usb_hc_device_t *hc,
     115    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    111116    void *buffer, size_t size,
    112     usbhc_iface_transfer_out_callback_t callback, void *arg)
     117    usb_hcd_transfer_callback_out_t callback, void *arg)
    113118{
    114119        printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n",
    115             target.address, target.endpoint,
    116             usb_str_transfer_type(transfer_type),
     120            dev->address, endpoint->endpoint,
     121            usb_str_transfer_type(endpoint->transfer_type),
    117122            size);
    118123
    119124        transfer_info_t *transfer
    120             = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
     125            = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
    121126        transfer->out_callback = callback;
     127
     128        usb_target_t target = {
     129                .address = dev->address,
     130                .endpoint = endpoint->endpoint
     131        };
    122132
    123133        hc_add_transaction_to_device(true, target, buffer, size,
    … …  
    127137}
    128138
    129 static int enqueue_transfer_in(device_t *dev,
    130     usb_target_t target, usb_transfer_type_t transfer_type,
     139static int enqueue_transfer_in(usb_hc_device_t *hc,
     140    usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
    131141    void *buffer, size_t size,
    132     usbhc_iface_transfer_in_callback_t callback, void *arg)
     142    usb_hcd_transfer_callback_in_t callback, void *arg)
    133143{
    134144        printf(NAME ": transfer IN [%d.%d (%s); %u]\n",
    135             target.address, target.endpoint,
    136             usb_str_transfer_type(transfer_type),
     145            dev->address, endpoint->endpoint,
     146            usb_str_transfer_type(endpoint->transfer_type),
    137147            size);
    138148
    139149        transfer_info_t *transfer
    140             = create_transfer_info(dev, USB_DIRECTION_IN, arg);
     150            = create_transfer_info(hc, USB_DIRECTION_IN, arg);
    141151        transfer->in_callback = callback;
     152
     153        usb_target_t target = {
     154                .address = dev->address,
     155                .endpoint = endpoint->endpoint
     156        };
    142157
    143158        hc_add_transaction_from_device(target, buffer, size,
    … …  
    148163
    149164
    150 static int get_address(device_t *dev, devman_handle_t handle,
    151     usb_address_t *address)
    152 {
    153         return ENOTSUP;
    154 }
    155 
    156 static int interrupt_out(device_t *dev, usb_target_t target,
    157     void *data, size_t size,
    158     usbhc_iface_transfer_out_callback_t callback, void *arg)
    159 {
    160         return enqueue_transfer_out(dev, target, USB_TRANSFER_INTERRUPT,
    161             data, size,
    162             callback, arg);
    163 }
    164 
    165 static int interrupt_in(device_t *dev, usb_target_t target,
    166     void *data, size_t size,
    167     usbhc_iface_transfer_in_callback_t callback, void *arg)
    168 {
    169         return enqueue_transfer_in(dev, target, USB_TRANSFER_INTERRUPT,
    170             data, size,
    171             callback, arg);
    172 }
    173 
    174 static int control_write_setup(device_t *dev, usb_target_t target,
    175     void *data, size_t size,
    176     usbhc_iface_transfer_out_callback_t callback, void *arg)
    177 {
    178         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    179             data, size,
    180             callback, arg);
    181 }
    182 
    183 static int control_write_data(device_t *dev, usb_target_t target,
    184     void *data, size_t size,
    185     usbhc_iface_transfer_out_callback_t callback, void *arg)
    186 {
    187         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    188             data, size,
    189             callback, arg);
    190 }
    191 
    192 static int control_write_status(device_t *dev, usb_target_t target,
    193     usbhc_iface_transfer_in_callback_t callback, void *arg)
    194 {
    195         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    196             NULL, 0,
    197             callback, arg);
    198 }
    199 
    200 static int control_read_setup(device_t *dev, usb_target_t target,
    201     void *data, size_t size,
    202     usbhc_iface_transfer_out_callback_t callback, void *arg)
    203 {
    204         return enqueue_transfer_setup(dev, target, USB_TRANSFER_CONTROL,
    205             data, size,
    206             callback, arg);
    207 }
    208 
    209 static int control_read_data(device_t *dev, usb_target_t target,
    210     void *data, size_t size,
    211     usbhc_iface_transfer_in_callback_t callback, void *arg)
    212 {
    213         return enqueue_transfer_in(dev, target, USB_TRANSFER_CONTROL,
    214             data, size,
    215             callback, arg);
    216 }
    217 
    218 static int control_read_status(device_t *dev, usb_target_t target,
    219     usbhc_iface_transfer_out_callback_t callback, void *arg)
    220 {
    221         return enqueue_transfer_out(dev, target, USB_TRANSFER_CONTROL,
    222             NULL, 0,
    223             callback, arg);
    224 }
    225 
    226 
    227 usbhc_iface_t vhc_iface = {
    228         .tell_address = get_address,
    229         .interrupt_out = interrupt_out,
    230         .interrupt_in = interrupt_in,
    231         .control_write_setup = control_write_setup,
    232         .control_write_data = control_write_data,
    233         .control_write_status = control_write_status,
    234         .control_read_setup = control_read_setup,
    235         .control_read_data = control_read_data,
    236         .control_read_status = control_read_status
     165usb_hcd_transfer_ops_t vhc_transfer_ops = {
     166        .transfer_out = enqueue_transfer_out,
     167        .transfer_in = enqueue_transfer_in,
     168        .transfer_setup = enqueue_transfer_setup
    237169};
    238170

  • uspace/drv/vhc/hcd.c

    r36c410e r2cb6571  
    5252#include "conn.h"
    5353
    54 static device_ops_t vhc_ops = {
    55         .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
    56         .default_handler = default_connection_handler
    57 };
    5854
    5955static int vhc_count = 0;
    60 static int vhc_add_device(device_t *dev)
     56static int vhc_add_device(usb_hc_device_t *dev)
    6157{
    6258        /*
    … …  
    6965        vhc_count++;
    7066
    71         dev->ops = &vhc_ops;
     67        dev->transfer_ops = &vhc_transfer_ops;
     68        dev->generic->ops->default_handler = default_connection_handler;
    7269
    7370        /*
    … …  
    8279}
    8380
    84 static driver_ops_t vhc_driver_ops = {
    85         .add_device = vhc_add_device,
    86 };
    87 
    88 static driver_t vhc_driver = {
     81static usb_hc_driver_t vhc_driver = {
    8982        .name = NAME,
    90         .driver_ops = &vhc_driver_ops
     83        .add_hc = &vhc_add_device
    9184};
    9285
    … …  
    121114        sleep(4);
    122115
    123         return driver_main(&vhc_driver);
     116        return usb_hcd_main(&vhc_driver);
    124117}
    125118

  • uspace/drv/vhc/vhc.ma

    r36c410e r2cb6571  
    1110 usb&hc=vhc
    2 
     210 usb&hc=vhc&hub

  • uspace/lib/usb/Makefile

    r36c410e r2cb6571  
    3535        src/hcdhubd.c \
    3636        src/hcdrv.c \
     37        src/hubdrv.c \
    3738        src/localdrv.c \
    3839        src/remotedrv.c \

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

    r36c410e r2cb6571  
    166166
    167167int usb_hcd_main(usb_hc_driver_t *);
    168 int usb_hcd_add_root_hub(device_t *dev);
     168int usb_hcd_add_root_hub(usb_hc_device_t *dev);
    169169
    170170/**

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

    r36c410e r2cb6571  
    5151 */
    5252static int add_device(device_t *dev) {
    53         return ENOTSUP;
     53        bool is_hc = str_cmp(dev->name, USB_HUB_DEVICE_NAME) != 0;
     54        printf("%s: add_device(name=\"%s\")\n", hc_driver->name, dev->name);
     55
     56        if (is_hc) {
     57                /*
     58                 * We are the HC itself.
     59                 */
     60                return usb_add_hc_device(dev);
     61        } else {
     62                /*
     63                 * We are some (maybe deeply nested) hub.
     64                 * Thus, assign our own operations and explore already
     65                 * connected devices.
     66                 */
     67                return usb_add_hub_device(dev);
     68        }
    5469}
    5570
    … …  
    90105 * @return Error code.
    91106 */
    92 int usb_hcd_add_root_hub(device_t *dev)
    93 {
     107int usb_hcd_add_root_hub(usb_hc_device_t *dev) {
    94108        char *id;
    95         int rc = asprintf(&id, "usb&hub");
     109        int rc = asprintf(&id, "usb&hc=%s&hub", hc_driver->name);
    96110        if (rc <= 0) {
    97111                return rc;
    98112        }
    99113
    100         rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true);
     114        rc = usb_hc_add_child_device(dev->generic, USB_HUB_DEVICE_NAME, id, true);
    101115        if (rc != EOK) {
    102116                free(id);

  • uspace/lib/usb/src/hcdhubd_private.h

    r36c410e r2cb6571  
    4646usb_address_t usb_get_address_by_handle(devman_handle_t);
    4747int usb_add_hc_device(device_t *);
     48int usb_add_hub_device(device_t *);
    4849
    4950/** lowest allowed usb address */

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

    r36c410e r2cb6571  
    4747LIST_INITIALIZE(hc_list);
    4848
    49 /* Fake driver to have the name item initialized. */
    50 static usb_hc_driver_t hc_driver_fake = {
    51         .name = "HCD",
    52 };
    53 
    5449/** Our HC driver. */
    55 usb_hc_driver_t *hc_driver = &hc_driver_fake;
     50usb_hc_driver_t *hc_driver = NULL;
    5651
    5752int usb_lowest_address = 1;
    … …  
    9186int usb_add_hc_device(device_t *dev)
    9287{
    93         return ENOTSUP;
    9488        usb_hc_device_t *hc_dev = usb_hc_device_create(dev);
    9589
Note: See TracChangeset for help on using the changeset viewer.