Commit c4f9e644 authored by Devendra Naga's avatar Devendra Naga Committed by Greg Kroah-Hartman
Browse files

staging:csr: remove usage of CsrSnprintf and use scnprintf 



This change tries to achieve the removal of the csr driver defined snprintf
and uses the kernel defined snprintf.

After this change i got following build warnings, which are solved in this patch

warnings generated:

drivers/staging/csr/io.c:929:13: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 4 has type ‘u32’
drivers/staging/csr/io.c:929:13: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 5 has type ‘u32’
drivers/staging/csr/csr_wifi_hip_udi.c: In function ‘unifi_print_status’:
drivers/staging/csr/csr_wifi_hip_udi.c:78:27: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 4 has type ‘u32’
drivers/staging/csr/csr_wifi_hip_udi.c:151:27: warning: format ‘%u’ expects type ‘unsigned int’, but argument 5 has type ‘long int’
drivers/staging/csr/csr_wifi_hip_udi.c:257:27: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 4 has type ‘u32’
drivers/staging/csr/csr_wifi_hip_udi.c:257:27: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 5 has type ‘u32’
drivers/staging/csr/csr_wifi_hip_udi.c:261:27: warning: format ‘%lu’ expects type ‘long unsigned int’, but argument 4 has type ‘u32’

Signed-off-by: default avatarDevendra Naga <develkernel412222@gmail.com>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 4f870fe6

drivers/staging/csr/Makefile

+0 −1
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ csr_wifi-y := bh.o \ 
		unifi_event.o			\

		unifi_pdu_processing.o		\

		unifi_sme.o			\

		csr_formatted_io.o		\

		csr_wifi_hip_card_sdio.o	\

		csr_wifi_hip_card_sdio_intr.o	\

		csr_wifi_hip_card_sdio_mem.o	\

drivers/staging/csr/csr_formatted_io.c

deleted100644 → 0
+0 −27
Original line number Diff line number Diff line 
/*****************************************************************************



            (c) Cambridge Silicon Radio Limited 2010

            All rights reserved and confidential information of CSR



            Refer to LICENSE.txt included with this source for details

            on the license terms.



*****************************************************************************/

#include <linux/kernel.h>

#include "csr_formatted_io.h"



s32 CsrSnprintf(char *dest, size_t n, const char *fmt, ...)

{

    s32 r;

    va_list args;

    va_start(args, fmt);

    r = vsnprintf(dest, n, fmt, args);

    va_end(args);



    if (dest && (n > 0))

    {

        dest[n - 1] = '\0';

    }



    return r;

}

drivers/staging/csr/csr_formatted_io.h

deleted100644 → 0
+0 −25
Original line number Diff line number Diff line 
#ifndef CSR_FORMATTED_IO_H__

#define CSR_FORMATTED_IO_H__

/*****************************************************************************



            (c) Cambridge Silicon Radio Limited 2010

            All rights reserved and confidential information of CSR



            Refer to LICENSE.txt included with this source for details

            on the license terms.



*****************************************************************************/



#ifdef __cplusplus

extern "C" {

#endif



#include <linux/types.h>



s32 CsrSnprintf(char *dest, size_t n, const char *fmt, ...);



#ifdef __cplusplus

}

#endif



#endif

drivers/staging/csr/csr_wifi_hip_card_sdio.c

+4 −4
Original line number Diff line number Diff line
@@ -1612,13 +1612,13 @@ static CsrResult card_allocate_memory_resources(card_t *card) 
    /* Reset any state carried forward from a previous life */

    card->fh_command_queue.q_rd_ptr = 0;

    card->fh_command_queue.q_wr_ptr = 0;

    (void)CsrSnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,

    (void)scnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,

                      "fh_cmd_q");

    for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)

    {

        card->fh_traffic_queue[i].q_rd_ptr = 0;

        card->fh_traffic_queue[i].q_wr_ptr = 0;

        (void)CsrSnprintf(card->fh_traffic_queue[i].name,

        (void)scnprintf(card->fh_traffic_queue[i].name,

                          UNIFI_QUEUE_NAME_MAX_LENGTH, "fh_data_q%d", i);

    }

#ifndef CSR_WIFI_HIP_TA_DISABLE
@@ -1826,13 +1826,13 @@ static void card_init_soft_queues(card_t *card) 
    /* Reset any state carried forward from a previous life */

    card->fh_command_queue.q_rd_ptr = 0;

    card->fh_command_queue.q_wr_ptr = 0;

    (void)CsrSnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,

    (void)scnprintf(card->fh_command_queue.name, UNIFI_QUEUE_NAME_MAX_LENGTH,

                      "fh_cmd_q");

    for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)

    {

        card->fh_traffic_queue[i].q_rd_ptr = 0;

        card->fh_traffic_queue[i].q_wr_ptr = 0;

        (void)CsrSnprintf(card->fh_traffic_queue[i].name,

        (void)scnprintf(card->fh_traffic_queue[i].name,

                          UNIFI_QUEUE_NAME_MAX_LENGTH, "fh_data_q%d", i);

    }

#ifndef CSR_WIFI_HIP_TA_DISABLE

drivers/staging/csr/csr_wifi_hip_udi.c

+47 −47
Original line number Diff line number Diff line
@@ -64,104 +64,104 @@ s32 unifi_print_status(card_t *card, char *str, s32 *remain) 
    }



    i = n = 0;

    written = CsrSnprintf(p, remaining, "Chip ID %u\n",

    written = scnprintf(p, remaining, "Chip ID %u\n",

                          (u16)card->chip_id);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "Chip Version %04X\n",

    written = scnprintf(p, remaining, "Chip Version %04X\n",

                          card->chip_version);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "HIP v%u.%u\n",

    written = scnprintf(p, remaining, "HIP v%u.%u\n",

                          (card->config_data.version >> 8) & 0xFF,

                          card->config_data.version & 0xFF);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "Build %lu: %s\n",

    written = scnprintf(p, remaining, "Build %u: %s\n",

                          card->build_id, card->build_id_string);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    cfg = &card->config_data;



    written = CsrSnprintf(p, remaining, "sdio ctrl offset          %u\n",

    written = scnprintf(p, remaining, "sdio ctrl offset          %u\n",

                          cfg->sdio_ctrl_offset);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "fromhost sigbuf handle    %u\n",

    written = scnprintf(p, remaining, "fromhost sigbuf handle    %u\n",

                          cfg->fromhost_sigbuf_handle);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "tohost_sigbuf_handle      %u\n",

    written = scnprintf(p, remaining, "tohost_sigbuf_handle      %u\n",

                          cfg->tohost_sigbuf_handle);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "num_fromhost_sig_frags    %u\n",

    written = scnprintf(p, remaining, "num_fromhost_sig_frags    %u\n",

                          cfg->num_fromhost_sig_frags);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "num_tohost_sig_frags      %u\n",

    written = scnprintf(p, remaining, "num_tohost_sig_frags      %u\n",

                          cfg->num_tohost_sig_frags);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "num_fromhost_data_slots   %u\n",

    written = scnprintf(p, remaining, "num_fromhost_data_slots   %u\n",

                          cfg->num_fromhost_data_slots);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "num_tohost_data_slots     %u\n",

    written = scnprintf(p, remaining, "num_tohost_data_slots     %u\n",

                          cfg->num_tohost_data_slots);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "data_slot_size            %u\n",

    written = scnprintf(p, remaining, "data_slot_size            %u\n",

                          cfg->data_slot_size);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    /* Added by protocol version 0x0001 */

    written = CsrSnprintf(p, remaining, "overlay_size              %u\n",

    written = scnprintf(p, remaining, "overlay_size              %u\n",

                          (u16)cfg->overlay_size);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    /* Added by protocol version 0x0300 */

    written = CsrSnprintf(p, remaining, "data_slot_round           %u\n",

    written = scnprintf(p, remaining, "data_slot_round           %u\n",

                          cfg->data_slot_round);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "sig_frag_size             %u\n",

    written = scnprintf(p, remaining, "sig_frag_size             %u\n",

                          cfg->sig_frag_size);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    /* Added by protocol version 0x0300 */

    written = CsrSnprintf(p, remaining, "tohost_sig_pad            %u\n",

    written = scnprintf(p, remaining, "tohost_sig_pad            %u\n",

                          cfg->tohost_signal_padding);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining, "\nInternal state:\n");

    written = scnprintf(p, remaining, "\nInternal state:\n");

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining, "Last PHY PANIC: %04x:%04x\n",

    written = scnprintf(p, remaining, "Last PHY PANIC: %04x:%04x\n",

                          card->last_phy_panic_code, card->last_phy_panic_arg);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "Last MAC PANIC: %04x:%04x\n",

    written = scnprintf(p, remaining, "Last MAC PANIC: %04x:%04x\n",

                          card->last_mac_panic_code, card->last_mac_panic_arg);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining, "fhsr: %u\n",

    written = scnprintf(p, remaining, "fhsr: %u\n",

                          (u16)card->from_host_signals_r);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "fhsw: %u\n",

    written = scnprintf(p, remaining, "fhsw: %u\n",

                          (u16)card->from_host_signals_w);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "thsr: %u\n",

    written = scnprintf(p, remaining, "thsr: %u\n",

                          (u16)card->to_host_signals_r);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "thsw: %u\n",

    written = scnprintf(p, remaining, "thsw: %u\n",

                          (u16)card->to_host_signals_w);

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining,

                          "fh buffer contains: %u signals, %u bytes\n",

    written = scnprintf(p, remaining,

                          "fh buffer contains: %d signals, %ld bytes\n",

                          card->fh_buffer.count,

                          card->fh_buffer.ptr - card->fh_buffer.buf);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining, "paused: ");

    written = scnprintf(p, remaining, "paused: ");

    UNIFI_SNPRINTF_RET(p, remaining, written);

    for (i = 0; i < sizeof(card->tx_q_paused_flag) / sizeof(card->tx_q_paused_flag[0]); i++)

    {

        written = CsrSnprintf(p, remaining, card->tx_q_paused_flag[i]?"1" : "0");

        written = scnprintf(p, remaining, card->tx_q_paused_flag[i]?"1" : "0");

        UNIFI_SNPRINTF_RET(p, remaining, written);

    }

    written = CsrSnprintf(p, remaining, "\n");

    written = scnprintf(p, remaining, "\n");

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining,

    written = scnprintf(p, remaining,

                          "fh command q: %u waiting, %u free of %u:\n",

                          CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_command_queue),

                          CSR_WIFI_HIP_Q_SLOTS_FREE(&card->fh_command_queue),
@@ -169,7 +169,7 @@ s32 unifi_print_status(card_t *card, char *str, s32 *remain) 
    UNIFI_SNPRINTF_RET(p, remaining, written);

    for (i = 0; i < UNIFI_NO_OF_TX_QS; i++)

    {

        written = CsrSnprintf(p, remaining,

        written = scnprintf(p, remaining,

                              "fh traffic q[%u]: %u waiting, %u free of %u:\n",

                              i,

                              CSR_WIFI_HIP_Q_SLOTS_USED(&card->fh_traffic_queue[i]),
@@ -178,58 +178,58 @@ s32 unifi_print_status(card_t *card, char *str, s32 *remain) 
        UNIFI_SNPRINTF_RET(p, remaining, written);

    }



    written = CsrSnprintf(p, remaining, "fh data slots free: %u\n",

    written = scnprintf(p, remaining, "fh data slots free: %u\n",

                          card->from_host_data?CardGetFreeFromHostDataSlots(card) : 0);

    UNIFI_SNPRINTF_RET(p, remaining, written);





    written = CsrSnprintf(p, remaining, "From host data slots:");

    written = scnprintf(p, remaining, "From host data slots:");

    UNIFI_SNPRINTF_RET(p, remaining, written);

    n = card->config_data.num_fromhost_data_slots;

    for (i = 0; i < n && card->from_host_data; i++)

    {

        written = CsrSnprintf(p, remaining, " %u",

        written = scnprintf(p, remaining, " %u",

                              (u16)card->from_host_data[i].bd.data_length);

        UNIFI_SNPRINTF_RET(p, remaining, written);

    }

    written = CsrSnprintf(p, remaining, "\n");

    written = scnprintf(p, remaining, "\n");

    UNIFI_SNPRINTF_RET(p, remaining, written);



    written = CsrSnprintf(p, remaining, "To host data slots:");

    written = scnprintf(p, remaining, "To host data slots:");

    UNIFI_SNPRINTF_RET(p, remaining, written);

    n = card->config_data.num_tohost_data_slots;

    for (i = 0; i < n && card->to_host_data; i++)

    {

        written = CsrSnprintf(p, remaining, " %u",

        written = scnprintf(p, remaining, " %u",

                              (u16)card->to_host_data[i].data_length);

        UNIFI_SNPRINTF_RET(p, remaining, written);

    }



    written = CsrSnprintf(p, remaining, "\n");

    written = scnprintf(p, remaining, "\n");

    UNIFI_SNPRINTF_RET(p, remaining, written);



#ifdef CSR_UNSAFE_SDIO_ACCESS

    written = CsrSnprintf(p, remaining, "Host State: %s\n", states[card->host_state]);

    written = scnprintf(p, remaining, "Host State: %s\n", states[card->host_state]);

    UNIFI_SNPRINTF_RET(p, remaining, written);



    r = unifi_check_io_status(card, &iostate);

    if (iostate == 1)

    {

        written = CsrSnprintf(p, remaining, "I/O Check: F1 disabled\n");

        written = scnprintf(p, remaining, "I/O Check: F1 disabled\n");

        UNIFI_SNPRINTF_RET(p, remaining, written);

    }

    else

    {

        if (iostate == 1)

        {

            written = CsrSnprintf(p, remaining, "I/O Check: pending interrupt\n");

            written = scnprintf(p, remaining, "I/O Check: pending interrupt\n");

            UNIFI_SNPRINTF_RET(p, remaining, written);

        }



        written = CsrSnprintf(p, remaining, "BH reason interrupt = %d\n",

        written = scnprintf(p, remaining, "BH reason interrupt = %d\n",

                              card->bh_reason_unifi);

        UNIFI_SNPRINTF_RET(p, remaining, written);

        written = CsrSnprintf(p, remaining, "BH reason host      = %d\n",

        written = scnprintf(p, remaining, "BH reason host      = %d\n",

                              card->bh_reason_host);

        UNIFI_SNPRINTF_RET(p, remaining, written);
@@ -238,26 +238,26 @@ s32 unifi_print_status(card_t *card, char *str, s32 *remain) 
            r = unifi_read_8_or_16(card, card->sdio_ctrl_addr + 2, &b);

            if ((r == CSR_RESULT_SUCCESS) && (!(b & 0x80)))

            {

                written = CsrSnprintf(p, remaining, "fhsr: %u (driver thinks is %u)\n",

                written = scnprintf(p, remaining, "fhsr: %u (driver thinks is %u)\n",

                                      b, card->from_host_signals_r);

                UNIFI_SNPRINTF_RET(p, remaining, written);

                break;

            }

        }

        iostate = unifi_read_shared_count(card, card->sdio_ctrl_addr + 4);

        written = CsrSnprintf(p, remaining, "thsw: %u (driver thinks is %u)\n",

        written = scnprintf(p, remaining, "thsw: %u (driver thinks is %u)\n",

                              iostate, card->to_host_signals_w);

        UNIFI_SNPRINTF_RET(p, remaining, written);

    }

#endif



    written = CsrSnprintf(p, remaining, "\nStats:\n");

    written = scnprintf(p, remaining, "\nStats:\n");

    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "Total SDIO bytes: R=%lu W=%lu\n",

    written = scnprintf(p, remaining, "Total SDIO bytes: R=%u W=%u\n",

                          card->sdio_bytes_read, card->sdio_bytes_written);



    UNIFI_SNPRINTF_RET(p, remaining, written);

    written = CsrSnprintf(p, remaining, "Interrupts generated on card: %lu\n",

    written = scnprintf(p, remaining, "Interrupts generated on card: %u\n",

                          card->unifi_interrupt_seq);

    UNIFI_SNPRINTF_RET(p, remaining, written);

CRA Git | Maintained and supported by SUSTech CRA and CCSE