Changeset b9fa0a9 in mainline for uspace/drv/ohci/iface.c


Ignore:
Timestamp:
2011-03-21T23:33:19Z (13 years ago)
Author:
Jan Vesely <jano.vesely@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
87644b4
Parents:
1c6a45f
Message:

80-column fixes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/drv/ohci/iface.c

    r1c6a45f rb9fa0a9  
    8585 * @return Error code.
    8686 */
    87 static int request_address(ddf_fun_t *fun, usb_speed_t speed,
    88     usb_address_t *address)
     87static int request_address(
     88    ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    8989{
    9090        assert(fun);
    … …  
    108108 * @return Error code.
    109109 */
    110 static int bind_address(ddf_fun_t *fun,
    111     usb_address_t address, devman_handle_t handle)
     110static int bind_address(
     111    ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
    112112{
    113113        assert(fun);
    … …  
    146146 * @return Error code.
    147147 */
    148 static int register_endpoint(ddf_fun_t *fun,
    149     usb_address_t address, usb_endpoint_t endpoint,
     148static int register_endpoint(
     149    ddf_fun_t *fun, usb_address_t address, usb_endpoint_t endpoint,
    150150    usb_transfer_type_t transfer_type, usb_direction_t direction,
    151151    size_t max_packet_size, unsigned int interval)
    … …  
    164164 * @return Error code.
    165165 */
    166 static int unregister_endpoint(ddf_fun_t *fun, usb_address_t address,
     166static int unregister_endpoint(
     167    ddf_fun_t *fun, usb_address_t address,
    167168    usb_endpoint_t endpoint, usb_direction_t direction)
    168169{
    … …  
    189190 * @return Error code.
    190191 */
    191 static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
    192     size_t max_packet_size, void *data, size_t size,
    193     usbhc_iface_transfer_out_callback_t callback, void *arg)
    194 {
    195         assert(fun);
    196         hc_t *hc = fun_to_hc(fun);
    197         assert(hc);
    198         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     192static int interrupt_out(
     193    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     194    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
     195{
     196        assert(fun);
     197        hc_t *hc = fun_to_hc(fun);
     198        assert(hc);
     199        usb_speed_t speed =
     200            usb_device_keeper_get_speed(&hc->manager, target.address);
    199201
    200202        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    201203            target.address, target.endpoint, size, max_packet_size);
    202204
    203         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    204             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    205             &hc->manager);
     205        usb_transfer_batch_t *batch =
     206            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     207                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    206208        if (!batch)
    207209                return ENOMEM;
    … …  
    210212        if (ret != EOK) {
    211213                batch_dispose(batch);
    212                 return ret;
    213         }
    214         return EOK;
     214        }
     215        return ret;
    215216}
    216217/*----------------------------------------------------------------------------*/
    … …  
    232233 * @return Error code.
    233234 */
    234 static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
    235     size_t max_packet_size, void *data, size_t size,
    236     usbhc_iface_transfer_in_callback_t callback, void *arg)
    237 {
    238         assert(fun);
    239         hc_t *hc = fun_to_hc(fun);
    240         assert(hc);
    241         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     235static int interrupt_in(
     236    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     237    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
     238{
     239        assert(fun);
     240        hc_t *hc = fun_to_hc(fun);
     241        assert(hc);
     242        usb_speed_t speed =
     243            usb_device_keeper_get_speed(&hc->manager, target.address);
    242244        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    243245            target.address, target.endpoint, size, max_packet_size);
    244246
    245         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    246             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    247             &hc->manager);
     247        usb_transfer_batch_t *batch =
     248            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     249                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    248250        if (!batch)
    249251                return ENOMEM;
    … …  
    252254        if (ret != EOK) {
    253255                batch_dispose(batch);
    254                 return ret;
    255         }
    256         return EOK;
     256        }
     257        return ret;
    257258}
    258259/*----------------------------------------------------------------------------*/
    … …  
    274275 * @return Error code.
    275276 */
    276 static int bulk_out(ddf_fun_t *fun, usb_target_t target,
    277     size_t max_packet_size, void *data, size_t size,
    278     usbhc_iface_transfer_out_callback_t callback, void *arg)
    279 {
    280         assert(fun);
    281         hc_t *hc = fun_to_hc(fun);
    282         assert(hc);
    283         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     277static int bulk_out(
     278    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     279    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
     280{
     281        assert(fun);
     282        hc_t *hc = fun_to_hc(fun);
     283        assert(hc);
     284        usb_speed_t speed =
     285            usb_device_keeper_get_speed(&hc->manager, target.address);
    284286
    285287        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    286288            target.address, target.endpoint, size, max_packet_size);
    287289
    288         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    289             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    290             &hc->manager);
     290        usb_transfer_batch_t *batch =
     291            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     292                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    291293        if (!batch)
    292294                return ENOMEM;
    … …  
    295297        if (ret != EOK) {
    296298                batch_dispose(batch);
    297                 return ret;
    298         }
    299         return EOK;
     299        }
     300        return ret;
    300301}
    301302/*----------------------------------------------------------------------------*/
    … …  
    317318 * @return Error code.
    318319 */
    319 static int bulk_in(ddf_fun_t *fun, usb_target_t target,
    320     size_t max_packet_size, void *data, size_t size,
    321     usbhc_iface_transfer_in_callback_t callback, void *arg)
    322 {
    323         assert(fun);
    324         hc_t *hc = fun_to_hc(fun);
    325         assert(hc);
    326         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     320static int bulk_in(
     321    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     322    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
     323{
     324        assert(fun);
     325        hc_t *hc = fun_to_hc(fun);
     326        assert(hc);
     327        usb_speed_t speed =
     328            usb_device_keeper_get_speed(&hc->manager, target.address);
    327329        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    328330            target.address, target.endpoint, size, max_packet_size);
    329331
    330         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    331             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    332             &hc->manager);
     332        usb_transfer_batch_t *batch =
     333            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     334                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    333335        if (!batch)
    334336                return ENOMEM;
    … …  
    337339        if (ret != EOK) {
    338340                batch_dispose(batch);
    339                 return ret;
    340         }
    341         return EOK;
     341        }
     342        return ret;
    342343}
    343344/*----------------------------------------------------------------------------*/
    … …  
    362363 * @return Error code.
    363364 */
    364 static int control_write(ddf_fun_t *fun, usb_target_t target,
    365     size_t max_packet_size,
     365static int control_write(
     366    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    366367    void *setup_data, size_t setup_size, void *data, size_t size,
    367368    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    370371        hc_t *hc = fun_to_hc(fun);
    371372        assert(hc);
    372         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     373        usb_speed_t speed =
     374            usb_device_keeper_get_speed(&hc->manager, target.address);
    373375        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    374376            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    377379                return EINVAL;
    378380
    379         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    380             max_packet_size, speed, data, size, setup_data, setup_size,
    381             NULL, callback, arg, &hc->manager);
     381        usb_transfer_batch_t *batch =
     382            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
     383                speed, data, size, setup_data, setup_size, NULL, callback, arg,
     384                &hc->manager);
    382385        if (!batch)
    383386                return ENOMEM;
    … …  
    387390        if (ret != EOK) {
    388391                batch_dispose(batch);
    389                 return ret;
    390         }
    391         return EOK;
     392        }
     393        return ret;
    392394}
    393395/*----------------------------------------------------------------------------*/
    … …  
    412414 * @return Error code.
    413415 */
    414 static int control_read(ddf_fun_t *fun, usb_target_t target,
    415     size_t max_packet_size,
     416static int control_read(
     417    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    416418    void *setup_data, size_t setup_size, void *data, size_t size,
    417419    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    420422        hc_t *hc = fun_to_hc(fun);
    421423        assert(hc);
    422         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     424        usb_speed_t speed =
     425            usb_device_keeper_get_speed(&hc->manager, target.address);
    423426
    424427        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    425428            speed, target.address, target.endpoint, size, max_packet_size);
    426         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    427             max_packet_size, speed, data, size, setup_data, setup_size, callback,
    428             NULL, arg, &hc->manager);
     429        usb_transfer_batch_t *batch =
     430            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size,
     431                speed, data, size, setup_data, setup_size, callback, NULL, arg,
     432                &hc->manager);
    429433        if (!batch)
    430434                return ENOMEM;
    … …  
    433437        if (ret != EOK) {
    434438                batch_dispose(batch);
    435                 return ret;
    436         }
    437         return EOK;
     439        }
     440        return ret;
    438441}
    439442/*----------------------------------------------------------------------------*/
Note: See TracChangeset for help on using the changeset viewer.