Changeset 68b5ed6e in mainline for uspace/drv/uhci-hcd


Ignore:
Timestamp:
2011-03-21T14:27:47Z (15 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
e34e77a
Parents:
3954a63b
Message:

Rename device_keeper* ⇒ usb_device_keeper*

Also extended some device keeper functions names to be more descriptive.

No change in functionality.

Location:
uspace/drv/uhci-hcd
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/uhci-hcd/batch.c

    r3954a63b r68b5ed6e  
    5050        td_t *tds;
    5151        size_t packets;
    52         device_keeper_t *manager;
     52        usb_device_keeper_t *manager;
    5353} uhci_batch_t;
    5454
    … …  
    8888    usbhc_iface_transfer_in_callback_t func_in,
    8989    usbhc_iface_transfer_out_callback_t func_out, void *arg,
    90     device_keeper_t *manager
     90    usb_device_keeper_t *manager
    9191    )
    9292{
    … …  
    182182                        td_print_status(&data->tds[i]);
    183183
    184                         device_keeper_set_toggle(data->manager,
     184                        usb_device_keeper_set_toggle(data->manager,
    185185                            instance->target, instance->direction,
    186186                            td_toggle(&data->tds[i]));
    … …  
    311311
    312312        const bool low_speed = instance->speed == USB_SPEED_LOW;
    313         int toggle = device_keeper_get_toggle(
     313        int toggle = usb_device_keeper_get_toggle(
    314314            data->manager, instance->target, instance->direction);
    315315        assert(toggle == 0 || toggle == 1);
    … …  
    343343        }
    344344        td_set_ioc(&data->tds[packet - 1]);
    345         device_keeper_set_toggle(data->manager, instance->target,
     345        usb_device_keeper_set_toggle(data->manager, instance->target,
    346346            instance->direction, toggle);
    347347}

  • uspace/drv/uhci-hcd/batch.h

    r3954a63b r68b5ed6e  
    5757    usbhc_iface_transfer_out_callback_t func_out,
    5858                void *arg,
    59                 device_keeper_t *manager
     59                usb_device_keeper_t *manager
    6060                );
    6161

  • uspace/drv/uhci-hcd/iface.c

    r3954a63b r68b5ed6e  
    5555        assert(hc);
    5656        usb_log_debug("Default address request with speed %d.\n", speed);
    57         device_keeper_reserve_default(&hc->device_manager, speed);
     57        usb_device_keeper_reserve_default_address(&hc->device_manager, speed);
    5858        return EOK;
    5959}
    … …  
    7070        assert(hc);
    7171        usb_log_debug("Default address release.\n");
    72         device_keeper_release_default(&hc->device_manager);
     72        usb_device_keeper_release_default_address(&hc->device_manager);
    7373        return EOK;
    7474}
    … …  
    9090
    9191        usb_log_debug("Address request with speed %d.\n", speed);
    92         *address = device_keeper_request(&hc->device_manager, speed);
     92        *address = device_keeper_get_free_address(&hc->device_manager, speed);
    9393        usb_log_debug("Address request with result: %d.\n", *address);
    9494        if (*address <= 0)
    … …  
    111111        assert(hc);
    112112        usb_log_debug("Address bind %d-%d.\n", address, handle);
    113         device_keeper_bind(&hc->device_manager, address, handle);
     113        usb_device_keeper_bind(&hc->device_manager, address, handle);
    114114        return EOK;
    115115}
    … …  
    127127        assert(hc);
    128128        usb_log_debug("Address release %d.\n", address);
    129         device_keeper_release(&hc->device_manager, address);
     129        usb_device_keeper_release(&hc->device_manager, address);
    130130        return EOK;
    131131}
    … …  
    149149        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    150150        assert(hc);
    151         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     151        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    152152
    153153        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    … …  
    186186        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    187187        assert(hc);
    188         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     188        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    189189        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    190190            target.address, target.endpoint, size, max_packet_size);
    … …  
    222222        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    223223        assert(hc);
    224         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     224        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    225225
    226226        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    … …  
    259259        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    260260        assert(hc);
    261         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     261        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    262262        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    263263            target.address, target.endpoint, size, max_packet_size);
    … …  
    298298        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    299299        assert(hc);
    300         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     300        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    301301        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    302302            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    310310        if (!batch)
    311311                return ENOMEM;
    312         device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
     312        usb_device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
    313313        batch_control_write(batch);
    314314        const int ret = uhci_hc_schedule(hc, batch);
    … …  
    341341        uhci_hc_t *hc = fun_to_uhci_hc(fun);
    342342        assert(hc);
    343         usb_speed_t speed = device_keeper_speed(&hc->device_manager, target.address);
     343        usb_speed_t speed = usb_device_keeper_get_speed(&hc->device_manager, target.address);
    344344
    345345        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",

  • uspace/drv/uhci-hcd/uhci.c

    r3954a63b r68b5ed6e  
    7070{
    7171        assert(fun);
    72         device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
    73 
    74         usb_address_t addr = device_keeper_find(manager, handle);
     72        usb_device_keeper_t *manager = &((uhci_t*)fun->dev->driver_data)->hc.device_manager;
     73
     74        usb_address_t addr = usb_device_keeper_find(manager, handle);
    7575        if (addr < 0) {
    7676                return addr;

  • uspace/drv/uhci-hcd/uhci_hc.c

    r3954a63b r68b5ed6e  
    234234
    235235        /* Init device keeper*/
    236         device_keeper_init(&instance->device_manager);
     236        usb_device_keeper_init(&instance->device_manager);
    237237        usb_log_debug("Initialized device manager.\n");
    238238

  • uspace/drv/uhci-hcd/uhci_hc.h

    r3954a63b r68b5ed6e  
    8383
    8484typedef struct uhci_hc {
    85         device_keeper_t device_manager;
     85        usb_device_keeper_t device_manager;
    8686
    8787        regs_t *registers;
Note: See TracChangeset for help on using the changeset viewer.