Changeset db51a6a6 in mainline for uspace/drv


Ignore:
Timestamp:
2018-01-22T12:20:14Z (8 years ago)
Author:
Ondřej Hlavatý <aearsis@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
998773d
Parents:
b3c39690
git-author:
Ondřej Hlavatý <aearsis@…> (2018-01-22 12:18:02)
git-committer:
Ondřej Hlavatý <aearsis@…> (2018-01-22 12:20:14)
Message:

typo: transferred is spelled with two r

Location:
uspace/drv/bus/usb
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/bus/usb/ehci/ehci_batch.c

    rb3c39690 rdb51a6a6  
    179179
    180180        /* Assume all data got through */
    181         ehci_batch->base.transfered_size = ehci_batch->base.buffer_size;
     181        ehci_batch->base.transferred_size = ehci_batch->base.buffer_size;
    182182
    183183        /* Check all TDs */
    … …  
    202202                         * we leave the very last(unused) TD behind.
    203203                         */
    204                         ehci_batch->base.transfered_size
     204                        ehci_batch->base.transferred_size
    205205                            -= td_remain_size(&ehci_batch->tds[i]);
    206206                } else {
    … …  
    215215        }
    216216
    217         assert(ehci_batch->base.transfered_size <= ehci_batch->base.buffer_size);
     217        assert(ehci_batch->base.transferred_size <= ehci_batch->base.buffer_size);
    218218
    219219        if (ehci_batch->base.dir == USB_DIRECTION_IN)
    220220                memcpy(ehci_batch->base.buffer,
    221221                    ehci_batch->data_buffer,
    222                     ehci_batch->base.transfered_size);
     222                    ehci_batch->base.transferred_size);
    223223
    224224        /* Clear TD pointers */

  • uspace/drv/bus/usb/ehci/ehci_bus.c

    rb3c39690 rdb51a6a6  
    148148        if (batch) {
    149149                batch->error = EINTR;
    150                 batch->transfered_size = 0;
     150                batch->transferred_size = 0;
    151151                usb_transfer_batch_finish(batch);
    152152        }

  • uspace/drv/bus/usb/ehci/ehci_rh.c

    rb3c39690 rdb51a6a6  
    146146        batch->error = virthub_base_request(&instance->base, batch->target,
    147147            batch->dir, (void*) batch->setup.buffer,
    148             batch->buffer, batch->buffer_size, &batch->transfered_size);
     148            batch->buffer, batch->buffer_size, &batch->transferred_size);
    149149        if (batch->error == ENAK) {
    150150                usb_log_debug("RH(%p): BATCH(%p) adding as unfinished",
    … …  
    180180                batch->error = virthub_base_request(&instance->base, batch->target,
    181181                    batch->dir, (void*) batch->setup.buffer,
    182                     batch->buffer, batch->buffer_size, &batch->transfered_size);
     182                    batch->buffer, batch->buffer_size, &batch->transferred_size);
    183183                usb_transfer_batch_finish(batch);
    184184        }

  • uspace/drv/bus/usb/ohci/ohci_batch.c

    rb3c39690 rdb51a6a6  
    187187
    188188        /* Assume all data got through */
    189         ohci_batch->base.transfered_size = ohci_batch->base.buffer_size;
     189        ohci_batch->base.transferred_size = ohci_batch->base.buffer_size;
    190190
    191191        /* Assume we will leave the last(unused) TD behind */
    … …  
    213213                         * we leave the very last(unused) TD behind.
    214214                         */
    215                         ohci_batch->base.transfered_size
     215                        ohci_batch->base.transferred_size
    216216                            -= td_remain_size(ohci_batch->tds[i]);
    217217                } else {
    … …  
    244244                }
    245245        }
    246         assert(ohci_batch->base.transfered_size <=
     246        assert(ohci_batch->base.transferred_size <=
    247247            ohci_batch->base.buffer_size);
    248248
    … …  
    254254                memcpy(ohci_batch->base.buffer,
    255255                    ohci_batch->device_buffer + setup_size,
    256                     ohci_batch->base.transfered_size);
     256                    ohci_batch->base.transferred_size);
    257257
    258258        /* Store the remaining TD */

  • uspace/drv/bus/usb/ohci/ohci_bus.c

    rb3c39690 rdb51a6a6  
    152152        if (batch) {
    153153                batch->error = EINTR;
    154                 batch->transfered_size = 0;
     154                batch->transferred_size = 0;
    155155                usb_transfer_batch_finish(batch);
    156156        }

  • uspace/drv/bus/usb/ohci/ohci_rh.c

    rb3c39690 rdb51a6a6  
    180180        batch->error = virthub_base_request(&instance->base, batch->target,
    181181            batch->dir, &batch->setup.packet,
    182             batch->buffer, batch->buffer_size, &batch->transfered_size);
     182            batch->buffer, batch->buffer_size, &batch->transferred_size);
    183183        if (batch->error == ENAK) {
    184184                /* This is safe because only status change interrupt transfers
    … …  
    208208                batch->error = virthub_base_request(&instance->base, batch->target,
    209209                    batch->dir, &batch->setup.packet,
    210                     batch->buffer, batch->buffer_size, &batch->transfered_size);
     210                    batch->buffer, batch->buffer_size, &batch->transferred_size);
    211211                usb_transfer_batch_finish(batch);
    212212        }

  • uspace/drv/bus/usb/uhci/hc.c

    rb3c39690 rdb51a6a6  
    362362                async_usleep(2000);
    363363                batch->base.error = EINTR;
    364                 batch->base.transfered_size = 0;
     364                batch->base.transferred_size = 0;
    365365                usb_transfer_batch_finish(&batch->base);
    366366        }

  • uspace/drv/bus/usb/uhci/uhci_batch.c

    rb3c39690 rdb51a6a6  
    163163            uhci_batch, USB_TRANSFER_BATCH_ARGS(*batch),
    164164            uhci_batch->td_count);
    165         batch->transfered_size = 0;
     165        batch->transferred_size = 0;
    166166
    167167        uhci_endpoint_t *uhci_ep = (uhci_endpoint_t *) batch->ep;
    … …  
    185185                }
    186186
    187                 batch->transfered_size
     187                batch->transferred_size
    188188                    += td_act_size(&uhci_batch->tds[i]);
    189189                if (td_is_short(&uhci_batch->tds[i]))
    … …  
    191191        }
    192192substract_ret:
    193         if (batch->transfered_size > 0 && batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
    194                 assert(batch->transfered_size >= USB_SETUP_PACKET_SIZE);
    195                 batch->transfered_size -= USB_SETUP_PACKET_SIZE;
     193        if (batch->transferred_size > 0 && batch->ep->transfer_type == USB_TRANSFER_CONTROL) {
     194                assert(batch->transferred_size >= USB_SETUP_PACKET_SIZE);
     195                batch->transferred_size -= USB_SETUP_PACKET_SIZE;
    196196        }
    197197
    198198        if (batch->dir == USB_DIRECTION_IN) {
    199                 assert(batch->transfered_size <= batch->buffer_size);
     199                assert(batch->transferred_size <= batch->buffer_size);
    200200                memcpy(batch->buffer,
    201201                    uhci_transfer_batch_data_buffer(uhci_batch),
    202                     batch->transfered_size);
     202                    batch->transferred_size);
    203203        }
    204204

  • uspace/drv/bus/usb/uhci/uhci_rh.c

    rb3c39690 rdb51a6a6  
    107107                batch->error = virthub_base_request(&instance->base, batch->target,
    108108                    batch->dir, (void*) batch->setup.buffer,
    109                     batch->buffer, batch->buffer_size, &batch->transfered_size);
     109                    batch->buffer, batch->buffer_size, &batch->transferred_size);
    110110                if (batch->error == ENAK)
    111111                        async_usleep(instance->base.endpoint_descriptor.poll_interval * 1000);

  • uspace/drv/bus/usb/vhc/transfer.c

    rb3c39690 rdb51a6a6  
    151151        assert(transfer);
    152152        transfer->batch.error = outcome;
    153         transfer->batch.transfered_size = data_transfer_size;
     153        transfer->batch.transferred_size = data_transfer_size;
    154154        usb_transfer_batch_finish(&transfer->batch);
    155155}

  • uspace/drv/bus/usb/xhci/endpoint.c

    rb3c39690 rdb51a6a6  
    209209        if (batch) {
    210210                batch->error = EINTR;
    211                 batch->transfered_size = 0;
     211                batch->transferred_size = 0;
    212212                usb_transfer_batch_finish(batch);
    213213        }

  • uspace/drv/bus/usb/xhci/isoch.c

    rb3c39690 rdb51a6a6  
    483483
    484484        /* Withdraw results from previous transfers. */
    485         transfer->batch.transfered_size = 0;
     485        transfer->batch.transferred_size = 0;
    486486        xhci_isoch_transfer_t *res = &isoch->transfers[isoch->dequeue];
    487487        while (res->state == ISOCH_COMPLETE) {
    … …  
    489489
    490490                res->state = ISOCH_EMPTY;
    491                 transfer->batch.transfered_size += res->size;
     491                transfer->batch.transferred_size += res->size;
    492492                transfer->batch.error = res->error;
    493493                if (res->error)
    … …  
    555555        if (!it->error) {
    556556                memcpy(transfer->batch.buffer, it->data.virt, it->size);
    557                 transfer->batch.transfered_size = it->size;
     557                transfer->batch.transferred_size = it->size;
    558558                transfer->batch.error = it->error;
    559559        }

  • uspace/drv/bus/usb/xhci/transfers.c

    rb3c39690 rdb51a6a6  
    340340                case XHCI_TRBC_SUCCESS:
    341341                        batch->error = EOK;
    342                         batch->transfered_size = batch->buffer_size - TRB_TRANSFER_LENGTH(*trb);
     342                        batch->transferred_size = batch->buffer_size - TRB_TRANSFER_LENGTH(*trb);
    343343                        break;
    344344
    … …  
    346346                        usb_log_warning("Transfer ended with data buffer error.");
    347347                        batch->error = EAGAIN;
    348                         batch->transfered_size = 0;
     348                        batch->transferred_size = 0;
    349349                        break;
    350350
    … …  
    352352                        usb_log_warning("Babble detected during the transfer.");
    353353                        batch->error = EAGAIN;
    354                         batch->transfered_size = 0;
     354                        batch->transferred_size = 0;
    355355                        break;
    356356
    … …  
    358358                        usb_log_warning("USB Transaction error.");
    359359                        batch->error = ESTALL;
    360                         batch->transfered_size = 0;
     360                        batch->transferred_size = 0;
    361361                        break;
    362362
    … …  
    364364                        usb_log_error("Invalid transfer parameters.");
    365365                        batch->error = EINVAL;
    366                         batch->transfered_size = 0;
     366                        batch->transferred_size = 0;
    367367                        break;
    368368
    … …  
    370370                        usb_log_warning("Stall condition detected.");
    371371                        batch->error = ESTALL;
    372                         batch->transfered_size = 0;
     372                        batch->transferred_size = 0;
    373373                        break;
    374374
    … …  
    376376                        usb_log_error("Split transcation error detected.");
    377377                        batch->error = EAGAIN;
    378                         batch->transfered_size = 0;
     378                        batch->transferred_size = 0;
    379379                        break;
    380380
    … …  
    386386        if (batch->dir == USB_DIRECTION_IN) {
    387387                assert(batch->buffer);
    388                 assert(batch->transfered_size <= batch->buffer_size);
    389                 memcpy(batch->buffer, transfer->hc_buffer.virt, batch->transfered_size);
     388                assert(batch->transferred_size <= batch->buffer_size);
     389                memcpy(batch->buffer, transfer->hc_buffer.virt, batch->transferred_size);
    390390        }
    391391
Note: See TracChangeset for help on using the changeset viewer.