1/******************************************************************************
2 * rtl871x_pwrctrl.c
3 *
4 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved.
5 * Linux device driver for RTL8192SU
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of version 2 of the GNU General Public License as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
19 *
20 * Modifications for inclusion into the Linux staging tree are
21 * Copyright(c) 2010 Larry Finger. All rights reserved.
22 *
23 * Contact information:
24 * WLAN FAE <wlanfae@realtek.com>
25 * Larry Finger <Larry.Finger@lwfinger.net>
26 *
27 ******************************************************************************/
28
29#define _RTL871X_PWRCTRL_C_
30
31#include "osdep_service.h"
32#include "drv_types.h"
33#include "osdep_intf.h"
34
35#define RTL8712_SDIO_LOCAL_BASE 0X10100000
36#define SDIO_HCPWM (RTL8712_SDIO_LOCAL_BASE + 0x0081)
37
38void r8712_set_rpwm(struct _adapter *padapter, u8 val8)
39{
40	u8	rpwm;
41	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
42
43	if (pwrpriv->rpwm == val8) {
44		if (pwrpriv->rpwm_retry == 0)
45			return;
46	}
47	if ((padapter->bDriverStopped == true) ||
48	    (padapter->bSurpriseRemoved == true))
49		return;
50	rpwm = val8 | pwrpriv->tog;
51	switch (val8) {
52	case PS_STATE_S1:
53		pwrpriv->cpwm = val8;
54		break;
55	case PS_STATE_S2:/* only for USB normal powersave mode use,
56			  * temp mark some code. */
57	case PS_STATE_S3:
58	case PS_STATE_S4:
59		pwrpriv->cpwm = val8;
60		break;
61	default:
62		break;
63	}
64	pwrpriv->rpwm_retry = 0;
65	pwrpriv->rpwm = val8;
66	r8712_write8(padapter, 0x1025FE58, rpwm);
67	pwrpriv->tog += 0x80;
68}
69
70void r8712_set_ps_mode(struct _adapter *padapter, uint ps_mode, uint smart_ps)
71{
72	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
73
74	if (ps_mode > PM_Card_Disable)
75		return;
76	/* if driver is in active state, we dont need set smart_ps.*/
77	if (ps_mode == PS_MODE_ACTIVE)
78		smart_ps = 0;
79	if ((pwrpriv->pwr_mode != ps_mode) || (pwrpriv->smart_ps != smart_ps)) {
80		if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
81			pwrpriv->bSleep = true;
82		else
83			pwrpriv->bSleep = false;
84		pwrpriv->pwr_mode = ps_mode;
85		pwrpriv->smart_ps = smart_ps;
86		schedule_work(&pwrpriv->SetPSModeWorkItem);
87	}
88}
89
90/*
91 * Caller:ISR handler...
92 *
93 * This will be called when CPWM interrupt is up.
94 *
95 * using to update cpwn of drv; and drv will make a decision to up or
96 * down pwr level
97 */
98void r8712_cpwm_int_hdl(struct _adapter *padapter,
99			struct reportpwrstate_parm *preportpwrstate)
100{
101	struct pwrctrl_priv *pwrpriv = &(padapter->pwrctrlpriv);
102	struct cmd_priv	*pcmdpriv = &(padapter->cmdpriv);
103
104	if (pwrpriv->cpwm_tog == ((preportpwrstate->state) & 0x80))
105		return;
106	del_timer(&padapter->pwrctrlpriv.rpwm_check_timer);
107	_enter_pwrlock(&pwrpriv->lock);
108	pwrpriv->cpwm = (preportpwrstate->state) & 0xf;
109	if (pwrpriv->cpwm >= PS_STATE_S2) {
110		if (pwrpriv->alives & CMD_ALIVE)
111			up(&(pcmdpriv->cmd_queue_sema));
112	}
113	pwrpriv->cpwm_tog = (preportpwrstate->state) & 0x80;
114	up(&pwrpriv->lock);
115}
116
117static inline void register_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
118{
119		pwrctrl->alives |= tag;
120}
121
122static inline void unregister_task_alive(struct pwrctrl_priv *pwrctrl, uint tag)
123{
124	if (pwrctrl->alives & tag)
125		pwrctrl->alives ^= tag;
126}
127
128static void _rpwm_check_handler (struct _adapter *padapter)
129{
130	struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
131
132	if (padapter->bDriverStopped == true ||
133	    padapter->bSurpriseRemoved == true)
134		return;
135	if (pwrpriv->cpwm != pwrpriv->rpwm)
136		schedule_work(&pwrpriv->rpwm_workitem);
137}
138
139static void SetPSModeWorkItemCallback(struct work_struct *work)
140{
141	struct pwrctrl_priv *pwrpriv = container_of(work,
142				       struct pwrctrl_priv, SetPSModeWorkItem);
143	struct _adapter *padapter = container_of(pwrpriv,
144				    struct _adapter, pwrctrlpriv);
145	if (!pwrpriv->bSleep) {
146		_enter_pwrlock(&pwrpriv->lock);
147		if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
148			r8712_set_rpwm(padapter, PS_STATE_S4);
149		up(&pwrpriv->lock);
150	}
151}
152
153static void rpwm_workitem_callback(struct work_struct *work)
154{
155	struct pwrctrl_priv *pwrpriv = container_of(work,
156				       struct pwrctrl_priv, rpwm_workitem);
157	struct _adapter *padapter = container_of(pwrpriv,
158				    struct _adapter, pwrctrlpriv);
159	if (pwrpriv->cpwm != pwrpriv->rpwm) {
160		_enter_pwrlock(&pwrpriv->lock);
161		r8712_read8(padapter, SDIO_HCPWM);
162		pwrpriv->rpwm_retry = 1;
163		r8712_set_rpwm(padapter, pwrpriv->rpwm);
164		up(&pwrpriv->lock);
165	}
166}
167
168static void rpwm_check_handler (unsigned long data)
169{
170	struct _adapter *adapter = (struct _adapter *)data;
171
172	_rpwm_check_handler(adapter);
173}
174
175void r8712_init_pwrctrl_priv(struct _adapter *padapter)
176{
177	struct pwrctrl_priv *pwrctrlpriv = &padapter->pwrctrlpriv;
178
179	memset((unsigned char *)pwrctrlpriv, 0, sizeof(struct pwrctrl_priv));
180	sema_init(&pwrctrlpriv->lock, 1);
181	pwrctrlpriv->cpwm = PS_STATE_S4;
182	pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
183	pwrctrlpriv->smart_ps = 0;
184	pwrctrlpriv->tog = 0x80;
185/* clear RPWM to ensure driver and fw back to initial state. */
186	r8712_write8(padapter, 0x1025FE58, 0);
187	INIT_WORK(&pwrctrlpriv->SetPSModeWorkItem, SetPSModeWorkItemCallback);
188	INIT_WORK(&pwrctrlpriv->rpwm_workitem, rpwm_workitem_callback);
189	setup_timer(&pwrctrlpriv->rpwm_check_timer, rpwm_check_handler,
190		    (unsigned long)padapter);
191}
192
193/*
194Caller: r8712_cmd_thread
195
196Check if the fw_pwrstate is okay for issuing cmd.
197If not (cpwm should be is less than P2 state), then the sub-routine
198will raise the cpwm to be greater than or equal to P2.
199
200Calling Context: Passive
201
202Return Value:
203
204_SUCCESS: r8712_cmd_thread can issue cmds to firmware afterwards.
205_FAIL: r8712_cmd_thread can not do anything.
206*/
207sint r8712_register_cmd_alive(struct _adapter *padapter)
208{
209	uint res = _SUCCESS;
210	struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
211
212	_enter_pwrlock(&pwrctrl->lock);
213	register_task_alive(pwrctrl, CMD_ALIVE);
214	if (pwrctrl->cpwm < PS_STATE_S2) {
215		r8712_set_rpwm(padapter, PS_STATE_S3);
216		res = _FAIL;
217	}
218	up(&pwrctrl->lock);
219	return res;
220}
221
222/*
223Caller: ISR
224
225If ISR's txdone,
226No more pkts for TX,
227Then driver shall call this fun. to power down firmware again.
228*/
229
230void r8712_unregister_cmd_alive(struct _adapter *padapter)
231{
232	struct pwrctrl_priv *pwrctrl = &padapter->pwrctrlpriv;
233
234	_enter_pwrlock(&pwrctrl->lock);
235	unregister_task_alive(pwrctrl, CMD_ALIVE);
236	if ((pwrctrl->cpwm > PS_STATE_S2) &&
237	   (pwrctrl->pwr_mode > PS_MODE_ACTIVE)) {
238		if ((pwrctrl->alives == 0) &&
239		    (check_fwstate(&padapter->mlmepriv,
240		     _FW_UNDER_LINKING) != true)) {
241			r8712_set_rpwm(padapter, PS_STATE_S0);
242		}
243	}
244	up(&pwrctrl->lock);
245}
246