libertas: Use netdev_<level> or dev_<level> where possible (f3a57fd1) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/net/wireless/libertas/cfg.c

+5 −4

Original line number	Original line	Diff line number	Diff line
	@@ -1324,7 +1324,8 @@ static int lbs_cfg_connect(struct wiphy wiphy, struct net_device dev,
	sme->ssid, sme->ssid_len,		sme->ssid, sme->ssid_len,
	WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);		WLAN_CAPABILITY_ESS, WLAN_CAPABILITY_ESS);
	if (!bss) {		if (!bss) {
	pr_err("assoc: bss %pM not in scan results\n", sme->bssid);		wiphy_err(wiphy, "assoc: bss %pM not in scan results\n",
			sme->bssid);
	ret = -ENOENT;		ret = -ENOENT;
	goto done;		goto done;
	}		}
	@@ -1381,7 +1382,7 @@ static int lbs_cfg_connect(struct wiphy wiphy, struct net_device dev,
	lbs_enable_rsn(priv, sme->crypto.cipher_group != 0);		lbs_enable_rsn(priv, sme->crypto.cipher_group != 0);
	break;		break;
	default:		default:
	pr_err("unsupported cipher group 0x%x\n",		wiphy_err(wiphy, "unsupported cipher group 0x%x\n",
	sme->crypto.cipher_group);		sme->crypto.cipher_group);
	ret = -ENOTSUPP;		ret = -ENOTSUPP;
	goto done;		goto done;
	@@ -1500,7 +1501,7 @@ static int lbs_cfg_add_key(struct wiphy wiphy, struct net_device netdev,
	params->key, params->key_len);		params->key, params->key_len);
	break;		break;
	default:		default:
	pr_err("unhandled cipher 0x%x\n", params->cipher);		wiphy_err(wiphy, "unhandled cipher 0x%x\n", params->cipher);
	ret = -ENOTSUPP;		ret = -ENOTSUPP;
	break;		break;
	}		}

drivers/net/wireless/libertas/cmd.c

+24 −18

Original line number	Original line	Diff line number	Diff line
	@@ -3,8 +3,6 @@
	* It prepares command and sends it to firmware when it is ready.		* It prepares command and sends it to firmware when it is ready.
	*/		*/

	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

	#include <linux/kfifo.h>		#include <linux/kfifo.h>
	#include <linux/sched.h>		#include <linux/sched.h>
	#include <linux/slab.h>		#include <linux/slab.h>
	@@ -112,7 +110,7 @@ int lbs_update_hw_spec(struct lbs_private *priv)
	* CF card firmware 5.0.16p0: cap 0x00000303		* CF card firmware 5.0.16p0: cap 0x00000303
	* USB dongle firmware 5.110.17p2: cap 0x00000303		* USB dongle firmware 5.110.17p2: cap 0x00000303
	*/		*/
	pr_info("%pM, fw %u.%u.%up%u, cap 0x%08x\n",		netdev_info(priv->dev, "%pM, fw %u.%u.%up%u, cap 0x%08x\n",
	cmd.permanentaddr,		cmd.permanentaddr,
	priv->fwrelease >> 24 & 0xff,		priv->fwrelease >> 24 & 0xff,
	priv->fwrelease >> 16 & 0xff,		priv->fwrelease >> 16 & 0xff,
	@@ -143,7 +141,8 @@ int lbs_update_hw_spec(struct lbs_private *priv)
	/* if it's unidentified region code, use the default (USA) */		/* if it's unidentified region code, use the default (USA) */
	if (i >= MRVDRV_MAX_REGION_CODE) {		if (i >= MRVDRV_MAX_REGION_CODE) {
	priv->regioncode = 0x10;		priv->regioncode = 0x10;
	pr_info("unidentified region code; using the default (USA)\n");		netdev_info(priv->dev,
			"unidentified region code; using the default (USA)\n");
	}		}

	if (priv->current_addr[0] == 0xff)		if (priv->current_addr[0] == 0xff)
	@@ -213,7 +212,7 @@ int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria,
	(uint8_t *)&cmd_config.wol_conf,		(uint8_t *)&cmd_config.wol_conf,
	sizeof(struct wol_config));		sizeof(struct wol_config));
	} else {		} else {
	pr_info("HOST_SLEEP_CFG failed %d\n", ret);		netdev_info(priv->dev, "HOST_SLEEP_CFG failed %d\n", ret);
	}		}

	return ret;		return ret;
	@@ -316,7 +315,7 @@ static int lbs_wait_for_ds_awake(struct lbs_private *priv)
	if (priv->is_deep_sleep) {		if (priv->is_deep_sleep) {
	if (!wait_event_interruptible_timeout(priv->ds_awake_q,		if (!wait_event_interruptible_timeout(priv->ds_awake_q,
	!priv->is_deep_sleep, (10 * HZ))) {		!priv->is_deep_sleep, (10 * HZ))) {
	pr_err("ds_awake_q: timer expired\n");		netdev_err(priv->dev, "ds_awake_q: timer expired\n");
	ret = -1;		ret = -1;
	}		}
	}		}
	@@ -341,7 +340,7 @@ int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
	netif_carrier_off(priv->dev);		netif_carrier_off(priv->dev);
	}		}
	} else {		} else {
	pr_err("deep sleep: already enabled\n");		netdev_err(priv->dev, "deep sleep: already enabled\n");
	}		}
	} else {		} else {
	if (priv->is_deep_sleep) {		if (priv->is_deep_sleep) {
	@@ -351,7 +350,8 @@ int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
	if (!ret) {		if (!ret) {
	ret = lbs_wait_for_ds_awake(priv);		ret = lbs_wait_for_ds_awake(priv);
	if (ret)		if (ret)
	pr_err("deep sleep: wakeup failed\n");		netdev_err(priv->dev,
			"deep sleep: wakeup failed\n");
	}		}
	}		}
	}		}
	@@ -385,7 +385,8 @@ int lbs_set_host_sleep(struct lbs_private *priv, int host_sleep)
	ret = lbs_host_sleep_cfg(priv, priv->wol_criteria,		ret = lbs_host_sleep_cfg(priv, priv->wol_criteria,
	(struct wol_config *)NULL);		(struct wol_config *)NULL);
	if (ret) {		if (ret) {
	pr_info("Host sleep configuration failed: %d\n",		netdev_info(priv->dev,
			"Host sleep configuration failed: %d\n",
	ret);		ret);
	return ret;		return ret;
	}		}
	@@ -396,7 +397,8 @@ int lbs_set_host_sleep(struct lbs_private *priv, int host_sleep)
	sizeof(cmd),		sizeof(cmd),
	lbs_ret_host_sleep_activate, 0);		lbs_ret_host_sleep_activate, 0);
	if (ret)		if (ret)
	pr_info("HOST_SLEEP_ACTIVATE failed: %d\n",		netdev_info(priv->dev,
			"HOST_SLEEP_ACTIVATE failed: %d\n",
	ret);		ret);
	}		}

	@@ -404,11 +406,12 @@ int lbs_set_host_sleep(struct lbs_private *priv, int host_sleep)
	priv->host_sleep_q,		priv->host_sleep_q,
	priv->is_host_sleep_activated,		priv->is_host_sleep_activated,
	(10 * HZ))) {		(10 * HZ))) {
	pr_err("host_sleep_q: timer expired\n");		netdev_err(priv->dev,
			"host_sleep_q: timer expired\n");
	ret = -1;		ret = -1;
	}		}
	} else {		} else {
	pr_err("host sleep: already enabled\n");		netdev_err(priv->dev, "host sleep: already enabled\n");
	}		}
	} else {		} else {
	if (priv->is_host_sleep_activated)		if (priv->is_host_sleep_activated)
	@@ -1008,7 +1011,8 @@ static void lbs_submit_command(struct lbs_private *priv,
	ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);		ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);

	if (ret) {		if (ret) {
	pr_info("DNLD_CMD: hw_host_to_card failed: %d\n", ret);		netdev_info(priv->dev, "DNLD_CMD: hw_host_to_card failed: %d\n",
			ret);
	/* Let the timer kick in and retry, and potentially reset		/* Let the timer kick in and retry, and potentially reset
	the whole thing if the condition persists */		the whole thing if the condition persists */
	timeo = HZ/4;		timeo = HZ/4;
	@@ -1277,7 +1281,8 @@ int lbs_execute_next_command(struct lbs_private *priv)
	spin_lock_irqsave(&priv->driver_lock, flags);		spin_lock_irqsave(&priv->driver_lock, flags);

	if (priv->cur_cmd) {		if (priv->cur_cmd) {
	pr_alert( "EXEC_NEXT_CMD: already processing command!\n");		netdev_alert(priv->dev,
			"EXEC_NEXT_CMD: already processing command!\n");
	spin_unlock_irqrestore(&priv->driver_lock, flags);		spin_unlock_irqrestore(&priv->driver_lock, flags);
	ret = -1;		ret = -1;
	goto done;		goto done;
	@@ -1439,7 +1444,7 @@ static void lbs_send_confirmsleep(struct lbs_private *priv)
	ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,		ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,
	sizeof(confirm_sleep));		sizeof(confirm_sleep));
	if (ret) {		if (ret) {
	pr_alert("confirm_sleep failed\n");		netdev_alert(priv->dev, "confirm_sleep failed\n");
	goto out;		goto out;
	}		}

	@@ -1665,7 +1670,8 @@ int __lbs_cmd(struct lbs_private *priv, uint16_t command,
	spin_lock_irqsave(&priv->driver_lock, flags);		spin_lock_irqsave(&priv->driver_lock, flags);
	ret = cmdnode->result;		ret = cmdnode->result;
	if (ret)		if (ret)
	pr_info("PREP_CMD: command 0x%04x failed: %d\n", command, ret);		netdev_info(priv->dev, "PREP_CMD: command 0x%04x failed: %d\n",
			command, ret);

	__lbs_cleanup_and_insert_cmd(priv, cmdnode);		__lbs_cleanup_and_insert_cmd(priv, cmdnode);
	spin_unlock_irqrestore(&priv->driver_lock, flags);		spin_unlock_irqrestore(&priv->driver_lock, flags);

drivers/net/wireless/libertas/cmdresp.c

+16 −16

Original line number	Original line	Diff line number	Diff line
	@@ -3,8 +3,6 @@
	* responses as well as events generated by firmware.		* responses as well as events generated by firmware.
	*/		*/

	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

	#include <linux/slab.h>		#include <linux/slab.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	#include <linux/sched.h>		#include <linux/sched.h>
	@@ -88,7 +86,8 @@ int lbs_process_command_response(struct lbs_private priv, u8 data, u32 len)
	lbs_deb_hex(LBS_DEB_CMD, "CMD_RESP", (void *) resp, len);		lbs_deb_hex(LBS_DEB_CMD, "CMD_RESP", (void *) resp, len);

	if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {		if (resp->seqnum != priv->cur_cmd->cmdbuf->seqnum) {
	pr_info("Received CMD_RESP with invalid sequence %d (expected %d)\n",		netdev_info(priv->dev,
			"Received CMD_RESP with invalid sequence %d (expected %d)\n",
	le16_to_cpu(resp->seqnum),		le16_to_cpu(resp->seqnum),
	le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));		le16_to_cpu(priv->cur_cmd->cmdbuf->seqnum));
	spin_unlock_irqrestore(&priv->driver_lock, flags);		spin_unlock_irqrestore(&priv->driver_lock, flags);
	@@ -97,7 +96,7 @@ int lbs_process_command_response(struct lbs_private priv, u8 data, u32 len)
	}		}
	if (respcmd != CMD_RET(curcmd) &&		if (respcmd != CMD_RET(curcmd) &&
	respcmd != CMD_RET_802_11_ASSOCIATE && curcmd != CMD_802_11_ASSOCIATE) {		respcmd != CMD_RET_802_11_ASSOCIATE && curcmd != CMD_802_11_ASSOCIATE) {
	pr_info("Invalid CMD_RESP %x to command %x!\n",		netdev_info(priv->dev, "Invalid CMD_RESP %x to command %x!\n",
	respcmd, curcmd);		respcmd, curcmd);
	spin_unlock_irqrestore(&priv->driver_lock, flags);		spin_unlock_irqrestore(&priv->driver_lock, flags);
	ret = -1;		ret = -1;
	@@ -107,7 +106,8 @@ int lbs_process_command_response(struct lbs_private priv, u8 data, u32 len)
	if (resp->result == cpu_to_le16(0x0004)) {		if (resp->result == cpu_to_le16(0x0004)) {
	/* 0x0004 means -EAGAIN. Drop the response, let it time out		/* 0x0004 means -EAGAIN. Drop the response, let it time out
	and be resubmitted */		and be resubmitted */
	pr_info("Firmware returns DEFER to command %x. Will let it time out...\n",		netdev_info(priv->dev,
			"Firmware returns DEFER to command %x. Will let it time out...\n",
	le16_to_cpu(resp->command));		le16_to_cpu(resp->command));
	spin_unlock_irqrestore(&priv->driver_lock, flags);		spin_unlock_irqrestore(&priv->driver_lock, flags);
	ret = -1;		ret = -1;
	@@ -319,28 +319,28 @@ int lbs_process_event(struct lbs_private *priv, u32 event)
	lbs_deb_cmd("EVENT: ADHOC beacon lost\n");		lbs_deb_cmd("EVENT: ADHOC beacon lost\n");
	break;		break;
	case MACREG_INT_CODE_RSSI_LOW:		case MACREG_INT_CODE_RSSI_LOW:
	pr_alert("EVENT: rssi low\n");		netdev_alert(priv->dev, "EVENT: rssi low\n");
	break;		break;
	case MACREG_INT_CODE_SNR_LOW:		case MACREG_INT_CODE_SNR_LOW:
	pr_alert("EVENT: snr low\n");		netdev_alert(priv->dev, "EVENT: snr low\n");
	break;		break;
	case MACREG_INT_CODE_MAX_FAIL:		case MACREG_INT_CODE_MAX_FAIL:
	pr_alert("EVENT: max fail\n");		netdev_alert(priv->dev, "EVENT: max fail\n");
	break;		break;
	case MACREG_INT_CODE_RSSI_HIGH:		case MACREG_INT_CODE_RSSI_HIGH:
	pr_alert("EVENT: rssi high\n");		netdev_alert(priv->dev, "EVENT: rssi high\n");
	break;		break;
	case MACREG_INT_CODE_SNR_HIGH:		case MACREG_INT_CODE_SNR_HIGH:
	pr_alert("EVENT: snr high\n");		netdev_alert(priv->dev, "EVENT: snr high\n");
	break;		break;

	case MACREG_INT_CODE_MESH_AUTO_STARTED:		case MACREG_INT_CODE_MESH_AUTO_STARTED:
	/* Ignore spurious autostart events */		/* Ignore spurious autostart events */
	pr_info("EVENT: MESH_AUTO_STARTED (ignoring)\n");		netdev_info(priv->dev, "EVENT: MESH_AUTO_STARTED (ignoring)\n");
	break;		break;

	default:		default:
	pr_alert("EVENT: unknown event id %d\n", event);		netdev_alert(priv->dev, "EVENT: unknown event id %d\n", event);
	break;		break;
	}		}

drivers/net/wireless/libertas/debugfs.c

+3 −4

Original line number	Original line	Diff line number	Diff line
	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

	#include <linux/dcache.h>		#include <linux/dcache.h>
	#include <linux/debugfs.h>		#include <linux/debugfs.h>
	#include <linux/delay.h>		#include <linux/delay.h>
	@@ -153,13 +151,14 @@ static ssize_t lbs_host_sleep_write(struct file *file,
	ret = lbs_set_host_sleep(priv, 0);		ret = lbs_set_host_sleep(priv, 0);
	else if (host_sleep == 1) {		else if (host_sleep == 1) {
	if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {		if (priv->wol_criteria == EHS_REMOVE_WAKEUP) {
	pr_info("wake parameters not configured\n");		netdev_info(priv->dev,
			"wake parameters not configured\n");
	ret = -EINVAL;		ret = -EINVAL;
	goto out_unlock;		goto out_unlock;
	}		}
	ret = lbs_set_host_sleep(priv, 1);		ret = lbs_set_host_sleep(priv, 1);
	} else {		} else {
	pr_err("invalid option\n");		netdev_err(priv->dev, "invalid option\n");
	ret = -EINVAL;		ret = -EINVAL;
	}		}

drivers/net/wireless/libertas/if_cs.c

+10 −5

Original line number	Original line	Diff line number	Diff line
	@@ -364,7 +364,7 @@ static int if_cs_send_cmd(struct lbs_private priv, u8 buf, u16 nb)
	if (status & IF_CS_BIT_COMMAND)		if (status & IF_CS_BIT_COMMAND)
	break;		break;
	if (++loops > 100) {		if (++loops > 100) {
	pr_err("card not ready for commands\n");		netdev_err(priv->dev, "card not ready for commands\n");
	goto done;		goto done;
	}		}
	mdelay(1);		mdelay(1);
	@@ -434,14 +434,16 @@ static int if_cs_receive_cmdres(struct lbs_private priv, u8 data, u32 *len)
	/* is hardware ready? */		/* is hardware ready? */
	status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);		status = if_cs_read16(priv->card, IF_CS_CARD_STATUS);
	if ((status & IF_CS_BIT_RESP) == 0) {		if ((status & IF_CS_BIT_RESP) == 0) {
	pr_err("no cmd response in card\n");		netdev_err(priv->dev, "no cmd response in card\n");
	*len = 0;		*len = 0;
	goto out;		goto out;
	}		}

	*len = if_cs_read16(priv->card, IF_CS_RESP_LEN);		*len = if_cs_read16(priv->card, IF_CS_RESP_LEN);
	if ((len == 0) \|\| (len > LBS_CMD_BUFFER_SIZE)) {		if ((len == 0) \|\| (len > LBS_CMD_BUFFER_SIZE)) {
	pr_err("card cmd buffer has invalid # of bytes (%d)\n", *len);		netdev_err(priv->dev,
			"card cmd buffer has invalid # of bytes (%d)\n",
			*len);
	goto out;		goto out;
	}		}

	@@ -475,7 +477,9 @@ static struct sk_buff if_cs_receive_data(struct lbs_private priv)

	len = if_cs_read16(priv->card, IF_CS_READ_LEN);		len = if_cs_read16(priv->card, IF_CS_READ_LEN);
	if (len == 0 \|\| len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {		if (len == 0 \|\| len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
	pr_err("card data buffer has invalid # of bytes (%d)\n", len);		netdev_err(priv->dev,
			"card data buffer has invalid # of bytes (%d)\n",
			len);
	priv->dev->stats.rx_dropped++;		priv->dev->stats.rx_dropped++;
	goto dat_err;		goto dat_err;
	}		}
	@@ -761,7 +765,8 @@ static int if_cs_host_to_card(struct lbs_private *priv,
	ret = if_cs_send_cmd(priv, buf, nb);		ret = if_cs_send_cmd(priv, buf, nb);
	break;		break;
	default:		default:
	pr_err("%s: unsupported type %d\n", __func__, type);		netdev_err(priv->dev, "%s: unsupported type %d\n",
			__func__, type);
	}		}

	lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);		lbs_deb_leave_args(LBS_DEB_CS, "ret %d", ret);