Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 54b141a in mainline


Ignore:
Timestamp:
2010-12-04T17:01:24Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master
Children:
e28d228
Parents:
2cb6571 (diff), ad104e0 (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 with vojtechhorky/

Files:
7 added
20 edited
1 moved

Legend:

Unmodified
Added
Removed
  • .bzrignore

    r2cb6571 r54b141a  
    9494./uspace/dist/drv/rootia32/
    9595./uspace/dist/drv/uhci/
     96./uspace/dist/drv/usbhub/
    9697./uspace/dist/drv/usbkbd/
    9798./uspace/dist/drv/vhc/
     
    130131./uspace/drv/rootia32/rootia32
    131132./uspace/drv/uhci/uhci
     133./uspace/drv/usbhub/usbhub
    132134./uspace/drv/usbkbd/usbkbd
    133135./uspace/drv/vhc/vhc
  • boot/arch/amd64/Makefile.inc

    r2cb6571 r54b141a  
    4242        ns8250 \
    4343        uhci \
     44        usbhub \
    4445        usbkbd
    4546       
  • uspace/Makefile

    r2cb6571 r54b141a  
    118118        DIRS += drv/ns8250
    119119        DIRS += drv/uhci
     120        DIRS += drv/usbhub
    120121        DIRS += drv/usbkbd
    121122endif
  • uspace/drv/uhci/Makefile

    r2cb6571 r54b141a  
    3333
    3434SOURCES = \
    35         main.c
     35        main.c \
     36        transfers.c
    3637
    3738include $(USPACE_PREFIX)/Makefile.common
  • uspace/drv/uhci/main.c

    r2cb6571 r54b141a  
    2828#include <usb/hcdhubd.h>
    2929#include <errno.h>
     30#include "uhci.h"
    3031
    31 static 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 
    43 static 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 
    55 static 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 
    67 static 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
     32static device_ops_t uhci_ops = {
     33        .interfaces[USBHC_DEV_IFACE] = &uhci_iface,
    7134};
    7235
    73 static int uhci_add_hc(usb_hc_device_t *device)
     36static int uhci_add_device(device_t *device)
    7437{
    75         device->transfer_ops = &uhci_transfer_ops;
     38        device->ops = &uhci_ops;
    7639
    7740        /*
     
    8346}
    8447
    85 usb_hc_driver_t uhci_driver = {
    86         .name = "uhci",
    87         .add_hc = uhci_add_hc
     48static driver_ops_t uhci_driver_ops = {
     49        .add_device = uhci_add_device,
     50};
     51
     52static driver_t uhci_driver = {
     53        .name = NAME,
     54        .driver_ops = &uhci_driver_ops
    8855};
    8956
     
    9360         * Do some global initializations.
    9461         */
     62        sleep(5);
    9563
    96         return usb_hcd_main(&uhci_driver);
     64        return driver_main(&uhci_driver);
    9765}
  • uspace/drv/uhci/uhci.ma

    r2cb6571 r54b141a  
    1110 pci/ven=8086&dev=7020
    2 10 usb&hc=uhci
    3 10 usb&hc=uhci&hub
     2
  • uspace/drv/usbhub/utils.c

    r2cb6571 r54b141a  
    3333 * @brief Hub driver.
    3434 */
    35 #include <usb/hcdhubd.h>
     35#include <driver.h>
    3636#include <usb/devreq.h>
    3737#include <usbhc_iface.h>
     38#include <usb/usbdrv.h>
    3839#include <usb/descriptor.h>
    3940#include <driver.h>
     
    4142#include <errno.h>
    4243#include <usb/classes/hub.h>
    43 #include "hcdhubd_private.h"
     44#include "usbhub.h"
    4445
    4546static void check_hub_changes(void);
     
    108109//*********************************************
    109110
    110 static void set_hub_address(usb_hc_device_t *hc, usb_address_t address);
    111 
    112111usb_hcd_hub_info_t * usb_create_hub_info(device_t * device) {
    113112        usb_hcd_hub_info_t* result = (usb_hcd_hub_info_t*) malloc(sizeof (usb_hcd_hub_info_t));
    114         //get parent device
    115         device_t * my_hcd = device;
    116         while (my_hcd->parent)
    117                 my_hcd = my_hcd->parent;
    118         //dev->
    119         printf("[hcdhubd]%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name);
    120         //we add the hub into the first hc
    121         //link_t *link_hc = hc_list.next;
    122         //usb_hc_device_t *hc = list_get_instance(link_hc,
    123         //              usb_hc_device_t, link);
    124         //must get generic device info
    125 
    126113
    127114        return result;
     
    134121 */
    135122int usb_add_hub_device(device_t *dev) {
    136         //usb_hc_device_t *hc = list_get_instance(hc_list.next, usb_hc_device_t, link);
    137         assert(dev->parent);
    138         usb_hc_device_t *hc = (usb_hc_device_t*)dev->parent->driver_data;
    139         usb_address_t addr =usb_use_free_address(hc);
    140         if(addr<0){
    141                 printf("[hcdhubd] ERROR: cannot find an address \n");
    142         }
    143         set_hub_address(hc, addr);
     123        printf(NAME ": add_hub_device(handle=%d)\n", (int) dev->handle);
    144124
    145125        check_hub_changes();
     
    150130         * connected devices.
    151131         */
    152         //insert hub into list
    153         //find owner hcd
    154         device_t * my_hcd = dev;
    155         while (my_hcd->parent)
    156                 my_hcd = my_hcd->parent;
    157         //dev->
    158         printf("[hcdhubd]%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name);
    159         my_hcd = dev;
    160         while (my_hcd->parent)
    161                 my_hcd = my_hcd->parent;
    162         //dev->
    163 
    164         printf("[hcdhubd]%s: owner hcd found: %s\n", hc_driver->name, my_hcd->name);
    165132
    166133        //create the hub structure
    167134        usb_hcd_hub_info_t * hub_info = usb_create_hub_info(dev);
    168 
    169 
    170         //append into the list
    171         //we add the hub into the first hc
    172         list_append(&hub_info->link, &hc->hubs);
    173 
    174 
     135        (void)hub_info;
    175136
    176137        return EOK;
     
    178139}
    179140
    180 /** Sample usage of usb_hc_async functions.
    181  * This function sets hub address using standard SET_ADDRESS request.
    182  *
    183  * @warning This function shall be removed once you are familiar with
    184  * the usb_hc_ API.
    185  *
    186  * @param hc Host controller the hub belongs to.
    187  * @param address New hub address.
    188  */
    189 static void set_hub_address(usb_hc_device_t *hc, usb_address_t address) {
    190         printf("[hcdhubd]%s: setting hub address to %d\n", hc->generic->name, address);
    191         usb_target_t target = {0, 0};
    192         usb_handle_t handle;
    193         int rc;
    194 
    195         usb_device_request_setup_packet_t setup_packet = {
    196                 .request_type = 0,
    197                 .request = USB_DEVREQ_SET_ADDRESS,
    198                 .index = 0,
    199                 .length = 0,
    200         };
    201         setup_packet.value = address;
    202 
    203         rc = usb_hc_async_control_write_setup(hc, target,
    204                         &setup_packet, sizeof (setup_packet), &handle);
    205         if (rc != EOK) {
    206                 return;
    207         }
    208 
    209         rc = usb_hc_async_wait_for(handle);
    210         if (rc != EOK) {
    211                 return;
    212         }
    213 
    214         rc = usb_hc_async_control_write_status(hc, target, &handle);
    215         if (rc != EOK) {
    216                 return;
    217         }
    218 
    219         rc = usb_hc_async_wait_for(handle);
    220         if (rc != EOK) {
    221                 return;
    222         }
    223 
    224         printf("[hcdhubd]%s: hub address changed successfully to %d\n",
    225                         hc->generic->name, address);
    226 }
    227141
    228142/** Check changes on all known hubs.
     
    230144static void check_hub_changes(void) {
    231145        /*
    232          * Iterate through all HCs.
     146         * Iterate through all hubs.
    233147         */
    234         link_t *link_hc;
    235         for (link_hc = hc_list.next;
    236                         link_hc != &hc_list;
    237                         link_hc = link_hc->next) {
    238                 usb_hc_device_t *hc = list_get_instance(link_hc,
    239                                 usb_hc_device_t, link);
     148        for (; false; ) {
    240149                /*
    241                  * Iterate through all their hubs.
     150                 * Check status change pipe of this hub.
    242151                 */
    243                 link_t *link_hub;
    244                 for (link_hub = hc->hubs.next;
    245                                 link_hub != &hc->hubs;
    246                                 link_hub = link_hub->next) {
    247                         usb_hcd_hub_info_t *hub = list_get_instance(link_hub,
    248                                         usb_hcd_hub_info_t, link);
     152                usb_target_t target = {
     153                        .address = 5,
     154                        .endpoint = 1
     155                };
    249156
    250                         /*
    251                          * Check status change pipe of this hub.
    252                          */
    253                         usb_target_t target = {
    254                                 .address = hub->device->address,
    255                                 .endpoint = 1
    256                         };
     157                size_t port_count = 7;
    257158
    258                         // FIXME: count properly
    259                         size_t byte_length = (hub->port_count / 8) + 1;
     159                /*
     160                 * Connect to respective HC.
     161                 */
     162                int hc = usb_drv_hc_connect(NULL, 0);
     163                if (hc < 0) {
     164                        continue;
     165                }
    260166
    261                         void *change_bitmap = malloc(byte_length);
    262                         size_t actual_size;
    263                         usb_handle_t handle;
     167                // FIXME: count properly
     168                size_t byte_length = (port_count / 8) + 1;
    264169
    265                         /*
    266                          * Send the request.
    267                          * FIXME: check returned value for possible errors
    268                          */
    269                         usb_hc_async_interrupt_in(hc, target,
    270                                         change_bitmap, byte_length, &actual_size,
    271                                         &handle);
     170                void *change_bitmap = malloc(byte_length);
     171                size_t actual_size;
     172                usb_handle_t handle;
    272173
    273                         usb_hc_async_wait_for(handle);
     174                /*
     175                 * Send the request.
     176                 * FIXME: check returned value for possible errors
     177                 */
     178                usb_drv_async_interrupt_in(hc, target,
     179                                change_bitmap, byte_length, &actual_size,
     180                                &handle);
    274181
    275                         /*
    276                          * TODO: handle the changes.
    277                          */
    278                 }
     182                usb_drv_async_wait_for(handle);
     183
     184                /*
     185                 * TODO: handle the changes.
     186                 */
     187
     188
     189                /*
     190                 * Hang-up the HC-connected phone.
     191                 */
     192                ipc_hangup(hc);
    279193        }
    280194}
  • uspace/drv/vhc/Makefile

    r2cb6571 r54b141a  
    3939
    4040SOURCES = \
     41        addrmgm.c \
    4142        conndev.c \
    4243        connhost.c \
  • uspace/drv/vhc/conn.h

    r2cb6571 r54b141a  
    3838#include <usb/usb.h>
    3939#include <usb/hcdhubd.h>
     40#include <usbhc_iface.h>
    4041#include "vhcd.h"
    4142#include "devices.h"
     
    4445
    4546usb_hcd_transfer_ops_t vhc_transfer_ops;
     47usbhc_iface_t vhc_iface;
     48
     49void address_init(void);
     50int reserve_default_address(device_t *);
     51int release_default_address(device_t *);
     52int request_address(device_t *, usb_address_t *);
     53int release_address(device_t *, usb_address_t);
     54
    4655
    4756void default_connection_handler(device_t *, ipc_callid_t, ipc_call_t *);
  • uspace/drv/vhc/connhost.c

    r2cb6571 r54b141a  
    4343typedef struct {
    4444        usb_direction_t direction;
    45         usb_hcd_transfer_callback_out_t out_callback;
    46         usb_hcd_transfer_callback_in_t in_callback;
    47         usb_hc_device_t *hc;
     45        usbhc_iface_transfer_out_callback_t out_callback;
     46        usbhc_iface_transfer_in_callback_t in_callback;
     47        device_t *dev;
    4848        void *arg;
    4949} transfer_info_t;
     
    5656        switch (transfer->direction) {
    5757                case USB_DIRECTION_IN:
    58                         transfer->in_callback(transfer->hc,
     58                        transfer->in_callback(transfer->dev,
    5959                            size, outcome,
    6060                            transfer->arg);
    6161                        break;
    6262                case USB_DIRECTION_OUT:
    63                         transfer->out_callback(transfer->hc,
     63                        transfer->out_callback(transfer->dev,
    6464                            outcome,
    6565                            transfer->arg);
     
    7373}
    7474
    75 static transfer_info_t *create_transfer_info(usb_hc_device_t *hc,
     75static transfer_info_t *create_transfer_info(device_t *dev,
    7676    usb_direction_t direction, void *arg)
    7777{
     
    8282        transfer->out_callback = NULL;
    8383        transfer->arg = arg;
    84         transfer->hc = hc;
     84        transfer->dev = dev;
    8585
    8686        return transfer;
    8787}
    8888
    89 static int enqueue_transfer_out(usb_hc_device_t *hc,
    90     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     89static int enqueue_transfer_out(device_t *dev,
     90    usb_target_t target, usb_transfer_type_t transfer_type,
    9191    void *buffer, size_t size,
    92     usb_hcd_transfer_callback_out_t callback, void *arg)
     92    usbhc_iface_transfer_out_callback_t callback, void *arg)
    9393{
    9494        printf(NAME ": transfer OUT [%d.%d (%s); %u]\n",
    95             dev->address, endpoint->endpoint,
    96             usb_str_transfer_type(endpoint->transfer_type),
     95            target.address, target.endpoint,
     96            usb_str_transfer_type(transfer_type),
    9797            size);
    9898
    9999        transfer_info_t *transfer
    100             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
     100            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
    101101        transfer->out_callback = callback;
    102 
    103         usb_target_t target = {
    104                 .address = dev->address,
    105                 .endpoint = endpoint->endpoint
    106         };
    107102
    108103        hc_add_transaction_to_device(false, target, buffer, size,
     
    112107}
    113108
    114 static int enqueue_transfer_setup(usb_hc_device_t *hc,
    115     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     109static int enqueue_transfer_setup(device_t *dev,
     110    usb_target_t target, usb_transfer_type_t transfer_type,
    116111    void *buffer, size_t size,
    117     usb_hcd_transfer_callback_out_t callback, void *arg)
     112    usbhc_iface_transfer_out_callback_t callback, void *arg)
    118113{
    119114        printf(NAME ": transfer SETUP [%d.%d (%s); %u]\n",
    120             dev->address, endpoint->endpoint,
    121             usb_str_transfer_type(endpoint->transfer_type),
     115            target.address, target.endpoint,
     116            usb_str_transfer_type(transfer_type),
    122117            size);
    123118
    124119        transfer_info_t *transfer
    125             = create_transfer_info(hc, USB_DIRECTION_OUT, arg);
     120            = create_transfer_info(dev, USB_DIRECTION_OUT, arg);
    126121        transfer->out_callback = callback;
    127 
    128         usb_target_t target = {
    129                 .address = dev->address,
    130                 .endpoint = endpoint->endpoint
    131         };
    132122
    133123        hc_add_transaction_to_device(true, target, buffer, size,
     
    137127}
    138128
    139 static int enqueue_transfer_in(usb_hc_device_t *hc,
    140     usb_hcd_attached_device_info_t *dev, usb_hc_endpoint_info_t *endpoint,
     129static int enqueue_transfer_in(device_t *dev,
     130    usb_target_t target, usb_transfer_type_t transfer_type,
    141131    void *buffer, size_t size,
    142     usb_hcd_transfer_callback_in_t callback, void *arg)
     132    usbhc_iface_transfer_in_callback_t callback, void *arg)
    143133{
    144134        printf(NAME ": transfer IN [%d.%d (%s); %u]\n",
    145             dev->address, endpoint->endpoint,
    146             usb_str_transfer_type(endpoint->transfer_type),
     135            target.address, target.endpoint,
     136            usb_str_transfer_type(transfer_type),
    147137            size);
    148138
    149139        transfer_info_t *transfer
    150             = create_transfer_info(hc, USB_DIRECTION_IN, arg);
     140            = create_transfer_info(dev, USB_DIRECTION_IN, arg);
    151141        transfer->in_callback = callback;
    152 
    153         usb_target_t target = {
    154                 .address = dev->address,
    155                 .endpoint = endpoint->endpoint
    156         };
    157142
    158143        hc_add_transaction_from_device(target, buffer, size,
     
    163148
    164149
    165 usb_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
     150static int get_address(device_t *dev, devman_handle_t handle,
     151    usb_address_t *address)
     152{
     153        return ENOTSUP;
     154}
     155
     156static 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
     165static 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
     174static 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
     183static 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
     192static 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
     200static 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
     209static 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
     218static 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
     227usbhc_iface_t vhc_iface = {
     228        .tell_address = get_address,
     229
     230        .reserve_default_address = reserve_default_address,
     231        .release_default_address = release_default_address,
     232        .request_address = request_address,
     233        .release_address = release_address,
     234
     235        .interrupt_out = interrupt_out,
     236        .interrupt_in = interrupt_in,
     237
     238        .control_write_setup = control_write_setup,
     239        .control_write_data = control_write_data,
     240        .control_write_status = control_write_status,
     241
     242        .control_read_setup = control_read_setup,
     243        .control_read_data = control_read_data,
     244        .control_read_status = control_read_status
    169245};
    170246
  • uspace/drv/vhc/hcd.c

    r2cb6571 r54b141a  
    5252#include "conn.h"
    5353
     54static device_ops_t vhc_ops = {
     55        .interfaces[USBHC_DEV_IFACE] = &vhc_iface,
     56        .default_handler = default_connection_handler
     57};
    5458
    5559static int vhc_count = 0;
    56 static int vhc_add_device(usb_hc_device_t *dev)
     60static int vhc_add_device(device_t *dev)
    5761{
    5862        /*
     
    6569        vhc_count++;
    6670
    67         dev->transfer_ops = &vhc_transfer_ops;
    68         dev->generic->ops->default_handler = default_connection_handler;
     71        dev->ops = &vhc_ops;
     72
     73        /*
     74         * Initialize address management.
     75         */
     76        address_init();
    6977
    7078        /*
     
    7987}
    8088
    81 static usb_hc_driver_t vhc_driver = {
     89static driver_ops_t vhc_driver_ops = {
     90        .add_device = vhc_add_device,
     91};
     92
     93static driver_t vhc_driver = {
    8294        .name = NAME,
    83         .add_hc = &vhc_add_device
     95        .driver_ops = &vhc_driver_ops
    8496};
    8597
     
    114126        sleep(4);
    115127
    116         return usb_hcd_main(&vhc_driver);
     128        return driver_main(&vhc_driver);
    117129}
    118130
  • uspace/drv/vhc/vhc.ma

    r2cb6571 r54b141a  
    1110 usb&hc=vhc
    2 10 usb&hc=vhc&hub
     2
  • uspace/lib/drv/generic/remote_usbhc.c

    r2cb6571 r54b141a  
    5252static void remote_usbhc_control_read_data(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5353static void remote_usbhc_control_read_status(device_t *, void *, ipc_callid_t, ipc_call_t *);
     54static void remote_usbhc_reserve_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
     55static void remote_usbhc_release_default_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
     56static void remote_usbhc_request_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
     57static void remote_usbhc_release_address(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5458//static void remote_usbhc(device_t *, void *, ipc_callid_t, ipc_call_t *);
    5559
     
    5761static remote_iface_func_ptr_t remote_usbhc_iface_ops [] = {
    5862        remote_usbhc_get_address,
     63
    5964        remote_usbhc_get_buffer,
     65
     66        remote_usbhc_reserve_default_address,
     67        remote_usbhc_release_default_address,
     68
     69        remote_usbhc_request_address,
     70        remote_usbhc_release_address,
     71
    6072        remote_usbhc_interrupt_out,
    6173        remote_usbhc_interrupt_in,
     74
    6275        remote_usbhc_control_write_setup,
    6376        remote_usbhc_control_write_data,
    6477        remote_usbhc_control_write_status,
     78
    6579        remote_usbhc_control_read_setup,
    6680        remote_usbhc_control_read_data,
     
    134148        free(trans->buffer);
    135149        free(trans);
     150}
     151
     152void remote_usbhc_reserve_default_address(device_t *device, void *iface,
     153    ipc_callid_t callid, ipc_call_t *call)
     154{
     155        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     156
     157        if (!usb_iface->reserve_default_address) {
     158                ipc_answer_0(callid, ENOTSUP);
     159                return;
     160        }
     161
     162        int rc = usb_iface->reserve_default_address(device);
     163
     164        ipc_answer_0(callid, rc);
     165}
     166
     167void remote_usbhc_release_default_address(device_t *device, void *iface,
     168    ipc_callid_t callid, ipc_call_t *call)
     169{
     170        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     171
     172        if (!usb_iface->release_default_address) {
     173                ipc_answer_0(callid, ENOTSUP);
     174                return;
     175        }
     176
     177        int rc = usb_iface->release_default_address(device);
     178
     179        ipc_answer_0(callid, rc);
     180}
     181
     182void remote_usbhc_request_address(device_t *device, void *iface,
     183    ipc_callid_t callid, ipc_call_t *call)
     184{
     185        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     186
     187        if (!usb_iface->request_address) {
     188                ipc_answer_0(callid, ENOTSUP);
     189                return;
     190        }
     191
     192        usb_address_t address;
     193        int rc = usb_iface->request_address(device, &address);
     194        if (rc != EOK) {
     195                ipc_answer_0(callid, rc);
     196        } else {
     197                ipc_answer_1(callid, EOK, (ipcarg_t) address);
     198        }
     199}
     200
     201void remote_usbhc_release_address(device_t *device, void *iface,
     202    ipc_callid_t callid, ipc_call_t *call)
     203{
     204        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
     205
     206        if (!usb_iface->release_address) {
     207                ipc_answer_0(callid, ENOTSUP);
     208                return;
     209        }
     210
     211        usb_address_t address = (usb_address_t) IPC_GET_ARG1(*call);
     212
     213        int rc = usb_iface->release_address(device, address);
     214
     215        ipc_answer_0(callid, rc);
    136216}
    137217
  • uspace/lib/drv/include/usbhc_iface.h

    r2cb6571 r54b141a  
    111111
    112112
     113        /** Reserve usage of default address.
     114         * This call informs the host controller that the caller will be
     115         * using default USB address. It is duty of the HC driver to ensure
     116         * that only single entity will have it reserved.
     117         * The address is returned via IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS.
     118         * The caller can start using the address after receiving EOK
     119         * answer.
     120         */
     121        IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS,
     122
     123        /** Release usage of default address.
     124         * @see IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS
     125         */
     126        IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS,
     127
     128        /** Asks for address assignment by host controller.
     129         * Answer:
     130         * - ELIMIT - host controller run out of address
     131         * - EOK - address assigned
     132         * Answer arguments:
     133         * - assigned address
     134         *
     135         * The address must be released by via IPC_M_USBHC_RELEASE_ADDRESS.
     136         */
     137        IPC_M_USBHC_REQUEST_ADDRESS,
     138
     139        /** Release address in use.
     140         * Arguments:
     141         * - address to be released
     142         * Answer:
     143         * - ENOENT - address not in use
     144         * - EPERM - trying to release default USB address
     145         */
     146        IPC_M_USBHC_RELEASE_ADDRESS,
     147
     148
    113149        /** Send interrupt data to device.
    114150         * See explanation at usb_iface_funcs_t (OUT transaction).
     
    183219typedef struct {
    184220        int (*tell_address)(device_t *, devman_handle_t, usb_address_t *);
     221
     222        int (*reserve_default_address)(device_t *);
     223        int (*release_default_address)(device_t *);
     224        int (*request_address)(device_t *, usb_address_t *);
     225        int (*release_address)(device_t *, usb_address_t);
    185226
    186227        usbhc_iface_transfer_out_t interrupt_out;
  • uspace/lib/usb/Makefile

    r2cb6571 r54b141a  
    3535        src/hcdhubd.c \
    3636        src/hcdrv.c \
    37         src/hubdrv.c \
    3837        src/localdrv.c \
    3938        src/remotedrv.c \
  • uspace/lib/usb/include/usb/hcdhubd.h

    r2cb6571 r54b141a  
    166166
    167167int usb_hcd_main(usb_hc_driver_t *);
    168 int usb_hcd_add_root_hub(usb_hc_device_t *dev);
     168int usb_hcd_add_root_hub(device_t *dev);
    169169
    170170/**
  • uspace/lib/usb/include/usb/usbdrv.h

    r2cb6571 r54b141a  
    4141int usb_drv_hc_connect(device_t *, unsigned int);
    4242
     43int usb_drv_reserve_default_address(int);
     44int usb_drv_release_default_address(int);
     45usb_address_t usb_drv_request_address(int);
     46int usb_drv_release_address(int, usb_address_t);
     47
    4348usb_address_t usb_drv_get_my_address(int, device_t *);
    4449
  • uspace/lib/usb/src/hcdhubd.c

    r2cb6571 r54b141a  
    5151 */
    5252static int add_device(device_t *dev) {
    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         }
     53        return ENOTSUP;
    6954}
    7055
     
    10590 * @return Error code.
    10691 */
    107 int usb_hcd_add_root_hub(usb_hc_device_t *dev) {
     92int usb_hcd_add_root_hub(device_t *dev)
     93{
    10894        char *id;
    109         int rc = asprintf(&id, "usb&hc=%s&hub", hc_driver->name);
     95        int rc = asprintf(&id, "usb&hub");
    11096        if (rc <= 0) {
    11197                return rc;
    11298        }
    11399
    114         rc = usb_hc_add_child_device(dev->generic, USB_HUB_DEVICE_NAME, id, true);
     100        rc = usb_hc_add_child_device(dev, USB_HUB_DEVICE_NAME, id, true);
    115101        if (rc != EOK) {
    116102                free(id);
  • uspace/lib/usb/src/hcdhubd_private.h

    r2cb6571 r54b141a  
    4646usb_address_t usb_get_address_by_handle(devman_handle_t);
    4747int usb_add_hc_device(device_t *);
    48 int usb_add_hub_device(device_t *);
    4948
    5049/** lowest allowed usb address */
  • uspace/lib/usb/src/hcdrv.c

    r2cb6571 r54b141a  
    4747LIST_INITIALIZE(hc_list);
    4848
     49/* Fake driver to have the name item initialized. */
     50static usb_hc_driver_t hc_driver_fake = {
     51        .name = "HCD",
     52};
     53
    4954/** Our HC driver. */
    50 usb_hc_driver_t *hc_driver = NULL;
     55usb_hc_driver_t *hc_driver = &hc_driver_fake;
    5156
    5257int usb_lowest_address = 1;
     
    8691int usb_add_hc_device(device_t *dev)
    8792{
     93        return ENOTSUP;
    8894        usb_hc_device_t *hc_dev = usb_hc_device_create(dev);
    8995
  • uspace/lib/usb/src/usbdrv.c

    r2cb6571 r54b141a  
    100100}
    101101
     102/** Tell HC to reserve default address.
     103 *
     104 * @param phone Open phone to host controller driver.
     105 * @return Error code.
     106 */
     107int usb_drv_reserve_default_address(int phone)
     108{
     109        return async_req_0_0(phone, IPC_M_USBHC_RESERVE_DEFAULT_ADDRESS);
     110}
     111
     112/** Tell HC to release default address.
     113 *
     114 * @param phone Open phone to host controller driver.
     115 * @return Error code.
     116 */
     117int usb_drv_release_default_address(int phone)
     118{
     119        return async_req_0_0(phone, IPC_M_USBHC_RELEASE_DEFAULT_ADDRESS);
     120}
     121
     122/** Ask HC for free address assignment.
     123 *
     124 * @param phone Open phone to host controller driver.
     125 * @return Assigned USB address or negative error code.
     126 */
     127usb_address_t usb_drv_request_address(int phone)
     128{
     129        ipcarg_t address;
     130        int rc = async_req_0_1(phone, IPC_M_USBHC_REQUEST_ADDRESS, &address);
     131        if (rc != EOK) {
     132                return rc;
     133        } else {
     134                return (usb_address_t) address;
     135        }
     136}
     137
     138/** Inform HC about address release.
     139 *
     140 * @param phone Open phone to host controller driver.
     141 * @param address Address to be released.
     142 * @return Error code.
     143 */
     144int usb_drv_release_address(int phone, usb_address_t address)
     145{
     146        return async_req_1_0(phone, IPC_M_USBHC_RELEASE_ADDRESS, address);
     147}
     148
    102149/** Send data to HCD.
    103150 *
Note: See TracChangeset for help on using the changeset viewer.