Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    ra963a68 r1387692  
    4242#include "uhci_hc.h"
    4343#include "utils/malloc32.h"
     44#include "uhci_struct/transfer_descriptor.h"
    4445
    4546#define DEFAULT_ERROR_COUNT 3
    4647
    47 static void batch_control(batch_t *instance,
     48typedef struct uhci_batch {
     49        qh_t *qh;
     50        td_t *tds;
     51        size_t packets;
     52        usb_device_keeper_t *manager;
     53} uhci_batch_t;
     54
     55static void batch_control(usb_transfer_batch_t *instance,
    4856    usb_packet_id data_stage, usb_packet_id status_stage);
    49 static void batch_data(batch_t *instance, usb_packet_id pid);
    50 static void batch_call_in(batch_t *instance);
    51 static void batch_call_out(batch_t *instance);
    52 static void batch_call_in_and_dispose(batch_t *instance);
    53 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);
    5460
    5561
    … …  
    7682 * transaction and callback.
    7783 */
    78 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,
    7985    usb_transfer_type_t transfer_type, size_t max_packet_size,
    80     usb_speed_t speed, char *buffer, size_t size,
     86    usb_speed_t speed, char *buffer, size_t buffer_size,
    8187    char* setup_buffer, size_t setup_size,
    8288    usbhc_iface_transfer_in_callback_t func_in,
    8389    usbhc_iface_transfer_out_callback_t func_out, void *arg,
    84     device_keeper_t *manager
     90    usb_device_keeper_t *manager
    8591    )
    8692{
    … …  
    97103        } else (void)0
    98104
    99         batch_t *instance = malloc(sizeof(batch_t));
     105        usb_transfer_batch_t *instance = malloc(sizeof(usb_transfer_batch_t));
    100106        CHECK_NULL_DISPOSE_RETURN(instance,
    101107            "Failed to allocate batch instance.\n");
    102         bzero(instance, sizeof(batch_t));
    103 
    104         instance->qh = malloc32(sizeof(qh_t));
    105         CHECK_NULL_DISPOSE_RETURN(instance->qh,
     108        usb_transfer_batch_init(instance, target, transfer_type, speed, max_packet_size,
     109            buffer, NULL, buffer_size, NULL, setup_size, func_in,
     110            func_out, arg, fun, NULL);
     111
     112
     113        uhci_batch_t *data = malloc(sizeof(uhci_batch_t));
     114        CHECK_NULL_DISPOSE_RETURN(instance,
     115            "Failed to allocate batch instance.\n");
     116        bzero(data, sizeof(uhci_batch_t));
     117        data->manager = manager;
     118        instance->private_data = data;
     119
     120        data->packets = (buffer_size + max_packet_size - 1) / max_packet_size;
     121        if (transfer_type == USB_TRANSFER_CONTROL) {
     122                data->packets += 2;
     123        }
     124
     125        data->tds = malloc32(sizeof(td_t) * data->packets);
     126        CHECK_NULL_DISPOSE_RETURN(
     127            data->tds, "Failed to allocate transfer descriptors.\n");
     128        bzero(data->tds, sizeof(td_t) * data->packets);
     129
     130        data->qh = malloc32(sizeof(qh_t));
     131        CHECK_NULL_DISPOSE_RETURN(data->qh,
    106132            "Failed to allocate batch queue head.\n");
    107         qh_init(instance->qh);
    108 
    109         instance->packets = (size + max_packet_size - 1) / max_packet_size;
    110         if (transfer_type == USB_TRANSFER_CONTROL) {
    111                 instance->packets += 2;
    112         }
    113 
    114         instance->tds = malloc32(sizeof(td_t) * instance->packets);
    115         CHECK_NULL_DISPOSE_RETURN(
    116             instance->tds, "Failed to allocate transfer descriptors.\n");
    117         bzero(instance->tds, sizeof(td_t) * instance->packets);
    118 
    119         if (size > 0) {
    120                 instance->transport_buffer = malloc32(size);
     133        qh_init(data->qh);
     134        qh_set_element_td(data->qh, addr_to_phys(data->tds));
     135
     136        if (buffer_size > 0) {
     137                instance->transport_buffer = malloc32(buffer_size);
    121138                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
    122139                    "Failed to allocate device accessible buffer.\n");
    … …  
    130147        }
    131148
    132 
    133         link_initialize(&instance->link);
    134 
    135         instance->max_packet_size = max_packet_size;
    136         instance->target = target;
    137         instance->transfer_type = transfer_type;
    138         instance->buffer = buffer;
    139         instance->buffer_size = size;
    140         instance->setup_size = setup_size;
    141         instance->fun = fun;
    142         instance->arg = arg;
    143         instance->speed = speed;
    144         instance->manager = manager;
    145         instance->callback_out = func_out;
    146         instance->callback_in = func_in;
    147 
    148         qh_set_element_td(instance->qh, addr_to_phys(instance->tds));
    149 
    150149        usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
    151150            instance, target.address, target.endpoint);
    … …  
    153152}
    154153/*----------------------------------------------------------------------------*/
    155 /** Mark batch as failed and continue with next step.
    156  *
    157  * @param[in] instance Batch structure to use.
    158  *
    159  */
    160 void batch_abort(batch_t *instance)
    161 {
    162         assert(instance);
    163         instance->error = EIO;
    164         instance->next_step(instance);
    165 }
    166 /*----------------------------------------------------------------------------*/
    167154/** Check batch TDs for activity.
    168155 *
    … …  
    174161 * is reached.
    175162 */
    176 bool batch_is_complete(batch_t *instance)
    177 {
    178         assert(instance);
     163bool batch_is_complete(usb_transfer_batch_t *instance)
     164{
     165        assert(instance);
     166        uhci_batch_t *data = instance->private_data;
     167        assert(data);
     168
    179169        usb_log_debug2("Batch(%p) checking %d packet(s) for completion.\n",
    180             instance, instance->packets);
     170            instance, data->packets);
    181171        instance->transfered_size = 0;
    182172        size_t i = 0;
    183         for (;i < instance->packets; ++i) {
    184                 if (td_is_active(&instance->tds[i])) {
     173        for (;i < data->packets; ++i) {
     174                if (td_is_active(&data->tds[i])) {
    185175                        return false;
    186176                }
    187177
    188                 instance->error = td_status(&instance->tds[i]);
     178                instance->error = td_status(&data->tds[i]);
    189179                if (instance->error != EOK) {
    190180                        usb_log_debug("Batch(%p) found error TD(%d):%x.\n",
    191                             instance, i, instance->tds[i].status);
    192                         td_print_status(&instance->tds[i]);
    193 
    194                         device_keeper_set_toggle(instance->manager,
    195                             instance->target, td_toggle(&instance->tds[i]));
     181                            instance, i, data->tds[i].status);
     182                        td_print_status(&data->tds[i]);
     183
     184                        usb_device_keeper_set_toggle(data->manager,
     185                            instance->target, instance->direction,
     186                            td_toggle(&data->tds[i]));
    196187                        if (i > 0)
    197188                                goto substract_ret;
    … …  
    199190                }
    200191
    201                 instance->transfered_size += td_act_size(&instance->tds[i]);
    202                 if (td_is_short(&instance->tds[i]))
     192                instance->transfered_size += td_act_size(&data->tds[i]);
     193                if (td_is_short(&data->tds[i]))
    203194                        goto substract_ret;
    204195        }
    … …  
    214205 * Uses genercir control function with pids OUT and IN.
    215206 */
    216 void batch_control_write(batch_t *instance)
     207void batch_control_write(usb_transfer_batch_t *instance)
    217208{
    218209        assert(instance);
    … …  
    231222 * Uses generic control with pids IN and OUT.
    232223 */
    233 void batch_control_read(batch_t *instance)
     224void batch_control_read(usb_transfer_batch_t *instance)
    234225{
    235226        assert(instance);
    … …  
    245236 * Data transaction with PID_IN.
    246237 */
    247 void batch_interrupt_in(batch_t *instance)
    248 {
    249         assert(instance);
     238void batch_interrupt_in(usb_transfer_batch_t *instance)
     239{
     240        assert(instance);
     241        instance->direction = USB_DIRECTION_IN;
    250242        batch_data(instance, USB_PID_IN);
    251243        instance->next_step = batch_call_in_and_dispose;
    … …  
    259251 * Data transaction with PID_OUT.
    260252 */
    261 void batch_interrupt_out(batch_t *instance)
    262 {
    263         assert(instance);
     253void batch_interrupt_out(usb_transfer_batch_t *instance)
     254{
     255        assert(instance);
     256        instance->direction = USB_DIRECTION_OUT;
    264257        /* We are data out, we are supposed to provide data */
    265258        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    276269 * Data transaction with PID_IN.
    277270 */
    278 void batch_bulk_in(batch_t *instance)
     271void batch_bulk_in(usb_transfer_batch_t *instance)
    279272{
    280273        assert(instance);
    281274        batch_data(instance, USB_PID_IN);
     275        instance->direction = USB_DIRECTION_IN;
    282276        instance->next_step = batch_call_in_and_dispose;
    283277        usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
    … …  
    290284 * Data transaction with PID_OUT.
    291285 */
    292 void batch_bulk_out(batch_t *instance)
    293 {
    294         assert(instance);
     286void batch_bulk_out(usb_transfer_batch_t *instance)
     287{
     288        assert(instance);
     289        instance->direction = USB_DIRECTION_OUT;
    295290        /* We are data out, we are supposed to provide data */
    296291        memcpy(instance->transport_buffer, instance->buffer,
    … …  
    309304 * The last packet is marked with IOC flag.
    310305 */
    311 void batch_data(batch_t *instance, usb_packet_id pid)
    312 {
    313         assert(instance);
     306void batch_data(usb_transfer_batch_t *instance, usb_packet_id pid)
     307{
     308        assert(instance);
     309        uhci_batch_t *data = instance->private_data;
     310        assert(data);
     311
    314312        const bool low_speed = instance->speed == USB_SPEED_LOW;
    315         int toggle =
    316             device_keeper_get_toggle(instance->manager, instance->target);
     313        int toggle = usb_device_keeper_get_toggle(
     314            data->manager, instance->target, instance->direction);
    317315        assert(toggle == 0 || toggle == 1);
    318316
    … …  
    320318        size_t remain_size = instance->buffer_size;
    321319        while (remain_size > 0) {
    322                 char *data =
     320                char *trans_data =
    323321                    instance->transport_buffer + instance->buffer_size
    324322                    - remain_size;
    … …  
    328326                    remain_size : instance->max_packet_size;
    329327
    330                 td_t *next_packet = (packet + 1 < instance->packets)
    331                     ? &instance->tds[packet + 1] : NULL;
    332 
    333                 assert(packet < instance->packets);
     328                td_t *next_packet = (packet + 1 < data->packets)
     329                    ? &data->tds[packet + 1] : NULL;
     330
     331                assert(packet < data->packets);
    334332                assert(packet_size <= remain_size);
    335333
    336334                td_init(
    337                     &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
    338                     toggle, false, low_speed, instance->target, pid, data,
     335                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
     336                    toggle, false, low_speed, instance->target, pid, trans_data,
    339337                    next_packet);
    340338
    … …  
    344342                ++packet;
    345343        }
    346         td_set_ioc(&instance->tds[packet - 1]);
    347         device_keeper_set_toggle(instance->manager, instance->target, toggle);
     344        td_set_ioc(&data->tds[packet - 1]);
     345        usb_device_keeper_set_toggle(data->manager, instance->target,
     346            instance->direction, toggle);
    348347}
    349348/*----------------------------------------------------------------------------*/
    … …  
    359358 * The last packet is marked with IOC.
    360359 */
    361 void batch_control(batch_t *instance,
     360void batch_control(usb_transfer_batch_t *instance,
    362361   usb_packet_id data_stage, usb_packet_id status_stage)
    363362{
    364363        assert(instance);
     364        uhci_batch_t *data = instance->private_data;
     365        assert(data);
     366        assert(data->packets >= 2);
    365367
    366368        const bool low_speed = instance->speed == USB_SPEED_LOW;
    367369        int toggle = 0;
    368370        /* setup stage */
    369         td_init(instance->tds, DEFAULT_ERROR_COUNT,
    370             instance->setup_size, toggle, false, low_speed, instance->target,
    371             USB_PID_SETUP, instance->setup_buffer, &instance->tds[1]);
     371        td_init(
     372            data->tds, DEFAULT_ERROR_COUNT, instance->setup_size, toggle, false,
     373            low_speed, instance->target, USB_PID_SETUP, instance->setup_buffer,
     374            &data->tds[1]);
    372375
    373376        /* data stage */
    … …  
    375378        size_t remain_size = instance->buffer_size;
    376379        while (remain_size > 0) {
    377                 char *data =
     380                char *control_data =
    378381                    instance->transport_buffer + instance->buffer_size
    379382                    - remain_size;
    … …  
    386389
    387390                td_init(
    388                     &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
     391                    &data->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
    389392                    toggle, false, low_speed, instance->target, data_stage,
    390                     data, &instance->tds[packet + 1]);
     393                    control_data, &data->tds[packet + 1]);
    391394
    392395                ++packet;
    393                 assert(packet < instance->packets);
     396                assert(packet < data->packets);
    394397                assert(packet_size <= remain_size);
    395398                remain_size -= packet_size;
    … …  
    397400
    398401        /* status stage */
    399         assert(packet == instance->packets - 1);
    400         td_init(&instance->tds[packet], DEFAULT_ERROR_COUNT,
    401             0, 1, false, low_speed, instance->target, status_stage, NULL, NULL);
    402 
    403         td_set_ioc(&instance->tds[packet]);
     402        assert(packet == data->packets - 1);
     403
     404        td_init(
     405            &data->tds[packet], DEFAULT_ERROR_COUNT, 0, 1, false, low_speed,
     406            instance->target, status_stage, NULL, NULL);
     407        td_set_ioc(&data->tds[packet]);
     408
    404409        usb_log_debug2("Control last TD status: %x.\n",
    405             instance->tds[packet].status);
    406 }
    407 /*----------------------------------------------------------------------------*/
    408 /** Prepare data, get error status and call callback in.
    409  *
    410  * @param[in] instance Batch structure to use.
    411  * Copies data from transport buffer, and calls callback with appropriate
    412  * parameters.
    413  */
    414 void batch_call_in(batch_t *instance)
    415 {
    416         assert(instance);
    417         assert(instance->callback_in);
    418 
    419         /* We are data in, we need data */
    420         memcpy(instance->buffer, instance->transport_buffer,
    421             instance->buffer_size);
    422 
    423         int err = instance->error;
    424         usb_log_debug("Batch(%p) callback IN(type:%d): %s(%d), %zu.\n",
    425             instance, instance->transfer_type, str_error(err), err,
    426             instance->transfered_size);
    427 
    428         instance->callback_in(
    429             instance->fun, err, instance->transfered_size, instance->arg);
    430 }
    431 /*----------------------------------------------------------------------------*/
    432 /** Get error status and call callback out.
    433  *
    434  * @param[in] instance Batch structure to use.
    435  */
    436 void batch_call_out(batch_t *instance)
    437 {
    438         assert(instance);
    439         assert(instance->callback_out);
    440 
    441         int err = instance->error;
    442         usb_log_debug("Batch(%p) callback OUT(type:%d): %s(%d).\n",
    443             instance, instance->transfer_type, str_error(err), err);
    444         instance->callback_out(instance->fun,
    445             err, instance->arg);
     410            data->tds[packet].status);
     411}
     412/*----------------------------------------------------------------------------*/
     413qh_t * batch_qh(usb_transfer_batch_t *instance)
     414{
     415        assert(instance);
     416        uhci_batch_t *data = instance->private_data;
     417        assert(data);
     418        return data->qh;
    446419}
    447420/*----------------------------------------------------------------------------*/
    … …  
    450423 * @param[in] instance Batch structure to use.
    451424 */
    452 void batch_call_in_and_dispose(batch_t *instance)
    453 {
    454         assert(instance);
    455         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);
    456429        batch_dispose(instance);
    457430}
    … …  
    461434 * @param[in] instance Batch structure to use.
    462435 */
    463 void batch_call_out_and_dispose(batch_t *instance)
    464 {
    465         assert(instance);
    466         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);
    467440        batch_dispose(instance);
    468441}
    … …  
    472445 * @param[in] instance Batch structure to use.
    473446 */
    474 void batch_dispose(batch_t *instance)
    475 {
    476         assert(instance);
     447void batch_dispose(usb_transfer_batch_t *instance)
     448{
     449        assert(instance);
     450        uhci_batch_t *data = instance->private_data;
     451        assert(data);
    477452        usb_log_debug("Batch(%p) disposing.\n", instance);
    478453        /* free32 is NULL safe */
    479         free32(instance->tds);
    480         free32(instance->qh);
     454        free32(data->tds);
     455        free32(data->qh);
    481456        free32(instance->setup_buffer);
    482457        free32(instance->transport_buffer);
     458        free(data);
    483459        free(instance);
    484460}
Note: See TracChangeset for help on using the changeset viewer.