[PATCH wireless-next 18/20] ti: Use pr_

Joe Perches
2012-06-15T05:53:58Z

Add newlines to calls, remove from macros.
Remove unnecessary duplicate newlines from calls.
Remove spaces before newlines.

Signed-off-by: Joe Perches <joe@perches.com>
---
drivers/net/wireless/ti/wl1251/acx.c | 151 ++++++++--------
drivers/net/wireless/ti/wl1251/boot.c | 51 +++---
drivers/net/wireless/ti/wl1251/cmd.c | 76 ++++----
drivers/net/wireless/ti/wl1251/init.c | 16 +-
drivers/net/wireless/ti/wl1251/io.c | 27 ++--
drivers/net/wireless/ti/wl1251/main.c | 103 ++++++------
drivers/net/wireless/ti/wl1251/ps.c | 16 +-
drivers/net/wireless/ti/wl1251/rx.c | 8 +-
drivers/net/wireless/ti/wl1251/sdio.c | 20 +-
drivers/net/wireless/ti/wl1251/spi.c | 20 +-
drivers/net/wireless/ti/wl1251/tx.c | 21 +--
drivers/net/wireless/ti/wl1251/wl1251.h | 20 +-
drivers/net/wireless/ti/wl12xx/acx.c | 2 +-
drivers/net/wireless/ti/wl12xx/cmd.c | 18 +-
drivers/net/wireless/ti/wl12xx/main.c | 39 ++--
drivers/net/wireless/ti/wl18xx/acx.c | 12 +-
drivers/net/wireless/ti/wl18xx/main.c | 54 +++---
drivers/net/wireless/ti/wl18xx/tx.c | 10 +-
drivers/net/wireless/ti/wlcore/acx.c | 229 ++++++++++++------------
drivers/net/wireless/ti/wlcore/boot.c | 56 +++---
drivers/net/wireless/ti/wlcore/cmd.c | 164 +++++++++---------
drivers/net/wireless/ti/wlcore/debug.h | 22 ++--
drivers/net/wireless/ti/wlcore/debugfs.c | 42 +++---
drivers/net/wireless/ti/wlcore/event.c | 16 +-
drivers/net/wireless/ti/wlcore/main.c | 281 ++++++++++++++---------------
drivers/net/wireless/ti/wlcore/ps.c | 34 ++--
drivers/net/wireless/ti/wlcore/rx.c | 33 ++--
drivers/net/wireless/ti/wlcore/scan.c | 68 ++++----
drivers/net/wireless/ti/wlcore/sdio.c | 3 +-
drivers/net/wireless/ti/wlcore/testmode.c | 16 +-
drivers/net/wireless/ti/wlcore/tx.c | 23 ++--
31 files changed, 816 insertions(+), 835 deletions(-)

diff --git a/drivers/net/wireless/ti/wl1251/acx.c b/drivers/net/wireless/ti/wl1251/acx.c
index ad87a1a..15f8f6e 100644
--- a/drivers/net/wireless/ti/wl1251/acx.c
+++ b/drivers/net/wireless/ti/wl1251/acx.c
@@ -15,7 +15,7 @@ int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
struct acx_fw_gen_frame_rates *rates;
int ret;

- wl1251_debug(DEBUG_ACX, "acx frame rates");
+ wl1251_debug(DEBUG_ACX, "acx frame rates\n");

rates = kzalloc(sizeof(*rates), GFP_KERNEL);
if (!rates) {
@@ -31,7 +31,7 @@ int wl1251_acx_frame_rates(struct wl1251 *wl, u8 ctrl_rate, u8 ctrl_mod,
ret = wl1251_cmd_configure(wl, ACX_FW_GEN_FRAME_RATES,
rates, sizeof(*rates));
if (ret < 0) {
- wl1251_error("Failed to set FW rates and modulation");
+ wl1251_err("Failed to set FW rates and modulation\n");
goto out;
}

@@ -46,7 +46,7 @@ int wl1251_acx_station_id(struct wl1251 *wl)
struct acx_dot11_station_id *mac;
int ret, i;

- wl1251_debug(DEBUG_ACX, "acx dot11_station_id");
+ wl1251_debug(DEBUG_ACX, "acx dot11_station_id\n");

mac = kzalloc(sizeof(*mac), GFP_KERNEL);
if (!mac) {
@@ -71,7 +71,7 @@ int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
struct acx_dot11_default_key *default_key;
int ret;

- wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)", key_id);
+ wl1251_debug(DEBUG_ACX, "acx dot11_default_key (%d)\n", key_id);

default_key = kzalloc(sizeof(*default_key), GFP_KERNEL);
if (!default_key) {
@@ -84,7 +84,7 @@ int wl1251_acx_default_key(struct wl1251 *wl, u8 key_id)
ret = wl1251_cmd_configure(wl, DOT11_DEFAULT_KEY,
default_key, sizeof(*default_key));
if (ret < 0) {
- wl1251_error("Couldn't set default key");
+ wl1251_err("Couldn't set default key\n");
goto out;
}

@@ -101,7 +101,7 @@ int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
struct acx_wake_up_condition *wake_up;
int ret;

- wl1251_debug(DEBUG_ACX, "acx wake up conditions");
+ wl1251_debug(DEBUG_ACX, "acx wake up conditions\n");

wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
if (!wake_up) {
@@ -115,7 +115,7 @@ int wl1251_acx_wake_up_conditions(struct wl1251 *wl, u8 wake_up_event,
ret = wl1251_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
wake_up, sizeof(*wake_up));
if (ret < 0) {
- wl1251_warning("could not set wake up conditions: %d", ret);
+ wl1251_warn("could not set wake up conditions: %d\n", ret);
goto out;
}

@@ -129,7 +129,7 @@ int wl1251_acx_sleep_auth(struct wl1251 *wl, u8 sleep_auth)
struct acx_sleep_auth *auth;
int ret;

- wl1251_debug(DEBUG_ACX, "acx sleep auth");
+ wl1251_debug(DEBUG_ACX, "acx sleep auth\n");

auth = kzalloc(sizeof(*auth), GFP_KERNEL);
if (!auth) {
@@ -151,7 +151,7 @@ int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)
struct acx_revision *rev;
int ret;

- wl1251_debug(DEBUG_ACX, "acx fw rev");
+ wl1251_debug(DEBUG_ACX, "acx fw rev\n");

rev = kzalloc(sizeof(*rev), GFP_KERNEL);
if (!rev) {
@@ -161,7 +161,7 @@ int wl1251_acx_fw_version(struct wl1251 *wl, char *buf, size_t len)

ret = wl1251_cmd_interrogate(wl, ACX_FW_REV, rev, sizeof(*rev));
if (ret < 0) {
- wl1251_warning("ACX_FW_REV interrogate failed");
+ wl1251_warn("ACX_FW_REV interrogate failed\n");
goto out;
}

@@ -185,7 +185,7 @@ int wl1251_acx_tx_power(struct wl1251 *wl, int power)
struct acx_current_tx_power *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr");
+ wl1251_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr\n");

if (power < 0 || power > 25)
return -EINVAL;
@@ -200,7 +200,7 @@ int wl1251_acx_tx_power(struct wl1251 *wl, int power)

ret = wl1251_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("configure of tx power failed: %d", ret);
+ wl1251_warn("configure of tx power failed: %d\n", ret);
goto out;
}

@@ -214,7 +214,7 @@ int wl1251_acx_feature_cfg(struct wl1251 *wl)
struct acx_feature_config *feature;
int ret;

- wl1251_debug(DEBUG_ACX, "acx feature cfg");
+ wl1251_debug(DEBUG_ACX, "acx feature cfg\n");

feature = kzalloc(sizeof(*feature), GFP_KERNEL);
if (!feature) {
@@ -229,7 +229,7 @@ int wl1251_acx_feature_cfg(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_FEATURE_CFG,
feature, sizeof(*feature));
if (ret < 0) {
- wl1251_error("Couldn't set HW encryption");
+ wl1251_err("Couldn't set HW encryption\n");
goto out;
}

@@ -243,7 +243,7 @@ int wl1251_acx_mem_map(struct wl1251 *wl, struct acx_header *mem_map,
{
int ret;

- wl1251_debug(DEBUG_ACX, "acx mem map");
+ wl1251_debug(DEBUG_ACX, "acx mem map\n");

ret = wl1251_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
if (ret < 0)
@@ -258,7 +258,7 @@ int wl1251_acx_data_path_params(struct wl1251 *wl,
struct acx_data_path_params *params;
int ret;

- wl1251_debug(DEBUG_ACX, "acx data path params");
+ wl1251_debug(DEBUG_ACX, "acx data path params\n");

params = kzalloc(sizeof(*params), GFP_KERNEL);
if (!params) {
@@ -288,10 +288,10 @@ int wl1251_acx_data_path_params(struct wl1251 *wl,
resp, sizeof(*resp));

if (ret < 0) {
- wl1251_warning("failed to read data path parameters: %d", ret);
+ wl1251_warn("failed to read data path parameters: %d\n", ret);
goto out;
} else if (resp->header.cmd.status != CMD_STATUS_SUCCESS) {
- wl1251_warning("data path parameter acx status failed");
+ wl1251_warn("data path parameter acx status failed\n");
ret = -EIO;
goto out;
}
@@ -306,7 +306,7 @@ int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
struct acx_rx_msdu_lifetime *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx rx msdu life time");
+ wl1251_debug(DEBUG_ACX, "acx rx msdu life time\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -318,7 +318,7 @@ int wl1251_acx_rx_msdu_life_time(struct wl1251 *wl, u32 life_time)
ret = wl1251_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("failed to set rx msdu life time: %d", ret);
+ wl1251_warn("failed to set rx msdu life time: %d\n", ret);
goto out;
}

@@ -332,7 +332,7 @@ int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
struct acx_rx_config *rx_config;
int ret;

- wl1251_debug(DEBUG_ACX, "acx rx config");
+ wl1251_debug(DEBUG_ACX, "acx rx config\n");

rx_config = kzalloc(sizeof(*rx_config), GFP_KERNEL);
if (!rx_config) {
@@ -346,7 +346,7 @@ int wl1251_acx_rx_config(struct wl1251 *wl, u32 config, u32 filter)
ret = wl1251_cmd_configure(wl, ACX_RX_CFG,
rx_config, sizeof(*rx_config));
if (ret < 0) {
- wl1251_warning("failed to set rx config: %d", ret);
+ wl1251_warn("failed to set rx config: %d\n", ret);
goto out;
}

@@ -360,7 +360,7 @@ int wl1251_acx_pd_threshold(struct wl1251 *wl)
struct acx_packet_detection *pd;
int ret;

- wl1251_debug(DEBUG_ACX, "acx data pd threshold");
+ wl1251_debug(DEBUG_ACX, "acx data pd threshold\n");

pd = kzalloc(sizeof(*pd), GFP_KERNEL);
if (!pd) {
@@ -372,7 +372,7 @@ int wl1251_acx_pd_threshold(struct wl1251 *wl)

ret = wl1251_cmd_configure(wl, ACX_PD_THRESHOLD, pd, sizeof(*pd));
if (ret < 0) {
- wl1251_warning("failed to set pd threshold: %d", ret);
+ wl1251_warn("failed to set pd threshold: %d\n", ret);
goto out;
}

@@ -386,7 +386,7 @@ int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)
struct acx_slot *slot;
int ret;

- wl1251_debug(DEBUG_ACX, "acx slot");
+ wl1251_debug(DEBUG_ACX, "acx slot\n");

slot = kzalloc(sizeof(*slot), GFP_KERNEL);
if (!slot) {
@@ -399,7 +399,7 @@ int wl1251_acx_slot(struct wl1251 *wl, enum acx_slot_type slot_time)

ret = wl1251_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
if (ret < 0) {
- wl1251_warning("failed to set slot time: %d", ret);
+ wl1251_warn("failed to set slot time: %d\n", ret);
goto out;
}

@@ -413,7 +413,7 @@ int wl1251_acx_group_address_tbl(struct wl1251 *wl)
struct acx_dot11_grp_addr_tbl *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx group address tbl");
+ wl1251_debug(DEBUG_ACX, "acx group address tbl\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -429,7 +429,7 @@ int wl1251_acx_group_address_tbl(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("failed to set group addr table: %d", ret);
+ wl1251_warn("failed to set group addr table: %d\n", ret);
goto out;
}

@@ -449,7 +449,7 @@ int wl1251_acx_service_period_timeout(struct wl1251 *wl)
goto out;
}

- wl1251_debug(DEBUG_ACX, "acx service period timeout");
+ wl1251_debug(DEBUG_ACX, "acx service period timeout\n");

rx_timeout->ps_poll_timeout = RX_TIMEOUT_PS_POLL_DEF;
rx_timeout->upsd_timeout = RX_TIMEOUT_UPSD_DEF;
@@ -457,8 +457,8 @@ int wl1251_acx_service_period_timeout(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
rx_timeout, sizeof(*rx_timeout));
if (ret < 0) {
- wl1251_warning("failed to set service period timeout: %d",
- ret);
+ wl1251_warn("failed to set service period timeout: %d\n",
+ ret);
goto out;
}

@@ -472,7 +472,7 @@ int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)
struct acx_rts_threshold *rts;
int ret;

- wl1251_debug(DEBUG_ACX, "acx rts threshold");
+ wl1251_debug(DEBUG_ACX, "acx rts threshold\n");

rts = kzalloc(sizeof(*rts), GFP_KERNEL);
if (!rts) {
@@ -484,7 +484,7 @@ int wl1251_acx_rts_threshold(struct wl1251 *wl, u16 rts_threshold)

ret = wl1251_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
if (ret < 0) {
- wl1251_warning("failed to set rts threshold: %d", ret);
+ wl1251_warn("failed to set rts threshold: %d\n", ret);
goto out;
}

@@ -498,7 +498,7 @@ int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter)
struct acx_beacon_filter_option *beacon_filter;
int ret;

- wl1251_debug(DEBUG_ACX, "acx beacon filter opt");
+ wl1251_debug(DEBUG_ACX, "acx beacon filter opt\n");

beacon_filter = kzalloc(sizeof(*beacon_filter), GFP_KERNEL);
if (!beacon_filter) {
@@ -512,7 +512,7 @@ int wl1251_acx_beacon_filter_opt(struct wl1251 *wl, bool enable_filter)
ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
beacon_filter, sizeof(*beacon_filter));
if (ret < 0) {
- wl1251_warning("failed to set beacon filter opt: %d", ret);
+ wl1251_warn("failed to set beacon filter opt: %d\n", ret);
goto out;
}

@@ -527,7 +527,7 @@ int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
int idx = 0;
int ret;

- wl1251_debug(DEBUG_ACX, "acx beacon filter table");
+ wl1251_debug(DEBUG_ACX, "acx beacon filter table\n");

ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
if (!ie_table) {
@@ -543,7 +543,7 @@ int wl1251_acx_beacon_filter_table(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
ie_table, sizeof(*ie_table));
if (ret < 0) {
- wl1251_warning("failed to set beacon filter table: %d", ret);
+ wl1251_warn("failed to set beacon filter table: %d\n", ret);
goto out;
}

@@ -557,7 +557,7 @@ int wl1251_acx_conn_monit_params(struct wl1251 *wl)
struct acx_conn_monit_params *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx connection monitor parameters");
+ wl1251_debug(DEBUG_ACX, "acx connection monitor parameters\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -571,8 +571,8 @@ int wl1251_acx_conn_monit_params(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("failed to set connection monitor "
- "parameters: %d", ret);
+ wl1251_warn("failed to set connection monitor parameters: %d\n",
+ ret);
goto out;
}

@@ -586,7 +586,7 @@ int wl1251_acx_sg_enable(struct wl1251 *wl)
struct acx_bt_wlan_coex *pta;
int ret;

- wl1251_debug(DEBUG_ACX, "acx sg enable");
+ wl1251_debug(DEBUG_ACX, "acx sg enable\n");

pta = kzalloc(sizeof(*pta), GFP_KERNEL);
if (!pta) {
@@ -598,7 +598,7 @@ int wl1251_acx_sg_enable(struct wl1251 *wl)

ret = wl1251_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
if (ret < 0) {
- wl1251_warning("failed to set softgemini enable: %d", ret);
+ wl1251_warn("failed to set softgemini enable: %d\n", ret);
goto out;
}

@@ -612,7 +612,7 @@ int wl1251_acx_sg_cfg(struct wl1251 *wl)
struct acx_bt_wlan_coex_param *param;
int ret;

- wl1251_debug(DEBUG_ACX, "acx sg cfg");
+ wl1251_debug(DEBUG_ACX, "acx sg cfg\n");

param = kzalloc(sizeof(*param), GFP_KERNEL);
if (!param) {
@@ -652,7 +652,7 @@ int wl1251_acx_sg_cfg(struct wl1251 *wl)

ret = wl1251_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
if (ret < 0) {
- wl1251_warning("failed to set sg config: %d", ret);
+ wl1251_warn("failed to set sg config: %d\n", ret);
goto out;
}

@@ -666,7 +666,7 @@ int wl1251_acx_cca_threshold(struct wl1251 *wl)
struct acx_energy_detection *detection;
int ret;

- wl1251_debug(DEBUG_ACX, "acx cca threshold");
+ wl1251_debug(DEBUG_ACX, "acx cca threshold\n");

detection = kzalloc(sizeof(*detection), GFP_KERNEL);
if (!detection) {
@@ -680,7 +680,7 @@ int wl1251_acx_cca_threshold(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_CCA_THRESHOLD,
detection, sizeof(*detection));
if (ret < 0)
- wl1251_warning("failed to set cca threshold: %d", ret);
+ wl1251_warn("failed to set cca threshold: %d\n", ret);

out:
kfree(detection);
@@ -692,7 +692,7 @@ int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)
struct acx_beacon_broadcast *bb;
int ret;

- wl1251_debug(DEBUG_ACX, "acx bcn dtim options");
+ wl1251_debug(DEBUG_ACX, "acx bcn dtim options\n");

bb = kzalloc(sizeof(*bb), GFP_KERNEL);
if (!bb) {
@@ -707,7 +707,7 @@ int wl1251_acx_bcn_dtim_options(struct wl1251 *wl)

ret = wl1251_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
if (ret < 0) {
- wl1251_warning("failed to set rx config: %d", ret);
+ wl1251_warn("failed to set rx config: %d\n", ret);
goto out;
}

@@ -721,7 +721,7 @@ int wl1251_acx_aid(struct wl1251 *wl, u16 aid)
struct acx_aid *acx_aid;
int ret;

- wl1251_debug(DEBUG_ACX, "acx aid");
+ wl1251_debug(DEBUG_ACX, "acx aid\n");

acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
if (!acx_aid) {
@@ -733,7 +733,7 @@ int wl1251_acx_aid(struct wl1251 *wl, u16 aid)

ret = wl1251_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
if (ret < 0) {
- wl1251_warning("failed to set aid: %d", ret);
+ wl1251_warn("failed to set aid: %d\n", ret);
goto out;
}

@@ -747,7 +747,7 @@ int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
struct acx_event_mask *mask;
int ret;

- wl1251_debug(DEBUG_ACX, "acx event mbox mask");
+ wl1251_debug(DEBUG_ACX, "acx event mbox mask\n");

mask = kzalloc(sizeof(*mask), GFP_KERNEL);
if (!mask) {
@@ -763,7 +763,7 @@ int wl1251_acx_event_mbox_mask(struct wl1251 *wl, u32 event_mask)
ret = wl1251_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
mask, sizeof(*mask));
if (ret < 0) {
- wl1251_warning("failed to set acx_event_mbox_mask: %d", ret);
+ wl1251_warn("failed to set acx_event_mbox_mask: %d\n", ret);
goto out;
}

@@ -778,7 +778,7 @@ int wl1251_acx_low_rssi(struct wl1251 *wl, s8 threshold, u8 weight,
struct acx_low_rssi *rssi;
int ret;

- wl1251_debug(DEBUG_ACX, "acx low rssi");
+ wl1251_debug(DEBUG_ACX, "acx low rssi\n");

rssi = kzalloc(sizeof(*rssi), GFP_KERNEL);
if (!rssi)
@@ -791,7 +791,7 @@ int wl1251_acx_low_rssi(struct wl1251 *wl, s8 threshold, u8 weight,

ret = wl1251_cmd_configure(wl, ACX_LOW_RSSI, rssi, sizeof(*rssi));
if (ret < 0)
- wl1251_warning("failed to set low rssi threshold: %d", ret);
+ wl1251_warn("failed to set low rssi threshold: %d\n", ret);

kfree(rssi);
return ret;
@@ -802,7 +802,7 @@ int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)
struct acx_preamble *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx_set_preamble");
+ wl1251_debug(DEBUG_ACX, "acx_set_preamble\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -814,7 +814,7 @@ int wl1251_acx_set_preamble(struct wl1251 *wl, enum acx_preamble_type preamble)

ret = wl1251_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("Setting of preamble failed: %d", ret);
+ wl1251_warn("Setting of preamble failed: %d\n", ret);
goto out;
}

@@ -829,7 +829,7 @@ int wl1251_acx_cts_protect(struct wl1251 *wl,
struct acx_ctsprotect *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect");
+ wl1251_debug(DEBUG_ACX, "acx_set_ctsprotect\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -841,7 +841,7 @@ int wl1251_acx_cts_protect(struct wl1251 *wl,

ret = wl1251_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("Setting of ctsprotect failed: %d", ret);
+ wl1251_warn("Setting of ctsprotect failed: %d\n", ret);
goto out;
}

@@ -864,7 +864,7 @@ int wl1251_acx_tsf_info(struct wl1251 *wl, u64 *mactime)
ret = wl1251_cmd_interrogate(wl, ACX_TSF_INFO,
tsf_info, sizeof(*tsf_info));
if (ret < 0) {
- wl1251_warning("ACX_FW_REV interrogate failed");
+ wl1251_warn("ACX_FW_REV interrogate failed\n");
goto out;
}

@@ -880,12 +880,12 @@ int wl1251_acx_statistics(struct wl1251 *wl, struct acx_statistics *stats)
{
int ret;

- wl1251_debug(DEBUG_ACX, "acx statistics");
+ wl1251_debug(DEBUG_ACX, "acx statistics\n");

ret = wl1251_cmd_interrogate(wl, ACX_STATISTICS, stats,
sizeof(*stats));
if (ret < 0) {
- wl1251_warning("acx statistics failed: %d", ret);
+ wl1251_warn("acx statistics failed: %d\n", ret);
return -ENOMEM;
}

@@ -897,7 +897,7 @@ int wl1251_acx_rate_policies(struct wl1251 *wl)
struct acx_rate_policy *acx;
int ret = 0;

- wl1251_debug(DEBUG_ACX, "acx rate policies");
+ wl1251_debug(DEBUG_ACX, "acx rate policies\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -915,7 +915,7 @@ int wl1251_acx_rate_policies(struct wl1251 *wl)

ret = wl1251_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("Setting of rate policies failed: %d", ret);
+ wl1251_warn("Setting of rate policies failed: %d\n", ret);
goto out;
}

@@ -929,7 +929,7 @@ int wl1251_acx_mem_cfg(struct wl1251 *wl)
struct wl1251_acx_config_memory *mem_conf;
int ret, i;

- wl1251_debug(DEBUG_ACX, "acx mem cfg");
+ wl1251_debug(DEBUG_ACX, "acx mem cfg\n");

mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
if (!mem_conf) {
@@ -962,7 +962,7 @@ int wl1251_acx_mem_cfg(struct wl1251 *wl)
ret = wl1251_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
sizeof(*mem_conf));
if (ret < 0) {
- wl1251_warning("wl1251 mem config failed: %d", ret);
+ wl1251_warn("wl1251 mem config failed: %d\n", ret);
goto out;
}

@@ -976,7 +976,7 @@ int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim)
struct wl1251_acx_wr_tbtt_and_dtim *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx tbtt and dtim");
+ wl1251_debug(DEBUG_ACX, "acx tbtt and dtim\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -990,7 +990,7 @@ int wl1251_acx_wr_tbtt_and_dtim(struct wl1251 *wl, u16 tbtt, u8 dtim)
ret = wl1251_cmd_configure(wl, ACX_WR_TBTT_AND_DTIM,
acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("failed to set tbtt and dtim: %d", ret);
+ wl1251_warn("failed to set tbtt and dtim: %d\n", ret);
goto out;
}

@@ -1005,7 +1005,7 @@ int wl1251_acx_bet_enable(struct wl1251 *wl, enum wl1251_acx_bet_mode mode,
struct wl1251_acx_bet_enable *acx;
int ret;

- wl1251_debug(DEBUG_ACX, "acx bet enable");
+ wl1251_debug(DEBUG_ACX, "acx bet enable\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1018,7 +1018,7 @@ int wl1251_acx_bet_enable(struct wl1251 *wl, enum wl1251_acx_bet_mode mode,

ret = wl1251_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("wl1251 acx bet enable failed: %d", ret);
+ wl1251_warn("wl1251 acx bet enable failed: %d\n", ret);
goto out;
}

@@ -1033,8 +1033,8 @@ int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,
struct wl1251_acx_ac_cfg *acx;
int ret = 0;

- wl1251_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
- "aifs %d txop %d", ac, cw_min, cw_max, aifs, txop);
+ wl1251_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d aifs %d txop %d\n",
+ ac, cw_min, cw_max, aifs, txop);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -1051,7 +1051,7 @@ int wl1251_acx_ac_cfg(struct wl1251 *wl, u8 ac, u8 cw_min, u16 cw_max,

ret = wl1251_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("acx ac cfg failed: %d", ret);
+ wl1251_warn("acx ac cfg failed: %d\n", ret);
goto out;
}

@@ -1068,9 +1068,8 @@ int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,
struct wl1251_acx_tid_cfg *acx;
int ret = 0;

- wl1251_debug(DEBUG_ACX, "acx tid cfg %d type %d tsid %d "
- "ps_scheme %d ack_policy %d", queue, type, tsid,
- ps_scheme, ack_policy);
+ wl1251_debug(DEBUG_ACX, "acx tid cfg %d type %d tsid %d ps_scheme %d ack_policy %d\n",
+ queue, type, tsid, ps_scheme, ack_policy);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -1087,7 +1086,7 @@ int wl1251_acx_tid_cfg(struct wl1251 *wl, u8 queue,

ret = wl1251_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_warning("acx tid cfg failed: %d", ret);
+ wl1251_warn("acx tid cfg failed: %d\n", ret);
goto out;
}

diff --git a/drivers/net/wireless/ti/wl1251/boot.c b/drivers/net/wireless/ti/wl1251/boot.c
index a2e5241..c30410f 100644
--- a/drivers/net/wireless/ti/wl1251/boot.c
+++ b/drivers/net/wireless/ti/wl1251/boot.c
@@ -46,14 +46,15 @@ int wl1251_boot_soft_reset(struct wl1251 *wl)
timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME);
while (1) {
boot_data = wl1251_reg_read32(wl, ACX_REG_SLV_SOFT_RESET);
- wl1251_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
+ wl1251_debug(DEBUG_BOOT, "soft reset bootdata 0x%x\n",
+ boot_data);
if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0)
break;

if (time_after(jiffies, timeout)) {
/* 1.2 check pWhalBus->uSelfClearTime if the
* timeout was reached */
- wl1251_error("soft reset timeout");
+ wl1251_err("soft reset timeout\n");
return -1;
}

@@ -92,15 +93,15 @@ int wl1251_boot_init_seq(struct wl1251 *wl)

/* read NVS params */
scr_pad6 = wl1251_reg_read32(wl, SCR_PAD6);
- wl1251_debug(DEBUG_BOOT, "scr_pad6 0x%x", scr_pad6);
+ wl1251_debug(DEBUG_BOOT, "scr_pad6 0x%x\n", scr_pad6);

/* read ELP_CMD */
elp_cmd = wl1251_reg_read32(wl, ELP_CMD);
- wl1251_debug(DEBUG_BOOT, "elp_cmd 0x%x", elp_cmd);
+ wl1251_debug(DEBUG_BOOT, "elp_cmd 0x%x\n", elp_cmd);

/* set the BB calibration time to be 300 usec (PLL_CAL_TIME) */
ref_freq = scr_pad6 & 0x000000FF;
- wl1251_debug(DEBUG_BOOT, "ref_freq 0x%x", ref_freq);
+ wl1251_debug(DEBUG_BOOT, "ref_freq 0x%x\n", ref_freq);

wl1251_reg_write32(wl, PLL_CAL_TIME, 0x9);

@@ -228,10 +229,11 @@ int wl1251_boot_run_firmware(struct wl1251 *wl)

chip_id = wl1251_reg_read32(wl, CHIP_ID_B);

- wl1251_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
+ wl1251_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x\n",
+ chip_id);

if (chip_id != wl->chip_id) {
- wl1251_error("chip id doesn't match after firmware boot");
+ wl1251_err("chip id doesn't match after firmware boot\n");
return -EIO;
}

@@ -242,8 +244,7 @@ int wl1251_boot_run_firmware(struct wl1251 *wl)
acx_intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);

if (acx_intr == 0xffffffff) {
- wl1251_error("error reading hardware complete "
- "init indication");
+ wl1251_err("error reading hardware complete init indication\n");
return -EIO;
}
/* check that ACX_INTR_INIT_COMPLETE is enabled */
@@ -255,8 +256,7 @@ int wl1251_boot_run_firmware(struct wl1251 *wl)
}

if (loop > INIT_LOOP) {
- wl1251_error("timeout waiting for the hardware to "
- "complete initialization");
+ wl1251_err("timeout waiting for the hardware to complete initialization\n");
return -EIO;
}

@@ -272,7 +272,7 @@ int wl1251_boot_run_firmware(struct wl1251 *wl)
WL1251_PART_WORK_REG_START,
WL1251_PART_WORK_REG_SIZE);

- wl1251_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x event_box_addr 0x%x",
+ wl1251_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x event_box_addr 0x%x\n",
wl->cmd_box_addr, wl->event_box_addr);

wl1251_acx_fw_version(wl, wl->fw_ver, sizeof(wl->fw_ver));
@@ -303,7 +303,7 @@ int wl1251_boot_run_firmware(struct wl1251 *wl)

ret = wl1251_event_unmask(wl);
if (ret < 0) {
- wl1251_error("EVENT mask setting failed");
+ wl1251_err("EVENT mask setting failed\n");
return ret;
}

@@ -321,24 +321,24 @@ static int wl1251_boot_upload_firmware(struct wl1251 *wl)

/* whal_FwCtrl_LoadFwImageSm() */

- wl1251_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x",
+ wl1251_debug(DEBUG_BOOT, "chip id before fw upload: 0x%x\n",
wl1251_reg_read32(wl, CHIP_ID_B));

/* 10.0 check firmware length and set partition */
fw_data_len = (wl->fw[4] << 24) | (wl->fw[5] << 16) |
(wl->fw[6] << 8) | (wl->fw[7]);

- wl1251_debug(DEBUG_BOOT, "fw_data_len %zu chunk_size %d", fw_data_len,
- CHUNK_SIZE);
+ wl1251_debug(DEBUG_BOOT, "fw_data_len %zu chunk_size %d\n", fw_data_len,
+ CHUNK_SIZE);

if ((fw_data_len % 4) != 0) {
- wl1251_error("firmware length not multiple of four");
+ wl1251_err("firmware length not multiple of four\n");
return -EIO;
}

buf = kmalloc(CHUNK_SIZE, GFP_KERNEL);
if (!buf) {
- wl1251_error("allocation for firmware upload chunk failed");
+ wl1251_err("allocation for firmware upload chunk failed\n");
return -ENOMEM;
}

@@ -370,7 +370,7 @@ static int wl1251_boot_upload_firmware(struct wl1251 *wl)
/* 10.3 upload the chunk */
addr = WL1251_PART_DOWN_MEM_START + chunk_num * CHUNK_SIZE;
p = wl->fw + FW_HDR_SIZE + chunk_num * CHUNK_SIZE;
- wl1251_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
+ wl1251_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x\n",
p, addr);

/* need to copy the chunk for dma */
@@ -389,7 +389,7 @@ static int wl1251_boot_upload_firmware(struct wl1251 *wl)
len = fw_data_len % CHUNK_SIZE;
memcpy(buf, p, len);

- wl1251_debug(DEBUG_BOOT, "uploading fw last chunk (%zu B) 0x%p to 0x%x",
+ wl1251_debug(DEBUG_BOOT, "uploading fw last chunk (%zu B) 0x%p to 0x%x\n",
len, p, addr);
wl1251_mem_write(wl, addr, buf, len);

@@ -435,7 +435,7 @@ static int wl1251_boot_upload_nvs(struct wl1251 *wl)
| (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));

wl1251_debug(DEBUG_BOOT,
- "nvs burst write 0x%x: 0x%x",
+ "nvs burst write 0x%x: 0x%x\n",
dest_addr, val);
wl1251_mem_write32(wl, dest_addr, val);

@@ -465,7 +465,7 @@ static int wl1251_boot_upload_nvs(struct wl1251 *wl)
| (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));

wl1251_debug(DEBUG_BOOT,
- "nvs write table 0x%x: 0x%x",
+ "nvs write table 0x%x: 0x%x\n",
nvs_start, val);
wl1251_mem_write32(wl, nvs_start, val);

@@ -517,8 +517,7 @@ int wl1251_boot(struct wl1251 *wl)
wl->boot_attr.minor = (tmp & 0x00FF0000) >> 16;
minor_minor_e2_ver = (tmp & 0xFF000000) >> 24;

- wl1251_debug(DEBUG_BOOT, "radioType 0x%x majorE2Ver 0x%x "
- "minorE2Ver 0x%x minor_minor_e2_ver 0x%x",
+ wl1251_debug(DEBUG_BOOT, "radioType 0x%x majorE2Ver 0x%x minorE2Ver 0x%x minor_minor_e2_ver 0x%x\n",
wl->boot_attr.radio_type, wl->boot_attr.major,
wl->boot_attr.minor, minor_minor_e2_ver);

@@ -529,13 +528,13 @@ int wl1251_boot(struct wl1251 *wl)
/* 9. NVS processing done */
boot_data = wl1251_reg_read32(wl, ACX_REG_ECPU_CONTROL);

- wl1251_debug(DEBUG_BOOT, "halt boot_data 0x%x", boot_data);
+ wl1251_debug(DEBUG_BOOT, "halt boot_data 0x%x\n", boot_data);

/* 10. check that ECPU_CONTROL_HALT bits are set in
* pWhalBus->uBootData and start uploading firmware
*/
if ((boot_data & ECPU_CONTROL_HALT) == 0) {
- wl1251_error("boot failed, ECPU_CONTROL_HALT not set");
+ wl1251_err("boot failed, ECPU_CONTROL_HALT not set\n");
ret = -EIO;
goto out;
}
diff --git a/drivers/net/wireless/ti/wl1251/cmd.c b/drivers/net/wireless/ti/wl1251/cmd.c
index d14d69d..a6a3e6e 100644
--- a/drivers/net/wireless/ti/wl1251/cmd.c
+++ b/drivers/net/wireless/ti/wl1251/cmd.c
@@ -40,7 +40,7 @@ int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len)
intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) {
if (time_after(jiffies, timeout)) {
- wl1251_error("command complete timeout");
+ wl1251_err("command complete timeout\n");
ret = -ETIMEDOUT;
goto out;
}
@@ -69,12 +69,12 @@ int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
{
int ret;

- wl1251_debug(DEBUG_CMD, "cmd test");
+ wl1251_debug(DEBUG_CMD, "cmd test\n");

ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);

if (ret < 0) {
- wl1251_warning("TEST command failed");
+ wl1251_warn("TEST command failed\n");
return ret;
}

@@ -91,8 +91,8 @@ int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
cmd_answer = buf;

if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
- wl1251_error("TEST command answer error: %d",
- cmd_answer->header.status);
+ wl1251_err("TEST command answer error: %d\n",
+ cmd_answer->header.status);
}

return 0;
@@ -111,7 +111,7 @@ int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)
struct acx_header *acx = buf;
int ret;

- wl1251_debug(DEBUG_CMD, "cmd interrogate");
+ wl1251_debug(DEBUG_CMD, "cmd interrogate\n");

acx->id = id;

@@ -120,7 +120,7 @@ int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)

ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
if (ret < 0) {
- wl1251_error("INTERROGATE command failed");
+ wl1251_err("INTERROGATE command failed\n");
goto out;
}

@@ -129,8 +129,8 @@ int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)

acx = buf;
if (acx->cmd.status != CMD_STATUS_SUCCESS)
- wl1251_error("INTERROGATE command error: %d",
- acx->cmd.status);
+ wl1251_err("INTERROGATE command error: %d\n",
+ acx->cmd.status);

out:
return ret;
@@ -149,7 +149,7 @@ int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)
struct acx_header *acx = buf;
int ret;

- wl1251_debug(DEBUG_CMD, "cmd configure");
+ wl1251_debug(DEBUG_CMD, "cmd configure\n");

acx->id = id;

@@ -158,7 +158,7 @@ int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)

ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
if (ret < 0) {
- wl1251_warning("CONFIGURE command NOK");
+ wl1251_warn("CONFIGURE command NOK\n");
return ret;
}

@@ -171,7 +171,7 @@ int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
struct wl1251_cmd_vbm_update *vbm;
int ret;

- wl1251_debug(DEBUG_CMD, "cmd vbm");
+ wl1251_debug(DEBUG_CMD, "cmd vbm\n");

vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
if (!vbm) {
@@ -182,8 +182,8 @@ int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
/* Count and period will be filled by the target */
vbm->tim.bitmap_ctrl = bitmap_control;
if (bitmap_len > PARTIAL_VBM_MAX) {
- wl1251_warning("cmd vbm len is %d B, truncating to %d",
- bitmap_len, PARTIAL_VBM_MAX);
+ wl1251_warn("cmd vbm len is %d B, truncating to %d\n",
+ bitmap_len, PARTIAL_VBM_MAX);
bitmap_len = PARTIAL_VBM_MAX;
}
memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);
@@ -194,7 +194,7 @@ int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,

ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
if (ret < 0) {
- wl1251_error("VBM command failed");
+ wl1251_err("VBM command failed\n");
goto out;
}

@@ -209,7 +209,7 @@ int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
int ret;
u16 cmd_rx, cmd_tx;

- wl1251_debug(DEBUG_CMD, "cmd data path");
+ wl1251_debug(DEBUG_CMD, "cmd data path\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -229,22 +229,22 @@ int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)

ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1251_error("rx %s cmd for channel %d failed",
- enable ? "start" : "stop", channel);
+ wl1251_err("rx %s cmd for channel %d failed\n",
+ enable ? "start" : "stop", channel);
goto out;
}

- wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
+ wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d\n",
enable ? "start" : "stop", channel);

ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1251_error("tx %s cmd for channel %d failed",
- enable ? "start" : "stop", channel);
+ wl1251_err("tx %s cmd for channel %d failed\n",
+ enable ? "start" : "stop", channel);
goto out;
}

- wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
+ wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d\n",
enable ? "start" : "stop", channel);

out:
@@ -265,7 +265,7 @@ int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
goto out;
}

- wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d",
+ wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d\n",
bss_type == BSS_TYPE_IBSS ? " ibss" : "",
channel, beacon_interval, dtim_interval);

@@ -297,7 +297,7 @@ int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,

ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
if (ret < 0) {
- wl1251_error("failed to initiate cmd join");
+ wl1251_err("failed to initiate cmd join\n");
goto out;
}

@@ -311,7 +311,7 @@ int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
struct wl1251_cmd_ps_params *ps_params = NULL;
int ret = 0;

- wl1251_debug(DEBUG_CMD, "cmd set ps mode");
+ wl1251_debug(DEBUG_CMD, "cmd set ps mode\n");

ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
if (!ps_params) {
@@ -328,7 +328,7 @@ int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
sizeof(*ps_params));
if (ret < 0) {
- wl1251_error("cmd set_ps_mode failed");
+ wl1251_err("cmd set_ps_mode failed\n");
goto out;
}

@@ -343,7 +343,7 @@ int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
struct cmd_read_write_memory *cmd;
int ret = 0;

- wl1251_debug(DEBUG_CMD, "cmd read memory");
+ wl1251_debug(DEBUG_CMD, "cmd read memory\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -359,7 +359,7 @@ int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,

ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1251_error("read memory command failed: %d", ret);
+ wl1251_err("read memory command failed: %d\n", ret);
goto out;
}

@@ -367,8 +367,8 @@ int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));

if (cmd->header.status != CMD_STATUS_SUCCESS)
- wl1251_error("error in read command result: %d",
- cmd->header.status);
+ wl1251_err("error in read command result: %d\n",
+ cmd->header.status);

memcpy(answer, cmd->value, len);

@@ -384,7 +384,7 @@ int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
size_t cmd_len;
int ret = 0;

- wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);
+ wl1251_debug(DEBUG_CMD, "cmd template %d\n", cmd_id);

WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
@@ -403,7 +403,7 @@ int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,

ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
if (ret < 0) {
- wl1251_warning("cmd set_template failed: %d", ret);
+ wl1251_warn("cmd set_template failed: %d\n", ret);
goto out;
}

@@ -419,7 +419,7 @@ int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,
struct wl1251_cmd_scan *cmd;
int i, ret = 0;

- wl1251_debug(DEBUG_CMD, "cmd scan");
+ wl1251_debug(DEBUG_CMD, "cmd scan\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd)
@@ -453,15 +453,15 @@ int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,

ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1251_error("cmd scan failed: %d", ret);
+ wl1251_err("cmd scan failed: %d\n", ret);
goto out;
}

wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));

if (cmd->header.status != CMD_STATUS_SUCCESS) {
- wl1251_error("cmd scan status wasn't success: %d",
- cmd->header.status);
+ wl1251_err("cmd scan status wasn't success: %d\n",
+ cmd->header.status);
ret = -EIO;
goto out;
}
@@ -476,7 +476,7 @@ int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)
struct wl1251_cmd_trigger_scan_to *cmd;
int ret;

- wl1251_debug(DEBUG_CMD, "cmd trigger scan to");
+ wl1251_debug(DEBUG_CMD, "cmd trigger scan to\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd)
@@ -486,7 +486,7 @@ int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)

ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1251_error("cmd trigger scan to failed: %d", ret);
+ wl1251_err("cmd trigger scan to failed: %d\n", ret);
goto out;
}

diff --git a/drivers/net/wireless/ti/wl1251/init.c b/drivers/net/wireless/ti/wl1251/init.c
index 89b43d3..2cdab26 100644
--- a/drivers/net/wireless/ti/wl1251/init.c
+++ b/drivers/net/wireless/ti/wl1251/init.c
@@ -35,13 +35,13 @@ int wl1251_hw_init_hwenc_config(struct wl1251 *wl)

ret = wl1251_acx_feature_cfg(wl);
if (ret < 0) {
- wl1251_warning("couldn't set feature config");
+ wl1251_warn("couldn't set feature config\n");
return ret;
}

ret = wl1251_acx_default_key(wl, wl->default_key);
if (ret < 0) {
- wl1251_warning("couldn't set default key");
+ wl1251_warn("couldn't set default key\n");
return ret;
}

@@ -211,7 +211,7 @@ int wl1251_hw_init_mem_config(struct wl1251 *wl)
wl->target_mem_map = kzalloc(sizeof(struct wl1251_acx_mem_map),
GFP_KERNEL);
if (!wl->target_mem_map) {
- wl1251_error("couldn't allocate target memory map");
+ wl1251_err("couldn't allocate target memory map\n");
return -ENOMEM;
}

@@ -219,7 +219,7 @@ int wl1251_hw_init_mem_config(struct wl1251 *wl)
ret = wl1251_acx_mem_map(wl, wl->target_mem_map,
sizeof(struct wl1251_acx_mem_map));
if (ret < 0) {
- wl1251_error("couldn't retrieve firmware memory map");
+ wl1251_err("couldn't retrieve firmware memory map\n");
kfree(wl->target_mem_map);
wl->target_mem_map = NULL;
return ret;
@@ -260,7 +260,7 @@ static int wl1251_hw_init_txq_fill(u8 qid,
(QOS_TX_LOW_VO_DEF * num_blocks) / 100;
break;
default:
- wl1251_error("Invalid TX queue id: %d", qid);
+ wl1251_err("Invalid TX queue id: %d\n", qid);
return -EINVAL;
}

@@ -273,7 +273,7 @@ static int wl1251_hw_init_tx_queue_config(struct wl1251 *wl)
struct wl1251_acx_mem_map *wl_mem_map = wl->target_mem_map;
int ret, i;

- wl1251_debug(DEBUG_ACX, "acx tx queue config");
+ wl1251_debug(DEBUG_ACX, "acx tx queue config\n");

config = kzalloc(sizeof(*config), GFP_KERNEL);
if (!config) {
@@ -311,7 +311,7 @@ static int wl1251_hw_init_data_path_config(struct wl1251 *wl)
wl->data_path = kzalloc(sizeof(struct acx_data_path_params_resp),
GFP_KERNEL);
if (!wl->data_path) {
- wl1251_error("Couldnt allocate data path parameters");
+ wl1251_err("Couldnt allocate data path parameters\n");
return -ENOMEM;
}

@@ -405,7 +405,7 @@ int wl1251_hw_init(struct wl1251 *wl)
goto out_free_data_path;

wl_mem_map = wl->target_mem_map;
- wl1251_info("%d tx blocks at 0x%x, %d rx blocks at 0x%x",
+ wl1251_info("%d tx blocks at 0x%x, %d rx blocks at 0x%x\n",
wl_mem_map->num_tx_mem_blocks,
wl->data_path->tx_control_addr,
wl_mem_map->num_rx_mem_blocks,
diff --git a/drivers/net/wireless/ti/wl1251/io.c b/drivers/net/wireless/ti/wl1251/io.c
index cdcadbf..2561ac2 100644
--- a/drivers/net/wireless/ti/wl1251/io.c
+++ b/drivers/net/wireless/ti/wl1251/io.c
@@ -46,7 +46,7 @@ static int wl1251_translate_reg_addr(struct wl1251 *wl, int addr)
if (addr < REGISTERS_BASE) {
/* Make sure we don't go over the table */
if (addr >= ACX_REG_TABLE_LEN) {
- wl1251_error("address out of range (%d)", addr);
+ wl1251_err("address out of range (%d)\n", addr);
return -EINVAL;
}
addr = wl1251_io_reg_table[addr];
@@ -137,20 +137,19 @@ void wl1251_set_partition(struct wl1251 *wl,
{
struct wl1251_partition partition[2];

- wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
+ wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X\n",
mem_start, mem_size);
- wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
+ wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X\n",
reg_start, reg_size);

/* Make sure that the two partitions together don't exceed the
* address range */
if ((mem_size + reg_size) > HW_ACCESS_MEMORY_MAX_RANGE) {
- wl1251_debug(DEBUG_SPI, "Total size exceeds maximum virtual"
- " address range. Truncating partition[0].");
+ wl1251_debug(DEBUG_SPI, "Total size exceeds maximum virtual address range. Truncating partition[0].\n");
mem_size = HW_ACCESS_MEMORY_MAX_RANGE - reg_size;
- wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
+ wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X\n",
mem_start, mem_size);
- wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
+ wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X\n",
reg_start, reg_size);
}

@@ -158,23 +157,21 @@ void wl1251_set_partition(struct wl1251 *wl,
((mem_start + mem_size) > reg_start)) {
/* Guarantee that the memory partition doesn't overlap the
* registers partition */
- wl1251_debug(DEBUG_SPI, "End of partition[0] is "
- "overlapping partition[1]. Adjusted.");
+ wl1251_debug(DEBUG_SPI, "End of partition[0] is overlapping partition[1]. Adjusted.\n");
mem_size = reg_start - mem_start;
- wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
+ wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X\n",
mem_start, mem_size);
- wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
+ wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X\n",
reg_start, reg_size);
} else if ((reg_start < mem_start) &&
((reg_start + reg_size) > mem_start)) {
/* Guarantee that the register partition doesn't overlap the
* memory partition */
- wl1251_debug(DEBUG_SPI, "End of partition[1] is"
- " overlapping partition[0]. Adjusted.");
+ wl1251_debug(DEBUG_SPI, "End of partition[1] is overlapping partition[0]. Adjusted.\n");
reg_size = mem_start - reg_start;
- wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X",
+ wl1251_debug(DEBUG_SPI, "mem_start %08X mem_size %08X\n",
mem_start, mem_size);
- wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X",
+ wl1251_debug(DEBUG_SPI, "reg_start %08X reg_size %08X\n",
reg_start, reg_size);
}

diff --git a/drivers/net/wireless/ti/wl1251/main.c b/drivers/net/wireless/ti/wl1251/main.c
index d1afb8e..47cb523 100644
--- a/drivers/net/wireless/ti/wl1251/main.c
+++ b/drivers/net/wireless/ti/wl1251/main.c
@@ -71,13 +71,13 @@ static int wl1251_fetch_firmware(struct wl1251 *wl)
ret = request_firmware(&fw, WL1251_FW_NAME, dev);

if (ret < 0) {
- wl1251_error("could not get firmware: %d", ret);
+ wl1251_err("could not get firmware: %d\n", ret);
return ret;
}

if (fw->size % 4) {
- wl1251_error("firmware size is not multiple of 32 bits: %zu",
- fw->size);
+ wl1251_err("firmware size is not multiple of 32 bits: %zu\n",
+ fw->size);
ret = -EILSEQ;
goto out;
}
@@ -86,7 +86,7 @@ static int wl1251_fetch_firmware(struct wl1251 *wl)
wl->fw = vmalloc(wl->fw_len);

if (!wl->fw) {
- wl1251_error("could not allocate memory for the firmware");
+ wl1251_err("could not allocate memory for the firmware\n");
ret = -ENOMEM;
goto out;
}
@@ -110,13 +110,13 @@ static int wl1251_fetch_nvs(struct wl1251 *wl)
ret = request_firmware(&fw, WL1251_NVS_NAME, dev);

if (ret < 0) {
- wl1251_error("could not get nvs file: %d", ret);
+ wl1251_err("could not get nvs file: %d\n", ret);
return ret;
}

if (fw->size % 4) {
- wl1251_error("nvs size is not multiple of 32 bits: %zu",
- fw->size);
+ wl1251_err("nvs size is not multiple of 32 bits: %zu\n",
+ fw->size);
ret = -EILSEQ;
goto out;
}
@@ -125,7 +125,7 @@ static int wl1251_fetch_nvs(struct wl1251 *wl)
wl->nvs = kmemdup(fw->data, wl->nvs_len, GFP_KERNEL);

if (!wl->nvs) {
- wl1251_error("could not allocate memory for the nvs file");
+ wl1251_err("could not allocate memory for the nvs file\n");
ret = -ENOMEM;
goto out;
}
@@ -147,7 +147,7 @@ static void wl1251_fw_wakeup(struct wl1251 *wl)
elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);

if (!(elp_reg & ELPCTRL_WLAN_READY))
- wl1251_warning("WLAN not ready");
+ wl1251_warn("WLAN not ready\n");
}

static int wl1251_chip_wakeup(struct wl1251 *wl)
@@ -181,16 +181,16 @@ static int wl1251_chip_wakeup(struct wl1251 *wl)

switch (wl->chip_id) {
case CHIP_ID_1251_PG12:
- wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)",
+ wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG12)\n",
wl->chip_id);
break;
case CHIP_ID_1251_PG11:
- wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)",
+ wl1251_debug(DEBUG_BOOT, "chip id 0x%x (1251 PG11)\n",
wl->chip_id);
break;
case CHIP_ID_1251_PG10:
default:
- wl1251_error("unsupported chip id: 0x%x", wl->chip_id);
+ wl1251_err("unsupported chip id: 0x%x\n", wl->chip_id);
ret = -ENODEV;
goto out;
}
@@ -222,7 +222,7 @@ static void wl1251_irq_work(struct work_struct *work)

mutex_lock(&wl->mutex);

- wl1251_debug(DEBUG_IRQ, "IRQ work");
+ wl1251_debug(DEBUG_IRQ, "IRQ work\n");

if (wl->state == WL1251_STATE_OFF)
goto out;
@@ -234,7 +234,7 @@ static void wl1251_irq_work(struct work_struct *work)
wl1251_reg_write32(wl, ACX_REG_INTERRUPT_MASK, WL1251_ACX_INTR_ALL);

intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_CLEAR);
- wl1251_debug(DEBUG_IRQ, "intr: 0x%x", intr);
+ wl1251_debug(DEBUG_IRQ, "intr: 0x%x\n", intr);

do {
if (wl->data_path) {
@@ -245,68 +245,67 @@ static void wl1251_irq_work(struct work_struct *work)
switch ((wl->rx_counter - wl->rx_handled) & 0xf) {
case 0:
wl1251_debug(DEBUG_IRQ,
- "RX: FW and host in sync");
+ "RX: FW and host in sync\n");
intr &= ~WL1251_ACX_INTR_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA;
break;
case 1:
- wl1251_debug(DEBUG_IRQ, "RX: FW +1");
+ wl1251_debug(DEBUG_IRQ, "RX: FW +1\n");
intr |= WL1251_ACX_INTR_RX0_DATA;
intr &= ~WL1251_ACX_INTR_RX1_DATA;
break;
case 2:
- wl1251_debug(DEBUG_IRQ, "RX: FW +2");
+ wl1251_debug(DEBUG_IRQ, "RX: FW +2\n");
intr |= WL1251_ACX_INTR_RX0_DATA;
intr |= WL1251_ACX_INTR_RX1_DATA;
break;
default:
- wl1251_warning(
- "RX: FW and host out of sync: %d",
- wl->rx_counter - wl->rx_handled);
+ wl1251_warn("RX: FW and host out of sync: %d\n",
+ wl->rx_counter - wl->rx_handled);
break;
}

wl->rx_handled = wl->rx_counter;

- wl1251_debug(DEBUG_IRQ, "RX counter: %d",
+ wl1251_debug(DEBUG_IRQ, "RX counter: %d\n",
wl->rx_counter);
}

intr &= wl->intr_mask;

if (intr == 0) {
- wl1251_debug(DEBUG_IRQ, "INTR is 0");
+ wl1251_debug(DEBUG_IRQ, "INTR is 0\n");
goto out_sleep;
}

if (intr & WL1251_ACX_INTR_RX0_DATA) {
- wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA");
+ wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX0_DATA\n");
wl1251_rx(wl);
}

if (intr & WL1251_ACX_INTR_RX1_DATA) {
- wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA");
+ wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_RX1_DATA\n");
wl1251_rx(wl);
}

if (intr & WL1251_ACX_INTR_TX_RESULT) {
- wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT");
+ wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_TX_RESULT\n");
wl1251_tx_complete(wl);
}

if (intr & WL1251_ACX_INTR_EVENT_A) {
- wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_A");
+ wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_A\n");
wl1251_event_handle(wl, 0);
}

if (intr & WL1251_ACX_INTR_EVENT_B) {
- wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_B");
+ wl1251_debug(DEBUG_IRQ, "WL1251_ACX_INTR_EVENT_B\n");
wl1251_event_handle(wl, 1);
}

if (intr & WL1251_ACX_INTR_INIT_COMPLETE)
wl1251_debug(DEBUG_IRQ,
- "WL1251_ACX_INTR_INIT_COMPLETE");
+ "WL1251_ACX_INTR_INIT_COMPLETE\n");

if (--ctr == 0)
break;
@@ -342,7 +341,7 @@ static int wl1251_join(struct wl1251 *wl, u8 bss_type, u8 channel,

ret = wl1251_event_wait(wl, JOIN_EVENT_COMPLETE_ID, 100);
if (ret < 0)
- wl1251_warning("join timeout");
+ wl1251_warn("join timeout\n");

out:
return ret;
@@ -394,7 +393,7 @@ static void wl1251_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
* the queue here, otherwise the queue will get too long.
*/
if (skb_queue_len(&wl->tx_queue) >= WL1251_TX_QUEUE_HIGH_WATERMARK) {
- wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues");
+ wl1251_debug(DEBUG_TX, "op_tx: tx_queue full, stop queues\n");

spin_lock_irqsave(&wl->wl_lock, flags);
ieee80211_stop_queues(wl->hw);
@@ -414,8 +413,8 @@ static int wl1251_op_start(struct ieee80211_hw *hw)
mutex_lock(&wl->mutex);

if (wl->state != WL1251_STATE_OFF) {
- wl1251_error("cannot start because not in off state: %d",
- wl->state);
+ wl1251_err("cannot start because not in off state: %d\n",
+ wl->state);
ret = -EBUSY;
goto out;
}
@@ -438,7 +437,7 @@ static int wl1251_op_start(struct ieee80211_hw *hw)

wl->state = WL1251_STATE_ON;

- wl1251_info("firmware booted (%s)", wl->fw_ver);
+ wl1251_info("firmware booted (%s)\n", wl->fw_ver);

/* update hw/fw version info in wiphy struct */
wiphy->hw_version = wl->chip_id;
@@ -457,7 +456,7 @@ static void wl1251_op_stop(struct ieee80211_hw *hw)
{
struct wl1251 *wl = hw->priv;

- wl1251_info("down");
+ wl1251_info("down\n");

wl1251_debug(DEBUG_MAC80211, "mac80211 stop");

@@ -615,7 +614,7 @@ static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed)
}

if (conf->flags & IEEE80211_CONF_PS && !wl->psm_requested) {
- wl1251_debug(DEBUG_PSM, "psm enabled");
+ wl1251_debug(DEBUG_PSM, "psm enabled\n");

wl->psm_requested = true;

@@ -632,7 +631,7 @@ static int wl1251_op_config(struct ieee80211_hw *hw, u32 changed)
goto out_sleep;
} else if (!(conf->flags & IEEE80211_CONF_PS) &&
wl->psm_requested) {
- wl1251_debug(DEBUG_PSM, "psm disabled");
+ wl1251_debug(DEBUG_PSM, "psm disabled\n");

wl->psm_requested = false;

@@ -765,7 +764,7 @@ static int wl1251_set_key_type(struct wl1251 *wl,
mac80211_key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
break;
default:
- wl1251_error("Unknown key cipher 0x%x", mac80211_key->cipher);
+ wl1251_err("Unknown key cipher 0x%x\n", mac80211_key->cipher);
return -EOPNOTSUPP;
}

@@ -795,9 +794,9 @@ static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,

addr = sta ? sta->addr : bcast_addr;

- wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x", cmd);
+ wl1251_debug(DEBUG_CRYPT, "CMD: 0x%x\n", cmd);
wl1251_dump(DEBUG_CRYPT, "ADDR: ", addr, ETH_ALEN);
- wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
+ wl1251_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x\n",
key->cipher, key->keyidx, key->keylen, key->flags);
wl1251_dump(DEBUG_CRYPT, "KEY: ", key->key, key->keylen);

@@ -821,13 +820,13 @@ static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
wl_cmd->key_action = KEY_REMOVE;
break;
default:
- wl1251_error("Unsupported key cmd 0x%x", cmd);
+ wl1251_err("Unsupported key cmd 0x%x\n", cmd);
break;
}

ret = wl1251_set_key_type(wl, wl_cmd, cmd, key, addr);
if (ret < 0) {
- wl1251_error("Set KEY type failed");
+ wl1251_err("Set KEY type failed\n");
goto out_sleep;
}

@@ -858,7 +857,7 @@ static int wl1251_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,

ret = wl1251_cmd_send(wl, CMD_SET_KEYS, wl_cmd, sizeof(*wl_cmd));
if (ret < 0) {
- wl1251_warning("could not set keys");
+ wl1251_warn("could not set keys\n");
goto out_sleep;
}

@@ -894,7 +893,7 @@ static int wl1251_op_hw_scan(struct ieee80211_hw *hw,
mutex_lock(&wl->mutex);

if (wl->scanning) {
- wl1251_debug(DEBUG_SCAN, "scan already in progress");
+ wl1251_debug(DEBUG_SCAN, "scan already in progress\n");
ret = -EINVAL;
goto out;
}
@@ -951,7 +950,7 @@ static int wl1251_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)

ret = wl1251_acx_rts_threshold(wl, (u16) value);
if (ret < 0)
- wl1251_warning("wl1251_op_set_rts_threshold failed: %d", ret);
+ wl1251_warn("wl1251_op_set_rts_threshold failed: %d\n", ret);

wl1251_ps_elp_sleep(wl);

@@ -1043,7 +1042,7 @@ static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw,
else
ret = wl1251_acx_slot(wl, SLOT_TIME_LONG);
if (ret < 0) {
- wl1251_warning("Set slot time failed %d", ret);
+ wl1251_warn("Set slot time failed %d\n", ret);
goto out_sleep;
}
}
@@ -1061,7 +1060,7 @@ static void wl1251_op_bss_info_changed(struct ieee80211_hw *hw,
else
ret = wl1251_acx_cts_protect(wl, CTSPROTECT_DISABLE);
if (ret < 0) {
- wl1251_warning("Set ctsprotect failed %d", ret);
+ wl1251_warn("Set ctsprotect failed %d\n", ret);
goto out_sleep;
}
}
@@ -1295,7 +1294,7 @@ static int wl1251_read_eeprom_mac(struct wl1251 *wl)

ret = wl1251_read_eeprom(wl, 0x1c, mac, sizeof(mac));
if (ret < 0) {
- wl1251_warning("failed to read MAC address from EEPROM");
+ wl1251_warn("failed to read MAC address from EEPROM\n");
return ret;
}

@@ -1317,13 +1316,13 @@ static int wl1251_register_hw(struct wl1251 *wl)

ret = ieee80211_register_hw(wl->hw);
if (ret < 0) {
- wl1251_error("unable to register mac80211 hw: %d", ret);
+ wl1251_err("unable to register mac80211 hw: %d\n", ret);
return ret;
}

wl->mac80211_registered = true;

- wl1251_notice("loaded");
+ wl1251_notice("loaded\n");

return 0;
}
@@ -1359,7 +1358,7 @@ int wl1251_init_ieee80211(struct wl1251 *wl)
goto out;

wl1251_debugfs_init(wl);
- wl1251_notice("initialized");
+ wl1251_notice("initialized\n");

ret = 0;

@@ -1377,7 +1376,7 @@ struct ieee80211_hw *wl1251_alloc_hw(void)

hw = ieee80211_alloc_hw(sizeof(*wl), &wl1251_ops);
if (!hw) {
- wl1251_error("could not alloc ieee80211_hw");
+ wl1251_err("could not alloc ieee80211_hw\n");
return ERR_PTR(-ENOMEM);
}

@@ -1435,7 +1434,7 @@ struct ieee80211_hw *wl1251_alloc_hw(void)

wl->rx_descriptor = kmalloc(sizeof(*wl->rx_descriptor), GFP_KERNEL);
if (!wl->rx_descriptor) {
- wl1251_error("could not allocate memory for rx descriptor");
+ wl1251_err("could not allocate memory for rx descriptor\n");
ieee80211_free_hw(hw);
return ERR_PTR(-ENOMEM);
}
diff --git a/drivers/net/wireless/ti/wl1251/ps.c b/drivers/net/wireless/ti/wl1251/ps.c
index db719f7..f784d1e 100644
--- a/drivers/net/wireless/ti/wl1251/ps.c
+++ b/drivers/net/wireless/ti/wl1251/ps.c
@@ -35,14 +35,14 @@ void wl1251_elp_work(struct work_struct *work)
dwork = container_of(work, struct delayed_work, work);
wl = container_of(dwork, struct wl1251, elp_work);

- wl1251_debug(DEBUG_PSM, "elp work");
+ wl1251_debug(DEBUG_PSM, "elp work\n");

mutex_lock(&wl->mutex);

if (wl->elp || wl->station_mode == STATION_ACTIVE_MODE)
goto out;

- wl1251_debug(DEBUG_PSM, "chip to elp");
+ wl1251_debug(DEBUG_PSM, "chip to elp\n");
wl1251_write_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR, ELPCTRL_SLEEP);
wl->elp = true;

@@ -74,7 +74,7 @@ int wl1251_ps_elp_wakeup(struct wl1251 *wl)
if (!wl->elp)
return 0;

- wl1251_debug(DEBUG_PSM, "waking up chip from elp");
+ wl1251_debug(DEBUG_PSM, "waking up chip from elp\n");

start = jiffies;
timeout = jiffies + msecs_to_jiffies(WL1251_WAKEUP_TIMEOUT);
@@ -89,14 +89,14 @@ int wl1251_ps_elp_wakeup(struct wl1251 *wl)
*/
while (!(elp_reg & ELPCTRL_WLAN_READY)) {
if (time_after(jiffies, timeout)) {
- wl1251_error("elp wakeup timeout");
+ wl1251_err("elp wakeup timeout\n");
return -ETIMEDOUT;
}
msleep(1);
elp_reg = wl1251_read_elp(wl, HW_ACCESS_ELP_CTRL_REG_ADDR);
}

- wl1251_debug(DEBUG_PSM, "wakeup time: %u ms",
+ wl1251_debug(DEBUG_PSM, "wakeup time: %u ms\n",
jiffies_to_msecs(jiffies - start));

wl->elp = false;
@@ -110,7 +110,7 @@ int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_station_mode mode)

switch (mode) {
case STATION_POWER_SAVE_MODE:
- wl1251_debug(DEBUG_PSM, "entering psm");
+ wl1251_debug(DEBUG_PSM, "entering psm\n");

/* enable beacon filtering */
ret = wl1251_acx_beacon_filter_opt(wl, true);
@@ -137,7 +137,7 @@ int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_station_mode mode)
return ret;
break;
case STATION_IDLE:
- wl1251_debug(DEBUG_PSM, "entering idle");
+ wl1251_debug(DEBUG_PSM, "entering idle\n");

ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_ELP);
if (ret < 0)
@@ -149,7 +149,7 @@ int wl1251_ps_set_mode(struct wl1251 *wl, enum wl1251_station_mode mode)
break;
case STATION_ACTIVE_MODE:
default:
- wl1251_debug(DEBUG_PSM, "leaving psm");
+ wl1251_debug(DEBUG_PSM, "leaving psm\n");

ret = wl1251_acx_sleep_auth(wl, WL1251_PSM_CAM);
if (ret < 0)
diff --git a/drivers/net/wireless/ti/wl1251/rx.c b/drivers/net/wireless/ti/wl1251/rx.c
index 6af3526..6ae6026 100644
--- a/drivers/net/wireless/ti/wl1251/rx.c
+++ b/drivers/net/wireless/ti/wl1251/rx.c
@@ -158,8 +158,8 @@ static void wl1251_rx_body(struct wl1251 *wl,
last_id_inc = (wl->rx_last_id + 1) % (RX_MAX_PACKET_ID + 1);

if (last_id_inc != curr_id) {
- wl1251_warning("curr ID:%d, last ID inc:%d",
- curr_id, last_id_inc);
+ wl1251_warn("curr ID:%d, last ID inc:%d\n",
+ curr_id, last_id_inc);
wl->rx_last_id = curr_id;
} else {
wl->rx_last_id = last_id_inc;
@@ -172,7 +172,7 @@ static void wl1251_rx_body(struct wl1251 *wl,

skb = __dev_alloc_skb(length, GFP_KERNEL);
if (!skb) {
- wl1251_error("Couldn't allocate RX frame");
+ wl1251_err("Couldn't allocate RX frame\n");
return;
}

@@ -189,7 +189,7 @@ static void wl1251_rx_body(struct wl1251 *wl,

wl1251_rx_status(wl, desc, &status, beacon);

- wl1251_debug(DEBUG_RX, "rx skb 0x%p: %d B %s", skb, skb->len,
+ wl1251_debug(DEBUG_RX, "rx skb 0x%p: %d B %s\n", skb, skb->len,
beacon ? "beacon" : "");

memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
diff --git a/drivers/net/wireless/ti/wl1251/sdio.c b/drivers/net/wireless/ti/wl1251/sdio.c
index e2750a1..234e2d9 100644
--- a/drivers/net/wireless/ti/wl1251/sdio.c
+++ b/drivers/net/wireless/ti/wl1251/sdio.c
@@ -54,7 +54,7 @@ static void wl1251_sdio_interrupt(struct sdio_func *func)
{
struct wl1251 *wl = sdio_get_drvdata(func);

- wl1251_debug(DEBUG_IRQ, "IRQ");
+ wl1251_debug(DEBUG_IRQ, "IRQ\n");

/* FIXME should be synchronous for sdio */
ieee80211_queue_work(wl->hw, &wl->irq_work);
@@ -76,7 +76,7 @@ static void wl1251_sdio_read(struct wl1251 *wl, int addr,
sdio_claim_host(func);
ret = sdio_memcpy_fromio(func, buf, addr, len);
if (ret)
- wl1251_error("sdio read failed (%d)", ret);
+ wl1251_err("sdio read failed (%d)\n", ret);
sdio_release_host(func);
}

@@ -89,7 +89,7 @@ static void wl1251_sdio_write(struct wl1251 *wl, int addr,
sdio_claim_host(func);
ret = sdio_memcpy_toio(func, addr, buf, len);
if (ret)
- wl1251_error("sdio write failed (%d)", ret);
+ wl1251_err("sdio write failed (%d)\n", ret);
sdio_release_host(func);
}

@@ -110,7 +110,7 @@ static void wl1251_sdio_read_elp(struct wl1251 *wl, int addr, u32 *val)
sdio_release_host(func);

if (ret)
- wl1251_error("sdio_readb failed (%d)", ret);
+ wl1251_err("sdio_readb failed (%d)\n", ret);
}

static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
@@ -124,7 +124,7 @@ static void wl1251_sdio_write_elp(struct wl1251 *wl, int addr, u32 val)
sdio_release_host(func);

if (ret)
- wl1251_error("sdio_writeb failed (%d)", ret);
+ wl1251_err("sdio_writeb failed (%d)\n", ret);
else
wl_sdio->elp_val = val;
}
@@ -263,7 +263,7 @@ static int wl1251_sdio_probe(struct sdio_func *func,
irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
ret = request_irq(wl->irq, wl1251_line_irq, 0, "wl1251", wl);
if (ret < 0) {
- wl1251_error("request_irq() failed: %d", ret);
+ wl1251_err("request_irq() failed: %d\n", ret);
goto disable;
}

@@ -272,12 +272,12 @@ static int wl1251_sdio_probe(struct sdio_func *func,
wl1251_sdio_ops.enable_irq = wl1251_enable_line_irq;
wl1251_sdio_ops.disable_irq = wl1251_disable_line_irq;

- wl1251_info("using dedicated interrupt line");
+ wl1251_info("using dedicated interrupt line\n");
} else {
wl1251_sdio_ops.enable_irq = wl1251_sdio_enable_irq;
wl1251_sdio_ops.disable_irq = wl1251_sdio_disable_irq;

- wl1251_info("using SDIO interrupt");
+ wl1251_info("using SDIO interrupt\n");
}

ret = wl1251_init_ieee80211(wl);
@@ -357,14 +357,14 @@ static int __init wl1251_sdio_init(void)

err = sdio_register_driver(&wl1251_sdio_driver);
if (err)
- wl1251_error("failed to register sdio driver: %d", err);
+ wl1251_err("failed to register sdio driver: %d\n", err);
return err;
}

static void __exit wl1251_sdio_exit(void)
{
sdio_unregister_driver(&wl1251_sdio_driver);
- wl1251_notice("unloaded");
+ wl1251_notice("unloaded\n");
}

module_init(wl1251_sdio_init);
diff --git a/drivers/net/wireless/ti/wl1251/spi.c b/drivers/net/wireless/ti/wl1251/spi.c
index 87f6305..440443e 100644
--- a/drivers/net/wireless/ti/wl1251/spi.c
+++ b/drivers/net/wireless/ti/wl1251/spi.c
@@ -35,7 +35,7 @@ static irqreturn_t wl1251_irq(int irq, void *cookie)
{
struct wl1251 *wl;

- wl1251_debug(DEBUG_IRQ, "IRQ");
+ wl1251_debug(DEBUG_IRQ, "IRQ\n");

wl = cookie;

@@ -57,7 +57,7 @@ static void wl1251_spi_reset(struct wl1251 *wl)

cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) {
- wl1251_error("could not allocate cmd for spi reset");
+ wl1251_err("could not allocate cmd for spi reset\n");
return;
}

@@ -83,7 +83,7 @@ static void wl1251_spi_wake(struct wl1251 *wl)

cmd = kzalloc(WSPI_INIT_CMD_LEN, GFP_KERNEL);
if (!cmd) {
- wl1251_error("could not allocate cmd for spi init");
+ wl1251_err("could not allocate cmd for spi init\n");
return;
}

@@ -242,7 +242,7 @@ static int __devinit wl1251_spi_probe(struct spi_device *spi)

pdata = spi->dev.platform_data;
if (!pdata) {
- wl1251_error("no platform data");
+ wl1251_err("no platform data\n");
return -ENODEV;
}

@@ -263,19 +263,19 @@ static int __devinit wl1251_spi_probe(struct spi_device *spi)

ret = spi_setup(spi);
if (ret < 0) {
- wl1251_error("spi_setup failed");
+ wl1251_err("spi_setup failed\n");
goto out_free;
}

wl->set_power = pdata->set_power;
if (!wl->set_power) {
- wl1251_error("set power function missing in platform data");
+ wl1251_err("set power function missing in platform data\n");
return -ENODEV;
}

wl->irq = spi->irq;
if (wl->irq < 0) {
- wl1251_error("irq missing in platform data");
+ wl1251_err("irq missing in platform data\n");
return -ENODEV;
}

@@ -284,7 +284,7 @@ static int __devinit wl1251_spi_probe(struct spi_device *spi)
irq_set_status_flags(wl->irq, IRQ_NOAUTOEN);
ret = request_irq(wl->irq, wl1251_irq, 0, DRIVER_NAME, wl);
if (ret < 0) {
- wl1251_error("request_irq() failed: %d", ret);
+ wl1251_err("request_irq() failed: %d\n", ret);
goto out_free;
}

@@ -331,7 +331,7 @@ static int __init wl1251_spi_init(void)

ret = spi_register_driver(&wl1251_spi_driver);
if (ret < 0) {
- wl1251_error("failed to register spi driver: %d", ret);
+ wl1251_err("failed to register spi driver: %d\n", ret);
goto out;
}

@@ -343,7 +343,7 @@ static void __exit wl1251_spi_exit(void)
{
spi_unregister_driver(&wl1251_spi_driver);

- wl1251_notice("unloaded");
+ wl1251_notice("unloaded\n");
}

module_init(wl1251_spi_init);
diff --git a/drivers/net/wireless/ti/wl1251/tx.c b/drivers/net/wireless/ti/wl1251/tx.c
index 28121c5..2a5f586 100644
--- a/drivers/net/wireless/ti/wl1251/tx.c
+++ b/drivers/net/wireless/ti/wl1251/tx.c
@@ -210,7 +210,7 @@ static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,
*/
if (unlikely((long)skb->data & 0x03)) {
int offset = (4 - (long)skb->data) & 0x03;
- wl1251_debug(DEBUG_TX, "skb offset %d", offset);
+ wl1251_debug(DEBUG_TX, "skb offset %d\n", offset);

/* check whether the current skb can be used */
if (skb_cloned(skb) || (skb_tailroom(skb) < offset)) {
@@ -218,7 +218,7 @@ static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,
GFP_KERNEL);

if (unlikely(newskb == NULL)) {
- wl1251_error("Can't allocate skb!");
+ wl1251_err("Can't allocate skb!\n");
return -EINVAL;
}

@@ -228,7 +228,7 @@ static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,
wl->tx_frames[tx_hdr->id] = skb = newskb;

offset = (4 - (long)skb->data) & 0x03;
- wl1251_debug(DEBUG_TX, "new skb offset %d", offset);
+ wl1251_debug(DEBUG_TX, "new skb offset %d\n", offset);
}

/* align the buffer on a 4-byte boundary */
@@ -251,8 +251,8 @@ static int wl1251_tx_send_packet(struct wl1251 *wl, struct sk_buff *skb,

wl1251_mem_write(wl, addr, skb->data, len);

- wl1251_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x "
- "queue %d", tx_hdr->id, skb, tx_hdr->length,
+ wl1251_debug(DEBUG_TX, "tx id %u skb 0x%p payload %u rate 0x%x queue %d\n",
+ tx_hdr->id, skb, tx_hdr->length,
tx_hdr->rate, tx_hdr->xmit_queue);

return 0;
@@ -387,7 +387,7 @@ static void wl1251_tx_packet_cb(struct wl1251 *wl,

skb = wl->tx_frames[result->id];
if (skb == NULL) {
- wl1251_error("SKB for packet %d is NULL", result->id);
+ wl1251_err("SKB for packet %d is NULL\n", result->id);
return;
}

@@ -412,8 +412,7 @@ static void wl1251_tx_packet_cb(struct wl1251 *wl,
skb_pull(skb, WL1251_TKIP_IV_SPACE);
}

- wl1251_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
- " status 0x%x (%s)",
+ wl1251_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x status 0x%x (%s)\n",
result->id, skb, result->ack_failures, result->rate,
result->status, wl1251_tx_parse_status(result->status));

@@ -461,14 +460,14 @@ void wl1251_tx_complete(struct wl1251 *wl)

if ((num_complete > 0) && (queue_len > 0)) {
/* firmware buffer has space, reschedule tx_work */
- wl1251_debug(DEBUG_TX, "tx_complete: reschedule tx_work");
+ wl1251_debug(DEBUG_TX, "tx_complete: reschedule tx_work\n");
ieee80211_queue_work(wl->hw, &wl->tx_work);
}

if (wl->tx_queue_stopped &&
queue_len <= WL1251_TX_QUEUE_LOW_WATERMARK) {
/* tx_queue has space, restart queues */
- wl1251_debug(DEBUG_TX, "tx_complete: waking queues");
+ wl1251_debug(DEBUG_TX, "tx_complete: waking queues\n");
spin_lock_irqsave(&wl->wl_lock, flags);
ieee80211_wake_queues(wl->hw);
wl->tx_queue_stopped = false;
@@ -538,7 +537,7 @@ void wl1251_tx_flush(struct wl1251 *wl)
while ((skb = skb_dequeue(&wl->tx_queue))) {
info = IEEE80211_SKB_CB(skb);

- wl1251_debug(DEBUG_TX, "flushing skb 0x%p", skb);
+ wl1251_debug(DEBUG_TX, "flushing skb 0x%p\n", skb);

if (!(info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS))
continue;
diff --git a/drivers/net/wireless/ti/wl1251/wl1251.h b/drivers/net/wireless/ti/wl1251/wl1251.h
index 9d8f581..e4d0063 100644
--- a/drivers/net/wireless/ti/wl1251/wl1251.h
+++ b/drivers/net/wireless/ti/wl1251/wl1251.h
@@ -54,22 +54,22 @@ enum {

#define DEBUG_DUMP_LIMIT 1024

-#define wl1251_error(fmt, arg...) \
- printk(KERN_ERR DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
+#define wl1251_err(fmt, arg...) \
+ pr_err(DRIVER_PREFIX "ERROR " fmt, ##arg)

-#define wl1251_warning(fmt, arg...) \
- printk(KERN_WARNING DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
+#define wl1251_warn(fmt, arg...) \
+ pr_warn(DRIVER_PREFIX "WARNING " fmt, ##arg)

-#define wl1251_notice(fmt, arg...) \
- printk(KERN_INFO DRIVER_PREFIX fmt "\n", ##arg)
+#define wl1251_notice(fmt, arg...) \
+ pr_info(DRIVER_PREFIX fmt, ##arg)

-#define wl1251_info(fmt, arg...) \
- printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg)
+#define wl1251_info(fmt, arg...) \
+ printk(KERN_DEBUG DRIVER_PREFIX fmt, ##arg)

#define wl1251_debug(level, fmt, arg...) \
- do { \
+ do { \
if (level & DEBUG_LEVEL) \
- printk(KERN_DEBUG DRIVER_PREFIX fmt "\n", ##arg); \
+ printk(KERN_DEBUG DRIVER_PREFIX fmt, ##arg); \
} while (0)

#define wl1251_dump(level, prefix, buf, len) \
diff --git a/drivers/net/wireless/ti/wl12xx/acx.c b/drivers/net/wireless/ti/wl12xx/acx.c
index bea06b2..77a1e21 100644
--- a/drivers/net/wireless/ti/wl12xx/acx.c
+++ b/drivers/net/wireless/ti/wl12xx/acx.c
@@ -42,7 +42,7 @@ int wl1271_acx_host_if_cfg_bitmap(struct wl1271 *wl, u32 host_cfg_bitmap)
ret = wl1271_cmd_configure(wl, ACX_HOST_IF_CFG_BITMAP,
bitmap_conf, sizeof(*bitmap_conf));
if (ret < 0) {
- wl1271_warning("wl1271 bitmap config opt failed: %d", ret);
+ wl1271_warn("wl1271 bitmap config opt failed: %d\n", ret);
goto out;
}

diff --git a/drivers/net/wireless/ti/wl12xx/cmd.c b/drivers/net/wireless/ti/wl12xx/cmd.c
index 50ba748..6bbc031 100644
--- a/drivers/net/wireless/ti/wl12xx/cmd.c
+++ b/drivers/net/wireless/ti/wl12xx/cmd.c
@@ -54,7 +54,7 @@ int wl1271_cmd_ext_radio_parms(struct wl1271 *wl)

ret = wl1271_cmd_test(wl, ext_radio_parms, sizeof(*ext_radio_parms), 0);
if (ret < 0)
- wl1271_warning("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed");
+ wl1271_warn("TEST_CMD_INI_FILE_RF_EXTENDED_PARAM failed\n");

kfree(ext_radio_parms);
return ret;
@@ -73,7 +73,7 @@ int wl1271_cmd_general_parms(struct wl1271 *wl)
return -ENODEV;

if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) {
- wl1271_warning("FEM index from INI out of bounds");
+ wl1271_warn("FEM index from INI out of bounds\n");
return -EINVAL;
}

@@ -93,7 +93,7 @@ int wl1271_cmd_general_parms(struct wl1271 *wl)

ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
if (ret < 0) {
- wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
+ wl1271_warn("CMD_INI_FILE_GENERAL_PARAM failed\n");
goto out;
}

@@ -101,7 +101,7 @@ int wl1271_cmd_general_parms(struct wl1271 *wl)
gen_parms->general_params.tx_bip_fem_manufacturer;

if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) {
- wl1271_warning("FEM index from FW out of bounds");
+ wl1271_warn("FEM index from FW out of bounds\n");
ret = -EINVAL;
goto out;
}
@@ -127,7 +127,7 @@ int wl128x_cmd_general_parms(struct wl1271 *wl)
return -ENODEV;

if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) {
- wl1271_warning("FEM index from ini out of bounds");
+ wl1271_warn("FEM index from ini out of bounds\n");
return -EINVAL;
}

@@ -148,7 +148,7 @@ int wl128x_cmd_general_parms(struct wl1271 *wl)

ret = wl1271_cmd_test(wl, gen_parms, sizeof(*gen_parms), answer);
if (ret < 0) {
- wl1271_warning("CMD_INI_FILE_GENERAL_PARAM failed");
+ wl1271_warn("CMD_INI_FILE_GENERAL_PARAM failed\n");
goto out;
}

@@ -156,7 +156,7 @@ int wl128x_cmd_general_parms(struct wl1271 *wl)
gen_parms->general_params.tx_bip_fem_manufacturer;

if (gp->tx_bip_fem_manufacturer >= WL1271_INI_FEM_MODULE_COUNT) {
- wl1271_warning("FEM index from FW out of bounds");
+ wl1271_warn("FEM index from FW out of bounds\n");
ret = -EINVAL;
goto out;
}
@@ -205,7 +205,7 @@ int wl1271_cmd_radio_parms(struct wl1271 *wl)

ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0);
if (ret < 0)
- wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
+ wl1271_warn("CMD_INI_FILE_RADIO_PARAM failed\n");

kfree(radio_parms);
return ret;
@@ -249,7 +249,7 @@ int wl128x_cmd_radio_parms(struct wl1271 *wl)

ret = wl1271_cmd_test(wl, radio_parms, sizeof(*radio_parms), 0);
if (ret < 0)
- wl1271_warning("CMD_INI_FILE_RADIO_PARAM failed");
+ wl1271_warn("CMD_INI_FILE_RADIO_PARAM failed\n");

kfree(radio_parms);
return ret;
diff --git a/drivers/net/wireless/ti/wl12xx/main.c b/drivers/net/wireless/ti/wl12xx/main.c
index 85d1600..64c7fb7 100644
--- a/drivers/net/wireless/ti/wl12xx/main.c
+++ b/drivers/net/wireless/ti/wl12xx/main.c
@@ -626,8 +626,8 @@ static int wl12xx_identify_chip(struct wl1271 *wl)

switch (wl->chip.id) {
case CHIP_ID_1271_PG10:
- wl1271_warning("chip id 0x%x (1271 PG10) support is obsolete",
- wl->chip.id);
+ wl1271_warn("chip id 0x%x (1271 PG10) support is obsolete\n",
+ wl->chip.id);

wl->quirks |= WLCORE_QUIRK_LEGACY_NVS |
WLCORE_QUIRK_TKIP_HEADER_SPACE;
@@ -642,7 +642,7 @@ static int wl12xx_identify_chip(struct wl1271 *wl)
break;

case CHIP_ID_1271_PG20:
- wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)",
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1271 PG20)\n",
wl->chip.id);

wl->quirks |= WLCORE_QUIRK_LEGACY_NVS |
@@ -659,7 +659,7 @@ static int wl12xx_identify_chip(struct wl1271 *wl)
break;

case CHIP_ID_1283_PG20:
- wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)",
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x (1283 PG20)\n",
wl->chip.id);
wl->plt_fw_name = WL128X_PLT_FW_NAME;
wl->sr_fw_name = WL128X_FW_NAME_SINGLE;
@@ -672,7 +672,7 @@ static int wl12xx_identify_chip(struct wl1271 *wl)
break;
case CHIP_ID_1283_PG10:
default:
- wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
+ wl1271_warn("unsupported chip id: 0x%x\n", wl->chip.id);
ret = -ENODEV;
goto out;
}
@@ -712,7 +712,7 @@ static u16 wl12xx_top_reg_read(struct wl1271 *wl, int addr)
} while (!(val & OCP_READY_MASK) && --timeout);

if (!timeout) {
- wl1271_warning("Top register access timed out.");
+ wl1271_warn("Top register access timed out\n");
return 0xffff;
}

@@ -720,7 +720,7 @@ static u16 wl12xx_top_reg_read(struct wl1271 *wl, int addr)
if ((val & OCP_STATUS_MASK) == OCP_STATUS_OK)
return val & 0xffff;
else {
- wl1271_warning("Top register access returned error.");
+ wl1271_warn("Top register access returned error\n");
return 0xffff;
}
}
@@ -906,7 +906,7 @@ static int wl127x_boot_clk(struct wl1271 *wl)

pause = wl1271_read32(wl, WL12XX_PLL_PARAMETERS);

- wl1271_debug(DEBUG_BOOT, "pause1 0x%x", pause);
+ wl1271_debug(DEBUG_BOOT, "pause1 0x%x\n", pause);

pause &= ~(WU_COUNTER_PAUSE_VAL);
pause |= WU_COUNTER_PAUSE_VAL;
@@ -927,14 +927,15 @@ static int wl1271_boot_soft_reset(struct wl1271 *wl)
timeout = jiffies + usecs_to_jiffies(SOFT_RESET_MAX_TIME);
while (1) {
boot_data = wl1271_read32(wl, WL12XX_SLV_SOFT_RESET);
- wl1271_debug(DEBUG_BOOT, "soft reset bootdata 0x%x", boot_data);
+ wl1271_debug(DEBUG_BOOT, "soft reset bootdata 0x%x\n",
+ boot_data);
if ((boot_data & ACX_SLV_SOFT_RESET_BIT) == 0)
break;

if (time_after(jiffies, timeout)) {
/* 1.2 check pWhalBus->uSelfClearTime if the
* timeout was reached */
- wl1271_error("soft reset timeout");
+ wl1271_err("soft reset timeout\n");
return -1;
}

@@ -979,7 +980,7 @@ static int wl12xx_pre_boot(struct wl1271 *wl)

clk = wl1271_read32(wl, WL12XX_DRPW_SCRATCH_START);

- wl1271_debug(DEBUG_BOOT, "clk2 0x%x", clk);
+ wl1271_debug(DEBUG_BOOT, "clk2 0x%x\n", clk);

if (wl->chip.id == CHIP_ID_1283_PG20)
clk |= ((selected_clock & 0x3) << 1) << 4;
@@ -1007,13 +1008,13 @@ static void wl12xx_pre_upload(struct wl1271 *wl)

/* write firmware's last address (ie. it's length) to
* ACX_EEPROMLESS_IND_REG */
- wl1271_debug(DEBUG_BOOT, "ACX_EEPROMLESS_IND_REG");
+ wl1271_debug(DEBUG_BOOT, "ACX_EEPROMLESS_IND_REG\n");

wl1271_write32(wl, WL12XX_EEPROMLESS_IND, WL12XX_EEPROMLESS_IND);

tmp = wlcore_read_reg(wl, REG_CHIP_ID_B);

- wl1271_debug(DEBUG_BOOT, "chip id 0x%x", tmp);
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x\n", tmp);

/* 6. read the EEPROM parameters */
tmp = wl1271_read32(wl, WL12XX_SCR_PAD2);
@@ -1115,7 +1116,7 @@ wl12xx_set_tx_desc_data_len(struct wl1271 *wl, struct wl1271_tx_hw_descr *desc,
desc->length = cpu_to_le16(aligned_len >> 2);

wl1271_debug(DEBUG_TX,
- "tx_fill_hdr: hlid: %d len: %d life: %d mem: %d extra: %d",
+ "tx_fill_hdr: hlid: %d len: %d life: %d mem: %d extra: %d\n",
desc->hlid,
le16_to_cpu(desc->length),
le16_to_cpu(desc->life_time),
@@ -1131,7 +1132,7 @@ wl12xx_set_tx_desc_data_len(struct wl1271 *wl, struct wl1271_tx_hw_descr *desc,
desc->length = cpu_to_le16(aligned_len >> 2);

wl1271_debug(DEBUG_TX,
- "tx_fill_hdr: pad: %d hlid: %d len: %d life: %d mem: %d",
+ "tx_fill_hdr: pad: %d hlid: %d len: %d life: %d mem: %d\n",
pad, desc->hlid,
le16_to_cpu(desc->length),
le16_to_cpu(desc->life_time),
@@ -1262,7 +1263,7 @@ static bool wl12xx_mac_in_fuse(struct wl1271 *wl)
}

wl1271_debug(DEBUG_PROBE,
- "PG Ver major = %d minor = %d, MAC %s present",
+ "PG Ver major = %d minor = %d, MAC %s present\n",
major, minor, supported ? "is" : "is not");

return supported;
@@ -1432,7 +1433,7 @@ static int __devinit wl12xx_probe(struct platform_device *pdev)

hw = wlcore_alloc_hw(sizeof(*priv));
if (IS_ERR(hw)) {
- wl1271_error("can't allocate hw");
+ wl1271_err("can't allocate hw\n");
return PTR_ERR(hw);
}

@@ -1470,7 +1471,7 @@ static int __devinit wl12xx_probe(struct platform_device *pdev)
else if (!strcmp(fref_param, "52"))
priv->ref_clock = WL12XX_REFCLOCK_52;
else
- wl1271_error("Invalid fref parameter %s", fref_param);
+ wl1271_err("Invalid fref parameter %s\n", fref_param);
}

if (!tcxo_param) {
@@ -1493,7 +1494,7 @@ static int __devinit wl12xx_probe(struct platform_device *pdev)
else if (!strcmp(tcxo_param, "33.6"))
priv->tcxo_clock = WL12XX_TCXOCLOCK_33_6;
else
- wl1271_error("Invalid tcxo parameter %s", tcxo_param);
+ wl1271_err("Invalid tcxo parameter %s\n", tcxo_param);
}

return wlcore_probe(wl, pdev);
diff --git a/drivers/net/wireless/ti/wl18xx/acx.c b/drivers/net/wireless/ti/wl18xx/acx.c
index 72840e2..355c3b9 100644
--- a/drivers/net/wireless/ti/wl18xx/acx.c
+++ b/drivers/net/wireless/ti/wl18xx/acx.c
@@ -32,7 +32,7 @@ int wl18xx_acx_host_if_cfg_bitmap(struct wl1271 *wl, u32 host_cfg_bitmap,
struct wl18xx_acx_host_config_bitmap *bitmap_conf;
int ret;

- wl1271_debug(DEBUG_ACX, "acx cfg bitmap %d blk %d spare %d field %d",
+ wl1271_debug(DEBUG_ACX, "acx cfg bitmap %d blk %d spare %d field %d\n",
host_cfg_bitmap, sdio_blk_size, extra_mem_blks,
len_field_size);

@@ -50,7 +50,7 @@ int wl18xx_acx_host_if_cfg_bitmap(struct wl1271 *wl, u32 host_cfg_bitmap,
ret = wl1271_cmd_configure(wl, ACX_HOST_IF_CFG_BITMAP,
bitmap_conf, sizeof(*bitmap_conf));
if (ret < 0) {
- wl1271_warning("wl1271 bitmap config opt failed: %d", ret);
+ wl1271_warn("wl1271 bitmap config opt failed: %d\n", ret);
goto out;
}

@@ -65,7 +65,7 @@ int wl18xx_acx_set_checksum_state(struct wl1271 *wl)
struct wl18xx_acx_checksum_state *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx checksum state");
+ wl1271_debug(DEBUG_ACX, "acx checksum state\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -77,7 +77,7 @@ int wl18xx_acx_set_checksum_state(struct wl1271 *wl)

ret = wl1271_cmd_configure(wl, ACX_CHECKSUM_CONFIG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to set Tx checksum state: %d", ret);
+ wl1271_warn("failed to set Tx checksum state: %d\n", ret);
goto out;
}

@@ -91,7 +91,7 @@ int wl18xx_acx_clear_statistics(struct wl1271 *wl)
struct wl18xx_acx_clear_statistics *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx clear statistics");
+ wl1271_debug(DEBUG_ACX, "acx clear statistics\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -101,7 +101,7 @@ int wl18xx_acx_clear_statistics(struct wl1271 *wl)

ret = wl1271_cmd_configure(wl, ACX_CLEAR_STATISTICS, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to clear firmware statistics: %d", ret);
+ wl1271_warn("failed to clear firmware statistics: %d\n", ret);
goto out;
}

diff --git a/drivers/net/wireless/ti/wl18xx/main.c b/drivers/net/wireless/ti/wl18xx/main.c
index ed9c365..98118c3 100644
--- a/drivers/net/wireless/ti/wl18xx/main.c
+++ b/drivers/net/wireless/ti/wl18xx/main.c
@@ -599,8 +599,8 @@ static int wl18xx_identify_chip(struct wl1271 *wl)

switch (wl->chip.id) {
case CHIP_ID_185x_PG20:
- wl1271_debug(DEBUG_BOOT, "chip id 0x%x (185x PG20)",
- wl->chip.id);
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x (185x PG20)\n",
+ wl->chip.id);
wl->sr_fw_name = WL18XX_FW_NAME;
/* wl18xx uses the same firmware for PLT */
wl->plt_fw_name = WL18XX_FW_NAME;
@@ -610,7 +610,7 @@ static int wl18xx_identify_chip(struct wl1271 *wl)

break;
case CHIP_ID_185x_PG10:
- wl1271_debug(DEBUG_BOOT, "chip id 0x%x (185x PG10)",
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x (185x PG10)\n",
wl->chip.id);
wl->sr_fw_name = WL18XX_FW_NAME;
/* wl18xx uses the same firmware for PLT */
@@ -625,7 +625,7 @@ static int wl18xx_identify_chip(struct wl1271 *wl)

break;
default:
- wl1271_warning("unsupported chip id: 0x%x", wl->chip.id);
+ wl1271_warn("unsupported chip id: 0x%x\n", wl->chip.id);
ret = -ENODEV;
goto out;
}
@@ -643,7 +643,8 @@ static void wl18xx_set_clk(struct wl1271 *wl)
/* TODO: PG2: apparently we need to read the clk type */

clk_freq = wl18xx_top_reg_read(wl, PRIMARY_CLK_DETECT);
- wl1271_debug(DEBUG_BOOT, "clock freq %d (%d, %d, %d, %d, %s)", clk_freq,
+ wl1271_debug(DEBUG_BOOT, "clock freq %d (%d, %d, %d, %d, %s)\n",
+ clk_freq,
wl18xx_clk_table[clk_freq].n, wl18xx_clk_table[clk_freq].m,
wl18xx_clk_table[clk_freq].p, wl18xx_clk_table[clk_freq].q,
wl18xx_clk_table[clk_freq].swallow ? "swallow" : "spit");
@@ -713,7 +714,7 @@ static void wl18xx_pre_upload(struct wl1271 *wl)

tmp = wlcore_read_reg(wl, REG_CHIP_ID_B);

- wl1271_debug(DEBUG_BOOT, "chip id 0x%x", tmp);
+ wl1271_debug(DEBUG_BOOT, "chip id 0x%x\n", tmp);

tmp = wl1271_read32(wl, WL18XX_SCR_PAD2);
}
@@ -821,8 +822,8 @@ wl18xx_set_tx_desc_data_len(struct wl1271 *wl, struct wl1271_tx_hw_descr *desc,
else
desc->wl18xx_mem.ctrl = 0;

- wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d "
- "len: %d life: %d mem: %d", desc->hlid,
+ wl1271_debug(DEBUG_TX, "tx_fill_hdr: hlid: %d len: %d life: %d mem: %d\n",
+ desc->hlid,
le16_to_cpu(desc->length),
le16_to_cpu(desc->life_time),
desc->wl18xx_mem.total_mem_blocks);
@@ -954,7 +955,7 @@ static u32 wl18xx_sta_get_ap_rate_mask(struct wl1271 *wl,

if (wlvif->channel_type == NL80211_CHAN_HT40MINUS ||
wlvif->channel_type == NL80211_CHAN_HT40PLUS) {
- wl1271_debug(DEBUG_ACX, "using wide channel rate mask");
+ wl1271_debug(DEBUG_ACX, "using wide channel rate mask\n");
hw_rate_set |= CONF_TX_RATE_USE_WIDE_CHAN;

/* we don't support MIMO in wide-channel mode */
@@ -970,10 +971,10 @@ static u32 wl18xx_ap_get_mimo_wide_rate_mask(struct wl1271 *wl,
if ((wlvif->channel_type == NL80211_CHAN_HT40MINUS ||
wlvif->channel_type == NL80211_CHAN_HT40PLUS) &&
!strcmp(ht_mode_param, "wide")) {
- wl1271_debug(DEBUG_ACX, "using wide channel rate mask");
+ wl1271_debug(DEBUG_ACX, "using wide channel rate mask\n");
return CONF_TX_RATE_USE_WIDE_CHAN;
} else if (!strcmp(ht_mode_param, "mimo")) {
- wl1271_debug(DEBUG_ACX, "using MIMO rate mask");
+ wl1271_debug(DEBUG_ACX, "using MIMO rate mask\n");

/*
* PG 1.0 has some problems with MCS_13, so disable it
@@ -1015,15 +1016,14 @@ static int wl18xx_conf_init(struct wl1271 *wl, struct device *dev)

ret = request_firmware(&fw, WL18XX_CONF_FILE_NAME, dev);
if (ret < 0) {
- wl1271_error("could not get configuration binary %s: %d",
- WL18XX_CONF_FILE_NAME, ret);
+ wl1271_err("could not get configuration binary %s: %d\n",
+ WL18XX_CONF_FILE_NAME, ret);
goto out_fallback;
}

if (fw->size != WL18XX_CONF_SIZE) {
- wl1271_error("configuration binary file size is wrong, "
- "expected %ld got %zd",
- WL18XX_CONF_SIZE, fw->size);
+ wl1271_err("configuration binary file size is wrong, expected %ld got %zd\n",
+ (unsigned long)WL18XX_CONF_SIZE, fw->size);
ret = -EINVAL;
goto out;
}
@@ -1031,17 +1031,16 @@ static int wl18xx_conf_init(struct wl1271 *wl, struct device *dev)
conf_file = (struct wlcore_conf_file *) fw->data;

if (conf_file->header.magic != cpu_to_le32(WL18XX_CONF_MAGIC)) {
- wl1271_error("configuration binary file magic number mismatch, "
- "expected 0x%0x got 0x%0x", WL18XX_CONF_MAGIC,
- conf_file->header.magic);
+ wl1271_err("configuration binary file magic number mismatch, expected 0x%0x got 0x%0x\n",
+ WL18XX_CONF_MAGIC,
+ conf_file->header.magic);
ret = -EINVAL;
goto out;
}

if (conf_file->header.version != cpu_to_le32(WL18XX_CONF_VERSION)) {
- wl1271_error("configuration binary file version not supported, "
- "expected 0x%08x got 0x%08x",
- WL18XX_CONF_VERSION, conf_file->header.version);
+ wl1271_err("configuration binary file version not supported, expected 0x%08x got 0x%08x\n",
+ WL18XX_CONF_VERSION, conf_file->header.version);
ret = -EINVAL;
goto out;
}
@@ -1052,7 +1051,7 @@ static int wl18xx_conf_init(struct wl1271 *wl, struct device *dev)
goto out;

out_fallback:
- wl1271_warning("falling back to default config");
+ wl1271_warn("falling back to default config\n");

/* apply driver default configuration */
memcpy(&wl->conf, &wl18xx_conf, sizeof(wl18xx_conf));
@@ -1097,7 +1096,8 @@ static int wl18xx_handle_static_data(struct wl1271 *wl,
struct wl18xx_static_data_priv *static_data_priv =
(struct wl18xx_static_data_priv *) static_data->priv;

- wl1271_info("PHY firmware version: %s", static_data_priv->phy_version);
+ wl1271_info("PHY firmware version: %s\n",
+ static_data_priv->phy_version);

return 0;
}
@@ -1275,7 +1275,7 @@ static int __devinit wl18xx_probe(struct platform_device *pdev)

hw = wlcore_alloc_hw(sizeof(*priv));
if (IS_ERR(hw)) {
- wl1271_error("can't allocate hw");
+ wl1271_err("can't allocate hw\n");
ret = PTR_ERR(hw);
goto out;
}
@@ -1316,7 +1316,7 @@ static int __devinit wl18xx_probe(struct platform_device *pdev)
&wl18xx_siso20_ht_cap,
sizeof(wl18xx_siso20_ht_cap));
} else {
- wl1271_error("invalid ht_mode '%s'", ht_mode_param);
+ wl1271_err("invalid ht_mode '%s'\n", ht_mode_param);
ret = -EINVAL;
goto out_free;
}
@@ -1340,7 +1340,7 @@ static int __devinit wl18xx_probe(struct platform_device *pdev)
/* HACK! Just for now we hardcode COM8 to 0x06 */
priv->conf.phy.low_band_component_type = 0x06;
} else {
- wl1271_error("invalid board type '%s'", board_type_param);
+ wl1271_err("invalid board type '%s'\n", board_type_param);
ret = -EINVAL;
goto out_free;
}
diff --git a/drivers/net/wireless/ti/wl18xx/tx.c b/drivers/net/wireless/ti/wl18xx/tx.c
index 5b1fb10..aef7eae 100644
--- a/drivers/net/wireless/ti/wl18xx/tx.c
+++ b/drivers/net/wireless/ti/wl18xx/tx.c
@@ -37,7 +37,7 @@ static void wl18xx_tx_complete_packet(struct wl1271 *wl, u8 tx_stat_byte)

/* check for id legality */
if (unlikely(id >= wl->num_tx_desc || wl->tx_frames[id] == NULL)) {
- wl1271_warning("illegal id in tx completion: %d", id);
+ wl1271_warn("illegal id in tx completion: %d\n", id);
return;
}

@@ -83,7 +83,7 @@ static void wl18xx_tx_complete_packet(struct wl1271 *wl, u8 tx_stat_byte)
skb_pull(skb, WL1271_EXTRA_SPACE_TKIP);
}

- wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p success %d",
+ wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p success %d\n",
id, skb, tx_success);

/* return the packet to the stack */
@@ -104,12 +104,12 @@ void wl18xx_tx_immediate_complete(struct wl1271 *wl)
return;

/* freed Tx descriptors */
- wl1271_debug(DEBUG_TX, "last released desc = %d, current idx = %d",
+ wl1271_debug(DEBUG_TX, "last released desc = %d, current idx = %d\n",
priv->last_fw_rls_idx, status_priv->fw_release_idx);

if (status_priv->fw_release_idx >= WL18XX_FW_MAX_TX_STATUS_DESC) {
- wl1271_error("invalid desc release index %d",
- status_priv->fw_release_idx);
+ wl1271_err("invalid desc release index %d\n",
+ status_priv->fw_release_idx);
WARN_ON(1);
return;
}
diff --git a/drivers/net/wireless/ti/wlcore/acx.c b/drivers/net/wireless/ti/wlcore/acx.c
index b9ec42c..55172d2 100644
--- a/drivers/net/wireless/ti/wlcore/acx.c
+++ b/drivers/net/wireless/ti/wlcore/acx.c
@@ -40,7 +40,7 @@ int wl1271_acx_wake_up_conditions(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_wake_up_condition *wake_up;
int ret;

- wl1271_debug(DEBUG_ACX, "acx wake up conditions (wake_up_event %d listen_interval %d)",
+ wl1271_debug(DEBUG_ACX, "acx wake up conditions (wake_up_event %d listen_interval %d)\n",
wake_up_event, listen_interval);

wake_up = kzalloc(sizeof(*wake_up), GFP_KERNEL);
@@ -56,7 +56,7 @@ int wl1271_acx_wake_up_conditions(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, ACX_WAKE_UP_CONDITIONS,
wake_up, sizeof(*wake_up));
if (ret < 0) {
- wl1271_warning("could not set wake up conditions: %d", ret);
+ wl1271_warn("could not set wake up conditions: %d\n", ret);
goto out;
}

@@ -70,7 +70,7 @@ int wl1271_acx_sleep_auth(struct wl1271 *wl, u8 sleep_auth)
struct acx_sleep_auth *auth;
int ret;

- wl1271_debug(DEBUG_ACX, "acx sleep auth");
+ wl1271_debug(DEBUG_ACX, "acx sleep auth\n");

auth = kzalloc(sizeof(*auth), GFP_KERNEL);
if (!auth) {
@@ -94,7 +94,7 @@ int wl1271_acx_tx_power(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_current_tx_power *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr %d", power);
+ wl1271_debug(DEBUG_ACX, "acx dot11_cur_tx_pwr %d\n", power);

if (power < 0 || power > 25)
return -EINVAL;
@@ -110,7 +110,7 @@ int wl1271_acx_tx_power(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, DOT11_CUR_TX_PWR, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("configure of tx power failed: %d", ret);
+ wl1271_warn("configure of tx power failed: %d\n", ret);
goto out;
}

@@ -124,7 +124,7 @@ int wl1271_acx_feature_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct acx_feature_config *feature;
int ret;

- wl1271_debug(DEBUG_ACX, "acx feature cfg");
+ wl1271_debug(DEBUG_ACX, "acx feature cfg\n");

feature = kzalloc(sizeof(*feature), GFP_KERNEL);
if (!feature) {
@@ -140,7 +140,7 @@ int wl1271_acx_feature_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ret = wl1271_cmd_configure(wl, ACX_FEATURE_CFG,
feature, sizeof(*feature));
if (ret < 0) {
- wl1271_error("Couldnt set HW encryption");
+ wl1271_err("Couldnt set HW encryption\n");
goto out;
}

@@ -154,7 +154,7 @@ int wl1271_acx_mem_map(struct wl1271 *wl, struct acx_header *mem_map,
{
int ret;

- wl1271_debug(DEBUG_ACX, "acx mem map");
+ wl1271_debug(DEBUG_ACX, "acx mem map\n");

ret = wl1271_cmd_interrogate(wl, ACX_MEM_MAP, mem_map, len);
if (ret < 0)
@@ -168,7 +168,7 @@ int wl1271_acx_rx_msdu_life_time(struct wl1271 *wl)
struct acx_rx_msdu_lifetime *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx rx msdu life time");
+ wl1271_debug(DEBUG_ACX, "acx rx msdu life time\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -180,7 +180,7 @@ int wl1271_acx_rx_msdu_life_time(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, DOT11_RX_MSDU_LIFE_TIME,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to set rx msdu life time: %d", ret);
+ wl1271_warn("failed to set rx msdu life time: %d\n", ret);
goto out;
}

@@ -195,7 +195,7 @@ int wl1271_acx_slot(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_slot *slot;
int ret;

- wl1271_debug(DEBUG_ACX, "acx slot");
+ wl1271_debug(DEBUG_ACX, "acx slot\n");

slot = kzalloc(sizeof(*slot), GFP_KERNEL);
if (!slot) {
@@ -209,7 +209,7 @@ int wl1271_acx_slot(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_SLOT, slot, sizeof(*slot));
if (ret < 0) {
- wl1271_warning("failed to set slot time: %d", ret);
+ wl1271_warn("failed to set slot time: %d\n", ret);
goto out;
}

@@ -224,7 +224,7 @@ int wl1271_acx_group_address_tbl(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_dot11_grp_addr_tbl *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx group address tbl");
+ wl1271_debug(DEBUG_ACX, "acx group address tbl\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -241,7 +241,7 @@ int wl1271_acx_group_address_tbl(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, DOT11_GROUP_ADDRESS_TBL,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to set group addr table: %d", ret);
+ wl1271_warn("failed to set group addr table: %d\n", ret);
goto out;
}

@@ -262,7 +262,7 @@ int wl1271_acx_service_period_timeout(struct wl1271 *wl,
goto out;
}

- wl1271_debug(DEBUG_ACX, "acx service period timeout");
+ wl1271_debug(DEBUG_ACX, "acx service period timeout\n");

rx_timeout->role_id = wlvif->role_id;
rx_timeout->ps_poll_timeout = cpu_to_le16(wl->conf.rx.ps_poll_timeout);
@@ -271,8 +271,8 @@ int wl1271_acx_service_period_timeout(struct wl1271 *wl,
ret = wl1271_cmd_configure(wl, ACX_SERVICE_PERIOD_TIMEOUT,
rx_timeout, sizeof(*rx_timeout));
if (ret < 0) {
- wl1271_warning("failed to set service period timeout: %d",
- ret);
+ wl1271_warn("failed to set service period timeout: %d\n",
+ ret);
goto out;
}

@@ -294,7 +294,7 @@ int wl1271_acx_rts_threshold(struct wl1271 *wl, struct wl12xx_vif *wlvif,
if (rts_threshold > IEEE80211_MAX_RTS_THRESHOLD)
rts_threshold = wl->conf.rx.rts_threshold;

- wl1271_debug(DEBUG_ACX, "acx rts threshold: %d", rts_threshold);
+ wl1271_debug(DEBUG_ACX, "acx rts threshold: %d\n", rts_threshold);

rts = kzalloc(sizeof(*rts), GFP_KERNEL);
if (!rts) {
@@ -307,7 +307,7 @@ int wl1271_acx_rts_threshold(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, DOT11_RTS_THRESHOLD, rts, sizeof(*rts));
if (ret < 0) {
- wl1271_warning("failed to set rts threshold: %d", ret);
+ wl1271_warn("failed to set rts threshold: %d\n", ret);
goto out;
}

@@ -322,7 +322,7 @@ int wl1271_acx_dco_itrim_params(struct wl1271 *wl)
struct conf_itrim_settings *c = &wl->conf.itrim;
int ret;

- wl1271_debug(DEBUG_ACX, "acx dco itrim parameters");
+ wl1271_debug(DEBUG_ACX, "acx dco itrim parameters\n");

dco = kzalloc(sizeof(*dco), GFP_KERNEL);
if (!dco) {
@@ -336,7 +336,7 @@ int wl1271_acx_dco_itrim_params(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, ACX_SET_DCO_ITRIM_PARAMS,
dco, sizeof(*dco));
if (ret < 0) {
- wl1271_warning("failed to set dco itrim parameters: %d", ret);
+ wl1271_warn("failed to set dco itrim parameters: %d\n", ret);
goto out;
}

@@ -351,7 +351,7 @@ int wl1271_acx_beacon_filter_opt(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_beacon_filter_option *beacon_filter = NULL;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx beacon filter opt");
+ wl1271_debug(DEBUG_ACX, "acx beacon filter opt\n");

if (enable_filter &&
wl->conf.conn.bcn_filt_mode == CONF_BCN_FILT_MODE_DISABLED)
@@ -375,7 +375,7 @@ int wl1271_acx_beacon_filter_opt(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_OPT,
beacon_filter, sizeof(*beacon_filter));
if (ret < 0) {
- wl1271_warning("failed to set beacon filter opt: %d", ret);
+ wl1271_warn("failed to set beacon filter opt: %d\n", ret);
goto out;
}

@@ -392,7 +392,7 @@ int wl1271_acx_beacon_filter_table(struct wl1271 *wl,
int ret;
bool vendor_spec = false;

- wl1271_debug(DEBUG_ACX, "acx beacon filter table");
+ wl1271_debug(DEBUG_ACX, "acx beacon filter table\n");

ie_table = kzalloc(sizeof(*ie_table), GFP_KERNEL);
if (!ie_table) {
@@ -431,7 +431,7 @@ int wl1271_acx_beacon_filter_table(struct wl1271 *wl,
ret = wl1271_cmd_configure(wl, ACX_BEACON_FILTER_TABLE,
ie_table, sizeof(*ie_table));
if (ret < 0) {
- wl1271_warning("failed to set beacon filter table: %d", ret);
+ wl1271_warn("failed to set beacon filter table: %d\n", ret);
goto out;
}

@@ -450,7 +450,7 @@ int wl1271_acx_conn_monit_params(struct wl1271 *wl, struct wl12xx_vif *wlvif,
u32 timeout = ACX_CONN_MONIT_DISABLE_VALUE;
int ret;

- wl1271_debug(DEBUG_ACX, "acx connection monitor parameters: %s",
+ wl1271_debug(DEBUG_ACX, "acx connection monitor parameters: %s\n",
enable ? "enabled" : "disabled");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
@@ -471,8 +471,8 @@ int wl1271_acx_conn_monit_params(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, ACX_CONN_MONIT_PARAMS,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to set connection monitor "
- "parameters: %d", ret);
+ wl1271_warn("failed to set connection monitor parameters: %d\n",
+ ret);
goto out;
}

@@ -487,7 +487,7 @@ int wl1271_acx_sg_enable(struct wl1271 *wl, bool enable)
struct acx_bt_wlan_coex *pta;
int ret;

- wl1271_debug(DEBUG_ACX, "acx sg enable");
+ wl1271_debug(DEBUG_ACX, "acx sg enable\n");

pta = kzalloc(sizeof(*pta), GFP_KERNEL);
if (!pta) {
@@ -502,7 +502,7 @@ int wl1271_acx_sg_enable(struct wl1271 *wl, bool enable)

ret = wl1271_cmd_configure(wl, ACX_SG_ENABLE, pta, sizeof(*pta));
if (ret < 0) {
- wl1271_warning("failed to set softgemini enable: %d", ret);
+ wl1271_warn("failed to set softgemini enable: %d\n", ret);
goto out;
}

@@ -517,7 +517,7 @@ int wl12xx_acx_sg_cfg(struct wl1271 *wl)
struct conf_sg_settings *c = &wl->conf.sg;
int i, ret;

- wl1271_debug(DEBUG_ACX, "acx sg cfg");
+ wl1271_debug(DEBUG_ACX, "acx sg cfg\n");

param = kzalloc(sizeof(*param), GFP_KERNEL);
if (!param) {
@@ -532,7 +532,7 @@ int wl12xx_acx_sg_cfg(struct wl1271 *wl)

ret = wl1271_cmd_configure(wl, ACX_SG_CFG, param, sizeof(*param));
if (ret < 0) {
- wl1271_warning("failed to set sg config: %d", ret);
+ wl1271_warn("failed to set sg config: %d\n", ret);
goto out;
}

@@ -546,7 +546,7 @@ int wl1271_acx_cca_threshold(struct wl1271 *wl)
struct acx_energy_detection *detection;
int ret;

- wl1271_debug(DEBUG_ACX, "acx cca threshold");
+ wl1271_debug(DEBUG_ACX, "acx cca threshold\n");

detection = kzalloc(sizeof(*detection), GFP_KERNEL);
if (!detection) {
@@ -560,7 +560,7 @@ int wl1271_acx_cca_threshold(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, ACX_CCA_THRESHOLD,
detection, sizeof(*detection));
if (ret < 0)
- wl1271_warning("failed to set cca threshold: %d", ret);
+ wl1271_warn("failed to set cca threshold: %d\n", ret);

out:
kfree(detection);
@@ -572,7 +572,7 @@ int wl1271_acx_bcn_dtim_options(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct acx_beacon_broadcast *bb;
int ret;

- wl1271_debug(DEBUG_ACX, "acx bcn dtim options");
+ wl1271_debug(DEBUG_ACX, "acx bcn dtim options\n");

bb = kzalloc(sizeof(*bb), GFP_KERNEL);
if (!bb) {
@@ -588,7 +588,7 @@ int wl1271_acx_bcn_dtim_options(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_configure(wl, ACX_BCN_DTIM_OPTIONS, bb, sizeof(*bb));
if (ret < 0) {
- wl1271_warning("failed to set rx config: %d", ret);
+ wl1271_warn("failed to set rx config: %d\n", ret);
goto out;
}

@@ -602,7 +602,7 @@ int wl1271_acx_aid(struct wl1271 *wl, struct wl12xx_vif *wlvif, u16 aid)
struct acx_aid *acx_aid;
int ret;

- wl1271_debug(DEBUG_ACX, "acx aid");
+ wl1271_debug(DEBUG_ACX, "acx aid\n");

acx_aid = kzalloc(sizeof(*acx_aid), GFP_KERNEL);
if (!acx_aid) {
@@ -615,7 +615,7 @@ int wl1271_acx_aid(struct wl1271 *wl, struct wl12xx_vif *wlvif, u16 aid)

ret = wl1271_cmd_configure(wl, ACX_AID, acx_aid, sizeof(*acx_aid));
if (ret < 0) {
- wl1271_warning("failed to set aid: %d", ret);
+ wl1271_warn("failed to set aid: %d\n", ret);
goto out;
}

@@ -629,7 +629,7 @@ int wl1271_acx_event_mbox_mask(struct wl1271 *wl, u32 event_mask)
struct acx_event_mask *mask;
int ret;

- wl1271_debug(DEBUG_ACX, "acx event mbox mask");
+ wl1271_debug(DEBUG_ACX, "acx event mbox mask\n");

mask = kzalloc(sizeof(*mask), GFP_KERNEL);
if (!mask) {
@@ -644,7 +644,7 @@ int wl1271_acx_event_mbox_mask(struct wl1271 *wl, u32 event_mask)
ret = wl1271_cmd_configure(wl, ACX_EVENT_MBOX_MASK,
mask, sizeof(*mask));
if (ret < 0) {
- wl1271_warning("failed to set acx_event_mbox_mask: %d", ret);
+ wl1271_warn("failed to set acx_event_mbox_mask: %d\n", ret);
goto out;
}

@@ -659,7 +659,7 @@ int wl1271_acx_set_preamble(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_preamble *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx_set_preamble");
+ wl1271_debug(DEBUG_ACX, "acx_set_preamble\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -672,7 +672,7 @@ int wl1271_acx_set_preamble(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_PREAMBLE_TYPE, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of preamble failed: %d", ret);
+ wl1271_warn("Setting of preamble failed: %d\n", ret);
goto out;
}

@@ -687,7 +687,7 @@ int wl1271_acx_cts_protect(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_ctsprotect *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx_set_ctsprotect");
+ wl1271_debug(DEBUG_ACX, "acx_set_ctsprotect\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -700,7 +700,7 @@ int wl1271_acx_cts_protect(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_CTS_PROTECTION, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of ctsprotect failed: %d", ret);
+ wl1271_warn("Setting of ctsprotect failed: %d\n", ret);
goto out;
}

@@ -713,12 +713,12 @@ int wl1271_acx_statistics(struct wl1271 *wl, void *stats)
{
int ret;

- wl1271_debug(DEBUG_ACX, "acx statistics");
+ wl1271_debug(DEBUG_ACX, "acx statistics\n");

ret = wl1271_cmd_interrogate(wl, ACX_STATISTICS, stats,
wl->stats.fw_stats_len);
if (ret < 0) {
- wl1271_warning("acx statistics failed: %d", ret);
+ wl1271_warn("acx statistics failed: %d\n", ret);
return -ENOMEM;
}

@@ -731,7 +731,7 @@ int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct conf_tx_rate_class *c = &wl->conf.tx.sta_rc_conf;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx rate policies");
+ wl1271_debug(DEBUG_ACX, "acx rate policies\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -740,8 +740,8 @@ int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif)
goto out;
}

- wl1271_debug(DEBUG_ACX, "basic_rate: 0x%x, full_rate: 0x%x",
- wlvif->basic_rate, wlvif->rate_set);
+ wl1271_debug(DEBUG_ACX, "basic_rate: 0x%x, full_rate: 0x%x\n",
+ wlvif->basic_rate, wlvif->rate_set);

/* configure one basic rate class */
acx->rate_policy_idx = cpu_to_le32(wlvif->sta.basic_rate_idx);
@@ -752,7 +752,7 @@ int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of rate policies failed: %d", ret);
+ wl1271_warn("Setting of rate policies failed: %d\n", ret);
goto out;
}

@@ -768,7 +768,7 @@ int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of rate policies failed: %d", ret);
+ wl1271_warn("Setting of rate policies failed: %d\n", ret);
goto out;
}

@@ -786,7 +786,7 @@ int wl1271_acx_sta_rate_policies(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of rate policies failed: %d", ret);
+ wl1271_warn("Setting of rate policies failed: %d\n", ret);
goto out;
}

@@ -801,7 +801,7 @@ int wl1271_acx_ap_rate_policy(struct wl1271 *wl, struct conf_tx_rate_class *c,
struct acx_rate_policy *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx ap rate policy %d rates 0x%x",
+ wl1271_debug(DEBUG_ACX, "acx ap rate policy %d rates 0x%x\n",
idx, c->enabled_rates);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
@@ -819,7 +819,7 @@ int wl1271_acx_ap_rate_policy(struct wl1271 *wl, struct conf_tx_rate_class *c,

ret = wl1271_cmd_configure(wl, ACX_RATE_POLICY, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of ap rate policy failed: %d", ret);
+ wl1271_warn("Setting of ap rate policy failed: %d\n", ret);
goto out;
}

@@ -834,8 +834,8 @@ int wl1271_acx_ac_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_ac_cfg *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d "
- "aifs %d txop %d", ac, cw_min, cw_max, aifsn, txop);
+ wl1271_debug(DEBUG_ACX, "acx ac cfg %d cw_ming %d cw_max %d aifs %d txop %d\n",
+ ac, cw_min, cw_max, aifsn, txop);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -853,7 +853,7 @@ int wl1271_acx_ac_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_AC_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx ac cfg failed: %d", ret);
+ wl1271_warn("acx ac cfg failed: %d\n", ret);
goto out;
}

@@ -870,7 +870,7 @@ int wl1271_acx_tid_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct acx_tid_config *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx tid config");
+ wl1271_debug(DEBUG_ACX, "acx tid config\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -890,7 +890,7 @@ int wl1271_acx_tid_cfg(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_TID_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of tid config failed: %d", ret);
+ wl1271_warn("Setting of tid config failed: %d\n", ret);
goto out;
}

@@ -911,7 +911,7 @@ int wl1271_acx_frag_threshold(struct wl1271 *wl, u32 frag_threshold)
if (frag_threshold > IEEE80211_MAX_FRAG_THRESHOLD)
frag_threshold = wl->conf.tx.frag_threshold;

- wl1271_debug(DEBUG_ACX, "acx frag threshold: %d", frag_threshold);
+ wl1271_debug(DEBUG_ACX, "acx frag threshold: %d\n", frag_threshold);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -923,7 +923,7 @@ int wl1271_acx_frag_threshold(struct wl1271 *wl, u32 frag_threshold)
acx->frag_threshold = cpu_to_le16((u16)frag_threshold);
ret = wl1271_cmd_configure(wl, ACX_FRAG_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of frag threshold failed: %d", ret);
+ wl1271_warn("Setting of frag threshold failed: %d\n", ret);
goto out;
}

@@ -937,7 +937,7 @@ int wl1271_acx_tx_config_options(struct wl1271 *wl)
struct acx_tx_config_options *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx tx config options");
+ wl1271_debug(DEBUG_ACX, "acx tx config options\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);

@@ -950,7 +950,7 @@ int wl1271_acx_tx_config_options(struct wl1271 *wl)
acx->tx_compl_threshold = cpu_to_le16(wl->conf.tx.tx_compl_threshold);
ret = wl1271_cmd_configure(wl, ACX_TX_CONFIG_OPT, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("Setting of tx options failed: %d", ret);
+ wl1271_warn("Setting of tx options failed: %d\n", ret);
goto out;
}

@@ -965,7 +965,7 @@ int wl12xx_acx_mem_cfg(struct wl1271 *wl)
struct conf_memory_settings *mem;
int ret;

- wl1271_debug(DEBUG_ACX, "wl1271 mem cfg");
+ wl1271_debug(DEBUG_ACX, "wl1271 mem cfg\n");

mem_conf = kzalloc(sizeof(*mem_conf), GFP_KERNEL);
if (!mem_conf) {
@@ -990,7 +990,7 @@ int wl12xx_acx_mem_cfg(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, ACX_MEM_CFG, mem_conf,
sizeof(*mem_conf));
if (ret < 0) {
- wl1271_warning("wl1271 mem config failed: %d", ret);
+ wl1271_warn("wl1271 mem config failed: %d\n", ret);
goto out;
}

@@ -1007,7 +1007,7 @@ int wl1271_acx_init_mem_config(struct wl1271 *wl)
wl->target_mem_map = kzalloc(sizeof(struct wl1271_acx_mem_map),
GFP_KERNEL);
if (!wl->target_mem_map) {
- wl1271_error("couldn't allocate target memory map");
+ wl1271_err("couldn't allocate target memory map\n");
return -ENOMEM;
}

@@ -1015,7 +1015,7 @@ int wl1271_acx_init_mem_config(struct wl1271 *wl)
ret = wl1271_acx_mem_map(wl, (void *)wl->target_mem_map,
sizeof(struct wl1271_acx_mem_map));
if (ret < 0) {
- wl1271_error("couldn't retrieve firmware memory map");
+ wl1271_err("couldn't retrieve firmware memory map\n");
kfree(wl->target_mem_map);
wl->target_mem_map = NULL;
return ret;
@@ -1024,7 +1024,7 @@ int wl1271_acx_init_mem_config(struct wl1271 *wl)
/* initialize TX block book keeping */
wl->tx_blocks_available =
le32_to_cpu(wl->target_mem_map->num_tx_mem_blocks);
- wl1271_debug(DEBUG_TX, "available tx blocks: %d",
+ wl1271_debug(DEBUG_TX, "available tx blocks: %d\n",
wl->tx_blocks_available);

return 0;
@@ -1036,7 +1036,7 @@ int wl1271_acx_init_rx_interrupt(struct wl1271 *wl)
struct wl1271_acx_rx_config_opt *rx_conf;
int ret;

- wl1271_debug(DEBUG_ACX, "wl1271 rx interrupt config");
+ wl1271_debug(DEBUG_ACX, "wl1271 rx interrupt config\n");

rx_conf = kzalloc(sizeof(*rx_conf), GFP_KERNEL);
if (!rx_conf) {
@@ -1052,7 +1052,7 @@ int wl1271_acx_init_rx_interrupt(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, ACX_RX_CONFIG_OPT, rx_conf,
sizeof(*rx_conf));
if (ret < 0) {
- wl1271_warning("wl1271 rx config opt failed: %d", ret);
+ wl1271_warn("wl1271 rx config opt failed: %d\n", ret);
goto out;
}

@@ -1067,7 +1067,7 @@ int wl1271_acx_bet_enable(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_acx_bet_enable *acx = NULL;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx bet enable");
+ wl1271_debug(DEBUG_ACX, "acx bet enable\n");

if (enable && wl->conf.conn.bet_enable == CONF_BET_MODE_DISABLE)
goto out;
@@ -1084,7 +1084,7 @@ int wl1271_acx_bet_enable(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_BET_ENABLE, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx bet enable failed: %d", ret);
+ wl1271_warn("acx bet enable failed: %d\n", ret);
goto out;
}

@@ -1099,7 +1099,7 @@ int wl1271_acx_arp_ip_filter(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_acx_arp_filter *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx arp ip filter, enable: %d", enable);
+ wl1271_debug(DEBUG_ACX, "acx arp ip filter, enable: %d\n", enable);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1117,7 +1117,7 @@ int wl1271_acx_arp_ip_filter(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, ACX_ARP_IP_FILTER,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("failed to set arp ip filter: %d", ret);
+ wl1271_warn("failed to set arp ip filter: %d\n", ret);
goto out;
}

@@ -1132,7 +1132,7 @@ int wl1271_acx_pm_config(struct wl1271 *wl)
struct conf_pm_config_settings *c = &wl->conf.pm_config;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx pm config");
+ wl1271_debug(DEBUG_ACX, "acx pm config\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1145,7 +1145,7 @@ int wl1271_acx_pm_config(struct wl1271 *wl)

ret = wl1271_cmd_configure(wl, ACX_PM_CONFIG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx pm config failed: %d", ret);
+ wl1271_warn("acx pm config failed: %d\n", ret);
goto out;
}

@@ -1161,7 +1161,7 @@ int wl1271_acx_keep_alive_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_acx_keep_alive_mode *acx = NULL;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx keep alive mode: %d", enable);
+ wl1271_debug(DEBUG_ACX, "acx keep alive mode: %d\n", enable);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1174,7 +1174,7 @@ int wl1271_acx_keep_alive_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_KEEP_ALIVE_MODE, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx keep alive mode failed: %d", ret);
+ wl1271_warn("acx keep alive mode failed: %d\n", ret);
goto out;
}

@@ -1189,7 +1189,7 @@ int wl1271_acx_keep_alive_config(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_acx_keep_alive_config *acx = NULL;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx keep alive config");
+ wl1271_debug(DEBUG_ACX, "acx keep alive config\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1206,7 +1206,7 @@ int wl1271_acx_keep_alive_config(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_configure(wl, ACX_SET_KEEP_ALIVE_CONFIG,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx keep alive config failed: %d", ret);
+ wl1271_warn("acx keep alive config failed: %d\n", ret);
goto out;
}

@@ -1221,7 +1221,7 @@ int wl1271_acx_rssi_snr_trigger(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_acx_rssi_snr_trigger *acx = NULL;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx rssi snr trigger");
+ wl1271_debug(DEBUG_ACX, "acx rssi snr trigger\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1247,7 +1247,7 @@ int wl1271_acx_rssi_snr_trigger(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_configure(wl, ACX_RSSI_SNR_TRIGGER, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx rssi snr trigger setting failed: %d", ret);
+ wl1271_warn("acx rssi snr trigger setting failed: %d\n", ret);
goto out;
}

@@ -1263,7 +1263,7 @@ int wl1271_acx_rssi_snr_avg_weights(struct wl1271 *wl,
struct conf_roam_trigger_settings *c = &wl->conf.roam_trigger;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx rssi snr avg weights");
+ wl1271_debug(DEBUG_ACX, "acx rssi snr avg weights\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1279,7 +1279,7 @@ int wl1271_acx_rssi_snr_avg_weights(struct wl1271 *wl,

ret = wl1271_cmd_configure(wl, ACX_RSSI_SNR_WEIGHTS, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx rssi snr trigger weights failed: %d", ret);
+ wl1271_warn("acx rssi snr trigger weights failed: %d\n", ret);
goto out;
}

@@ -1296,9 +1296,8 @@ int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,
int ret = 0;
u32 ht_capabilites = 0;

- wl1271_debug(DEBUG_ACX, "acx ht capabilities setting "
- "sta supp: %d sta cap: %d", ht_cap->ht_supported,
- ht_cap->cap);
+ wl1271_debug(DEBUG_ACX, "acx ht capabilities setting sta supp: %d sta cap: %d\n",
+ ht_cap->ht_supported, ht_cap->cap);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1326,7 +1325,7 @@ int wl1271_acx_set_ht_capabilities(struct wl1271 *wl,

ret = wl1271_cmd_configure(wl, ACX_PEER_HT_CAP, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx ht capabilities setting failed: %d", ret);
+ wl1271_warn("acx ht capabilities setting failed: %d\n", ret);
goto out;
}

@@ -1342,7 +1341,7 @@ int wl1271_acx_set_ht_information(struct wl1271 *wl,
struct wl1271_acx_ht_information *acx;
int ret = 0;

- wl1271_debug(DEBUG_ACX, "acx ht information setting");
+ wl1271_debug(DEBUG_ACX, "acx ht information setting\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1362,7 +1361,7 @@ int wl1271_acx_set_ht_information(struct wl1271 *wl,
ret = wl1271_cmd_configure(wl, ACX_HT_BSS_OPERATION, acx, sizeof(*acx));

if (ret < 0) {
- wl1271_warning("acx ht information setting failed: %d", ret);
+ wl1271_warn("acx ht information setting failed: %d\n", ret);
goto out;
}

@@ -1378,7 +1377,7 @@ int wl12xx_acx_set_ba_initiator_policy(struct wl1271 *wl,
struct wl1271_acx_ba_initiator_policy *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx ba initiator policy");
+ wl1271_debug(DEBUG_ACX, "acx ba initiator policy\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1397,7 +1396,7 @@ int wl12xx_acx_set_ba_initiator_policy(struct wl1271 *wl,
acx,
sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx ba initiator policy failed: %d", ret);
+ wl1271_warn("acx ba initiator policy failed: %d\n", ret);
goto out;
}

@@ -1413,7 +1412,7 @@ int wl12xx_acx_set_ba_receiver_session(struct wl1271 *wl, u8 tid_index,
struct wl1271_acx_ba_receiver_setup *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx ba receiver session setting");
+ wl1271_debug(DEBUG_ACX, "acx ba receiver session setting\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1430,7 +1429,7 @@ int wl12xx_acx_set_ba_receiver_session(struct wl1271 *wl, u8 tid_index,
ret = wl1271_cmd_configure(wl, ACX_BA_SESSION_RX_SETUP, acx,
sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx ba receiver session failed: %d", ret);
+ wl1271_warn("acx ba receiver session failed: %d\n", ret);
goto out;
}

@@ -1456,7 +1455,7 @@ int wl12xx_acx_tsf_info(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_interrogate(wl, ACX_TSF_INFO,
tsf_info, sizeof(*tsf_info));
if (ret < 0) {
- wl1271_warning("acx tsf info interrogate failed");
+ wl1271_warn("acx tsf info interrogate failed\n");
goto out;
}

@@ -1475,7 +1474,7 @@ int wl1271_acx_ps_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
u32 conf_queues, enable_queues;
int i, ret = 0;

- wl1271_debug(DEBUG_ACX, "acx ps rx streaming");
+ wl1271_debug(DEBUG_ACX, "acx ps rx streaming\n");

rx_streaming = kzalloc(sizeof(*rx_streaming), GFP_KERNEL);
if (!rx_streaming) {
@@ -1508,7 +1507,7 @@ int wl1271_acx_ps_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
rx_streaming,
sizeof(*rx_streaming));
if (ret < 0) {
- wl1271_warning("acx ps rx streaming failed: %d", ret);
+ wl1271_warn("acx ps rx streaming failed: %d\n", ret);
goto out;
}
}
@@ -1522,7 +1521,7 @@ int wl1271_acx_ap_max_tx_retry(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct wl1271_acx_ap_max_tx_retry *acx = NULL;
int ret;

- wl1271_debug(DEBUG_ACX, "acx ap max tx retry");
+ wl1271_debug(DEBUG_ACX, "acx ap max tx retry\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx)
@@ -1533,7 +1532,7 @@ int wl1271_acx_ap_max_tx_retry(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_configure(wl, ACX_MAX_TX_FAILURE, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx ap max tx retry failed: %d", ret);
+ wl1271_warn("acx ap max tx retry failed: %d\n", ret);
goto out;
}

@@ -1547,7 +1546,7 @@ int wl12xx_acx_config_ps(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct wl1271_acx_config_ps *config_ps;
int ret;

- wl1271_debug(DEBUG_ACX, "acx config ps");
+ wl1271_debug(DEBUG_ACX, "acx config ps\n");

config_ps = kzalloc(sizeof(*config_ps), GFP_KERNEL);
if (!config_ps) {
@@ -1563,7 +1562,7 @@ int wl12xx_acx_config_ps(struct wl1271 *wl, struct wl12xx_vif *wlvif)
sizeof(*config_ps));

if (ret < 0) {
- wl1271_warning("acx config ps failed: %d", ret);
+ wl1271_warn("acx config ps failed: %d\n", ret);
goto out;
}

@@ -1577,7 +1576,7 @@ int wl1271_acx_set_inconnection_sta(struct wl1271 *wl, u8 *addr)
struct wl1271_acx_inconnection_sta *acx = NULL;
int ret;

- wl1271_debug(DEBUG_ACX, "acx set inconnaction sta %pM", addr);
+ wl1271_debug(DEBUG_ACX, "acx set inconnaction sta %pM\n", addr);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx)
@@ -1588,7 +1587,7 @@ int wl1271_acx_set_inconnection_sta(struct wl1271 *wl, u8 *addr)
ret = wl1271_cmd_configure(wl, ACX_UPDATE_INCONNECTION_STA_LIST,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx set inconnaction sta failed: %d", ret);
+ wl1271_warn("acx set inconnaction sta failed: %d\n", ret);
goto out;
}

@@ -1602,7 +1601,7 @@ int wl1271_acx_fm_coex(struct wl1271 *wl)
struct wl1271_acx_fm_coex *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx fm coex setting");
+ wl1271_debug(DEBUG_ACX, "acx fm coex setting\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1628,7 +1627,7 @@ int wl1271_acx_fm_coex(struct wl1271 *wl)

ret = wl1271_cmd_configure(wl, ACX_FM_COEX_CFG, acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx fm coex setting failed: %d", ret);
+ wl1271_warn("acx fm coex setting failed: %d\n", ret);
goto out;
}

@@ -1643,7 +1642,7 @@ int wl12xx_acx_set_rate_mgmt_params(struct wl1271 *wl)
struct conf_rate_policy_settings *conf = &wl->conf.rate;
int ret;

- wl1271_debug(DEBUG_ACX, "acx set rate mgmt params");
+ wl1271_debug(DEBUG_ACX, "acx set rate mgmt params\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx)
@@ -1670,7 +1669,7 @@ int wl12xx_acx_set_rate_mgmt_params(struct wl1271 *wl)
ret = wl1271_cmd_configure(wl, ACX_SET_RATE_MGMT_PARAMS,
acx, sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx set rate mgmt params failed: %d", ret);
+ wl1271_warn("acx set rate mgmt params failed: %d\n", ret);
goto out;
}

@@ -1685,7 +1684,7 @@ int wl12xx_acx_config_hangover(struct wl1271 *wl)
struct conf_hangover_settings *conf = &wl->conf.hangover;
int ret;

- wl1271_debug(DEBUG_ACX, "acx config hangover");
+ wl1271_debug(DEBUG_ACX, "acx config hangover\n");

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
if (!acx) {
@@ -1709,7 +1708,7 @@ int wl12xx_acx_config_hangover(struct wl1271 *wl)
sizeof(*acx));

if (ret < 0) {
- wl1271_warning("acx config hangover failed: %d", ret);
+ wl1271_warn("acx config hangover failed: %d\n", ret);
goto out;
}

@@ -1727,7 +1726,7 @@ int wl1271_acx_default_rx_filter_enable(struct wl1271 *wl, bool enable,
struct acx_default_rx_filter *acx;
int ret;

- wl1271_debug(DEBUG_ACX, "acx default rx filter en: %d act: %d",
+ wl1271_debug(DEBUG_ACX, "acx default rx filter en: %d act: %d\n",
enable, action);

acx = kzalloc(sizeof(*acx), GFP_KERNEL);
@@ -1740,7 +1739,7 @@ int wl1271_acx_default_rx_filter_enable(struct wl1271 *wl, bool enable,
ret = wl1271_cmd_configure(wl, ACX_ENABLE_RX_DATA_FILTER, acx,
sizeof(*acx));
if (ret < 0) {
- wl1271_warning("acx default rx filter enable failed: %d", ret);
+ wl1271_warn("acx default rx filter enable failed: %d\n", ret);
goto out;
}

@@ -1762,14 +1761,14 @@ int wl1271_acx_set_rx_filter(struct wl1271 *wl, u8 index, bool enable,
WARN_ON(index >= WL1271_MAX_RX_FILTERS);

wl1271_debug(DEBUG_ACX,
- "acx set rx filter idx: %d enable: %d filter: %p",
+ "acx set rx filter idx: %d enable: %d filter: %p\n",
index, enable, filter);

if (enable) {
fields_size = wl1271_rx_filter_get_fields_size(filter);

- wl1271_debug(DEBUG_ACX, "act: %d num_fields: %d field_size: %d",
- filter->action, filter->num_fields, fields_size);
+ wl1271_debug(DEBUG_ACX, "act: %d num_fields: %d field_size: %d\n",
+ filter->action, filter->num_fields, fields_size);
}

acx_size = ALIGN(sizeof(*acx) + fields_size, 4);
@@ -1791,7 +1790,7 @@ int wl1271_acx_set_rx_filter(struct wl1271 *wl, u8 index, bool enable,

ret = wl1271_cmd_configure(wl, ACX_SET_RX_DATA_FILTER, acx, acx_size);
if (ret < 0) {
- wl1271_warning("setting rx filter failed: %d", ret);
+ wl1271_warn("setting rx filter failed: %d\n", ret);
goto out;
}

diff --git a/drivers/net/wireless/ti/wlcore/boot.c b/drivers/net/wireless/ti/wlcore/boot.c
index 0fda500..2cefdbf 100644
--- a/drivers/net/wireless/ti/wlcore/boot.c
+++ b/drivers/net/wireless/ti/wlcore/boot.c
@@ -62,7 +62,7 @@ static int wlcore_boot_parse_fw_ver(struct wl1271 *wl,
&wl->chip.fw_ver[4]);

if (ret != 5) {
- wl1271_warning("fw version incorrect value");
+ wl1271_warn("fw version incorrect value\n");
memset(wl->chip.fw_ver, 0, sizeof(wl->chip.fw_ver));
ret = -EINVAL;
goto out;
@@ -112,19 +112,19 @@ static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf,

/* whal_FwCtrl_LoadFwImageSm() */

- wl1271_debug(DEBUG_BOOT, "starting firmware upload");
+ wl1271_debug(DEBUG_BOOT, "starting firmware upload\n");

- wl1271_debug(DEBUG_BOOT, "fw_data_len %zd chunk_size %d",
+ wl1271_debug(DEBUG_BOOT, "fw_data_len %zd chunk_size %d\n",
fw_data_len, CHUNK_SIZE);

if ((fw_data_len % 4) != 0) {
- wl1271_error("firmware length not multiple of four");
+ wl1271_err("firmware length not multiple of four\n");
return -EIO;
}

chunk = kmalloc(CHUNK_SIZE, GFP_KERNEL);
if (!chunk) {
- wl1271_error("allocation for firmware upload chunk failed");
+ wl1271_err("allocation for firmware upload chunk failed\n");
return -ENOMEM;
}

@@ -151,7 +151,7 @@ static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf,
addr = dest + chunk_num * CHUNK_SIZE;
p = buf + chunk_num * CHUNK_SIZE;
memcpy(chunk, p, CHUNK_SIZE);
- wl1271_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x",
+ wl1271_debug(DEBUG_BOOT, "uploading fw chunk 0x%p to 0x%x\n",
p, addr);
wl1271_write(wl, addr, chunk, CHUNK_SIZE, false);

@@ -162,7 +162,7 @@ static int wl1271_boot_upload_firmware_chunk(struct wl1271 *wl, void *buf,
addr = dest + chunk_num * CHUNK_SIZE;
p = buf + chunk_num * CHUNK_SIZE;
memcpy(chunk, p, fw_data_len % CHUNK_SIZE);
- wl1271_debug(DEBUG_BOOT, "uploading fw last chunk (%zd B) 0x%p to 0x%x",
+ wl1271_debug(DEBUG_BOOT, "uploading fw last chunk (%zd B) 0x%p to 0x%x\n",
fw_data_len % CHUNK_SIZE, p, addr);
wl1271_write(wl, addr, chunk, fw_data_len % CHUNK_SIZE, false);

@@ -180,7 +180,8 @@ int wlcore_boot_upload_firmware(struct wl1271 *wl)
chunks = be32_to_cpup((__be32 *) fw);
fw += sizeof(u32);

- wl1271_debug(DEBUG_BOOT, "firmware chunks to be uploaded: %u", chunks);
+ wl1271_debug(DEBUG_BOOT, "firmware chunks to be uploaded: %u\n",
+ chunks);

while (chunks--) {
addr = be32_to_cpup((__be32 *) fw);
@@ -189,10 +190,10 @@ int wlcore_boot_upload_firmware(struct wl1271 *wl)
fw += sizeof(u32);

if (len > 300000) {
- wl1271_info("firmware chunk too long: %u", len);
+ wl1271_info("firmware chunk too long: %u\n", len);
return -EINVAL;
}
- wl1271_debug(DEBUG_BOOT, "chunk %d addr 0x%x len %u",
+ wl1271_debug(DEBUG_BOOT, "chunk %d addr 0x%x len %u\n",
chunks, addr, len);
ret = wl1271_boot_upload_firmware_chunk(wl, fw, len, addr);
if (ret != 0)
@@ -212,7 +213,7 @@ int wlcore_boot_upload_nvs(struct wl1271 *wl)
u8 *nvs_ptr, *nvs_aligned;

if (wl->nvs == NULL) {
- wl1271_error("NVS file is needed during boot");
+ wl1271_err("NVS file is needed during boot\n");
return -ENODEV;
}

@@ -233,8 +234,8 @@ int wlcore_boot_upload_nvs(struct wl1271 *wl)
if (wl->nvs_len != sizeof(struct wl1271_nvs_file) &&
(wl->nvs_len != WL1271_INI_LEGACY_NVS_FILE_SIZE ||
wl->enable_11a)) {
- wl1271_error("nvs size is not as expected: %zu != %zu",
- wl->nvs_len, sizeof(struct wl1271_nvs_file));
+ wl1271_err("nvs size is not as expected: %zu != %zu\n",
+ wl->nvs_len, sizeof(struct wl1271_nvs_file));
kfree(wl->nvs);
wl->nvs = NULL;
wl->nvs_len = 0;
@@ -251,9 +252,9 @@ int wlcore_boot_upload_nvs(struct wl1271 *wl)
if (nvs->general_params.dual_mode_select)
wl->enable_11a = true;
} else {
- wl1271_error("nvs size is not as expected: %zu != %zu",
- wl->nvs_len,
- sizeof(struct wl128x_nvs_file));
+ wl1271_err("nvs size is not as expected: %zu != %zu\n",
+ wl->nvs_len,
+ sizeof(struct wl128x_nvs_file));
kfree(wl->nvs);
wl->nvs = NULL;
wl->nvs_len = 0;
@@ -305,7 +306,7 @@ int wlcore_boot_upload_nvs(struct wl1271 *wl)
| (nvs_ptr[2] << 16) | (nvs_ptr[3] << 24));

wl1271_debug(DEBUG_BOOT,
- "nvs burst write 0x%x: 0x%x",
+ "nvs burst write 0x%x: 0x%x\n",
dest_addr, val);
wl1271_write32(wl, dest_addr, val);

@@ -348,7 +349,7 @@ int wlcore_boot_upload_nvs(struct wl1271 *wl)
return 0;

out_badnvs:
- wl1271_error("nvs data is malformed");
+ wl1271_err("nvs data is malformed\n");
return -EILSEQ;
}
EXPORT_SYMBOL_GPL(wlcore_boot_upload_nvs);
@@ -365,10 +366,11 @@ int wlcore_boot_run_firmware(struct wl1271 *wl)

chip_id = wlcore_read_reg(wl, REG_CHIP_ID_B);

- wl1271_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x", chip_id);
+ wl1271_debug(DEBUG_BOOT, "chip id after firmware boot: 0x%x\n",
+ chip_id);

if (chip_id != wl->chip.id) {
- wl1271_error("chip id doesn't match after firmware boot");
+ wl1271_err("chip id doesn't match after firmware boot\n");
return -EIO;
}

@@ -379,8 +381,7 @@ int wlcore_boot_run_firmware(struct wl1271 *wl)
intr = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR);

if (intr == 0xffffffff) {
- wl1271_error("error reading hardware complete "
- "init indication");
+ wl1271_err("error reading hardware complete init indication\n");
return -EIO;
}
/* check that ACX_INTR_INIT_COMPLETE is enabled */
@@ -392,26 +393,25 @@ int wlcore_boot_run_firmware(struct wl1271 *wl)
}

if (loop > INIT_LOOP) {
- wl1271_error("timeout waiting for the hardware to "
- "complete initialization");
+ wl1271_err("timeout waiting for the hardware to complete initialization\n");
return -EIO;
}

/* get hardware config command mail box */
wl->cmd_box_addr = wlcore_read_reg(wl, REG_COMMAND_MAILBOX_PTR);

- wl1271_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x", wl->cmd_box_addr);
+ wl1271_debug(DEBUG_MAILBOX, "cmd_box_addr 0x%x\n", wl->cmd_box_addr);

/* get hardware config event mail box */
wl->mbox_ptr[0] = wlcore_read_reg(wl, REG_EVENT_MAILBOX_PTR);
wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);

- wl1271_debug(DEBUG_MAILBOX, "MBOX ptrs: 0x%x 0x%x",
+ wl1271_debug(DEBUG_MAILBOX, "MBOX ptrs: 0x%x 0x%x\n",
wl->mbox_ptr[0], wl->mbox_ptr[1]);

ret = wlcore_boot_static_data(wl);
if (ret < 0) {
- wl1271_error("error getting static data");
+ wl1271_err("error getting static data\n");
return ret;
}

@@ -440,7 +440,7 @@ int wlcore_boot_run_firmware(struct wl1271 *wl)

ret = wl1271_event_unmask(wl);
if (ret < 0) {
- wl1271_error("EVENT mask setting failed");
+ wl1271_err("EVENT mask setting failed\n");
return ret;
}

diff --git a/drivers/net/wireless/ti/wlcore/cmd.c b/drivers/net/wireless/ti/wlcore/cmd.c
index 885364c..c90b339 100644
--- a/drivers/net/wireless/ti/wlcore/cmd.c
+++ b/drivers/net/wireless/ti/wlcore/cmd.c
@@ -78,7 +78,7 @@ int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,
intr = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR);
while (!(intr & WL1271_ACX_INTR_CMD_COMPLETE)) {
if (time_after(jiffies, timeout)) {
- wl1271_error("command complete timeout");
+ wl1271_err("command complete timeout\n");
ret = -ETIMEDOUT;
goto fail;
}
@@ -99,7 +99,7 @@ int wl1271_cmd_send(struct wl1271 *wl, u16 id, void *buf, size_t len,

status = le16_to_cpu(cmd->status);
if (status != CMD_STATUS_SUCCESS) {
- wl1271_error("command execute failure %d", status);
+ wl1271_err("command execute failure %d\n", status);
ret = -EIO;
goto fail;
}
@@ -132,7 +132,7 @@ static int wl1271_cmd_wait_for_event_or_timeout(struct wl1271 *wl, u32 mask)

do {
if (time_after(jiffies, timeout)) {
- wl1271_debug(DEBUG_CMD, "timeout waiting for event %d",
+ wl1271_debug(DEBUG_CMD, "timeout waiting for event %d\n",
(int)mask);
ret = -ETIMEDOUT;
goto out;
@@ -173,7 +173,7 @@ int wl12xx_cmd_role_enable(struct wl1271 *wl, u8 *addr, u8 role_type,
struct wl12xx_cmd_role_enable *cmd;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd role enable");
+ wl1271_debug(DEBUG_CMD, "cmd role enable\n");

if (WARN_ON(*role_id != WL12XX_INVALID_ROLE_ID))
return -EBUSY;
@@ -196,7 +196,7 @@ int wl12xx_cmd_role_enable(struct wl1271 *wl, u8 *addr, u8 role_type,

ret = wl1271_cmd_send(wl, CMD_ROLE_ENABLE, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role enable");
+ wl1271_err("failed to initiate cmd role enable\n");
goto out_free;
}

@@ -215,7 +215,7 @@ int wl12xx_cmd_role_disable(struct wl1271 *wl, u8 *role_id)
struct wl12xx_cmd_role_disable *cmd;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd role disable");
+ wl1271_debug(DEBUG_CMD, "cmd role disable\n");

if (WARN_ON(*role_id == WL12XX_INVALID_ROLE_ID))
return -ENOENT;
@@ -229,7 +229,7 @@ int wl12xx_cmd_role_disable(struct wl1271 *wl, u8 *role_id)

ret = wl1271_cmd_send(wl, CMD_ROLE_DISABLE, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role disable");
+ wl1271_err("failed to initiate cmd role disable\n");
goto out_free;
}

@@ -321,7 +321,7 @@ static int wl12xx_cmd_role_start_dev(struct wl1271 *wl,
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role start dev %d", wlvif->dev_role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role start dev %d\n", wlvif->dev_role_id);

cmd->role_id = wlvif->dev_role_id;
if (wlvif->band == IEEE80211_BAND_5GHZ)
@@ -336,12 +336,12 @@ static int wl12xx_cmd_role_start_dev(struct wl1271 *wl,
cmd->device.hlid = wlvif->dev_hlid;
cmd->device.session = wl12xx_get_new_session_id(wl, wlvif);

- wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d",
+ wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d\n",
cmd->role_id, cmd->device.hlid, cmd->device.session);

ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role enable");
+ wl1271_err("failed to initiate cmd role enable\n");
goto err_hlid;
}

@@ -373,7 +373,7 @@ static int wl12xx_cmd_role_stop_dev(struct wl1271 *wl,
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role stop dev");
+ wl1271_debug(DEBUG_CMD, "cmd role stop dev\n");

cmd->role_id = wlvif->dev_role_id;
cmd->disc_type = DISCONNECT_IMMEDIATE;
@@ -381,13 +381,13 @@ static int wl12xx_cmd_role_stop_dev(struct wl1271 *wl,

ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role stop");
+ wl1271_err("failed to initiate cmd role stop\n");
goto out_free;
}

ret = wl1271_cmd_wait_for_event(wl, ROLE_STOP_COMPLETE_EVENT_ID);
if (ret < 0) {
- wl1271_error("cmd role stop dev event completion error");
+ wl1271_err("cmd role stop dev event completion error\n");
goto out_free;
}

@@ -412,7 +412,7 @@ int wl12xx_cmd_role_start_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role start sta %d", wlvif->role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role start sta %d\n", wlvif->role_id);

cmd->role_id = wlvif->role_id;
if (wlvif->band == IEEE80211_BAND_5GHZ)
@@ -436,14 +436,13 @@ int wl12xx_cmd_role_start_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
cmd->sta.session = wl12xx_get_new_session_id(wl, wlvif);
cmd->sta.remote_rates = cpu_to_le32(wlvif->rate_set);

- wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d "
- "basic_rate_set: 0x%x, remote_rates: 0x%x",
+ wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d basic_rate_set: 0x%x, remote_rates: 0x%x\n",
wlvif->role_id, cmd->sta.hlid, cmd->sta.session,
wlvif->basic_rate_set, wlvif->rate_set);

ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role start sta");
+ wl1271_err("failed to initiate cmd role start sta\n");
goto err_hlid;
}

@@ -475,7 +474,7 @@ int wl12xx_cmd_role_stop_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role stop sta %d", wlvif->role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role stop sta %d\n", wlvif->role_id);

cmd->role_id = wlvif->role_id;
cmd->disc_type = DISCONNECT_IMMEDIATE;
@@ -483,7 +482,7 @@ int wl12xx_cmd_role_stop_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif)

ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role stop sta");
+ wl1271_err("failed to initiate cmd role stop sta\n");
goto out_free;
}

@@ -504,11 +503,11 @@ int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
u32 supported_rates;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd role start ap %d", wlvif->role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role start ap %d\n", wlvif->role_id);

/* trying to use hidden SSID with an old hostapd version */
if (wlvif->ssid_len == 0 && !bss_conf->hidden_ssid) {
- wl1271_error("got a null SSID from beacon/bss");
+ wl1271_err("got a null SSID from beacon/bss\n");
ret = -EINVAL;
goto out;
}
@@ -555,7 +554,7 @@ int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
supported_rates = CONF_TX_AP_ENABLED_RATES | CONF_TX_MCS_RATES |
wlcore_hw_ap_get_mimo_wide_rate_mask(wl, wlvif);

- wl1271_debug(DEBUG_CMD, "cmd role start ap with supported_rates 0x%08x",
+ wl1271_debug(DEBUG_CMD, "cmd role start ap with supported_rates 0x%08x\n",
supported_rates);

cmd->ap.local_rates = cpu_to_le32(supported_rates);
@@ -568,14 +567,14 @@ int wl12xx_cmd_role_start_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
cmd->band = WLCORE_BAND_5GHZ;
break;
default:
- wl1271_warning("ap start - unknown band: %d", (int)wlvif->band);
+ wl1271_warn("ap start - unknown band: %d\n", (int)wlvif->band);
cmd->band = WLCORE_BAND_2_4GHZ;
break;
}

ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role start ap");
+ wl1271_err("failed to initiate cmd role start ap\n");
goto out_free_bcast;
}

@@ -605,13 +604,13 @@ int wl12xx_cmd_role_stop_ap(struct wl1271 *wl, struct wl12xx_vif *wlvif)
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role stop ap %d", wlvif->role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role stop ap %d\n", wlvif->role_id);

cmd->role_id = wlvif->role_id;

ret = wl1271_cmd_send(wl, CMD_ROLE_STOP, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role stop ap");
+ wl1271_err("failed to initiate cmd role stop ap\n");
goto out_free;
}

@@ -638,7 +637,7 @@ int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif)
goto out;
}

- wl1271_debug(DEBUG_CMD, "cmd role start ibss %d", wlvif->role_id);
+ wl1271_debug(DEBUG_CMD, "cmd role start ibss %d\n", wlvif->role_id);

cmd->role_id = wlvif->role_id;
if (wlvif->band == IEEE80211_BAND_5GHZ)
@@ -661,17 +660,16 @@ int wl12xx_cmd_role_start_ibss(struct wl1271 *wl, struct wl12xx_vif *wlvif)
cmd->ibss.hlid = wlvif->sta.hlid;
cmd->ibss.remote_rates = cpu_to_le32(wlvif->rate_set);

- wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d "
- "basic_rate_set: 0x%x, remote_rates: 0x%x",
+ wl1271_debug(DEBUG_CMD, "role start: roleid=%d, hlid=%d, session=%d basic_rate_set: 0x%x, remote_rates: 0x%x\n",
wlvif->role_id, cmd->sta.hlid, cmd->sta.session,
wlvif->basic_rate_set, wlvif->rate_set);

- wl1271_debug(DEBUG_CMD, "vif->bss_conf.bssid = %pM",
+ wl1271_debug(DEBUG_CMD, "vif->bss_conf.bssid = %pM\n",
vif->bss_conf.bssid);

ret = wl1271_cmd_send(wl, CMD_ROLE_START, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd role enable");
+ wl1271_err("failed to initiate cmd role enable\n");
goto err_hlid;
}

@@ -702,7 +700,7 @@ int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer)
int ret;
size_t res_len = 0;

- wl1271_debug(DEBUG_CMD, "cmd test");
+ wl1271_debug(DEBUG_CMD, "cmd test\n");

if (answer)
res_len = buf_len;
@@ -710,7 +708,7 @@ int wl1271_cmd_test(struct wl1271 *wl, void *buf, size_t buf_len, u8 answer)
ret = wl1271_cmd_send(wl, CMD_TEST, buf, buf_len, res_len);

if (ret < 0) {
- wl1271_warning("TEST command failed");
+ wl1271_warn("TEST command failed\n");
return ret;
}

@@ -731,7 +729,7 @@ int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len)
struct acx_header *acx = buf;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd interrogate");
+ wl1271_debug(DEBUG_CMD, "cmd interrogate\n");

acx->id = cpu_to_le16(id);

@@ -740,7 +738,7 @@ int wl1271_cmd_interrogate(struct wl1271 *wl, u16 id, void *buf, size_t len)

ret = wl1271_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx), len);
if (ret < 0)
- wl1271_error("INTERROGATE command failed");
+ wl1271_err("INTERROGATE command failed\n");

return ret;
}
@@ -758,7 +756,7 @@ int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len)
struct acx_header *acx = buf;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd configure (%d)", id);
+ wl1271_debug(DEBUG_CMD, "cmd configure (%d)\n", id);

acx->id = cpu_to_le16(id);

@@ -767,7 +765,7 @@ int wl1271_cmd_configure(struct wl1271 *wl, u16 id, void *buf, size_t len)

ret = wl1271_cmd_send(wl, CMD_CONFIGURE, acx, len, 0);
if (ret < 0) {
- wl1271_warning("CONFIGURE command NOK");
+ wl1271_warn("CONFIGURE command NOK\n");
return ret;
}

@@ -781,7 +779,7 @@ int wl1271_cmd_data_path(struct wl1271 *wl, bool enable)
int ret;
u16 cmd_rx, cmd_tx;

- wl1271_debug(DEBUG_CMD, "cmd data path");
+ wl1271_debug(DEBUG_CMD, "cmd data path\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -802,22 +800,22 @@ int wl1271_cmd_data_path(struct wl1271 *wl, bool enable)

ret = wl1271_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("rx %s cmd for channel %d failed",
- enable ? "start" : "stop", cmd->channel);
+ wl1271_err("rx %s cmd for channel %d failed\n",
+ enable ? "start" : "stop", cmd->channel);
goto out;
}

- wl1271_debug(DEBUG_BOOT, "rx %s cmd channel %d",
+ wl1271_debug(DEBUG_BOOT, "rx %s cmd channel %d\n",
enable ? "start" : "stop", cmd->channel);

ret = wl1271_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("tx %s cmd for channel %d failed",
- enable ? "start" : "stop", cmd->channel);
+ wl1271_err("tx %s cmd for channel %d failed\n",
+ enable ? "start" : "stop", cmd->channel);
goto out;
}

- wl1271_debug(DEBUG_BOOT, "tx %s cmd channel %d",
+ wl1271_debug(DEBUG_BOOT, "tx %s cmd channel %d\n",
enable ? "start" : "stop", cmd->channel);

out:
@@ -832,7 +830,7 @@ int wl1271_cmd_ps_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_cmd_ps_params *ps_params = NULL;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd set ps mode");
+ wl1271_debug(DEBUG_CMD, "cmd set ps mode\n");

ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
if (!ps_params) {
@@ -847,7 +845,7 @@ int wl1271_cmd_ps_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = wl1271_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
sizeof(*ps_params), 0);
if (ret < 0) {
- wl1271_error("cmd set_ps_mode failed");
+ wl1271_err("cmd set_ps_mode failed\n");
goto out;
}

@@ -863,7 +861,7 @@ int wl1271_cmd_template_set(struct wl1271 *wl, u8 role_id,
struct wl1271_cmd_template_set *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd template_set %d (role %d)",
+ wl1271_debug(DEBUG_CMD, "cmd template_set %d (role %d)\n",
template_id, role_id);

WARN_ON(buf_len > WL1271_CMD_TEMPL_MAX_SIZE);
@@ -889,7 +887,7 @@ int wl1271_cmd_template_set(struct wl1271 *wl, u8 role_id,

ret = wl1271_cmd_send(wl, CMD_SET_TEMPLATE, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_warning("cmd set_template failed: %d", ret);
+ wl1271_warn("cmd set_template failed: %d\n", ret);
goto out_free;
}

@@ -927,7 +925,7 @@ int wl12xx_cmd_build_null_data(struct wl1271 *wl, struct wl12xx_vif *wlvif)
out:
dev_kfree_skb(skb);
if (ret)
- wl1271_warning("cmd buld null data failed %d", ret);
+ wl1271_warn("cmd buld null data failed %d\n", ret);

return ret;

@@ -952,7 +950,7 @@ int wl12xx_cmd_build_klv_null_data(struct wl1271 *wl,
out:
dev_kfree_skb(skb);
if (ret)
- wl1271_warning("cmd build klv null data failed %d", ret);
+ wl1271_warn("cmd build klv null data failed %d\n", ret);

return ret;

@@ -1038,7 +1036,7 @@ struct sk_buff *wl1271_cmd_build_ap_probe_req(struct wl1271 *wl,
skb->data, skb->len, 0, rate);

if (ret < 0)
- wl1271_error("Unable to set ap probe request template.");
+ wl1271_err("Unable to set ap probe request template\n");

out:
return skb;
@@ -1057,7 +1055,7 @@ int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, struct wl12xx_vif *wlvif)
skb = dev_alloc_skb(sizeof(*hdr) + sizeof(__le16) + sizeof(*tmpl) +
WL1271_EXTRA_SPACE_MAX);
if (!skb) {
- wl1271_error("failed to allocate buffer for arp rsp template");
+ wl1271_err("failed to allocate buffer for arp rsp template\n");
return -ENOMEM;
}

@@ -1097,8 +1095,8 @@ int wl1271_cmd_build_arp_rsp(struct wl1271 *wl, struct wl12xx_vif *wlvif)
extra = 0;
break;
default:
- wl1271_warning("Unknown encryption type: %d",
- wlvif->encryption_type);
+ wl1271_warn("Unknown encryption type: %d\n",
+ wlvif->encryption_type);
ret = -EINVAL;
goto out;
}
@@ -1165,7 +1163,7 @@ int wl12xx_cmd_set_default_wep_key(struct wl1271 *wl, u8 id, u8 hlid)
struct wl1271_cmd_set_keys *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d", id);
+ wl1271_debug(DEBUG_CMD, "cmd set_default_wep_key %d\n", id);

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1181,7 +1179,7 @@ int wl12xx_cmd_set_default_wep_key(struct wl1271 *wl, u8 id, u8 hlid)

ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_warning("cmd set_default_wep_key failed: %d", ret);
+ wl1271_warn("cmd set_default_wep_key failed: %d\n", ret);
goto out;
}

@@ -1246,7 +1244,7 @@ int wl1271_cmd_set_sta_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_warning("could not set keys");
+ wl1271_warn("could not set keys\n");
goto out;
}

@@ -1282,8 +1280,8 @@ int wl1271_cmd_set_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
lid_type = UNICAST_LID_TYPE;
}

- wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d"
- " hlid: %d", (int)action, (int)id, (int)lid_type,
+ wl1271_debug(DEBUG_CRYPT, "ap key action: %d id: %d lid: %d type: %d hlid: %d\n",
+ (int)action, (int)id, (int)lid_type,
(int)key_type, (int)hlid);

cmd->lid_key_type = lid_type;
@@ -1313,7 +1311,7 @@ int wl1271_cmd_set_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_send(wl, CMD_SET_KEYS, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_warning("could not set ap keys");
+ wl1271_warn("could not set ap keys\n");
goto out;
}

@@ -1327,7 +1325,7 @@ int wl12xx_cmd_set_peer_state(struct wl1271 *wl, u8 hlid)
struct wl12xx_cmd_set_peer_state *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd set peer state (hlid=%d)", hlid);
+ wl1271_debug(DEBUG_CMD, "cmd set peer state (hlid=%d)\n", hlid);

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1340,7 +1338,7 @@ int wl12xx_cmd_set_peer_state(struct wl1271 *wl, u8 hlid)

ret = wl1271_cmd_send(wl, CMD_SET_PEER_STATE, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send set peer state command");
+ wl1271_err("failed to send set peer state command\n");
goto out_free;
}

@@ -1358,7 +1356,7 @@ int wl12xx_cmd_add_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif,
int i, ret;
u32 sta_rates;

- wl1271_debug(DEBUG_CMD, "cmd add peer %d", (int)hlid);
+ wl1271_debug(DEBUG_CMD, "cmd add peer %d\n", (int)hlid);

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1392,12 +1390,12 @@ int wl12xx_cmd_add_peer(struct wl1271 *wl, struct wl12xx_vif *wlvif,
cpu_to_le32(wl1271_tx_enabled_rates_get(wl, sta_rates,
wlvif->band));

- wl1271_debug(DEBUG_CMD, "new peer rates=0x%x queues=0x%x",
+ wl1271_debug(DEBUG_CMD, "new peer rates=0x%x queues=0x%x\n",
cmd->supported_rates, sta->uapsd_queues);

ret = wl1271_cmd_send(wl, CMD_ADD_PEER, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd add peer");
+ wl1271_err("failed to initiate cmd add peer\n");
goto out_free;
}

@@ -1413,7 +1411,7 @@ int wl12xx_cmd_remove_peer(struct wl1271 *wl, u8 hlid)
struct wl12xx_cmd_remove_peer *cmd;
int ret;

- wl1271_debug(DEBUG_CMD, "cmd remove peer %d", (int)hlid);
+ wl1271_debug(DEBUG_CMD, "cmd remove peer %d\n", (int)hlid);

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1428,7 +1426,7 @@ int wl12xx_cmd_remove_peer(struct wl1271 *wl, u8 hlid)

ret = wl1271_cmd_send(wl, CMD_REMOVE_PEER, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to initiate cmd remove peer");
+ wl1271_err("failed to initiate cmd remove peer\n");
goto out_free;
}

@@ -1451,7 +1449,7 @@ int wl12xx_cmd_config_fwlog(struct wl1271 *wl)
struct wl12xx_cmd_config_fwlog *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd config firmware logger");
+ wl1271_debug(DEBUG_CMD, "cmd config firmware logger\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1467,7 +1465,7 @@ int wl12xx_cmd_config_fwlog(struct wl1271 *wl)

ret = wl1271_cmd_send(wl, CMD_CONFIG_FWLOGGER, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send config firmware logger command");
+ wl1271_err("failed to send config firmware logger command\n");
goto out_free;
}

@@ -1483,7 +1481,7 @@ int wl12xx_cmd_start_fwlog(struct wl1271 *wl)
struct wl12xx_cmd_start_fwlog *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd start firmware logger");
+ wl1271_debug(DEBUG_CMD, "cmd start firmware logger\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1493,7 +1491,7 @@ int wl12xx_cmd_start_fwlog(struct wl1271 *wl)

ret = wl1271_cmd_send(wl, CMD_START_FWLOGGER, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send start firmware logger command");
+ wl1271_err("failed to send start firmware logger command\n");
goto out_free;
}

@@ -1509,7 +1507,7 @@ int wl12xx_cmd_stop_fwlog(struct wl1271 *wl)
struct wl12xx_cmd_stop_fwlog *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd stop firmware logger");
+ wl1271_debug(DEBUG_CMD, "cmd stop firmware logger\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1519,7 +1517,7 @@ int wl12xx_cmd_stop_fwlog(struct wl1271 *wl)

ret = wl1271_cmd_send(wl, CMD_STOP_FWLOGGER, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send stop firmware logger command");
+ wl1271_err("failed to send stop firmware logger command\n");
goto out_free;
}

@@ -1536,7 +1534,7 @@ static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl12xx_cmd_roc *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd roc %d (%d)", wlvif->channel, role_id);
+ wl1271_debug(DEBUG_CMD, "cmd roc %d (%d)\n", wlvif->channel, role_id);

if (WARN_ON(role_id == WL12XX_INVALID_ROLE_ID))
return -EINVAL;
@@ -1557,7 +1555,7 @@ static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
cmd->band = WLCORE_BAND_5GHZ;
break;
default:
- wl1271_error("roc - unknown band: %d", (int)wlvif->band);
+ wl1271_err("roc - unknown band: %d\n", (int)wlvif->band);
ret = -EINVAL;
goto out_free;
}
@@ -1565,7 +1563,7 @@ static int wl12xx_cmd_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif,

ret = wl1271_cmd_send(wl, CMD_REMAIN_ON_CHANNEL, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send ROC command");
+ wl1271_err("failed to send ROC command\n");
goto out_free;
}

@@ -1581,7 +1579,7 @@ static int wl12xx_cmd_croc(struct wl1271 *wl, u8 role_id)
struct wl12xx_cmd_croc *cmd;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd croc (%d)", role_id);
+ wl1271_debug(DEBUG_CMD, "cmd croc (%d)\n", role_id);

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1593,7 +1591,7 @@ static int wl12xx_cmd_croc(struct wl1271 *wl, u8 role_id)
ret = wl1271_cmd_send(wl, CMD_CANCEL_REMAIN_ON_CHANNEL, cmd,
sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send ROC command");
+ wl1271_err("failed to send ROC command\n");
goto out_free;
}

@@ -1623,7 +1621,7 @@ int wl12xx_roc(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 role_id)
ret = wl1271_cmd_wait_for_event(wl,
REMAIN_ON_CHANNEL_COMPLETE_EVENT_ID);
if (ret < 0) {
- wl1271_error("cmd roc event completion error");
+ wl1271_err("cmd roc event completion error\n");
goto out;
}
}
@@ -1664,7 +1662,7 @@ int wl12xx_cmd_channel_switch(struct wl1271 *wl,
struct wl12xx_cmd_channel_switch *cmd;
int ret;

- wl1271_debug(DEBUG_ACX, "cmd channel switch");
+ wl1271_debug(DEBUG_ACX, "cmd channel switch\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1682,7 +1680,7 @@ int wl12xx_cmd_channel_switch(struct wl1271 *wl,

ret = wl1271_cmd_send(wl, CMD_CHANNEL_SWITCH, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to send channel switch command");
+ wl1271_err("failed to send channel switch command\n");
goto out_free;
}

@@ -1698,7 +1696,7 @@ int wl12xx_cmd_stop_channel_switch(struct wl1271 *wl)
struct wl12xx_cmd_stop_channel_switch *cmd;
int ret;

- wl1271_debug(DEBUG_ACX, "cmd stop channel switch");
+ wl1271_debug(DEBUG_ACX, "cmd stop channel switch\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -1708,7 +1706,7 @@ int wl12xx_cmd_stop_channel_switch(struct wl1271 *wl)

ret = wl1271_cmd_send(wl, CMD_STOP_CHANNEL_SWICTH, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("failed to stop channel switch command");
+ wl1271_err("failed to stop channel switch command\n");
goto out_free;
}

diff --git a/drivers/net/wireless/ti/wlcore/debug.h b/drivers/net/wireless/ti/wlcore/debug.h
index 6b800b3..83b72c2 100644
--- a/drivers/net/wireless/ti/wlcore/debug.h
+++ b/drivers/net/wireless/ti/wlcore/debug.h
@@ -61,22 +61,22 @@ extern u32 wl12xx_debug_level;

#define DEBUG_DUMP_LIMIT 1024

-#define wl1271_error(fmt, arg...) \
- pr_err(DRIVER_PREFIX "ERROR " fmt "\n", ##arg)
+#define wl1271_err(fmt, arg...) \
+ pr_err(DRIVER_PREFIX "ERROR " fmt, ##arg)

-#define wl1271_warning(fmt, arg...) \
- pr_warning(DRIVER_PREFIX "WARNING " fmt "\n", ##arg)
+#define wl1271_warn(fmt, arg...) \
+ pr_warn(DRIVER_PREFIX "WARNING " fmt, ##arg)

-#define wl1271_notice(fmt, arg...) \
- pr_info(DRIVER_PREFIX fmt "\n", ##arg)
+#define wl1271_notice(fmt, arg...) \
+ pr_info(DRIVER_PREFIX fmt, ##arg)

-#define wl1271_info(fmt, arg...) \
- pr_info(DRIVER_PREFIX fmt "\n", ##arg)
+#define wl1271_info(fmt, arg...) \
+ pr_info(DRIVER_PREFIX fmt, ##arg)

-#define wl1271_debug(level, fmt, arg...) \
- do { \
+#define wl1271_debug(level, fmt, arg...) \
+ do { \
if (level & wl12xx_debug_level) \
- pr_debug(DRIVER_PREFIX fmt "\n", ##arg); \
+ pr_debug(DRIVER_PREFIX fmt, ##arg); \
} while (0)

/* TODO: use pr_debug_hex_dump when it becomes available */
diff --git a/drivers/net/wireless/ti/wlcore/debugfs.c b/drivers/net/wireless/ti/wlcore/debugfs.c
index 689a847..d5bbc9a 100644
--- a/drivers/net/wireless/ti/wlcore/debugfs.c
+++ b/drivers/net/wireless/ti/wlcore/debugfs.c
@@ -109,7 +109,7 @@ static void chip_op_handler(struct wl1271 *wl, unsigned long value,
int (*chip_op) (struct wl1271 *wl);

if (!arg) {
- wl1271_warning("debugfs chip_op_handler with no callback");
+ wl1271_warn("debugfs chip_op_handler with no callback\n");
return;
}

@@ -153,12 +153,12 @@ static inline void no_write_handler(struct wl1271 *wl,
\
ret = kstrtoul_from_user(user_buf, count, 10, &value); \
if (ret < 0) { \
- wl1271_warning("illegal value for " #param); \
+ wl1271_warn("illegal value for " #param); \
return -EINVAL; \
} \
\
if (value < min_val || value > max_val) { \
- wl1271_warning(#param " is not in valid range"); \
+ wl1271_warn(#param " is not in valid range"); \
return -ERANGE; \
} \
\
@@ -209,7 +209,7 @@ static ssize_t gpio_power_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in gpio_power");
+ wl1271_warn("illegal value in gpio_power\n");
return -EINVAL;
}

@@ -271,12 +271,12 @@ static ssize_t dynamic_ps_timeout_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in dynamic_ps");
+ wl1271_warn("illegal value in dynamic_ps\n");
return -EINVAL;
}

if (value < 1 || value > 65535) {
- wl1271_warning("dyanmic_ps_timeout is not in valid range");
+ wl1271_warn("dyanmic_ps_timeout is not in valid range\n");
return -ERANGE;
}

@@ -335,12 +335,12 @@ static ssize_t forced_ps_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in forced_ps");
+ wl1271_warn("illegal value in forced_ps\n");
return -EINVAL;
}

if (value != 1 && value != 0) {
- wl1271_warning("forced_ps should be either 0 or 1");
+ wl1271_warn("forced_ps should be either 0 or 1\n");
return -ERANGE;
}

@@ -403,12 +403,12 @@ static ssize_t split_scan_timeout_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in split_scan_timeout");
+ wl1271_warn("illegal value in split_scan_timeout\n");
return -EINVAL;
}

if (value == 0)
- wl1271_info("split scan will be disabled");
+ wl1271_info("split scan will be disabled\n");

mutex_lock(&wl->mutex);

@@ -641,12 +641,12 @@ static ssize_t dtim_interval_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value for dtim_interval");
+ wl1271_warn("illegal value for dtim_interval\n");
return -EINVAL;
}

if (value < 1 || value > 10) {
- wl1271_warning("dtim value is not in valid range");
+ wl1271_warn("dtim value is not in valid range\n");
return -ERANGE;
}

@@ -702,12 +702,12 @@ static ssize_t suspend_dtim_interval_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value for suspend_dtim_interval");
+ wl1271_warn("illegal value for suspend_dtim_interval\n");
return -EINVAL;
}

if (value < 1 || value > 10) {
- wl1271_warning("suspend_dtim value is not in valid range");
+ wl1271_warn("suspend_dtim value is not in valid range\n");
return -ERANGE;
}

@@ -757,12 +757,12 @@ static ssize_t beacon_interval_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value for beacon_interval");
+ wl1271_warn("illegal value for beacon_interval\n");
return -EINVAL;
}

if (value < 1 || value > 255) {
- wl1271_warning("beacon interval value is not in valid range");
+ wl1271_warn("beacon interval value is not in valid range\n");
return -ERANGE;
}

@@ -801,13 +801,13 @@ static ssize_t rx_streaming_interval_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in rx_streaming_interval!");
+ wl1271_warn("illegal value in rx_streaming_interval!\n");
return -EINVAL;
}

/* valid values: 0, 10-100 */
if (value && (value < 10 || value > 100)) {
- wl1271_warning("value is not in range!");
+ wl1271_warn("value is not in range!\n");
return -ERANGE;
}

@@ -856,13 +856,13 @@ static ssize_t rx_streaming_always_write(struct file *file,

ret = kstrtoul_from_user(user_buf, count, 10, &value);
if (ret < 0) {
- wl1271_warning("illegal value in rx_streaming_write!");
+ wl1271_warn("illegal value in rx_streaming_write!\n");
return -EINVAL;
}

/* valid values: 0, 10-100 */
if (!(value == 0 || value == 1)) {
- wl1271_warning("value is not in valid!");
+ wl1271_warn("value is not in valid!\n");
return -EINVAL;
}

@@ -918,7 +918,7 @@ static ssize_t beacon_filtering_write(struct file *file,

ret = kstrtoul(buf, 0, &value);
if (ret < 0) {
- wl1271_warning("illegal value for beacon_filtering!");
+ wl1271_warn("illegal value for beacon_filtering!\n");
return -EINVAL;
}

diff --git a/drivers/net/wireless/ti/wlcore/event.c b/drivers/net/wireless/ti/wlcore/event.c
index c976f04..49217f7 100644
--- a/drivers/net/wireless/ti/wlcore/event.c
+++ b/drivers/net/wireless/ti/wlcore/event.c
@@ -120,15 +120,15 @@ static int wl1271_event_process(struct wl1271 *wl)
}

if (vector & PERIODIC_SCAN_REPORT_EVENT_ID) {
- wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_REPORT_EVENT "
- "(status 0x%0x)", mbox->scheduled_scan_status);
+ wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_REPORT_EVENT (status 0x%0x)\n",
+ mbox->scheduled_scan_status);

wl1271_scan_sched_scan_results(wl);
}

if (vector & PERIODIC_SCAN_COMPLETE_EVENT_ID) {
- wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_COMPLETE_EVENT "
- "(status 0x%0x)", mbox->scheduled_scan_status);
+ wl1271_debug(DEBUG_EVENT, "PERIODIC_SCAN_COMPLETE_EVENT (status 0x%0x)\n",
+ mbox->scheduled_scan_status);
if (wl->sched_scanning) {
ieee80211_sched_scan_stopped(wl->hw);
wl->sched_scanning = false;
@@ -187,8 +187,7 @@ static int wl1271_event_process(struct wl1271 *wl)

if (vector & BA_SESSION_RX_CONSTRAINT_EVENT_ID) {
u8 role_id = mbox->role_id;
- wl1271_debug(DEBUG_EVENT, "BA_SESSION_RX_CONSTRAINT_EVENT_ID. "
- "ba_allowed = 0x%x, role_id=%d",
+ wl1271_debug(DEBUG_EVENT, "BA_SESSION_RX_CONSTRAINT_EVENT_ID. ba_allowed = 0x%x, role_id=%d\n",
mbox->rx_ba_allowed, role_id);

wl12xx_for_each_wlvif(wl, wlvif) {
@@ -202,9 +201,8 @@ static int wl1271_event_process(struct wl1271 *wl)
}

if (vector & CHANNEL_SWITCH_COMPLETE_EVENT_ID) {
- wl1271_debug(DEBUG_EVENT, "CHANNEL_SWITCH_COMPLETE_EVENT_ID. "
- "status = 0x%x",
- mbox->channel_switch_status);
+ wl1271_debug(DEBUG_EVENT, "CHANNEL_SWITCH_COMPLETE_EVENT_ID. status = 0x%x\n",
+ mbox->channel_switch_status);
/*
* That event uses for two cases:
* 1) channel switch complete with status=0
diff --git a/drivers/net/wireless/ti/wlcore/main.c b/drivers/net/wireless/ti/wlcore/main.c
index 1156e3f..3795568 100644
--- a/drivers/net/wireless/ti/wlcore/main.c
+++ b/drivers/net/wireless/ti/wlcore/main.c
@@ -85,7 +85,7 @@ static int wl12xx_set_authorized(struct wl1271 *wl,

wl12xx_croc(wl, wlvif->role_id);

- wl1271_info("Association completed.");
+ wl1271_info("Association completed\n");
return 0;
}

@@ -260,7 +260,7 @@ static void wl12xx_tx_watchdog_work(struct work_struct *work)
* time (e.g. pending Tx on the non-ROC channels)
*/
if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
- wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
+ wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC\n",
wl->conf.tx.tx_watchdog_timeout);
wl12xx_rearm_tx_watchdog_locked(wl);
goto out;
@@ -271,7 +271,7 @@ static void wl12xx_tx_watchdog_work(struct work_struct *work)
* time
*/
if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
- wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
+ wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan\n",
wl->conf.tx.tx_watchdog_timeout);
wl12xx_rearm_tx_watchdog_locked(wl);
goto out;
@@ -284,16 +284,15 @@ static void wl12xx_tx_watchdog_work(struct work_struct *work)
* stations are removed due to inactivity.
*/
if (wl->active_sta_count) {
- wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
- " %d stations",
- wl->conf.tx.tx_watchdog_timeout,
- wl->active_sta_count);
+ wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has %d stations\n",
+ wl->conf.tx.tx_watchdog_timeout,
+ wl->active_sta_count);
wl12xx_rearm_tx_watchdog_locked(wl);
goto out;
}

- wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
- wl->conf.tx.tx_watchdog_timeout);
+ wl1271_err("Tx stuck (in FW) for %d ms. Starting recovery.\n",
+ wl->conf.tx.tx_watchdog_timeout);
wl12xx_queue_recovery_work(wl);

out:
@@ -315,7 +314,7 @@ static void wlcore_adjust_conf(struct wl1271 *wl)
wl->conf.fwlog.mem_blocks = 0;
wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
} else {
- wl1271_error("Unknown fwlog parameter %s", fwlog_param);
+ wl1271_err("Unknown fwlog parameter %s\n", fwlog_param);
}
}
}
@@ -358,7 +357,7 @@ static void wl12xx_irq_update_links_status(struct wl1271 *wl,
cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
if (wl->ap_fw_ps_map != cur_fw_ps_map) {
wl1271_debug(DEBUG_PSM,
- "link ps prev 0x%x cur 0x%x changed 0x%x",
+ "link ps prev 0x%x cur 0x%x changed 0x%x\n",
wl->ap_fw_ps_map, cur_fw_ps_map,
wl->ap_fw_ps_map ^ cur_fw_ps_map);

@@ -395,8 +394,7 @@ static void wl12xx_fw_status(struct wl1271 *wl,
wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR, status_1,
status_len, false);

- wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
- "drv_rx_counter = %d, tx_results_counter = %d)",
+ wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, drv_rx_counter = %d, tx_results_counter = %d)\n",
status_1->intr,
status_1->fw_rx_counter,
status_1->drv_rx_counter,
@@ -512,7 +510,7 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)

mutex_lock(&wl->mutex);

- wl1271_debug(DEBUG_IRQ, "IRQ work");
+ wl1271_debug(DEBUG_IRQ, "IRQ work\n");

if (unlikely(wl->state == WL1271_STATE_OFF))
goto out;
@@ -542,7 +540,7 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
}

if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
- wl1271_error("HW watchdog interrupt received! starting recovery.");
+ wl1271_err("HW watchdog interrupt received! Starting recovery.\n");
wl->watchdog_recovery = true;
wl12xx_queue_recovery_work(wl);

@@ -551,8 +549,7 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
}

if (unlikely(intr & WL1271_ACX_SW_INTR_WATCHDOG)) {
- wl1271_error("SW watchdog interrupt received! "
- "starting recovery.");
+ wl1271_err("SW watchdog interrupt received! Starting recovery.\n");
wl->watchdog_recovery = true;
wl12xx_queue_recovery_work(wl);

@@ -561,7 +558,7 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
}

if (likely(intr & WL1271_ACX_INTR_DATA)) {
- wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
+ wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA\n");

wl12xx_rx(wl, wl->fw_status_1);

@@ -590,21 +587,21 @@ static irqreturn_t wl1271_irq(int irq, void *cookie)
}

if (intr & WL1271_ACX_INTR_EVENT_A) {
- wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
+ wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A\n");
wl1271_event_handle(wl, 0);
}

if (intr & WL1271_ACX_INTR_EVENT_B) {
- wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
+ wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B\n");
wl1271_event_handle(wl, 1);
}

if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
wl1271_debug(DEBUG_IRQ,
- "WL1271_ACX_INTR_INIT_COMPLETE");
+ "WL1271_ACX_INTR_INIT_COMPLETE\n");

if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
- wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
+ wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE\n");
}

wl1271_ps_elp_sleep(wl);
@@ -679,18 +676,18 @@ static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
if (wl->fw_type == fw_type)
return 0;

- wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
+ wl1271_debug(DEBUG_BOOT, "booting firmware %s\n", fw_name);

ret = request_firmware(&fw, fw_name, wl->dev);

if (ret < 0) {
- wl1271_error("could not get firmware %s: %d", fw_name, ret);
+ wl1271_err("could not get firmware %s: %d\n", fw_name, ret);
return ret;
}

if (fw->size % 4) {
- wl1271_error("firmware size is not multiple of 32 bits: %zu",
- fw->size);
+ wl1271_err("firmware size is not multiple of 32 bits: %zu\n",
+ fw->size);
ret = -EILSEQ;
goto out;
}
@@ -701,7 +698,7 @@ static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
wl->fw = vmalloc(wl->fw_len);

if (!wl->fw) {
- wl1271_error("could not allocate memory for the firmware");
+ wl1271_err("could not allocate memory for the firmware\n");
ret = -ENOMEM;
goto out;
}
@@ -723,7 +720,7 @@ static void wl1271_fetch_nvs(struct wl1271 *wl)
ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);

if (ret < 0) {
- wl1271_debug(DEBUG_BOOT, "could not get nvs file %s: %d",
+ wl1271_debug(DEBUG_BOOT, "could not get nvs file %s: %d\n",
WL12XX_NVS_NAME, ret);
return;
}
@@ -731,7 +728,7 @@ static void wl1271_fetch_nvs(struct wl1271 *wl)
wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);

if (!wl->nvs) {
- wl1271_error("could not allocate memory for the nvs file");
+ wl1271_err("could not allocate memory for the nvs file\n");
goto out;
}

@@ -781,7 +778,7 @@ static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
(wl->conf.fwlog.mem_blocks == 0))
return;

- wl1271_info("Reading FW panic log");
+ wl1271_info("Reading FW panic log\n");

block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
if (!block)
@@ -845,8 +842,7 @@ static void wl1271_recovery_work(struct work_struct *work)

/* change partitions momentarily so we can read the FW pc */
wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
- wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x "
- "hint_sts: 0x%08x",
+ wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x hint_sts: 0x%08x\n",
wl->chip.fw_ver_str,
wlcore_read_reg(wl, REG_PC_ON_RECOVERY),
wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR));
@@ -856,7 +852,7 @@ static void wl1271_recovery_work(struct work_struct *work)
!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));

if (no_recovery) {
- wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
+ wl1271_info("No recovery (chosen on module load). Fw will remain stuck.\n");
clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
goto out_unlock;
}
@@ -998,11 +994,11 @@ int wl1271_plt_start(struct wl1271 *wl)

mutex_lock(&wl->mutex);

- wl1271_notice("power up");
+ wl1271_notice("power up\n");

if (wl->state != WL1271_STATE_OFF) {
- wl1271_error("cannot go into PLT state because not "
- "in off state: %d", wl->state);
+ wl1271_err("cannot go into PLT state because not in off state: %d\n",
+ wl->state);
ret = -EBUSY;
goto out;
}
@@ -1019,7 +1015,7 @@ int wl1271_plt_start(struct wl1271 *wl)

wl->plt = true;
wl->state = WL1271_STATE_ON;
- wl1271_notice("firmware booted in PLT mode (%s)",
+ wl1271_notice("firmware booted in PLT mode (%s)\n",
wl->chip.fw_ver_str);

/* update hw/fw version info in wiphy struct */
@@ -1033,8 +1029,8 @@ power_off:
wl1271_power_off(wl);
}

- wl1271_error("firmware boot in PLT mode failed despite %d retries",
- WL1271_BOOT_RETRIES);
+ wl1271_err("firmware boot in PLT mode failed despite %d retries\n",
+ WL1271_BOOT_RETRIES);
out:
mutex_unlock(&wl->mutex);

@@ -1045,7 +1041,7 @@ int wl1271_plt_stop(struct wl1271 *wl)
{
int ret = 0;

- wl1271_notice("power down");
+ wl1271_notice("power down\n");

/*
* Interrupts must be disabled before setting the state to OFF.
@@ -1064,8 +1060,8 @@ int wl1271_plt_stop(struct wl1271 *wl)
*/
wlcore_enable_interrupts(wl);

- wl1271_error("cannot power down because not in PLT "
- "state: %d", wl->state);
+ wl1271_err("cannot power down because not in PLT state: %d\n",
+ wl->state);
ret = -EBUSY;
goto out;
}
@@ -1121,12 +1117,12 @@ static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
(wlcore_is_queue_stopped(wl, q) &&
!wlcore_is_queue_stopped_by_reason(wl, q,
WLCORE_QUEUE_STOP_REASON_WATERMARK))) {
- wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
+ wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d\n", hlid, q);
ieee80211_free_txskb(hw, skb);
goto out;
}

- wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
+ wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d\n",
hlid, q, skb->len);
skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);

@@ -1137,7 +1133,7 @@ static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
* the queue here, otherwise the queue will get too long.
*/
if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
- wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
+ wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d\n", q);
wlcore_stop_queue_locked(wl, q,
WLCORE_QUEUE_STOP_REASON_WATERMARK);
}
@@ -1200,7 +1196,7 @@ static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)

skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
if (!skb) {
- wl1271_warning("Failed to allocate a dummy packet skb");
+ wl1271_warn("Failed to allocate a dummy packet skb\n");
return NULL;
}

@@ -1233,7 +1229,7 @@ wl1271_validate_wowlan_pattern(struct cfg80211_wowlan_trig_pkt_pattern *p)
int i, pattern_len = 0;

if (!p->mask) {
- wl1271_warning("No mask in WoWLAN pattern");
+ wl1271_warn("No mask in WoWLAN pattern\n");
return -EINVAL;
}

@@ -1276,12 +1272,12 @@ wl1271_validate_wowlan_pattern(struct cfg80211_wowlan_trig_pkt_pattern *p)
}

if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
- wl1271_warning("RX Filter too complex. Too many segments");
+ wl1271_warn("RX Filter too complex. Too many segments\n");
return -EINVAL;
}

if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
- wl1271_warning("RX filter pattern is too big");
+ wl1271_warn("RX filter pattern is too big\n");
return -E2BIG;
}

@@ -1313,7 +1309,7 @@ int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
struct wl12xx_rx_filter_field *field;

if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
- wl1271_warning("Max fields per RX filter. can't alloc another");
+ wl1271_warn("Max fields per RX filter. can't alloc another\n");
return -EINVAL;
}

@@ -1321,7 +1317,7 @@ int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,

field->pattern = kzalloc(len, GFP_KERNEL);
if (!field->pattern) {
- wl1271_warning("Failed to allocate RX filter pattern");
+ wl1271_warn("Failed to allocate RX filter pattern\n");
return -ENOMEM;
}

@@ -1381,7 +1377,7 @@ static int wl1271_convert_wowlan_pattern_to_rx_filter(

filter = wl1271_rx_filter_alloc();
if (!filter) {
- wl1271_warning("Failed to alloc rx filter");
+ wl1271_warn("Failed to alloc rx filter\n");
ret = -ENOMEM;
goto err;
}
@@ -1452,7 +1448,7 @@ static int wl1271_configure_wowlan(struct wl1271 *wl,
for (i = 0; i < wow->n_patterns; i++) {
ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
if (ret) {
- wl1271_warning("Bad wowlan pattern %d", i);
+ wl1271_warn("Bad wowlan pattern %d\n", i);
return ret;
}
}
@@ -1469,8 +1465,8 @@ static int wl1271_configure_wowlan(struct wl1271 *wl,

ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
if (ret) {
- wl1271_warning("Failed to create an RX filter from "
- "wowlan pattern %d", i);
+ wl1271_warn("Failed to create an RX filter from wowlan pattern %d\n",
+ i);
goto out;
}

@@ -1506,7 +1502,7 @@ static int wl1271_configure_suspend_sta(struct wl1271 *wl,
wl->conf.conn.suspend_listen_interval);

if (ret < 0)
- wl1271_error("suspend: set wake up conditions failed: %d", ret);
+ wl1271_err("suspend: set wake up conditions failed: %d\n", ret);

wl1271_ps_elp_sleep(wl);

@@ -1568,8 +1564,8 @@ static void wl1271_configure_resume(struct wl1271 *wl,
wl->conf.conn.listen_interval);

if (ret < 0)
- wl1271_error("resume: wake up conditions failed: %d",
- ret);
+ wl1271_err("resume: wake up conditions failed: %d\n",
+ ret);

} else if (is_ap) {
ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
@@ -1596,7 +1592,7 @@ static int wl1271_op_suspend(struct ieee80211_hw *hw,
ret = wl1271_configure_suspend(wl, wlvif, wow);
if (ret < 0) {
mutex_unlock(&wl->mutex);
- wl1271_warning("couldn't prepare device to suspend");
+ wl1271_warn("couldn't prepare device to suspend\n");
return ret;
}
}
@@ -1815,7 +1811,7 @@ static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
return WL1271_ROLE_IBSS;

default:
- wl1271_error("invalid bss_type: %d", wlvif->bss_type);
+ wl1271_err("invalid bss_type: %d\n", wlvif->bss_type);
}
return WL12XX_INVALID_ROLE_TYPE;
}
@@ -1949,12 +1945,12 @@ power_off:
}

if (!booted) {
- wl1271_error("firmware boot failed despite %d retries",
- WL1271_BOOT_RETRIES);
+ wl1271_err("firmware boot failed despite %d retries\n",
+ WL1271_BOOT_RETRIES);
goto out;
}

- wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
+ wl1271_info("firmware booted (%s)\n", wl->chip.fw_ver_str);

/* update hw/fw version info in wiphy struct */
wiphy->hw_version = wl->chip.id;
@@ -2156,7 +2152,7 @@ static void __wl1271_op_remove_interface(struct wl1271 *wl,
if (wl->state != WL1271_STATE_ON)
return;

- wl1271_info("down");
+ wl1271_info("down\n");

if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
wl->scan_vif == vif) {
@@ -2314,7 +2310,7 @@ static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
* users who really like to roam a lot :)
*/
if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
- wl1271_info("JOIN while associated.");
+ wl1271_info("JOIN while associated\n");

/* clear encryption type */
wlvif->encryption_type = KEY_NONE;
@@ -2456,8 +2452,8 @@ static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
if (is_ap) {
ret = wl1271_init_ap_rates(wl, wlvif);
if (ret < 0)
- wl1271_error("AP rate policy change failed %d",
- ret);
+ wl1271_err("AP rate policy change failed %d\n",
+ ret);
} else {
/*
* FIXME: the mac80211 should really provide a fixed
@@ -2473,8 +2469,8 @@ static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
wlvif->basic_rate_set);
ret = wl1271_acx_sta_rate_policies(wl, wlvif);
if (ret < 0)
- wl1271_warning("rate policy for channel "
- "failed %d", ret);
+ wl1271_warn("rate policy for channel failed %d\n",
+ ret);

/*
* change the ROC channel. do it only if we are
@@ -2513,23 +2509,23 @@ static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ps_mode_str = "auto";
}

- wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
+ wl1271_debug(DEBUG_PSM, "%s ps enabled\n", ps_mode_str);

ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);

if (ret < 0)
- wl1271_warning("enter %s ps failed %d",
- ps_mode_str, ret);
+ wl1271_warn("enter %s ps failed %d\n",
+ ps_mode_str, ret);

} else if (!(conf->flags & IEEE80211_CONF_PS) &&
test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {

- wl1271_debug(DEBUG_PSM, "auto ps disabled");
+ wl1271_debug(DEBUG_PSM, "auto ps disabled\n");

ret = wl1271_ps_set_mode(wl, wlvif,
STATION_ACTIVE_MODE);
if (ret < 0)
- wl1271_warning("exit auto ps failed %d", ret);
+ wl1271_warn("exit auto ps failed %d\n", ret);
}
}

@@ -2553,13 +2549,12 @@ static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)

channel = ieee80211_frequency_to_channel(conf->channel->center_freq);

- wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
- " changed 0x%x",
+ wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s changed 0x%x\n",
channel,
conf->flags & IEEE80211_CONF_PS ? "on" : "off",
conf->power_level,
conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
- changed);
+ changed);

/*
* mac80211 will go to idle nearly immediately after transmitting some
@@ -2624,7 +2619,7 @@ static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,

fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
if (!fp) {
- wl1271_error("Out of memory setting filters.");
+ wl1271_err("Out of memory setting filters\n");
return 0;
}

@@ -2661,8 +2656,8 @@ static void wl1271_op_configure_filter(struct ieee80211_hw *hw,

int ret;

- wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
- " total %x", changed, *total);
+ wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x total %x\n",
+ changed, *total);

mutex_lock(&wl->mutex);

@@ -2714,7 +2709,7 @@ static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
struct wl1271_ap_key *ap_key;
int i;

- wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
+ wl1271_debug(DEBUG_CRYPT, "record ap key id %d\n", (int)id);

if (key_size > MAX_KEY_SIZE)
return -EINVAL;
@@ -2728,7 +2723,7 @@ static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
break;

if (wlvif->ap.recorded_keys[i]->id == id) {
- wl1271_warning("trying to record key replacement");
+ wl1271_warn("trying to record key replacement\n");
return -EINVAL;
}
}
@@ -2910,8 +2905,8 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,

wl1271_debug(DEBUG_MAC80211, "mac80211 set key");

- wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
- wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
+ wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p\n", cmd, sta);
+ wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x\n",
key_conf->cipher, key_conf->keyidx,
key_conf->keylen, key_conf->flags);
wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
@@ -2954,7 +2949,7 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
break;
default:
- wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
+ wl1271_err("Unknown key algo 0x%x\n", key_conf->cipher);

ret = -EOPNOTSUPP;
goto out_sleep;
@@ -2967,7 +2962,7 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
key_conf->keylen, key_conf->key,
tx_seq_32, tx_seq_16, sta);
if (ret < 0) {
- wl1271_error("Could not add or replace key");
+ wl1271_err("Could not add or replace key\n");
goto out_sleep;
}

@@ -2981,7 +2976,7 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
wlvif->encryption_type = key_type;
ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
if (ret < 0) {
- wl1271_warning("build arp rsp failed: %d", ret);
+ wl1271_warn("build arp rsp failed: %d\n", ret);
goto out_sleep;
}
}
@@ -2993,13 +2988,13 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
key_conf->keylen, key_conf->key,
0, 0, sta);
if (ret < 0) {
- wl1271_error("Could not remove key");
+ wl1271_err("Could not remove key\n");
goto out_sleep;
}
break;

default:
- wl1271_error("Unsupported key cmd 0x%x", cmd);
+ wl1271_err("Unsupported key cmd 0x%x\n", cmd);
ret = -EOPNOTSUPP;
break;
}
@@ -3190,7 +3185,7 @@ static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)

ret = wl1271_acx_frag_threshold(wl, value);
if (ret < 0)
- wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
+ wl1271_warn("wl1271_op_set_frag_threshold failed: %d\n", ret);

wl1271_ps_elp_sleep(wl);

@@ -3220,7 +3215,7 @@ static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
wl12xx_for_each_wlvif(wl, wlvif) {
ret = wl1271_acx_rts_threshold(wl, wlvif, value);
if (ret < 0)
- wl1271_warning("set rts threshold failed: %d", ret);
+ wl1271_warn("set rts threshold failed: %d\n", ret);
}
wl1271_ps_elp_sleep(wl);

@@ -3239,13 +3234,13 @@ static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
skb->len - offset);

if (!ptr) {
- wl1271_error("No SSID in IEs!");
+ wl1271_err("No SSID in IEs!\n");
return -ENOENT;
}

ssid_len = ptr[1];
if (ssid_len > IEEE80211_MAX_SSID_LEN) {
- wl1271_error("SSID is too long!");
+ wl1271_err("SSID is too long!\n");
return -EINVAL;
}

@@ -3306,7 +3301,7 @@ static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
if (ret < 0)
goto out;

- wl1271_debug(DEBUG_AP, "probe response updated");
+ wl1271_debug(DEBUG_AP, "probe response updated\n");
set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);

out:
@@ -3334,7 +3329,7 @@ static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
rates);

if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
- wl1271_error("probe_rsp template too big");
+ wl1271_err("probe_rsp template too big\n");
return -EINVAL;
}

@@ -3344,7 +3339,7 @@ static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
probe_rsp_len - ie_offset);
if (!ptr) {
- wl1271_error("No SSID in beacon!");
+ wl1271_err("No SSID in beacon!\n");
return -EINVAL;
}

@@ -3385,7 +3380,7 @@ static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
else
ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
if (ret < 0) {
- wl1271_warning("Set slot time failed %d", ret);
+ wl1271_warn("Set slot time failed %d\n", ret);
goto out;
}
}
@@ -3405,7 +3400,7 @@ static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
ret = wl1271_acx_cts_protect(wl, wlvif,
CTSPROTECT_DISABLE);
if (ret < 0) {
- wl1271_warning("Set ctsprotect failed %d", ret);
+ wl1271_warn("Set ctsprotect failed %d\n", ret);
goto out;
}
}
@@ -3432,7 +3427,7 @@ static int wlcore_set_beacon_template(struct wl1271 *wl,
goto out;
}

- wl1271_debug(DEBUG_MASTER, "beacon updated");
+ wl1271_debug(DEBUG_MASTER, "beacon updated\n");

ret = wl1271_ssid_set(vif, beacon, ieoffset);
if (ret < 0) {
@@ -3505,8 +3500,8 @@ static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
int ret = 0;

if ((changed & BSS_CHANGED_BEACON_INT)) {
- wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
- bss_conf->beacon_int);
+ wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d\n",
+ bss_conf->beacon_int);

wlvif->beacon_int = bss_conf->beacon_int;
}
@@ -3525,7 +3520,7 @@ static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,

out:
if (ret != 0)
- wl1271_error("beacon info change failed: %d", ret);
+ wl1271_err("beacon info change failed: %d\n", ret);
return ret;
}

@@ -3548,7 +3543,7 @@ static void wl1271_bss_info_changed_ap(struct wl1271 *wl,

ret = wl1271_init_ap_rates(wl, wlvif);
if (ret < 0) {
- wl1271_error("AP rate policy change failed %d", ret);
+ wl1271_err("AP rate policy change failed %d\n", ret);
goto out;
}

@@ -3581,7 +3576,7 @@ static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
goto out;

set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
- wl1271_debug(DEBUG_AP, "started AP");
+ wl1271_debug(DEBUG_AP, "started AP\n");
}
} else {
if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
@@ -3592,7 +3587,7 @@ static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
&wlvif->flags);
- wl1271_debug(DEBUG_AP, "stopped AP");
+ wl1271_debug(DEBUG_AP, "stopped AP\n");
}
}
}
@@ -3607,7 +3602,7 @@ static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
ret = wl1271_acx_set_ht_information(wl, wlvif,
bss_conf->ht_operation_mode);
if (ret < 0) {
- wl1271_warning("Set ht information failed %d", ret);
+ wl1271_warn("Set ht information failed %d\n", ret);
goto out;
}
}
@@ -3658,7 +3653,7 @@ static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
do_join = true;

if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
- wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
+ wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s\n",
bss_conf->enable_beacon ? "enabled" : "disabled");

do_join = true;
@@ -3667,7 +3662,7 @@ static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
if (changed & BSS_CHANGED_IDLE && !is_ibss) {
ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
if (ret < 0)
- wl1271_warning("idle mode change failed %d", ret);
+ wl1271_warn("idle mode change failed %d\n", ret);
}

if ((changed & BSS_CHANGED_CQM)) {
@@ -3829,7 +3824,7 @@ sta_not_found:
}

if (changed & BSS_CHANGED_IBSS) {
- wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
+ wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d\n",
bss_conf->ibss_joined);

if (bss_conf->ibss_joined) {
@@ -3856,7 +3851,7 @@ sta_not_found:
if (do_join) {
ret = wl1271_join(wl, wlvif, set_assoc);
if (ret < 0) {
- wl1271_warning("cmd join failed %d", ret);
+ wl1271_warn("cmd join failed %d\n", ret);
goto out;
}

@@ -3889,8 +3884,8 @@ sta_not_found:
true,
wlvif->sta.hlid);
if (ret < 0) {
- wl1271_warning("Set ht cap true failed %d",
- ret);
+ wl1271_warn("Set ht cap true failed %d\n",
+ ret);
goto out;
}
}
@@ -3901,8 +3896,8 @@ sta_not_found:
false,
wlvif->sta.hlid);
if (ret < 0) {
- wl1271_warning("Set ht cap false failed %d",
- ret);
+ wl1271_warn("Set ht cap false failed %d\n",
+ ret);
goto out;
}
}
@@ -3914,7 +3909,7 @@ sta_not_found:
ret = wl1271_acx_set_ht_information(wl, wlvif,
bss_conf->ht_operation_mode);
if (ret < 0) {
- wl1271_warning("Set ht information failed %d", ret);
+ wl1271_warn("Set ht information failed %d\n", ret);
goto out;
}
}
@@ -3937,7 +3932,7 @@ sta_not_found:
*/
ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
if (ret < 0) {
- wl1271_warning("build arp rsp failed: %d", ret);
+ wl1271_warn("build arp rsp failed: %d\n", ret);
goto out;
}

@@ -4112,14 +4107,14 @@ static int wl1271_allocate_sta(struct wl1271 *wl,

if (wl->active_sta_count >= AP_MAX_STATIONS) {
- wl1271_warning("could not allocate HLID - too much stations");
+ wl1271_warn("could not allocate HLID - too much stations\n");
return -EBUSY;
}

wl_sta = (struct wl1271_station *)sta->drv_priv;
ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
if (ret < 0) {
- wl1271_warning("could not allocate HLID - too many links");
+ wl1271_warn("could not allocate HLID - too many links\n");
return -EBUSY;
}

@@ -4344,14 +4339,14 @@ static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,

if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
ret = -EBUSY;
- wl1271_error("exceeded max RX BA sessions");
+ wl1271_err("exceeded max RX BA sessions\n");
break;
}

if (*ba_bitmap & BIT(tid)) {
ret = -EINVAL;
- wl1271_error("cannot enable RX BA session on active "
- "tid: %d", tid);
+ wl1271_err("cannot enable RX BA session on active tid: %d\n",
+ tid);
break;
}

@@ -4366,8 +4361,8 @@ static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
case IEEE80211_AMPDU_RX_STOP:
if (!(*ba_bitmap & BIT(tid))) {
ret = -EINVAL;
- wl1271_error("no active RX BA session on tid: %d",
- tid);
+ wl1271_err("no active RX BA session on tid: %d\n",
+ tid);
break;
}

@@ -4390,7 +4385,7 @@ static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
break;

default:
- wl1271_error("Incorrect ampdu action id=%x\n", action);
+ wl1271_err("Incorrect ampdu action id=%x\n", action);
ret = -EINVAL;
}

@@ -4411,8 +4406,8 @@ static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
int i, ret = 0;

wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
- mask->control[NL80211_BAND_2GHZ].legacy,
- mask->control[NL80211_BAND_5GHZ].legacy);
+ mask->control[NL80211_BAND_2GHZ].legacy,
+ mask->control[NL80211_BAND_5GHZ].legacy);

mutex_lock(&wl->mutex);

@@ -4685,13 +4680,13 @@ u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
BUG_ON(band >= 2);

if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
- wl1271_error("Illegal RX rate from HW: %d", rate);
+ wl1271_err("Illegal RX rate from HW: %d\n", rate);
return 0;
}

idx = wl->band_rate_to_idx[band][rate];
if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
- wl1271_error("Unsupported RX rate from HW: %d", rate);
+ wl1271_err("Unsupported RX rate from HW: %d\n", rate);
return 0;
}

@@ -4726,7 +4721,7 @@ static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,

ret = kstrtoul(buf, 10, &res);
if (ret < 0) {
- wl1271_warning("incorrect value written to bt_coex_mode");
+ wl1271_warn("incorrect value written to bt_coex_mode\n");
return count;
}

@@ -4853,7 +4848,7 @@ static void wl1271_connection_loss_work(struct work_struct *work)
dwork = container_of(work, struct delayed_work, work);
wl = container_of(dwork, struct wl1271, connection_loss_work);

- wl1271_info("Connection loss work.");
+ wl1271_info("Connection loss work\n");

mutex_lock(&wl->mutex);

@@ -4876,11 +4871,11 @@ static void wl12xx_derive_mac_addresses(struct wl1271 *wl,
{
int i;

- wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d",
+ wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d\n",
oui, nic, n);

if (nic + n - 1 > 0xffffff)
- wl1271_warning("NIC part of the MAC address wraps around!");
+ wl1271_warn("NIC part of the MAC address wraps around!\n");

for (i = 0; i < n; i++) {
wl->addresses[i].addr[0] = (u8)(oui >> 16);
@@ -4952,7 +4947,7 @@ static int wl1271_register_hw(struct wl1271 *wl)

ret = ieee80211_register_hw(wl->hw);
if (ret < 0) {
- wl1271_error("unable to register mac80211 hw: %d", ret);
+ wl1271_err("unable to register mac80211 hw: %d\n", ret);
goto out;
}

@@ -4960,7 +4955,7 @@ static int wl1271_register_hw(struct wl1271 *wl)

wl1271_debugfs_init(wl);

- wl1271_notice("loaded");
+ wl1271_notice("loaded\n");

out:
return ret;
@@ -5092,7 +5087,7 @@ struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size)

hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
if (!hw) {
- wl1271_error("could not alloc ieee80211_hw");
+ wl1271_err("could not alloc ieee80211_hw\n");
ret = -ENOMEM;
goto err_hw_alloc;
}
@@ -5102,7 +5097,7 @@ struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size)

wl->priv = kzalloc(priv_size, GFP_KERNEL);
if (!wl->priv) {
- wl1271_error("could not alloc wl priv");
+ wl1271_err("could not alloc wl priv\n");
ret = -ENOMEM;
goto err_priv_alloc;
}
@@ -5260,7 +5255,7 @@ static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
struct wl1271 *wl = cookie;
unsigned long flags;

- wl1271_debug(DEBUG_IRQ, "IRQ");
+ wl1271_debug(DEBUG_IRQ, "IRQ\n");

/* complete the ELP completion */
spin_lock_irqsave(&wl->wl_lock, flags);
@@ -5273,7 +5268,7 @@ static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
/* don't enqueue a work right now. mark it as pending */
set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
- wl1271_debug(DEBUG_IRQ, "should not enqueue work");
+ wl1271_debug(DEBUG_IRQ, "should not enqueue work\n");
disable_irq_nosync(wl->irq);
pm_wakeup_event(wl->dev, 0);
spin_unlock_irqrestore(&wl->wl_lock, flags);
@@ -5317,7 +5312,7 @@ int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
irqflags,
pdev->name, wl);
if (ret < 0) {
- wl1271_error("request_irq() failed: %d", ret);
+ wl1271_err("request_irq() failed: %d\n", ret);
goto out_free_hw;
}

@@ -5338,7 +5333,7 @@ int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)

ret = wl12xx_get_hw_info(wl);
if (ret < 0) {
- wl1271_error("couldn't get hw info");
+ wl1271_err("couldn't get hw info\n");
goto out;
}

@@ -5357,21 +5352,21 @@ int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
/* Create sysfs file to control bt coex state */
ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
if (ret < 0) {
- wl1271_error("failed to create sysfs file bt_coex_state");
+ wl1271_err("failed to create sysfs file bt_coex_state\n");
goto out_irq;
}

/* Create sysfs file to get HW PG version */
ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
if (ret < 0) {
- wl1271_error("failed to create sysfs file hw_pg_ver");
+ wl1271_err("failed to create sysfs file hw_pg_ver\n");
goto out_bt_coex_state;
}

/* Create sysfs file for the FW log */
ret = device_create_bin_file(wl->dev, &fwlog_attr);
if (ret < 0) {
- wl1271_error("failed to create sysfs file fwlog");
+ wl1271_err("failed to create sysfs file fwlog\n");
goto out_hw_pg_ver;
}

diff --git a/drivers/net/wireless/ti/wlcore/ps.c b/drivers/net/wireless/ti/wlcore/ps.c
index 47e81b3..eef201f4 100644
--- a/drivers/net/wireless/ti/wlcore/ps.c
+++ b/drivers/net/wireless/ti/wlcore/ps.c
@@ -39,7 +39,7 @@ void wl1271_elp_work(struct work_struct *work)
dwork = container_of(work, struct delayed_work, work);
wl = container_of(dwork, struct wl1271, elp_work);

- wl1271_debug(DEBUG_PSM, "elp work");
+ wl1271_debug(DEBUG_PSM, "elp work\n");

mutex_lock(&wl->mutex);

@@ -62,7 +62,7 @@ void wl1271_elp_work(struct work_struct *work)
goto out;
}

- wl1271_debug(DEBUG_PSM, "chip to elp");
+ wl1271_debug(DEBUG_PSM, "chip to elp\n");
wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_SLEEP);
set_bit(WL1271_FLAG_IN_ELP, &wl->flags);

@@ -122,7 +122,7 @@ int wl1271_ps_elp_wakeup(struct wl1271 *wl)
if (!test_bit(WL1271_FLAG_IN_ELP, &wl->flags))
return 0;

- wl1271_debug(DEBUG_PSM, "waking up chip from elp");
+ wl1271_debug(DEBUG_PSM, "waking up chip from elp\n");

/*
* The spinlock is required here to synchronize both the work and
@@ -141,19 +141,19 @@ int wl1271_ps_elp_wakeup(struct wl1271 *wl)
ret = wait_for_completion_timeout(
&compl, msecs_to_jiffies(WL1271_WAKEUP_TIMEOUT));
if (ret == 0) {
- wl1271_error("ELP wakeup timeout!");
+ wl1271_err("ELP wakeup timeout!\n");
wl12xx_queue_recovery_work(wl);
ret = -ETIMEDOUT;
goto err;
} else if (ret < 0) {
- wl1271_error("ELP wakeup completion error.");
+ wl1271_err("ELP wakeup completion error\n");
goto err;
}
}

clear_bit(WL1271_FLAG_IN_ELP, &wl->flags);

- wl1271_debug(DEBUG_PSM, "wakeup time: %u ms",
+ wl1271_debug(DEBUG_PSM, "wakeup time: %u ms\n",
jiffies_to_msecs(jiffies - start_time));
goto out;

@@ -176,14 +176,14 @@ int wl1271_ps_set_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
switch (mode) {
case STATION_AUTO_PS_MODE:
case STATION_POWER_SAVE_MODE:
- wl1271_debug(DEBUG_PSM, "entering psm (mode=%d,timeout=%u)",
+ wl1271_debug(DEBUG_PSM, "entering psm (mode=%d,timeout=%u)\n",
mode, timeout);

ret = wl1271_acx_wake_up_conditions(wl, wlvif,
wl->conf.conn.wake_up_event,
wl->conf.conn.listen_interval);
if (ret < 0) {
- wl1271_error("couldn't set wake up conditions");
+ wl1271_err("couldn't set wake up conditions\n");
return ret;
}

@@ -205,7 +205,7 @@ int wl1271_ps_set_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
}
break;
case STATION_ACTIVE_MODE:
- wl1271_debug(DEBUG_PSM, "leaving psm");
+ wl1271_debug(DEBUG_PSM, "leaving psm\n");

/* disable beacon early termination */
if ((wlvif->band == IEEE80211_BAND_2GHZ) &&
@@ -222,7 +222,7 @@ int wl1271_ps_set_mode(struct wl1271 *wl, struct wl12xx_vif *wlvif,
clear_bit(WLVIF_FLAG_IN_PS, &wlvif->flags);
break;
default:
- wl1271_warning("trying to set ps to unsupported mode %d", mode);
+ wl1271_warn("trying to set ps to unsupported mode %d\n", mode);
ret = -EINVAL;
}

@@ -270,15 +270,15 @@ void wl12xx_ps_link_start(struct wl1271 *wl, struct wl12xx_vif *wlvif,
if (test_bit(hlid, &wl->ap_ps_map))
return;

- wl1271_debug(DEBUG_PSM, "start mac80211 PSM on hlid %d pkts %d "
- "clean_queues %d", hlid, wl->links[hlid].allocated_pkts,
+ wl1271_debug(DEBUG_PSM, "start mac80211 PSM on hlid %d pkts %d clean_queues %d\n",
+ hlid, wl->links[hlid].allocated_pkts,
clean_queues);

rcu_read_lock();
sta = ieee80211_find_sta(vif, wl->links[hlid].addr);
if (!sta) {
- wl1271_error("could not find sta %pM for starting ps",
- wl->links[hlid].addr);
+ wl1271_err("could not find sta %pM for starting ps\n",
+ wl->links[hlid].addr);
rcu_read_unlock();
return;
}
@@ -301,15 +301,15 @@ void wl12xx_ps_link_end(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
if (!test_bit(hlid, &wl->ap_ps_map))
return;

- wl1271_debug(DEBUG_PSM, "end mac80211 PSM on hlid %d", hlid);
+ wl1271_debug(DEBUG_PSM, "end mac80211 PSM on hlid %d\n", hlid);

__clear_bit(hlid, &wl->ap_ps_map);

rcu_read_lock();
sta = ieee80211_find_sta(vif, wl->links[hlid].addr);
if (!sta) {
- wl1271_error("could not find sta %pM for ending ps",
- wl->links[hlid].addr);
+ wl1271_err("could not find sta %pM for ending ps\n",
+ wl->links[hlid].addr);
goto end;
}

diff --git a/drivers/net/wireless/ti/wlcore/rx.c b/drivers/net/wireless/ti/wlcore/rx.c
index 78200dc..99d5021 100644
--- a/drivers/net/wireless/ti/wlcore/rx.c
+++ b/drivers/net/wireless/ti/wlcore/rx.c
@@ -94,7 +94,7 @@ static void wl1271_rx_status(struct wl1271 *wl,

if (unlikely(desc_err_code == WL1271_RX_DESC_MIC_FAIL)) {
status->flag |= RX_FLAG_MMIC_ERROR;
- wl1271_warning("Michael MIC error");
+ wl1271_warn("Michael MIC error\n");
}
}
}
@@ -121,8 +121,8 @@ static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length,

pkt_data_len = wlcore_hw_get_rx_packet_len(wl, data, length);
if (!pkt_data_len) {
- wl1271_error("Invalid packet arrived from HW. length %d",
- length);
+ wl1271_err("Invalid packet arrived from HW. length %d\n",
+ length);
return -EINVAL;
}

@@ -143,22 +143,22 @@ static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length,
/* discard corrupted packets */
case WL1271_RX_DESC_DRIVER_RX_Q_FAIL:
case WL1271_RX_DESC_DECRYPT_FAIL:
- wl1271_warning("corrupted packet in RX with status: 0x%x",
- desc->status & WL1271_RX_DESC_STATUS_MASK);
+ wl1271_warn("corrupted packet in RX with status: 0x%x\n",
+ desc->status & WL1271_RX_DESC_STATUS_MASK);
return -EINVAL;
case WL1271_RX_DESC_SUCCESS:
case WL1271_RX_DESC_MIC_FAIL:
break;
default:
- wl1271_error("invalid RX descriptor status: 0x%x",
- desc->status & WL1271_RX_DESC_STATUS_MASK);
+ wl1271_err("invalid RX descriptor status: 0x%x\n",
+ desc->status & WL1271_RX_DESC_STATUS_MASK);
return -EINVAL;
}

/* skb length not including rx descriptor */
skb = __dev_alloc_skb(pkt_data_len + reserved, GFP_KERNEL);
if (!skb) {
- wl1271_error("Couldn't allocate RX frame");
+ wl1271_err("Couldn't allocate RX frame\n");
return -ENOMEM;
}

@@ -189,7 +189,7 @@ static int wl1271_rx_handle_data(struct wl1271 *wl, u8 *data, u32 length,
wlcore_hw_set_rx_csum(wl, desc, skb);

seq_num = (le16_to_cpu(hdr->seq_ctrl) & IEEE80211_SCTL_SEQ) >> 4;
- wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s seq %d hlid %d", skb,
+ wl1271_debug(DEBUG_RX, "rx skb 0x%p: %d B %s seq %d hlid %d\n", skb,
skb->len - desc->pad_len,
beacon ? "beacon" : "",
seq_num, *hlid);
@@ -228,7 +228,7 @@ void wl12xx_rx(struct wl1271 *wl, struct wl_fw_status_1 *status)
}

if (buf_size == 0) {
- wl1271_warning("received empty data");
+ wl1271_warn("received empty data\n");
break;
}

@@ -257,9 +257,8 @@ void wl12xx_rx(struct wl1271 *wl, struct wl_fw_status_1 *status)
if (hlid < WL12XX_MAX_LINKS)
__set_bit(hlid, active_hlids);
else
- WARN(1,
- "hlid exceeded WL12XX_MAX_LINKS "
- "(%d)\n", hlid);
+ WARN(1, "hlid exceeded WL12XX_MAX_LINKS (%d)\n",
+ hlid);
}

wl->rx_counter++;
@@ -288,16 +287,16 @@ int wl1271_rx_filter_enable(struct wl1271 *wl,
int ret;

if (wl->rx_filter_enabled[index] == enable) {
- wl1271_warning("Request to enable an already "
- "enabled rx filter %d", index);
+ wl1271_warn("Request to enable an already enabled rx filter %d\n",
+ index);
return 0;
}

ret = wl1271_acx_set_rx_filter(wl, index, enable, filter);

if (ret) {
- wl1271_error("Failed to %s rx data filter %d (err=%d)",
- enable ? "enable" : "disable", index, ret);
+ wl1271_err("Failed to %s rx data filter %d (err=%d)\n",
+ enable ? "enable" : "disable", index, ret);
return ret;
}

diff --git a/drivers/net/wireless/ti/wlcore/scan.c b/drivers/net/wireless/ti/wlcore/scan.c
index d9daed5..f53e6ca 100644
--- a/drivers/net/wireless/ti/wlcore/scan.c
+++ b/drivers/net/wireless/ti/wlcore/scan.c
@@ -42,7 +42,7 @@ void wl1271_scan_complete_work(struct work_struct *work)
dwork = container_of(work, struct delayed_work, work);
wl = container_of(dwork, struct wl1271, scan_complete_work);

- wl1271_debug(DEBUG_SCAN, "Scanning complete");
+ wl1271_debug(DEBUG_SCAN, "Scanning complete\n");

mutex_lock(&wl->mutex);

@@ -78,7 +78,7 @@ void wl1271_scan_complete_work(struct work_struct *work)
wl1271_ps_elp_sleep(wl);

if (wl->scan.failed) {
- wl1271_info("Scan completed due to error.");
+ wl1271_info("Scan completed due to error\n");
wl12xx_queue_recovery_work(wl);
}

@@ -114,17 +114,17 @@ static int wl1271_get_scan_channels(struct wl1271 *wl,
* marked as passive.
*/
(passive || !(flags & IEEE80211_CHAN_PASSIVE_SCAN))) {
- wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
+ wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d\n",
req->channels[i]->band,
req->channels[i]->center_freq);
- wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
+ wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X\n",
req->channels[i]->hw_value,
req->channels[i]->flags);
wl1271_debug(DEBUG_SCAN,
- "max_antenna_gain %d, max_power %d",
+ "max_antenna_gain %d, max_power %d\n",
req->channels[i]->max_antenna_gain,
req->channels[i]->max_power);
- wl1271_debug(DEBUG_SCAN, "beacon_found %d",
+ wl1271_debug(DEBUG_SCAN, "beacon_found %d\n",
req->channels[i]->beacon_found);

if (!passive) {
@@ -228,7 +228,7 @@ static int wl1271_scan_send(struct wl1271 *wl, struct ieee80211_vif *vif,
wl->scan.req->ie,
wl->scan.req->ie_len);
if (ret < 0) {
- wl1271_error("PROBE request template failed");
+ wl1271_err("PROBE request template failed\n");
goto out;
}

@@ -236,7 +236,7 @@ static int wl1271_scan_send(struct wl1271 *wl, struct ieee80211_vif *vif,
ret = wl1271_cmd_send(wl, CMD_TRIGGER_SCAN_TO, trigger,
sizeof(*trigger), 0);
if (ret < 0) {
- wl1271_error("trigger scan to failed for hw scan");
+ wl1271_err("trigger scan to failed for hw scan\n");
goto out;
}

@@ -244,7 +244,7 @@ static int wl1271_scan_send(struct wl1271 *wl, struct ieee80211_vif *vif,

ret = wl1271_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("SCAN failed");
+ wl1271_err("SCAN failed\n");
goto out;
}

@@ -332,7 +332,7 @@ void wl1271_scan_stm(struct wl1271 *wl, struct ieee80211_vif *vif)
break;

default:
- wl1271_error("invalid scan state");
+ wl1271_err("invalid scan state\n");
break;
}

@@ -387,7 +387,7 @@ int wl1271_scan_stop(struct wl1271 *wl)
if (WARN_ON(wl->scan.state == WL1271_SCAN_STATE_IDLE))
return -EINVAL;

- wl1271_debug(DEBUG_CMD, "cmd scan stop");
+ wl1271_debug(DEBUG_CMD, "cmd scan stop\n");

cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
if (!cmd) {
@@ -398,7 +398,7 @@ int wl1271_scan_stop(struct wl1271 *wl)
ret = wl1271_cmd_send(wl, CMD_STOP_SCAN, cmd,
sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("cmd stop_scan failed");
+ wl1271_err("cmd stop_scan failed\n");
goto out;
}
out:
@@ -450,15 +450,15 @@ wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
/* if radar is set, we ignore the passive flag */
(radar ||
!!(flags & IEEE80211_CHAN_PASSIVE_SCAN) == passive)) {
- wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d ",
+ wl1271_debug(DEBUG_SCAN, "band %d, center_freq %d\n",
req->channels[i]->band,
req->channels[i]->center_freq);
- wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X",
+ wl1271_debug(DEBUG_SCAN, "hw_value %d, flags %X\n",
req->channels[i]->hw_value,
req->channels[i]->flags);
- wl1271_debug(DEBUG_SCAN, "max_power %d",
+ wl1271_debug(DEBUG_SCAN, "max_power %d\n",
req->channels[i]->max_power);
- wl1271_debug(DEBUG_SCAN, "min_dwell_time %d max dwell time %d",
+ wl1271_debug(DEBUG_SCAN, "min_dwell_time %d max dwell time %d\n",
min_dwell_time_active,
max_dwell_time_active);

@@ -493,7 +493,7 @@ wl1271_scan_get_sched_scan_channels(struct wl1271 *wl,
* the passive channel list
*/
(*n_pactive_ch)++;
- wl1271_debug(DEBUG_SCAN, "n_pactive_ch = %d",
+ wl1271_debug(DEBUG_SCAN, "n_pactive_ch = %d\n",
*n_pactive_ch);
}

@@ -550,11 +550,11 @@ wl1271_scan_sched_scan_channels(struct wl1271 *wl,

cfg->n_pactive_ch = n_pactive_ch;

- wl1271_debug(DEBUG_SCAN, " 2.4GHz: active %d passive %d",
+ wl1271_debug(DEBUG_SCAN, " 2.4GHz: active %d passive %d\n",
cfg->active[0], cfg->passive[0]);
- wl1271_debug(DEBUG_SCAN, " 5GHz: active %d passive %d",
+ wl1271_debug(DEBUG_SCAN, " 5GHz: active %d passive %d\n",
cfg->active[1], cfg->passive[1]);
- wl1271_debug(DEBUG_SCAN, " DFS: %d", cfg->dfs);
+ wl1271_debug(DEBUG_SCAN, " DFS: %d\n", cfg->dfs);

return cfg->passive[0] || cfg->active[0] ||
cfg->passive[1] || cfg->active[1] || cfg->dfs ||
@@ -572,7 +572,7 @@ wl12xx_scan_sched_scan_ssid_list(struct wl1271 *wl,
struct cfg80211_ssid *ssids = req->ssids;
int ret = 0, type, i, j, n_match_ssids = 0;

- wl1271_debug(DEBUG_CMD, "cmd sched scan ssid list");
+ wl1271_debug(DEBUG_CMD, "cmd sched scan ssid list\n");

/* count the match sets that contain SSIDs */
for (i = 0; i < req->n_match_sets; i++)
@@ -655,7 +655,7 @@ wl12xx_scan_sched_scan_ssid_list(struct wl1271 *wl,
ret = wl1271_cmd_send(wl, CMD_CONNECTION_SCAN_SSID_CFG, cmd,
sizeof(*cmd), 0);
if (ret < 0) {
- wl1271_error("cmd sched scan ssid list failed");
+ wl1271_err("cmd sched scan ssid list failed\n");
goto out_free;
}

@@ -677,7 +677,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
int i, ret;
bool force_passive = !req->n_ssids;

- wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config");
+ wl1271_debug(DEBUG_CMD, "cmd sched_scan scan config\n");

cfg = kzalloc(sizeof(*cfg), GFP_KERNEL);
if (!cfg)
@@ -707,10 +707,10 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,

cfg->filter_type = ret;

- wl1271_debug(DEBUG_SCAN, "filter_type = %d", cfg->filter_type);
+ wl1271_debug(DEBUG_SCAN, "filter_type = %d\n", cfg->filter_type);

if (!wl1271_scan_sched_scan_channels(wl, req, cfg)) {
- wl1271_error("scan channel list is empty");
+ wl1271_err("scan channel list is empty\n");
ret = -EINVAL;
goto out;
}
@@ -724,7 +724,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
ies->ie[band],
ies->len[band]);
if (ret < 0) {
- wl1271_error("2.4GHz PROBE request template failed");
+ wl1271_err("2.4GHz PROBE request template failed\n");
goto out;
}
}
@@ -738,7 +738,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
ies->ie[band],
ies->len[band]);
if (ret < 0) {
- wl1271_error("5GHz PROBE request template failed");
+ wl1271_err("5GHz PROBE request template failed\n");
goto out;
}
}
@@ -748,7 +748,7 @@ int wl1271_scan_sched_scan_config(struct wl1271 *wl,
ret = wl1271_cmd_send(wl, CMD_CONNECTION_SCAN_CFG, cfg,
sizeof(*cfg), 0);
if (ret < 0) {
- wl1271_error("SCAN configuration failed");
+ wl1271_err("SCAN configuration failed\n");
goto out;
}
out:
@@ -761,7 +761,7 @@ int wl1271_scan_sched_scan_start(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct wl1271_cmd_sched_scan_start *start;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd periodic scan start");
+ wl1271_debug(DEBUG_CMD, "cmd periodic scan start\n");

if (wlvif->bss_type != BSS_TYPE_STA_BSS)
return -EOPNOTSUPP;
@@ -779,7 +779,7 @@ int wl1271_scan_sched_scan_start(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ret = wl1271_cmd_send(wl, CMD_START_PERIODIC_SCAN, start,
sizeof(*start), 0);
if (ret < 0) {
- wl1271_error("failed to send scan start command");
+ wl1271_err("failed to send scan start command\n");
goto out_free;
}

@@ -790,7 +790,7 @@ out_free:

void wl1271_scan_sched_scan_results(struct wl1271 *wl)
{
- wl1271_debug(DEBUG_SCAN, "got periodic scan results");
+ wl1271_debug(DEBUG_SCAN, "got periodic scan results\n");

ieee80211_sched_scan_results(wl->hw);
}
@@ -800,12 +800,12 @@ void wl1271_scan_sched_scan_stop(struct wl1271 *wl, struct wl12xx_vif *wlvif)
struct wl1271_cmd_sched_scan_stop *stop;
int ret = 0;

- wl1271_debug(DEBUG_CMD, "cmd periodic scan stop");
+ wl1271_debug(DEBUG_CMD, "cmd periodic scan stop\n");

/* FIXME: what to do if alloc'ing to stop fails? */
stop = kzalloc(sizeof(*stop), GFP_KERNEL);
if (!stop) {
- wl1271_error("failed to alloc memory to send sched scan stop");
+ wl1271_err("failed to alloc memory to send sched scan stop\n");
return;
}

@@ -815,7 +815,7 @@ void wl1271_scan_sched_scan_stop(struct wl1271 *wl, struct wl12xx_vif *wlvif)
ret = wl1271_cmd_send(wl, CMD_STOP_PERIODIC_SCAN, stop,
sizeof(*stop), 0);
if (ret < 0) {
- wl1271_error("failed to send sched scan stop command");
+ wl1271_err("failed to send sched scan stop command\n");
goto out_free;
}

diff --git a/drivers/net/wireless/ti/wlcore/sdio.c b/drivers/net/wireless/ti/wlcore/sdio.c
index c67ec48..b7ade55 100644
--- a/drivers/net/wireless/ti/wlcore/sdio.c
+++ b/drivers/net/wireless/ti/wlcore/sdio.c
@@ -342,8 +342,7 @@ static int wl1271_suspend(struct device *dev)
sdio_flags = sdio_get_host_pm_caps(func);

if (!(sdio_flags & MMC_PM_KEEP_POWER)) {
- dev_err(dev, "can't keep power while host "
- "is suspended\n");
+ dev_err(dev, "can't keep power while host is suspended\n");
ret = -EINVAL;
goto out;
}
diff --git a/drivers/net/wireless/ti/wlcore/testmode.c b/drivers/net/wireless/ti/wlcore/testmode.c
index 0e59ea2..05cd2de 100644
--- a/drivers/net/wireless/ti/wlcore/testmode.c
+++ b/drivers/net/wireless/ti/wlcore/testmode.c
@@ -76,7 +76,7 @@ static int wl1271_tm_cmd_test(struct wl1271 *wl, struct nlattr *tb[])
void *buf;
u8 answer = 0;

- wl1271_debug(DEBUG_TESTMODE, "testmode cmd test");
+ wl1271_debug(DEBUG_TESTMODE, "testmode cmd test\n");

if (!tb[WL1271_TM_ATTR_DATA])
return -EINVAL;
@@ -103,7 +103,7 @@ static int wl1271_tm_cmd_test(struct wl1271 *wl, struct nlattr *tb[])

ret = wl1271_cmd_test(wl, buf, buf_len, answer);
if (ret < 0) {
- wl1271_warning("testmode cmd test failed: %d", ret);
+ wl1271_warn("testmode cmd test failed: %d\n", ret);
goto out_sleep;
}

@@ -142,7 +142,7 @@ static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])
struct sk_buff *skb;
u8 ie_id;

- wl1271_debug(DEBUG_TESTMODE, "testmode cmd interrogate");
+ wl1271_debug(DEBUG_TESTMODE, "testmode cmd interrogate\n");

if (!tb[WL1271_TM_ATTR_IE_ID])
return -EINVAL;
@@ -168,7 +168,7 @@ static int wl1271_tm_cmd_interrogate(struct wl1271 *wl, struct nlattr *tb[])

ret = wl1271_cmd_interrogate(wl, ie_id, cmd, sizeof(*cmd));
if (ret < 0) {
- wl1271_warning("testmode cmd interrogate failed: %d", ret);
+ wl1271_warn("testmode cmd interrogate failed: %d\n", ret);
goto out_free;
}

@@ -205,7 +205,7 @@ static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
void *buf;
u8 ie_id;

- wl1271_debug(DEBUG_TESTMODE, "testmode cmd configure");
+ wl1271_debug(DEBUG_TESTMODE, "testmode cmd configure\n");

if (!tb[WL1271_TM_ATTR_DATA])
return -EINVAL;
@@ -224,7 +224,7 @@ static int wl1271_tm_cmd_configure(struct wl1271 *wl, struct nlattr *tb[])
mutex_unlock(&wl->mutex);

if (ret < 0) {
- wl1271_warning("testmode cmd configure failed: %d", ret);
+ wl1271_warn("testmode cmd configure failed: %d\n", ret);
return ret;
}

@@ -236,7 +236,7 @@ static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])
u32 val;
int ret;

- wl1271_debug(DEBUG_TESTMODE, "testmode cmd set plt mode");
+ wl1271_debug(DEBUG_TESTMODE, "testmode cmd set plt mode\n");

if (!tb[WL1271_TM_ATTR_PLT_MODE])
return -EINVAL;
@@ -260,7 +260,7 @@ static int wl1271_tm_cmd_set_plt_mode(struct wl1271 *wl, struct nlattr *tb[])

static int wl1271_tm_cmd_recover(struct wl1271 *wl, struct nlattr *tb[])
{
- wl1271_debug(DEBUG_TESTMODE, "testmode cmd recover");
+ wl1271_debug(DEBUG_TESTMODE, "testmode cmd recover\n");

wl12xx_queue_recovery_work(wl);

diff --git a/drivers/net/wireless/ti/wlcore/tx.c b/drivers/net/wireless/ti/wlcore/tx.c
index 6983e7a..6a0bebd 100644
--- a/drivers/net/wireless/ti/wlcore/tx.c
+++ b/drivers/net/wireless/ti/wlcore/tx.c
@@ -54,7 +54,7 @@ static int wl1271_set_default_wep_key(struct wl1271 *wl,
if (ret < 0)
return ret;

- wl1271_debug(DEBUG_CRYPT, "default wep key idx: %d", (int)id);
+ wl1271_debug(DEBUG_CRYPT, "default wep key idx: %d\n", (int)id);
return 0;
}

@@ -235,7 +235,7 @@ static int wl1271_tx_allocate(struct wl1271 *wl, struct wl12xx_vif *wlvif,
ret = 0;

wl1271_debug(DEBUG_TX,
- "tx_allocate: size: %d, blocks: %d, id: %d",
+ "tx_allocate: size: %d, blocks: %d, id: %d\n",
total_len, total_blocks, id);
} else {
wl1271_free_tx_id(wl, id);
@@ -380,7 +380,7 @@ static int wl1271_prepare_tx_frame(struct wl1271 *wl, struct wl12xx_vif *wlvif,
}
hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
if (hlid == WL12XX_INVALID_LINK_ID) {
- wl1271_error("invalid hlid. dropping skb 0x%p", skb);
+ wl1271_err("invalid hlid. dropping skb 0x%p\n", skb);
return -EINVAL;
}

@@ -797,7 +797,7 @@ static void wl1271_tx_complete_packet(struct wl1271 *wl,

/* check for id legality */
if (unlikely(id >= wl->num_tx_desc || wl->tx_frames[id] == NULL)) {
- wl1271_warning("TX result illegal id: %d", id);
+ wl1271_warn("TX result illegal id: %d\n", id);
return;
}

@@ -865,8 +865,7 @@ static void wl1271_tx_complete_packet(struct wl1271 *wl,
skb_pull(skb, WL1271_EXTRA_SPACE_TKIP);
}

- wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x"
- " status 0x%x",
+ wl1271_debug(DEBUG_TX, "tx status id %u skb 0x%p failures %u rate 0x%x status 0x%x\n",
result->id, skb, result->ack_failures,
result->rate_class_index, result->status);

@@ -895,11 +894,11 @@ void wl1271_tx_complete(struct wl1271 *wl)
tx_result_host_counter), fw_counter);

count = fw_counter - wl->tx_results_count;
- wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d", count);
+ wl1271_debug(DEBUG_TX, "tx_complete received, packets: %d\n", count);

/* verify that the result buffer is not getting overrun */
if (unlikely(count > TX_HW_RESULT_QUEUE_LEN))
- wl1271_warning("TX result overflow from chipset: %d", count);
+ wl1271_warn("TX result overflow from chipset: %d\n", count);

/* process the results */
for (i = 0; i < count; i++) {
@@ -926,7 +925,7 @@ void wl1271_tx_reset_link_queues(struct wl1271 *wl, u8 hlid)
for (i = 0; i < NUM_TX_QUEUES; i++) {
total[i] = 0;
while ((skb = skb_dequeue(&wl->links[hlid].tx_queue[i]))) {
- wl1271_debug(DEBUG_TX, "link freeing skb 0x%p", skb);
+ wl1271_debug(DEBUG_TX, "link freeing skb 0x%p\n", skb);

if (!wl12xx_is_dummy_packet(wl, skb)) {
info = IEEE80211_SKB_CB(skb);
@@ -994,7 +993,7 @@ void wl12xx_tx_reset(struct wl1271 *wl)

skb = wl->tx_frames[i];
wl1271_free_tx_id(wl, i);
- wl1271_debug(DEBUG_TX, "freeing skb 0x%p", skb);
+ wl1271_debug(DEBUG_TX, "freeing skb 0x%p\n", skb);

if (!wl12xx_is_dummy_packet(wl, skb)) {
/*
@@ -1037,7 +1036,7 @@ void wl1271_tx_flush(struct wl1271 *wl)

while (!time_after(jiffies, timeout)) {
mutex_lock(&wl->mutex);
- wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d",
+ wl1271_debug(DEBUG_TX, "flushing tx buffer: %d %d\n",
wl->tx_frames_cnt,
wl1271_tx_total_queue_count(wl));
if ((wl->tx_frames_cnt == 0) &&
@@ -1049,7 +1048,7 @@ void wl1271_tx_flush(struct wl1271 *wl)
msleep(1);
}

- wl1271_warning("Unable to flush all TX buffers, timed out.");
+ wl1271_warn("Unable to flush all TX buffers, timed out\n");

/* forcibly flush all Tx buffers on our queues */
mutex_lock(&wl->mutex);
--
1.7.8.111.gad25c.dirty