Changeset b9fa0a9 in mainline


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

Location:
uspace/drv
Files:
2 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/*----------------------------------------------------------------------------*/

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

    r1c6a45f rb9fa0a9  
    7878 * @return Error code.
    7979 */
    80 static int request_address(ddf_fun_t *fun, usb_speed_t speed,
    81     usb_address_t *address)
     80static int request_address(
     81    ddf_fun_t *fun, usb_speed_t speed, usb_address_t *address)
    8282{
    8383        assert(fun);
    … …  
    139139 * @return Error code.
    140140 */
    141 static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
    142     size_t max_packet_size, void *data, size_t size,
    143     usbhc_iface_transfer_out_callback_t callback, void *arg)
    144 {
    145         assert(fun);
    146         hc_t *hc = fun_to_hc(fun);
    147         assert(hc);
    148         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     141static int interrupt_out(
     142    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     143    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
     144{
     145        assert(fun);
     146        hc_t *hc = fun_to_hc(fun);
     147        assert(hc);
     148        usb_speed_t speed =
     149            usb_device_keeper_get_speed(&hc->manager, target.address);
    149150
    150151        usb_log_debug("Interrupt OUT %d:%d %zu(%zu).\n",
    151152            target.address, target.endpoint, size, max_packet_size);
    152153
    153         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    154             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    155             &hc->manager);
     154        usb_transfer_batch_t *batch =
     155            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     156                speed, data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    156157        if (!batch)
    157158                return ENOMEM;
    … …  
    160161        if (ret != EOK) {
    161162                batch_dispose(batch);
    162                 return ret;
    163         }
    164         return EOK;
     163        }
     164        return ret;
    165165}
    166166/*----------------------------------------------------------------------------*/
    … …  
    176176 * @return Error code.
    177177 */
    178 static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
    179     size_t max_packet_size, void *data, size_t size,
    180     usbhc_iface_transfer_in_callback_t callback, void *arg)
    181 {
    182         assert(fun);
    183         hc_t *hc = fun_to_hc(fun);
    184         assert(hc);
    185         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     178static int interrupt_in(
     179    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     180    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
     181{
     182        assert(fun);
     183        hc_t *hc = fun_to_hc(fun);
     184        assert(hc);
     185        usb_speed_t speed =
     186            usb_device_keeper_get_speed(&hc->manager, target.address);
    186187        usb_log_debug("Interrupt IN %d:%d %zu(%zu).\n",
    187188            target.address, target.endpoint, size, max_packet_size);
    188189
    189         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_INTERRUPT,
    190             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    191             &hc->manager);
     190        usb_transfer_batch_t *batch =
     191            batch_get(fun, target, USB_TRANSFER_INTERRUPT, max_packet_size,
     192                speed, data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    192193        if (!batch)
    193194                return ENOMEM;
    … …  
    196197        if (ret != EOK) {
    197198                batch_dispose(batch);
    198                 return ret;
    199         }
    200         return EOK;
     199        }
     200        return ret;
    201201}
    202202/*----------------------------------------------------------------------------*/
    … …  
    212212 * @return Error code.
    213213 */
    214 static int bulk_out(ddf_fun_t *fun, usb_target_t target,
    215     size_t max_packet_size, void *data, size_t size,
    216     usbhc_iface_transfer_out_callback_t callback, void *arg)
    217 {
    218         assert(fun);
    219         hc_t *hc = fun_to_hc(fun);
    220         assert(hc);
    221         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     214static int bulk_out(
     215    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     216    size_t size, usbhc_iface_transfer_out_callback_t callback, void *arg)
     217{
     218        assert(fun);
     219        hc_t *hc = fun_to_hc(fun);
     220        assert(hc);
     221        usb_speed_t speed =
     222            usb_device_keeper_get_speed(&hc->manager, target.address);
    222223
    223224        usb_log_debug("Bulk OUT %d:%d %zu(%zu).\n",
    224225            target.address, target.endpoint, size, max_packet_size);
    225226
    226         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    227             max_packet_size, speed, data, size, NULL, 0, NULL, callback, arg,
    228             &hc->manager);
     227        usb_transfer_batch_t *batch =
     228            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     229                data, size, NULL, 0, NULL, callback, arg, &hc->manager);
    229230        if (!batch)
    230231                return ENOMEM;
    … …  
    233234        if (ret != EOK) {
    234235                batch_dispose(batch);
    235                 return ret;
    236         }
    237         return EOK;
     236        }
     237        return ret;
    238238}
    239239/*----------------------------------------------------------------------------*/
    … …  
    249249 * @return Error code.
    250250 */
    251 static int bulk_in(ddf_fun_t *fun, usb_target_t target,
    252     size_t max_packet_size, void *data, size_t size,
    253     usbhc_iface_transfer_in_callback_t callback, void *arg)
    254 {
    255         assert(fun);
    256         hc_t *hc = fun_to_hc(fun);
    257         assert(hc);
    258         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     251static int bulk_in(
     252    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size, void *data,
     253    size_t size, usbhc_iface_transfer_in_callback_t callback, void *arg)
     254{
     255        assert(fun);
     256        hc_t *hc = fun_to_hc(fun);
     257        assert(hc);
     258        usb_speed_t speed =
     259            usb_device_keeper_get_speed(&hc->manager, target.address);
    259260        usb_log_debug("Bulk IN %d:%d %zu(%zu).\n",
    260261            target.address, target.endpoint, size, max_packet_size);
    261262
    262         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_BULK,
    263             max_packet_size, speed, data, size, NULL, 0, callback, NULL, arg,
    264             &hc->manager);
     263        usb_transfer_batch_t *batch =
     264            batch_get(fun, target, USB_TRANSFER_BULK, max_packet_size, speed,
     265                data, size, NULL, 0, callback, NULL, arg, &hc->manager);
    265266        if (!batch)
    266267                return ENOMEM;
    … …  
    269270        if (ret != EOK) {
    270271                batch_dispose(batch);
    271                 return ret;
    272         }
    273         return EOK;
     272        }
     273        return ret;
    274274}
    275275/*----------------------------------------------------------------------------*/
    … …  
    287287 * @return Error code.
    288288 */
    289 static int control_write(ddf_fun_t *fun, usb_target_t target,
    290     size_t max_packet_size,
     289static int control_write(
     290    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    291291    void *setup_data, size_t setup_size, void *data, size_t size,
    292292    usbhc_iface_transfer_out_callback_t callback, void *arg)
    … …  
    295295        hc_t *hc = fun_to_hc(fun);
    296296        assert(hc);
    297         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     297        usb_speed_t speed =
     298            usb_device_keeper_get_speed(&hc->manager, target.address);
    298299        usb_log_debug("Control WRITE (%d) %d:%d %zu(%zu).\n",
    299300            speed, target.address, target.endpoint, size, max_packet_size);
    … …  
    302303                return EINVAL;
    303304
    304         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    305             max_packet_size, speed, data, size, setup_data, setup_size,
    306             NULL, callback, arg, &hc->manager);
     305        usb_transfer_batch_t *batch =
     306            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
     307                data, size, setup_data, setup_size, NULL, callback, arg,
     308                &hc->manager);
    307309        if (!batch)
    308310                return ENOMEM;
    … …  
    312314        if (ret != EOK) {
    313315                batch_dispose(batch);
    314                 return ret;
    315         }
    316         return EOK;
     316        }
     317        return ret;
    317318}
    318319/*----------------------------------------------------------------------------*/
    … …  
    330331 * @return Error code.
    331332 */
    332 static int control_read(ddf_fun_t *fun, usb_target_t target,
    333     size_t max_packet_size,
     333static int control_read(
     334    ddf_fun_t *fun, usb_target_t target, size_t max_packet_size,
    334335    void *setup_data, size_t setup_size, void *data, size_t size,
    335336    usbhc_iface_transfer_in_callback_t callback, void *arg)
    … …  
    338339        hc_t *hc = fun_to_hc(fun);
    339340        assert(hc);
    340         usb_speed_t speed = usb_device_keeper_get_speed(&hc->manager, target.address);
     341        usb_speed_t speed =
     342            usb_device_keeper_get_speed(&hc->manager, target.address);
    341343
    342344        usb_log_debug("Control READ(%d) %d:%d %zu(%zu).\n",
    343345            speed, target.address, target.endpoint, size, max_packet_size);
    344         usb_transfer_batch_t *batch = batch_get(fun, target, USB_TRANSFER_CONTROL,
    345             max_packet_size, speed, data, size, setup_data, setup_size, callback,
    346             NULL, arg, &hc->manager);
     346        usb_transfer_batch_t *batch =
     347            batch_get(fun, target, USB_TRANSFER_CONTROL, max_packet_size, speed,
     348                data, size, setup_data, setup_size, callback, NULL, arg,
     349                &hc->manager);
    347350        if (!batch)
    348351                return ENOMEM;
    … …  
    351354        if (ret != EOK) {
    352355                batch_dispose(batch);
    353                 return ret;
    354         }
    355         return EOK;
     356        }
     357        return ret;
    356358}
    357359/*----------------------------------------------------------------------------*/
Note: See TracChangeset for help on using the changeset viewer.