Changeset 338d54a7 in mainline


Ignore:
Timestamp:
2018-03-10T22:55:07Z (7 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
850fd32
Parents:
5ef16903
Message:

Gratuitous nested block makes ccheck sad.

Files:
14 edited

Legend:

Unmodified
Added
Removed

  • kernel/arch/arm32/src/fpu_context.c

    r5ef16903 r338d54a7  
    180180void fpu_setup(void)
    181181{
     182        uint32_t mvfr0;
     183
    182184        /* Enable coprocessor access*/
    183185        fpu_enable_coprocessor_access();
    … …  
    205207        case FPU_VFPv3_COMMONv2:
    206208        case FPU_VFPv3_NO_COMMON:
    207         case FPU_VFPv3_COMMONv3: {
    208                 const uint32_t mvfr0 = mvfr0_read();
     209        case FPU_VFPv3_COMMONv3:
     210                mvfr0 = mvfr0_read();
    209211                /* See page B4-1637 */
    210212                if ((mvfr0 & 0xf) == 0x1) {
    … …  
    219221                break;
    220222        }
    221 
    222         }
    223223}
    224224

  • uspace/app/top/screen.c

    r5ef16903 r338d54a7  
    390390                int width = table->columns[column_index].width;
    391391                field_t *field = &table->fields[i];
     392                uint64_t val;
     393                const char *psuffix;
     394                char suffix;
    392395
    393396                if (column_index != 0) {
    … …  
    407410                        printf("%*" PRIu64, width, field->uint);
    408411                        break;
    409                 case FIELD_UINT_SUFFIX_BIN: {
    410                         uint64_t val = field->uint;
    411                         const char *suffix;
     412                case FIELD_UINT_SUFFIX_BIN:
     413                        val = field->uint;
    412414                        width -= 3;
    413                         bin_order_suffix(val, &val, &suffix, true);
    414                         printf("%*" PRIu64 "%s", width, val, suffix);
    415                         break;
    416                 }
    417                 case FIELD_UINT_SUFFIX_DEC: {
    418                         uint64_t val = field->uint;
    419                         char suffix;
     415                        bin_order_suffix(val, &val, &psuffix, true);
     416                        printf("%*" PRIu64 "%s", width, val, psuffix);
     417                        break;
     418                case FIELD_UINT_SUFFIX_DEC:
     419                        val = field->uint;
    420420                        width -= 1;
    421421                        order_suffix(val, &val, &suffix);
    422422                        printf("%*" PRIu64 "%c", width, val, suffix);
    423423                        break;
    424                 }
    425424                case FIELD_PERCENT:
    426425                        width -= 5; /* nnn.% */

  • uspace/dist/src/c/demos/top/screen.c

    r5ef16903 r338d54a7  
    4545#include <inttypes.h>
    4646#include <macros.h>
     47#include <str.h>
    4748#include "screen.h"
    4849#include "top.h"
    … …  
    389390                int width = table->columns[column_index].width;
    390391                field_t *field = &table->fields[i];
     392                uint64_t val;
     393                const char *psuffix;
     394                char suffix;
    391395
    392396                if (column_index != 0) {
    … …  
    406410                        printf("%*" PRIu64, width, field->uint);
    407411                        break;
    408                 case FIELD_UINT_SUFFIX_BIN: {
    409                         uint64_t val = field->uint;
    410                         const char *suffix;
     412                case FIELD_UINT_SUFFIX_BIN:
     413                        val = field->uint;
    411414                        width -= 3;
    412                         bin_order_suffix(val, &val, &suffix, true);
    413                         printf("%*" PRIu64 "%s", width, val, suffix);
    414                         break;
    415                 }
    416                 case FIELD_UINT_SUFFIX_DEC: {
    417                         uint64_t val = field->uint;
    418                         char suffix;
     415                        bin_order_suffix(val, &val, &psuffix, true);
     416                        printf("%*" PRIu64 "%s", width, val, psuffix);
     417                        break;
     418                case FIELD_UINT_SUFFIX_DEC:
     419                        val = field->uint;
    419420                        width -= 1;
    420421                        order_suffix(val, &val, &suffix);
    421422                        printf("%*" PRIu64 "%c", width, val, suffix);
    422423                        break;
    423                 }
    424424                case FIELD_PERCENT:
    425425                        width -= 5; /* nnn.% */
    … …  
    537537 *
    538538 */
    539 errno_t tgetchar(unsigned int sec)
     539int tgetchar(unsigned int sec)
    540540{
    541541        /*

  • uspace/dist/src/c/demos/top/screen.h

    r5ef16903 r338d54a7  
    4747    _HELENOS_PRINTF_ATTRIBUTE(1, 2);
    4848
    49 extern errno_t tgetchar(unsigned int);
     49extern int tgetchar(unsigned int);
    5050
    5151#endif

  • uspace/dist/src/c/demos/top/top.c

    r5ef16903 r338d54a7  
    4343#include <errno.h>
    4444#include <gsort.h>
     45#include <str.h>
    4546#include "screen.h"
    4647#include "top.h"

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

    r5ef16903 r338d54a7  
    343343        ohci_rh_t *hub;
    344344        unsigned port;
     345        uint32_t rhda;
    345346        TEST_SIZE_INIT(0, port, hub);
    346347        const unsigned feature = uint16_usb2host(setup_packet->value);
    … …  
    349350        {
    350351        case USB_HUB_FEATURE_PORT_POWER:          /*8*/
    351                 {
    352                         const uint32_t rhda =
    353                             OHCI_RD(hub->registers->rh_desc_a);
    354                         /* No power switching */
    355                         if (rhda & RHDA_NPS_FLAG)
    356                                 return ENOTSUP;
    357                         /* Ganged power switching, one port powers all */
    358                         if (!(rhda & RHDA_PSM_FLAG)) {
    359                                 OHCI_WR(hub->registers->rh_status,
    360                                     RHS_CLEAR_GLOBAL_POWER);
    361                                 return EOK;
    362                         }
    363                         OHCI_WR(hub->registers->rh_port_status[port],
    364                             RHPS_CLEAR_PORT_POWER);
     352                rhda = OHCI_RD(hub->registers->rh_desc_a);
     353                /* No power switching */
     354                if (rhda & RHDA_NPS_FLAG)
     355                        return ENOTSUP;
     356                /* Ganged power switching, one port powers all */
     357                if (!(rhda & RHDA_PSM_FLAG)) {
     358                        OHCI_WR(hub->registers->rh_status,
     359                            RHS_CLEAR_GLOBAL_POWER);
    365360                        return EOK;
    366361                }
    367 
     362                OHCI_WR(hub->registers->rh_port_status[port],
     363                    RHPS_CLEAR_PORT_POWER);
     364                return EOK;
    368365        case USB2_HUB_FEATURE_PORT_ENABLE:         /*1*/
    369366                OHCI_WR(hub->registers->rh_port_status[port],
    … …  
    407404        ohci_rh_t *hub;
    408405        unsigned port;
     406        uint32_t rhda;
    409407        TEST_SIZE_INIT(0, port, hub);
    410408        const unsigned feature = uint16_usb2host(setup_packet->value);
    … …  
    412410        switch (feature) {
    413411        case USB_HUB_FEATURE_PORT_POWER:   /*8*/
    414                 {
    415                         const uint32_t rhda = OHCI_RD(hub->registers->rh_desc_a);
    416 
    417                         /* No power switching */
    418                         if (rhda & RHDA_NPS_FLAG)
    419                                 return EOK;
    420 
    421                         /* Ganged power switching, one port powers all */
    422                         if (!(rhda & RHDA_PSM_FLAG)) {
    423                                 OHCI_WR(hub->registers->rh_status,RHS_SET_GLOBAL_POWER);
    424                                 return EOK;
    425                         }
     412                rhda = OHCI_RD(hub->registers->rh_desc_a);
     413
     414                /* No power switching */
     415                if (rhda & RHDA_NPS_FLAG)
     416                        return EOK;
     417
     418                /* Ganged power switching, one port powers all */
     419                if (!(rhda & RHDA_PSM_FLAG)) {
     420                        OHCI_WR(hub->registers->rh_status,RHS_SET_GLOBAL_POWER);
     421                        return EOK;
    426422                }
    427423                /* Fall through, for per port power */

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

    r5ef16903 r338d54a7  
    310310        while (isoch->transfers[isoch->hw_enqueue].state == ISOCH_FILLED) {
    311311                xhci_isoch_transfer_t * const it = &isoch->transfers[isoch->hw_enqueue];
     312                suseconds_t delay;
    312313
    313314                assert(it->state == ISOCH_FILLED);
    … …  
    317318
    318319                switch (wd.position) {
    319                 case WINDOW_TOO_SOON: {
    320                         const suseconds_t delay = wd.offset * 125;
     320                case WINDOW_TOO_SOON:
     321                        delay = wd.offset * 125;
    321322                        usb_log_debug("[isoch] delaying feeding buffer %zu for %ldus",
    322323                                it - isoch->transfers, delay);
    … …  
    324325                            isoch_feed_out_timer, ep);
    325326                        goto out;
    326                 }
    327327
    328328                case WINDOW_INSIDE:
    … …  
    396396        while (isoch->transfers[isoch->enqueue].state <= ISOCH_FILLED) {
    397397                xhci_isoch_transfer_t * const it = &isoch->transfers[isoch->enqueue];
     398                suseconds_t delay;
    398399
    399400                /* IN buffers are "filled" with free space */
    … …  
    408409
    409410                switch (wd.position) {
    410                 case WINDOW_TOO_SOON: {
     411                case WINDOW_TOO_SOON:
    411412                        /* Not allowed to feed yet. Defer to later. */
    412                         const suseconds_t delay = wd.offset * 125;
     413                        delay = wd.offset * 125;
    413414                        usb_log_debug("[isoch] delaying feeding buffer %zu for %ldus",
    414415                            it - isoch->transfers, delay);
    … …  
    416417                            isoch_feed_in_timer, ep);
    417418                        goto out;
    418                 }
    419 
    420419                case WINDOW_TOO_LATE:
    421420                        usb_log_debug("[isoch] missed feeding buffer %zu at 0x%llx by"

  • uspace/drv/hid/atkbd/atkbd.c

    r5ef16903 r338d54a7  
    302302        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    303303        at_kbd_t *kbd = ddf_dev_data_get(ddf_fun_get_dev(fun));
     304        async_sess_t *sess;
    304305
    305306        switch (method) {
    306         case KBDEV_SET_IND: {
     307        case KBDEV_SET_IND:
    307308                async_answer_0(icallid, ENOTSUP);
    308309                break;
    309         }
    310310        /*
    311311         * This might be ugly but async_callback_receive_start makes no
    312312         * difference for incorrect call and malloc failure.
    313313         */
    314         case IPC_M_CONNECT_TO_ME: {
    315                 async_sess_t *sess =
    316                     async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     314        case IPC_M_CONNECT_TO_ME:
     315                sess = async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
    317316
    318317                /* Probably ENOMEM error, try again. */
    … …  
    334333
    335334                break;
    336         }
    337335        default:
    338336                ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);

  • uspace/drv/hid/ps2mouse/ps2mouse.c

    r5ef16903 r338d54a7  
    408408        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    409409        ps2_mouse_t *mouse = ddf_dev_data_get(ddf_fun_get_dev(fun));
     410        async_sess_t *sess;
    410411
    411412        switch (method) {
    412413        /* This might be ugly but async_callback_receive_start makes no
    413414         * difference for incorrect call and malloc failure. */
    414         case IPC_M_CONNECT_TO_ME: {
    415                 async_sess_t *sess =
    416                     async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     415        case IPC_M_CONNECT_TO_ME:
     416                sess = async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
    417417                /* Probably ENOMEM error, try again. */
    418418                if (sess == NULL) {
    … …  
    431431                }
    432432                break;
    433         }
    434433        default:
    435434                ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);

  • uspace/drv/hid/usbhid/kbd/kbddev.c

    r5ef16903 r338d54a7  
    165165        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    166166        usb_kbd_t *kbd_dev = ddf_fun_data_get(fun);
     167        async_sess_t *sess;
    167168
    168169        switch (method) {
    … …  
    174175        /* This might be ugly but async_callback_receive_start makes no
    175176         * difference for incorrect call and malloc failure. */
    176         case IPC_M_CONNECT_TO_ME: {
    177                 async_sess_t *sess =
    178                     async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     177        case IPC_M_CONNECT_TO_ME:
     178                sess = async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
    179179                /* Probably ENOMEM error, try again. */
    180180                if (sess == NULL) {
    … …  
    194194                }
    195195                break;
    196         }
    197196        default:
    198197                        usb_log_error("%s: Unknown method: %d.",

  • uspace/drv/hid/xtkbd/xtkbd.c

    r5ef16903 r338d54a7  
    338338        const sysarg_t method = IPC_GET_IMETHOD(*icall);
    339339        xt_kbd_t *kbd = ddf_dev_data_get(ddf_fun_get_dev(fun));
     340        unsigned mods;
     341        async_sess_t *sess;
    340342
    341343        switch (method) {
    342         case KBDEV_SET_IND: {
     344        case KBDEV_SET_IND:
    343345                /*
    344346                 * XT keyboards do not support setting mods,
    345347                 * assume AT keyboard with Scan Code Set 1.
    346348                 */
    347                 const unsigned mods = IPC_GET_ARG1(*icall);
     349                mods = IPC_GET_ARG1(*icall);
    348350                const uint8_t status = 0 |
    349351                    ((mods & KM_CAPS_LOCK) ? LI_CAPS : 0) |
    … …  
    362364                async_answer_0(icallid, rc);
    363365                break;
    364         }
    365366        /*
    366367         * This might be ugly but async_callback_receive_start makes no
    367368         * difference for incorrect call and malloc failure.
    368369         */
    369         case IPC_M_CONNECT_TO_ME: {
    370                 async_sess_t *sess =
    371                     async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
     370        case IPC_M_CONNECT_TO_ME:
     371                sess = async_callback_receive_start(EXCHANGE_SERIALIZE, icall);
    372372
    373373                /* Probably ENOMEM error, try again. */
    … …  
    389389
    390390                break;
    391         }
    392391        default:
    393392                ddf_msg(LVL_ERROR, "Unknown method: %d.", (int)method);

  • uspace/srv/audio/hound/audio_device.c

    r5ef16903 r338d54a7  
    263263static void device_event_callback(ipc_callid_t iid, ipc_call_t *icall, void *arg)
    264264{
     265        struct timeval time1;
     266        errno_t ret;
     267
    265268        /* Answer initial request */
    266269        async_answer_0(iid, EOK);
    … …  
    272275                async_answer_0(callid, EOK);
    273276                switch(IPC_GET_IMETHOD(call)) {
    274                 case PCM_EVENT_FRAMES_PLAYED: {
    275                         struct timeval time1;
     277                case PCM_EVENT_FRAMES_PLAYED:
    276278                        getuptime(&time1);
    277279                        //TODO add underrun detection.
    … …  
    285287                            tv_sub_diff(&time2, &time1));
    286288                        break;
    287                 }
    288                 case PCM_EVENT_CAPTURE_TERMINATED: {
     289                case PCM_EVENT_CAPTURE_TERMINATED:
    289290                        log_verbose("Capture terminated");
    290291                        dev->source.format = AUDIO_FORMAT_ANY;
    291                         const errno_t ret = release_buffer(dev);
     292                        ret = release_buffer(dev);
    292293                        if (ret != EOK) {
    293294                                log_error("Failed to release buffer: %s",
    … …  
    296297                        audio_pcm_unregister_event_callback(dev->sess);
    297298                        break;
    298                 }
    299                 case PCM_EVENT_PLAYBACK_TERMINATED: {
     299                case PCM_EVENT_PLAYBACK_TERMINATED:
    300300                        log_verbose("Playback Terminated");
    301301                        dev->sink.format = AUDIO_FORMAT_ANY;
    302                         const errno_t ret = release_buffer(dev);
     302                        ret = release_buffer(dev);
    303303                        if (ret != EOK) {
    304304                                log_error("Failed to release buffer: %s",
    … …  
    307307                        audio_pcm_unregister_event_callback(dev->sess);
    308308                        break;
    309                 }
    310                 case PCM_EVENT_FRAMES_CAPTURED: {
    311                         const errno_t ret = audio_source_push_data(&dev->source,
     309                case PCM_EVENT_FRAMES_CAPTURED:
     310                        ret = audio_source_push_data(&dev->source,
    312311                            dev->buffer.position, dev->buffer.fragment_size);
    313312                        advance_buffer(dev, dev->buffer.fragment_size);
    … …  
    315314                                log_warning("Failed to push recorded data");
    316315                        break;
    317                 }
    318316                case 0:
    319317                        log_info("Device event callback hangup");
    320318                        return;
    321319                }
    322 
    323320        }
    324321}

  • uspace/srv/logger/ctl.c

    r5ef16903 r338d54a7  
    6565void logger_connection_handler_control(ipc_callid_t callid)
    6666{
     67        errno_t rc;
     68        int fd;
     69
    6770        async_answer_0(callid, EOK);
    6871        logger_log("control: new client.\n");
    … …  
    7679
    7780                switch (IPC_GET_IMETHOD(call)) {
    78                 case LOGGER_CONTROL_SET_DEFAULT_LEVEL: {
    79                         errno_t rc = set_default_logging_level(IPC_GET_ARG1(call));
     81                case LOGGER_CONTROL_SET_DEFAULT_LEVEL:
     82                        rc = set_default_logging_level(IPC_GET_ARG1(call));
    8083                        async_answer_0(callid, rc);
    8184                        break;
    82                 }
    83                 case LOGGER_CONTROL_SET_LOG_LEVEL: {
    84                         errno_t rc = handle_log_level_change(IPC_GET_ARG1(call));
     85                case LOGGER_CONTROL_SET_LOG_LEVEL:
     86                        rc = handle_log_level_change(IPC_GET_ARG1(call));
    8587                        async_answer_0(callid, rc);
    8688                        break;
    87                 }
    88                 case LOGGER_CONTROL_SET_ROOT: {
    89                         int fd;
    90                         errno_t rc = vfs_receive_handle(true, &fd);
     89                case LOGGER_CONTROL_SET_ROOT:
     90                        rc = vfs_receive_handle(true, &fd);
    9191                        if (rc == EOK) {
    9292                                rc = vfs_root_set(fd);
    … …  
    9595                        async_answer_0(callid, rc);
    9696                        break;
    97                 }
    9897                default:
    9998                        async_answer_0(callid, EINVAL);

  • uspace/srv/logger/writer.c

    r5ef16903 r338d54a7  
    9696void logger_connection_handler_writer(ipc_callid_t callid)
    9797{
     98        logger_log_t *log;
     99        errno_t rc;
     100
    98101        /* Acknowledge the connection. */
    99102        async_answer_0(callid, EOK);
    … …  
    112115
    113116                switch (IPC_GET_IMETHOD(call)) {
    114                 case LOGGER_WRITER_CREATE_LOG: {
    115                         logger_log_t *log = handle_create_log(IPC_GET_ARG1(call));
     117                case LOGGER_WRITER_CREATE_LOG:
     118                        log = handle_create_log(IPC_GET_ARG1(call));
    116119                        if (log == NULL) {
    117120                                async_answer_0(callid, ENOMEM);
    … …  
    126129                        async_answer_1(callid, EOK, (sysarg_t) log);
    127130                        break;
    128                 }
    129                 case LOGGER_WRITER_MESSAGE: {
    130                         errno_t rc = handle_receive_message(IPC_GET_ARG1(call),
     131                case LOGGER_WRITER_MESSAGE:
     132                        rc = handle_receive_message(IPC_GET_ARG1(call),
    131133                            IPC_GET_ARG2(call));
    132134                        async_answer_0(callid, rc);
    133135                        break;
    134                 }
    135136                default:
    136137                        async_answer_0(callid, EINVAL);
Note: See TracChangeset for help on using the changeset viewer.