[deliverable/linux.git] / drivers / net / wireless / wl12xx / wl1271_event.c

/*
 * This file is part of wl1271
 *
 * Copyright (C) 2008-2009 Nokia Corporation
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include "wl1271.h"
#include "wl1271_reg.h"
#include "wl1271_spi.h"
#include "wl1271_event.h"
#include "wl1271_ps.h"
#include "wl12xx_80211.h"

static int wl1271_event_scan_complete(struct wl1271 *wl,
				      struct event_mailbox *mbox)
{
	int size = sizeof(struct wl12xx_probe_req_template);
	wl1271_debug(DEBUG_EVENT, "status: 0x%x",
		     mbox->scheduled_scan_status);

	if (wl->scanning) {
		if (wl->scan.state == WL1271_SCAN_BAND_DUAL) {
			wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
						NULL, size);
			/* 2.4 GHz band scanned, scan 5 GHz band, pretend
			 * to the wl1271_cmd_scan function that we are not
			 * scanning as it checks that.
			 */
			wl->scanning = false;
			wl1271_cmd_scan(wl, wl->scan.ssid, wl->scan.ssid_len,
						wl->scan.active,
						wl->scan.high_prio,
						WL1271_SCAN_BAND_5_GHZ,
						wl->scan.probe_requests);
		} else {
			if (wl->scan.state == WL1271_SCAN_BAND_2_4_GHZ)
				wl1271_cmd_template_set(wl,
						CMD_TEMPL_CFG_PROBE_REQ_2_4,
						NULL, size);
			else
				wl1271_cmd_template_set(wl,
						CMD_TEMPL_CFG_PROBE_REQ_5,
						NULL, size);

			mutex_unlock(&wl->mutex);
			ieee80211_scan_completed(wl->hw, false);
			mutex_lock(&wl->mutex);
			wl->scanning = false;
		}
	}
	return 0;
}

static int wl1271_event_ps_report(struct wl1271 *wl,
				  struct event_mailbox *mbox,
				  bool *beacon_loss)
{
	int ret = 0;

	wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status);

	switch (mbox->ps_status) {
	case EVENT_ENTER_POWER_SAVE_FAIL:
		if (!wl->psm) {
			wl->psm_entry_retry = 0;
			break;
		}

		if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) {
			wl->psm_entry_retry++;
			ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
		} else {
			wl1271_error("PSM entry failed, giving up.\n");
			wl->psm_entry_retry = 0;
			*beacon_loss = true;
		}
		break;
	case EVENT_ENTER_POWER_SAVE_SUCCESS:
		wl->psm_entry_retry = 0;
		break;
	case EVENT_EXIT_POWER_SAVE_FAIL:
		wl1271_info("PSM exit failed");
		break;
	case EVENT_EXIT_POWER_SAVE_SUCCESS:
	default:
		break;
	}

	return ret;
}

static void wl1271_event_mbox_dump(struct event_mailbox *mbox)
{
	wl1271_debug(DEBUG_EVENT, "MBOX DUMP:");
	wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
	wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
}

static int wl1271_event_process(struct wl1271 *wl, struct event_mailbox *mbox)
{
	int ret;
	u32 vector;
	bool beacon_loss = false;

	wl1271_event_mbox_dump(mbox);

	vector = le32_to_cpu(mbox->events_vector);
	vector &= ~(le32_to_cpu(mbox->events_mask));
	wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector);

	if (vector & SCAN_COMPLETE_EVENT_ID) {
		ret = wl1271_event_scan_complete(wl, mbox);
		if (ret < 0)
			return ret;
	}

	/*
	 * The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon
	 * filtering) is enabled. Without PSM, the stack will receive all
	 * beacons and can detect beacon loss by itself.
	 */
	if (vector & BSS_LOSE_EVENT_ID && wl->psm) {
		wl1271_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");

		/* indicate to the stack, that beacons have been lost */
		beacon_loss = true;
	}

	if (vector & PS_REPORT_EVENT_ID) {
		wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT");
		ret = wl1271_event_ps_report(wl, mbox, &beacon_loss);
		if (ret < 0)
			return ret;
	}

	if (beacon_loss) {
		/* Obviously, it's dangerous to release the mutex while
		   we are holding many of the variables in the wl struct.
		   That's why it's done last in the function, and care must
		   be taken that nothing more is done after this function
		   returns. */
		mutex_unlock(&wl->mutex);
		ieee80211_beacon_loss(wl->vif);
		mutex_lock(&wl->mutex);
	}

	return 0;
}

int wl1271_event_unmask(struct wl1271 *wl)
{
	int ret;

	ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask));
	if (ret < 0)
		return ret;

	return 0;
}

void wl1271_event_mbox_config(struct wl1271 *wl)
{
	wl->mbox_ptr[0] = wl1271_spi_read32(wl, REG_EVENT_MAILBOX_PTR);
	wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);

	wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
		     wl->mbox_ptr[0], wl->mbox_ptr[1]);
}

int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num, bool do_ack)
{
	struct event_mailbox mbox;
	int ret;

	wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);

	if (mbox_num > 1)
		return -EINVAL;

	/* first we read the mbox descriptor */
	wl1271_spi_read(wl, wl->mbox_ptr[mbox_num], &mbox,
			sizeof(struct event_mailbox), false);

	/* process the descriptor */
	ret = wl1271_event_process(wl, &mbox);
	if (ret < 0)
		return ret;

	/* then we let the firmware know it can go on...*/
	if (do_ack)
		wl1271_spi_write32(wl, ACX_REG_INTERRUPT_TRIG,
				   INTR_TRIG_EVENT_ACK);

	return 0;
}
Commit	Line	Data
f5fc0f86 LC	1	/*
	2	* This file is part of wl1271
	3	*
	4	* Copyright (C) 2008-2009 Nokia Corporation
	5	*
	6	* Contact: Luciano Coelho <luciano.coelho@nokia.com>
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License
	10	* version 2 as published by the Free Software Foundation.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
	20	* 02110-1301 USA
	21	*
	22	*/
	23
	24	#include "wl1271.h"
	25	#include "wl1271_reg.h"
	26	#include "wl1271_spi.h"
	27	#include "wl1271_event.h"
	28	#include "wl1271_ps.h"
66497dc3	29	#include "wl12xx_80211.h"
f5fc0f86 LC	30
	31	static int wl1271_event_scan_complete(struct wl1271 *wl,
	32	struct event_mailbox *mbox)
	33	{
abb0b3bf	34	int size = sizeof(struct wl12xx_probe_req_template);
f5fc0f86 LC	35	wl1271_debug(DEBUG_EVENT, "status: 0x%x",
	36	mbox->scheduled_scan_status);
	37
	38	if (wl->scanning) {
abb0b3bf TP	39	if (wl->scan.state == WL1271_SCAN_BAND_DUAL) {
	40	wl1271_cmd_template_set(wl, CMD_TEMPL_CFG_PROBE_REQ_2_4,
	41	NULL, size);
	42	/* 2.4 GHz band scanned, scan 5 GHz band, pretend
	43	* to the wl1271_cmd_scan function that we are not
	44	* scanning as it checks that.
	45	*/
	46	wl->scanning = false;
	47	wl1271_cmd_scan(wl, wl->scan.ssid, wl->scan.ssid_len,
	48	wl->scan.active,
	49	wl->scan.high_prio,
	50	WL1271_SCAN_BAND_5_GHZ,
	51	wl->scan.probe_requests);
	52	} else {
	53	if (wl->scan.state == WL1271_SCAN_BAND_2_4_GHZ)
	54	wl1271_cmd_template_set(wl,
	55	CMD_TEMPL_CFG_PROBE_REQ_2_4,
	56	NULL, size);
	57	else
	58	wl1271_cmd_template_set(wl,
	59	CMD_TEMPL_CFG_PROBE_REQ_5,
	60	NULL, size);
f5fc0f86	61
abb0b3bf TP	62	mutex_unlock(&wl->mutex);
	63	ieee80211_scan_completed(wl->hw, false);
	64	mutex_lock(&wl->mutex);
	65	wl->scanning = false;
	66	}
	67	}
f5fc0f86 LC	68	return 0;
	69	}
	70
19ad0715 JO	71	static int wl1271_event_ps_report(struct wl1271 *wl,
	72	struct event_mailbox *mbox,
	73	bool *beacon_loss)
	74	{
	75	int ret = 0;
	76
	77	wl1271_debug(DEBUG_EVENT, "ps_status: 0x%x", mbox->ps_status);
	78
	79	switch (mbox->ps_status) {
	80	case EVENT_ENTER_POWER_SAVE_FAIL:
461fa136 JO	81	if (!wl->psm) {
	82	wl->psm_entry_retry = 0;
	83	break;
	84	}
	85
19ad0715 JO	86	if (wl->psm_entry_retry < wl->conf.conn.psm_entry_retries) {
19ad0715 JO	87	wl->psm_entry_retry++;
19ad0715 JO	88	ret = wl1271_ps_set_mode(wl, STATION_POWER_SAVE_MODE);
19ad0715 JO	89	} else {
461fa136	90	wl1271_error("PSM entry failed, giving up.\n");
19ad0715 JO	91	wl->psm_entry_retry = 0;
	92	*beacon_loss = true;
	93	}
	94	break;
	95	case EVENT_ENTER_POWER_SAVE_SUCCESS:
	96	wl->psm_entry_retry = 0;
	97	break;
	98	case EVENT_EXIT_POWER_SAVE_FAIL:
	99	wl1271_info("PSM exit failed");
	100	break;
	101	case EVENT_EXIT_POWER_SAVE_SUCCESS:
	102	default:
	103	break;
	104	}
	105
	106	return ret;
	107	}
	108
f5fc0f86 LC	109	static void wl1271_event_mbox_dump(struct event_mailbox *mbox)
	110	{
	111	wl1271_debug(DEBUG_EVENT, "MBOX DUMP:");
	112	wl1271_debug(DEBUG_EVENT, "\tvector: 0x%x", mbox->events_vector);
	113	wl1271_debug(DEBUG_EVENT, "\tmask: 0x%x", mbox->events_mask);
	114	}
	115
	116	static int wl1271_event_process(struct wl1271 wl, struct event_mailbox mbox)
	117	{
	118	int ret;
	119	u32 vector;
19ad0715	120	bool beacon_loss = false;
f5fc0f86 LC	121
	122	wl1271_event_mbox_dump(mbox);
	123
d0f63b20 LC	124	vector = le32_to_cpu(mbox->events_vector);
d0f63b20 LC	125	vector &= ~(le32_to_cpu(mbox->events_mask));
f5fc0f86 LC	126	wl1271_debug(DEBUG_EVENT, "vector: 0x%x", vector);
	127
	128	if (vector & SCAN_COMPLETE_EVENT_ID) {
	129	ret = wl1271_event_scan_complete(wl, mbox);
	130	if (ret < 0)
	131	return ret;
	132	}
	133
b771eee5 JO	134	/*
	135	* The BSS_LOSE_EVENT_ID is only needed while psm (and hence beacon
	136	* filtering) is enabled. Without PSM, the stack will receive all
	137	* beacons and can detect beacon loss by itself.
	138	*/
	139	if (vector & BSS_LOSE_EVENT_ID && wl->psm) {
f5fc0f86 LC	140	wl1271_debug(DEBUG_EVENT, "BSS_LOSE_EVENT");
f5fc0f86 LC	141
b771eee5	142	/* indicate to the stack, that beacons have been lost */
19ad0715 JO	143	beacon_loss = true;
	144	}
	145
	146	if (vector & PS_REPORT_EVENT_ID) {
	147	wl1271_debug(DEBUG_EVENT, "PS_REPORT_EVENT");
	148	ret = wl1271_event_ps_report(wl, mbox, &beacon_loss);
	149	if (ret < 0)
	150	return ret;
	151	}
	152
	153	if (beacon_loss) {
	154	/* Obviously, it's dangerous to release the mutex while
	155	we are holding many of the variables in the wl struct.
	156	That's why it's done last in the function, and care must
	157	be taken that nothing more is done after this function
	158	returns. */
	159	mutex_unlock(&wl->mutex);
b771eee5	160	ieee80211_beacon_loss(wl->vif);
19ad0715	161	mutex_lock(&wl->mutex);
f5fc0f86 LC	162	}
	163
	164	return 0;
	165	}
	166
	167	int wl1271_event_unmask(struct wl1271 *wl)
	168	{
	169	int ret;
	170
	171	ret = wl1271_acx_event_mbox_mask(wl, ~(wl->event_mask));
	172	if (ret < 0)
	173	return ret;
	174
	175	return 0;
	176	}
	177
	178	void wl1271_event_mbox_config(struct wl1271 *wl)
	179	{
74621417	180	wl->mbox_ptr[0] = wl1271_spi_read32(wl, REG_EVENT_MAILBOX_PTR);
f5fc0f86 LC	181	wl->mbox_ptr[1] = wl->mbox_ptr[0] + sizeof(struct event_mailbox);
	182
	183	wl1271_debug(DEBUG_EVENT, "MBOX ptrs: 0x%x 0x%x",
	184	wl->mbox_ptr[0], wl->mbox_ptr[1]);
	185	}
	186
1fd2794f	187	int wl1271_event_handle(struct wl1271 *wl, u8 mbox_num, bool do_ack)
f5fc0f86 LC	188	{
	189	struct event_mailbox mbox;
	190	int ret;
	191
	192	wl1271_debug(DEBUG_EVENT, "EVENT on mbox %d", mbox_num);
	193
	194	if (mbox_num > 1)
	195	return -EINVAL;
	196
	197	/* first we read the mbox descriptor */
74621417 JO	198	wl1271_spi_read(wl, wl->mbox_ptr[mbox_num], &mbox,
74621417 JO	199	sizeof(struct event_mailbox), false);
f5fc0f86 LC	200
	201	/* process the descriptor */
	202	ret = wl1271_event_process(wl, &mbox);
	203	if (ret < 0)
	204	return ret;
	205
	206	/* then we let the firmware know it can go on...*/
1fd2794f JO	207	if (do_ack)
	208	wl1271_spi_write32(wl, ACX_REG_INTERRUPT_TRIG,
	209	INTR_TRIG_EVENT_ACK);
f5fc0f86 LC	210
	211	return 0;
	212	}