Changeset 68b5ed6e in mainline


Ignore:
Timestamp:
2011-03-21T14:27:47Z (13 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
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/batch.c

    r3954a63b r68b5ed6e  
    5858    usbhc_iface_transfer_out_callback_t func_out,
    5959                void *arg,
    60                 device_keeper_t *manager
     60                usb_device_keeper_t *manager
    6161                )
    6262{

  • uspace/drv/ohci/batch.h

    r3954a63b r68b5ed6e  
    5454    usbhc_iface_transfer_out_callback_t func_out,
    5555                void *arg,
    56                 device_keeper_t *manager
     56                usb_device_keeper_t *manager
    5757                );
    5858

  • uspace/drv/ohci/hc.c

    r3954a63b r68b5ed6e  
    6565        }
    6666        instance->ddf_instance = fun;
    67         device_keeper_init(&instance->manager);
     67        usb_device_keeper_init(&instance->manager);
    6868
    6969

  • uspace/drv/ohci/hc.h

    r3954a63b r68b5ed6e  
    5353        rh_t rh;
    5454        ddf_fun_t *ddf_instance;
    55         device_keeper_t manager;
     55        usb_device_keeper_t manager;
    5656} hc_t;
    5757

  • uspace/drv/ohci/iface.c

    r3954a63b r68b5ed6e  
    6464  assert(hc);
    6565  usb_log_debug("Default address request with speed %d.\n", speed);
    66   device_keeper_reserve_default(&hc->manager, speed);
     66  usb_device_keeper_reserve_default_address(&hc->manager, speed);
    6767  return EOK;
    6868}
    … …  
    7979  assert(hc);
    8080  usb_log_debug("Default address release.\n");
    81   device_keeper_release_default(&hc->manager);
     81  usb_device_keeper_release_default_address(&hc->manager);
    8282  return EOK;
    8383}
    … …  
    9999
    100100  usb_log_debug("Address request with speed %d.\n", speed);
    101   *address = device_keeper_request(&hc->manager, speed);
     101  *address = device_keeper_get_free_address(&hc->manager, speed);
    102102  usb_log_debug("Address request with result: %d.\n", *address);
    103103  if (*address <= 0)
    … …  
    120120  assert(hc);
    121121  usb_log_debug("Address bind %d-%d.\n", address, handle);
    122   device_keeper_bind(&hc->manager, address, handle);
     122  usb_device_keeper_bind(&hc->manager, address, handle);
    123123  return EOK;
    124124}
    … …  
    136136  assert(hc);
    137137  usb_log_debug("Address release %d.\n", address);
    138   device_keeper_release(&hc->manager, address);
     138  usb_device_keeper_release(&hc->manager, address);
    139139  return EOK;
    140140}
    … …  
    200200  hc_t *hc = fun_to_hc(fun);
    201201  assert(hc);
    202   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     202  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    203203
    204204  usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    … …  
    243243  hc_t *hc = fun_to_hc(fun);
    244244  assert(hc);
    245   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     245  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    246246  usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    247247      target.address, target.endpoint, size, max_packet_size);
    … …  
    285285  hc_t *hc = fun_to_hc(fun);
    286286  assert(hc);
    287   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     287  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    288288
    289289  usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    … …  
    329329  hc_t *hc = fun_to_hc(fun);
    330330  assert(hc);
    331   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     331  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    332332  usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    333333      target.address, target.endpoint, size, max_packet_size);
    … …  
    376376  hc_t *hc = fun_to_hc(fun);
    377377  assert(hc);
    378   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     378  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    379379  usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    380380      speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    388388  if (!batch)
    389389    return ENOMEM;
    390   device_keeper_reset_if_need(&hc->manager, target, setup_data);
     390  usb_device_keeper_reset_if_need(&hc->manager, target, setup_data);
    391391  batch_control_write(batch);
    392392  const int ret = hc_schedule(hc, batch);
    … …  
    427427  hc_t *hc = fun_to_hc(fun);
    428428  assert(hc);
    429   usb_speed_t speed = device_keeper_speed(&hc->manager, target.address);
     429  usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
    430430
    431431  usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",

  • uspace/drv/ohci/main.c

    r3954a63b r68b5ed6e  
    6161{
    6262        assert(fun);
    63         device_keeper_t *manager = &fun_to_hc(fun)->manager;
    64   usb_address_t addr = device_keeper_find(manager, handle);
     63        usb_device_keeper_t *manager = &fun_to_hc(fun)->manager;
     64  usb_address_t addr = usb_device_keeper_find(manager, handle);
    6565  if (addr < 0) {
    6666    return addr;

  • 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;

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

    r3954a63b r68b5ed6e  
    4848};
    4949
    50 typedef struct device_keeper {
     50typedef struct {
    5151        struct usb_device_info devices[USB_ADDRESS_COUNT];
    5252        fibril_mutex_t guard;
    5353        fibril_condvar_t default_address_occupied;
    5454        usb_address_t last_address;
    55 } device_keeper_t;
     55} usb_device_keeper_t;
    5656
    57 void device_keeper_init(device_keeper_t *instance);
     57void usb_device_keeper_init(usb_device_keeper_t *instance);
    5858
    59 void device_keeper_reserve_default(
    60     device_keeper_t *instance, usb_speed_t speed);
     59void usb_device_keeper_reserve_default_address(
     60    usb_device_keeper_t *instance, usb_speed_t speed);
    6161
    62 void device_keeper_release_default(device_keeper_t *instance);
     62void usb_device_keeper_release_default_address(usb_device_keeper_t *instance);
    6363
    64 void device_keeper_reset_if_need(
    65     device_keeper_t *instance, usb_target_t target,
     64void usb_device_keeper_reset_if_need(
     65    usb_device_keeper_t *instance, usb_target_t target,
    6666    const unsigned char *setup_data);
    6767
    68 int device_keeper_get_toggle(
    69     device_keeper_t *instance, usb_target_t target, usb_direction_t direction);
     68int usb_device_keeper_get_toggle(
     69    usb_device_keeper_t *instance, usb_target_t target, usb_direction_t direction);
    7070
    71 int device_keeper_set_toggle(device_keeper_t *instance,
     71int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
    7272    usb_target_t target, usb_direction_t direction, bool toggle);
    7373
    74 usb_address_t device_keeper_request(
    75     device_keeper_t *instance, usb_speed_t speed);
     74usb_address_t device_keeper_get_free_address(
     75    usb_device_keeper_t *instance, usb_speed_t speed);
    7676
    77 void device_keeper_bind(
    78     device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
     77void usb_device_keeper_bind(
     78    usb_device_keeper_t *instance, usb_address_t address, devman_handle_t handle);
    7979
    80 void device_keeper_release(device_keeper_t *instance, usb_address_t address);
     80void usb_device_keeper_release(usb_device_keeper_t *instance, usb_address_t address);
    8181
    82 usb_address_t device_keeper_find(
    83     device_keeper_t *instance, devman_handle_t handle);
     82usb_address_t usb_device_keeper_find(
     83    usb_device_keeper_t *instance, devman_handle_t handle);
    8484
    85 usb_speed_t device_keeper_speed(
    86     device_keeper_t *instance, usb_address_t address);
     85usb_speed_t usb_device_keeper_get_speed(
     86    usb_device_keeper_t *instance, usb_address_t address);
    8787#endif
    8888/**

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

    r3954a63b r68b5ed6e  
    4545 * Set all values to false/0.
    4646 */
    47 void device_keeper_init(device_keeper_t *instance)
     47void usb_device_keeper_init(usb_device_keeper_t *instance)
    4848{
    4949        assert(instance);
    … …  
    6565 * @param[in] speed Speed of the device requesting default address.
    6666 */
    67 void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)
     67void usb_device_keeper_reserve_default_address(usb_device_keeper_t *instance, usb_speed_t speed)
    6868{
    6969        assert(instance);
    … …  
    8383 * @param[in] speed Speed of the device requesting default address.
    8484 */
    85 void device_keeper_release_default(device_keeper_t *instance)
     85void usb_device_keeper_release_default_address(usb_device_keeper_t *instance)
    8686{
    8787        assert(instance);
    … …  
    100100 * Really ugly one.
    101101 */
    102 void device_keeper_reset_if_need(
    103     device_keeper_t *instance, usb_target_t target, const unsigned char *data)
     102void usb_device_keeper_reset_if_need(
     103    usb_device_keeper_t *instance, usb_target_t target, const unsigned char *data)
    104104{
    105105        assert(instance);
    … …  
    144144 * @return Error code
    145145 */
    146 int device_keeper_get_toggle(
    147     device_keeper_t *instance, usb_target_t target, usb_direction_t direction)
     146int usb_device_keeper_get_toggle(
     147    usb_device_keeper_t *instance, usb_target_t target, usb_direction_t direction)
    148148{
    149149        assert(instance);
    … …  
    173173 * @return Error code.
    174174 */
    175 int device_keeper_set_toggle(device_keeper_t *instance,
     175int usb_device_keeper_set_toggle(usb_device_keeper_t *instance,
    176176    usb_target_t target, usb_direction_t direction, bool toggle)
    177177{
    … …  
    207207 * @return Free address, or error code.
    208208 */
    209 usb_address_t device_keeper_request(
    210     device_keeper_t *instance, usb_speed_t speed)
     209usb_address_t device_keeper_get_free_address(
     210    usb_device_keeper_t *instance, usb_speed_t speed)
    211211{
    212212        assert(instance);
    … …  
    241241 * @param[in] handle Devman handle of the device.
    242242 */
    243 void device_keeper_bind(
    244     device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
     243void usb_device_keeper_bind(
     244    usb_device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
    245245{
    246246        assert(instance);
    … …  
    258258 * @param[in] address Device address
    259259 */
    260 void device_keeper_release(device_keeper_t *instance, usb_address_t address)
     260void usb_device_keeper_release(usb_device_keeper_t *instance, usb_address_t address)
    261261{
    262262        assert(instance);
    … …  
    276276 * @return USB Address, or error code.
    277277 */
    278 usb_address_t device_keeper_find(
    279     device_keeper_t *instance, devman_handle_t handle)
     278usb_address_t usb_device_keeper_find(
     279    usb_device_keeper_t *instance, devman_handle_t handle)
    280280{
    281281        assert(instance);
    … …  
    299299 * @return USB speed.
    300300 */
    301 usb_speed_t device_keeper_speed(
    302     device_keeper_t *instance, usb_address_t address)
     301usb_speed_t usb_device_keeper_get_speed(
     302    usb_device_keeper_t *instance, usb_address_t address)
    303303{
    304304        assert(instance);
Note: See TracChangeset for help on using the changeset viewer.