← Back to branch summary

~vojtech-horky/helenos/numa

« back to all changes in this revision

Viewing changes to uspace/drv/bus/usb/vhc/connhost.c

  • Committer: Vojtech Horky
  • Date: 2011-09-28 15:13:08 UTC
  • mfrom: (538.1.714 helenos-mainline)
  • Revision ID: vojtechhorky@users.sourceforge.net-20110928151308-2pz4s2w035n48o8a
Merge mainline changes

Conflicts fixed without problems (mostly caused by separating
ABI into /abi/).

Show diffs side-by-side

added added

removed removed

Lines of Context:
uspace/drv/bus/usb/vhc/connhost.c
61
61
{
62
62
        VHC_DATA(vhc, fun);
63
63
 
64
 
        usb_address_t addr = device_keeper_get_free_address(&vhc->dev_keeper,
65
 
            USB_SPEED_HIGH);
 
64
        usb_address_t addr = usb_device_manager_get_free_address(
 
65
            &vhc->dev_manager, USB_SPEED_HIGH);
66
66
        if (addr < 0) {
67
67
                return addr;
68
68
        }
87
87
        VHC_DATA(vhc, fun);
88
88
        usb_log_debug("Binding handle %" PRIun " to address %d.\n",
89
89
            handle, address);
90
 
        usb_device_keeper_bind(&vhc->dev_keeper, address, handle);
 
90
        usb_device_manager_bind(&vhc->dev_manager, address, handle);
91
91
 
92
92
        return EOK;
93
93
}
104
104
{
105
105
        VHC_DATA(vhc, fun);
106
106
        bool found =
107
 
            usb_device_keeper_find_by_address(&vhc->dev_keeper, address, handle);
 
107
            usb_device_manager_find_by_address(&vhc->dev_manager, address, handle);
108
108
        return found ? EOK : ENOENT;
109
109
}
110
110
 
118
118
{
119
119
        VHC_DATA(vhc, fun);
120
120
        usb_log_debug("Releasing address %d...\n", address);
121
 
        usb_device_keeper_release(&vhc->dev_keeper, address);
 
121
        usb_device_manager_release(&vhc->dev_manager, address);
122
122
 
123
123
        return ENOTSUP;
124
124
}
171
171
{
172
172
        VHC_DATA(vhc, fun);
173
173
 
174
 
        endpoint_t *ep = usb_endpoint_manager_get_ep(&vhc->ep_manager,
175
 
            address, endpoint, direction, NULL);
176
 
        if (ep == NULL) {
177
 
                return ENOENT;
178
 
        }
179
 
 
180
174
        int rc = usb_endpoint_manager_unregister_ep(&vhc->ep_manager,
181
175
            address, endpoint, direction);
182
176
 
183
177
        return rc;
184
178
}
185
 
 
 
179
#if 0
186
180
/** Schedule interrupt out transfer.
187
181
 *
188
182
 * The callback is supposed to be called once the transfer (on the wire) is
412
406
 
413
407
        return EOK;
414
408
}
 
409
#endif
 
410
static int usb_read(ddf_fun_t *fun, usb_target_t target, uint64_t setup_buffer,
 
411
    uint8_t *data_buffer, size_t data_buffer_size,
 
412
    usbhc_iface_transfer_in_callback_t callback, void *arg)
 
413
{
 
414
        VHC_DATA(vhc, fun);
 
415
 
 
416
        endpoint_t *ep = usb_endpoint_manager_get_ep(&vhc->ep_manager,
 
417
            target.address, target.endpoint, USB_DIRECTION_IN, NULL);
 
418
        if (ep == NULL) {
 
419
                return ENOENT;
 
420
        }
 
421
        const usb_transfer_type_t transfer_type = ep->transfer_type;
 
422
 
 
423
 
 
424
        vhc_transfer_t *transfer = vhc_transfer_create(target.address,
 
425
            target.endpoint, USB_DIRECTION_IN, transfer_type,
 
426
            fun, arg);
 
427
        if (transfer == NULL) {
 
428
                return ENOMEM;
 
429
        }
 
430
        if (transfer_type == USB_TRANSFER_CONTROL) {
 
431
                transfer->setup_buffer = malloc(sizeof(uint64_t));
 
432
                assert(transfer->setup_buffer);
 
433
                memcpy(transfer->setup_buffer, &setup_buffer, sizeof(uint64_t));
 
434
                transfer->setup_buffer_size = sizeof(uint64_t);
 
435
        }
 
436
        transfer->data_buffer = data_buffer;
 
437
        transfer->data_buffer_size = data_buffer_size;
 
438
        transfer->callback_in = callback;
 
439
 
 
440
        int rc = vhc_virtdev_add_transfer(vhc, transfer);
 
441
        if (rc != EOK) {
 
442
                if (transfer->setup_buffer != NULL) {
 
443
                        free(transfer->setup_buffer);
 
444
                }
 
445
                free(transfer);
 
446
                return rc;
 
447
        }
 
448
 
 
449
        return EOK;
 
450
}
 
451
 
 
452
static int usb_write(ddf_fun_t *fun, usb_target_t target, uint64_t setup_buffer,
 
453
    const uint8_t *data_buffer, size_t data_buffer_size,
 
454
    usbhc_iface_transfer_out_callback_t callback, void *arg)
 
455
{
 
456
        VHC_DATA(vhc, fun);
 
457
 
 
458
        endpoint_t *ep = usb_endpoint_manager_get_ep(&vhc->ep_manager,
 
459
            target.address, target.endpoint, USB_DIRECTION_OUT, NULL);
 
460
        if (ep == NULL) {
 
461
                return ENOENT;
 
462
        }
 
463
        const usb_transfer_type_t transfer_type = ep->transfer_type;
 
464
 
 
465
 
 
466
        vhc_transfer_t *transfer = vhc_transfer_create(target.address,
 
467
            target.endpoint, USB_DIRECTION_OUT, transfer_type,
 
468
            fun, arg);
 
469
        if (transfer == NULL) {
 
470
                return ENOMEM;
 
471
        }
 
472
        if (transfer_type == USB_TRANSFER_CONTROL) {
 
473
                transfer->setup_buffer = malloc(sizeof(uint64_t));
 
474
                assert(transfer->setup_buffer);
 
475
                memcpy(transfer->setup_buffer, &setup_buffer, sizeof(uint64_t));
 
476
                transfer->setup_buffer_size = sizeof(uint64_t);
 
477
        }
 
478
        transfer->data_buffer = (void*)data_buffer;
 
479
        transfer->data_buffer_size = data_buffer_size;
 
480
        transfer->callback_out = callback;
 
481
 
 
482
        int rc = vhc_virtdev_add_transfer(vhc, transfer);
 
483
        if (rc != EOK) {
 
484
                free(transfer->setup_buffer);
 
485
                free(transfer);
 
486
                return rc;
 
487
        }
 
488
 
 
489
        return EOK;
 
490
}
415
491
 
416
492
static int tell_address(ddf_fun_t *fun, devman_handle_t handle,
417
493
    usb_address_t *address)
441
517
        }
442
518
 
443
519
        usb_log_debug("tell_address_rh(handle=%" PRIun ")\n", handle);
444
 
        usb_address_t addr = usb_device_keeper_find(&vhc->dev_keeper, handle);
 
520
        usb_address_t addr = usb_device_manager_find(&vhc->dev_manager, handle);
445
521
        if (addr < 0) {
446
522
                return addr;
447
523
        } else {
459
535
        .register_endpoint = register_endpoint,
460
536
        .unregister_endpoint = unregister_endpoint,
461
537
 
462
 
        .interrupt_out = interrupt_out,
463
 
        .interrupt_in = interrupt_in,
464
 
 
465
 
        .bulk_in = bulk_in,
466
 
        .bulk_out = bulk_out,
467
 
 
468
 
        .control_write = control_write,
469
 
        .control_read = control_read
 
538
        .write = usb_write,
 
539
        .read = usb_read,
470
540
};
471
541
 
472
542
usb_iface_t vhc_usb_iface = {