Changeset 1387692 in mainline for uspace/drv/uhci-hcd


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

Rename batch_* ⇒ usb_transfer_batch_*

No change in functionality.

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

Legend:

Unmodified
Added
Removed

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

    re34e77a r1387692  
    5353} uhci_batch_t;
    5454
    55 static void batch_control(batch_t *instance,
     55static void batch_control(usb_transfer_batch_t *instance,
    5656    usb_packet_id data_stage, usb_packet_id status_stage);
    57 static void batch_data(batch_t *instance, usb_packet_id pid);
    58 static void batch_call_in_and_dispose(batch_t *instance);
    59 static void batch_call_out_and_dispose(batch_t *instance);
     57static void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid);
     58static void batch_call_in_and_dispose(usb_transfer_batch_t *instance);
     59static void batch_call_out_and_dispose(usb_transfer_batch_t *instance);
    6060
    6161
    … …  
    8282 * transaction and callback.
    8383 */
    84 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     84usb_transfer_batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
    8585    usb_transfer_type_t transfer_type, size_t max_packet_size,
    8686    usb_speed_t speed, char *buffer, size_t buffer_size,
    … …  
    103103        } else (void)0
    104104
    105         batch_t *instance = malloc(sizeof(batch_t));
     105        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
    106106        CHECK_NULL_DISPOSE_RETURN(instance,
    107107            "Failed to allocate batch instance.\n");
    108         batch_init(instance, target, transfer_type, speed, max_packet_size,
     108        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
    109109            buffer, NULL, buffer_size, NULL, setup_size, func_in,
    110110            func_out, arg, fun, NULL);
    … …  
    161161 * is reached.
    162162 */
    163 bool batch_is_complete(batch_t *instance)
     163bool batch_is_complete(usb_transfer_batch_t *instance)
    164164{
    165165        assert(instance);
    … …  
    205205 * Uses genercir control function with pids OUT and IN.
    206206 */
    207 void batch_control_write(batch_t *instance)
     207void batch_control_write(usb_transfer_batch_t *instance)
    208208{
    209209        assert(instance);
    … …  
    222222 * Uses generic control with pids IN and OUT.
    223223 */
    224 void batch_control_read(batch_t *instance)
     224void batch_control_read(usb_transfer_batch_t *instance)
    225225{
    226226        assert(instance);
    … …  
    236236 * Data transaction with PID_IN.
    237237 */
    238 void batch_interrupt_in(batch_t *instance)
     238void batch_interrupt_in(usb_transfer_batch_t *instance)
    239239{
    240240        assert(instance);
    … …  
    251251 * Data transaction with PID_OUT.
    252252 */
    253 void batch_interrupt_out(batch_t *instance)
     253void batch_interrupt_out(usb_transfer_batch_t *instance)
    254254{
    255255        assert(instance);
    … …  
    269269 * Data transaction with PID_IN.
    270270 */
    271 void batch_bulk_in(batch_t *instance)
     271void batch_bulk_in(usb_transfer_batch_t *instance)
    272272{
    273273        assert(instance);
    … …  
    284284 * Data transaction with PID_OUT.
    285285 */
    286 void batch_bulk_out(batch_t *instance)
     286void batch_bulk_out(usb_transfer_batch_t *instance)
    287287{
    288288        assert(instance);
    … …  
    304304 * The last packet is marked with IOC flag.
    305305 */
    306 void batch_data(batch_t *instance, usb_packet_id pid)
     306void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid)
    307307{
    308308        assert(instance);
    … …  
    358358 * The last packet is marked with IOC.
    359359 */
    360 void batch_control(batch_t *instance,
     360void batch_control(usb_transfer_batch_t *instance,
    361361   usb_packet_id data_stage, usb_packet_id status_stage)
    362362{
    … …  
    411411}
    412412/*----------------------------------------------------------------------------*/
    413 qh_t * batch_qh(batch_t *instance)
     413qh_t * batch_qh(usb_transfer_batch_t *instance)
    414414{
    415415        assert(instance);
    … …  
    423423 * @param[in] instance Batch structure to use.
    424424 */
    425 void batch_call_in_and_dispose(batch_t *instance)
    426 {
    427         assert(instance);
    428         batch_call_in(instance);
     425void batch_call_in_and_dispose(usb_transfer_batch_t *instance)
     426{
     427        assert(instance);
     428        usb_transfer_batch_call_in(instance);
    429429        batch_dispose(instance);
    430430}
    … …  
    434434 * @param[in] instance Batch structure to use.
    435435 */
    436 void batch_call_out_and_dispose(batch_t *instance)
    437 {
    438         assert(instance);
    439         batch_call_out(instance);
     436void batch_call_out_and_dispose(usb_transfer_batch_t *instance)
     437{
     438        assert(instance);
     439        usb_transfer_batch_call_out(instance);
    440440        batch_dispose(instance);
    441441}
    … …  
    445445 * @param[in] instance Batch structure to use.
    446446 */
    447 void batch_dispose(batch_t *instance)
     447void batch_dispose(usb_transfer_batch_t *instance)
    448448{
    449449        assert(instance);

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

    re34e77a r1387692  
    4444#include "uhci_struct/queue_head.h"
    4545
    46 batch_t * batch_get(
     46usb_transfer_batch_t * batch_get(
    4747    ddf_fun_t *fun,
    4848                usb_target_t target,
    … …  
    6060                );
    6161
    62 void batch_dispose(batch_t *instance);
     62void batch_dispose(usb_transfer_batch_t *instance);
    6363
    64 bool batch_is_complete(batch_t *instance);
     64bool batch_is_complete(usb_transfer_batch_t *instance);
    6565
    66 void batch_control_write(batch_t *instance);
     66void batch_control_write(usb_transfer_batch_t *instance);
    6767
    68 void batch_control_read(batch_t *instance);
     68void batch_control_read(usb_transfer_batch_t *instance);
    6969
    70 void batch_interrupt_in(batch_t *instance);
     70void batch_interrupt_in(usb_transfer_batch_t *instance);
    7171
    72 void batch_interrupt_out(batch_t *instance);
     72void batch_interrupt_out(usb_transfer_batch_t *instance);
    7373
    74 void batch_bulk_in(batch_t *instance);
     74void batch_bulk_in(usb_transfer_batch_t *instance);
    7575
    76 void batch_bulk_out(batch_t *instance);
     76void batch_bulk_out(usb_transfer_batch_t *instance);
    7777
    78 qh_t * batch_qh(batch_t *instance);
     78qh_t * batch_qh(usb_transfer_batch_t *instance);
    7979#endif
    8080/**

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

    re34e77a r1387692  
    154154            target.address, target.endpoint, size, max_packet_size);
    155155
    156         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     156        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    157157            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    158158            &hc->device_manager);
    … …  
    190190            target.address, target.endpoint, size, max_packet_size);
    191191
    192         batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
     192        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    193193            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    194194                        &hc->device_manager);
    … …  
    227227            target.address, target.endpoint, size, max_packet_size);
    228228
    229         batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     229        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    230230            max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    231231            &hc->device_manager);
    … …  
    263263            target.address, target.endpoint, size, max_packet_size);
    264264
    265         batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
     265        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    266266            max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    267267            &hc->device_manager);
    … …  
    305305                return EINVAL;
    306306
    307         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     307        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    308308            max_packet_size, speed, data, size, setup_data, setup_size,
    309309            NULL, callback, arg, &hc->device_manager);
    … …  
    345345        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    346346            speed, target.address, target.endpoint, size, max_packet_size);
    347         batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
     347        usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    348348            max_packet_size, speed, data, size, setup_data, setup_size, callback,
    349349            NULL, arg, &hc->device_manager);

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

    re34e77a r1387692  
    3838
    3939static void transfer_list_remove_batch(
    40     transfer_list_t *instance, batch_t *batch);
     40    transfer_list_t *instance, usb_transfer_batch_t *batch);
    4141/*----------------------------------------------------------------------------*/
    4242/** Initialize transfer list structures.
    … …  
    9292 * The batch is added to the end of the list and queue.
    9393 */
    94 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch)
     94void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
    9595{
    9696        assert(instance);
    … …  
    115115        } else {
    116116                /* There is something scheduled */
    117                 batch_t *last = list_get_instance(
    118                     instance->batch_list.prev, batch_t, link);
     117                usb_transfer_batch_t *last = list_get_instance(
     118                    instance->batch_list.prev, usb_transfer_batch_t, link);
    119119                qh_set_next_qh(batch_qh(last), pa);
    120120        }
    … …  
    122122        list_append(&batch->link, &instance->batch_list);
    123123
    124         batch_t *first = list_get_instance(
    125             instance->batch_list.next, batch_t, link);
     124        usb_transfer_batch_t *first = list_get_instance(
     125            instance->batch_list.next, usb_transfer_batch_t, link);
    126126        usb_log_debug("Batch(%p) added to queue %s, first is %p.\n",
    127127                batch, instance->name, first);
    … …  
    148148        while (current != &instance->batch_list) {
    149149                link_t *next = current->next;
    150                 batch_t *batch = list_get_instance(current, batch_t, link);
     150                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
    151151
    152152                if (batch_is_complete(batch)) {
    … …  
    162162                link_t *item = done.next;
    163163                list_remove(item);
    164                 batch_t *batch = list_get_instance(item, batch_t, link);
     164                usb_transfer_batch_t *batch = list_get_instance(item, usb_transfer_batch_t, link);
    165165                batch->next_step(batch);
    166166        }
    … …  
    176176        while (list_empty(&instance->batch_list)) {
    177177                link_t *current = instance->batch_list.next;
    178                 batch_t *batch = list_get_instance(current, batch_t, link);
     178                usb_transfer_batch_t *batch = list_get_instance(current, usb_transfer_batch_t, link);
    179179                transfer_list_remove_batch(instance, batch);
    180                 batch_finish(batch, EIO);
     180                usb_transfer_batch_finish(batch, EIO);
    181181        }
    182182        fibril_mutex_unlock(&instance->guard);
    … …  
    191191 * Does not lock the transfer list, caller is responsible for that.
    192192 */
    193 void transfer_list_remove_batch(transfer_list_t *instance, batch_t *batch)
     193void transfer_list_remove_batch(transfer_list_t *instance, usb_transfer_batch_t *batch)
    194194{
    195195        assert(instance);
    … …  
    207207                pos = "FIRST";
    208208        } else {
    209                 batch_t *prev =
    210                     list_get_instance(batch->link.prev, batch_t, link);
     209                usb_transfer_batch_t *prev =
     210                    list_get_instance(batch->link.prev, usb_transfer_batch_t, link);
    211211                qh_set_next_qh(batch_qh(prev), batch_qh(batch)->next);
    212212                pos = "NOT FIRST";

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

    re34e77a r1387692  
    6666void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next);
    6767
    68 void transfer_list_add_batch(transfer_list_t *instance, batch_t *batch);
     68void transfer_list_add_batch(transfer_list_t *instance, usb_transfer_batch_t *batch);
    6969
    7070void transfer_list_remove_finished(transfer_list_t *instance);

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

    re34e77a r1387692  
    316316 * Checks for bandwidth availability and appends the batch to the proper queue.
    317317 */
    318 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch)
     318int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch)
    319319{
    320320        assert(instance);

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

    re34e77a r1387692  
    109109    void *regs, size_t reg_size, bool interupts);
    110110
    111 int uhci_hc_schedule(uhci_hc_t *instance, batch_t *batch);
     111int uhci_hc_schedule(uhci_hc_t *instance, usb_transfer_batch_t *batch);
    112112
    113113void uhci_hc_interrupt(uhci_hc_t *instance, uint16_t status);
Note: See TracChangeset for help on using the changeset viewer.