Loading...
Note: File does not exist in v6.8.
1/******************************************************************************
2 *
3 * Copyright(c) 2009-2014 Realtek Corporation.
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2 of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
12 * more details.
13 *
14 * The full GNU General Public License is included in this distribution in the
15 * file called LICENSE.
16 *
17 * Contact Information:
18 * wlanfae <wlanfae@realtek.com>
19 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
20 * Hsinchu 300, Taiwan.
21 *
22 * Larry Finger <Larry.Finger@lwfinger.net>
23 *
24 *****************************************************************************/
25
26#include "../wifi.h"
27#include "../pci.h"
28#include "../base.h"
29#include "fw_common.h"
30#include <linux/module.h>
31
32void rtl8723_enable_fw_download(struct ieee80211_hw *hw, bool enable)
33{
34 struct rtl_priv *rtlpriv = rtl_priv(hw);
35 u8 tmp;
36
37 if (enable) {
38 tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
39 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, tmp | 0x04);
40
41 tmp = rtl_read_byte(rtlpriv, REG_MCUFWDL);
42 rtl_write_byte(rtlpriv, REG_MCUFWDL, tmp | 0x01);
43
44 tmp = rtl_read_byte(rtlpriv, REG_MCUFWDL + 2);
45 rtl_write_byte(rtlpriv, REG_MCUFWDL + 2, tmp & 0xf7);
46 } else {
47 tmp = rtl_read_byte(rtlpriv, REG_MCUFWDL);
48 rtl_write_byte(rtlpriv, REG_MCUFWDL, tmp & 0xfe);
49
50 rtl_write_byte(rtlpriv, REG_MCUFWDL + 1, 0x00);
51 }
52}
53EXPORT_SYMBOL_GPL(rtl8723_enable_fw_download);
54
55void rtl8723_fw_block_write(struct ieee80211_hw *hw,
56 const u8 *buffer, u32 size)
57{
58 struct rtl_priv *rtlpriv = rtl_priv(hw);
59 u32 blocksize = sizeof(u32);
60 u8 *bufferptr = (u8 *)buffer;
61 u32 *pu4byteptr = (u32 *)buffer;
62 u32 i, offset, blockcount, remainsize;
63
64 blockcount = size / blocksize;
65 remainsize = size % blocksize;
66
67 for (i = 0; i < blockcount; i++) {
68 offset = i * blocksize;
69 rtl_write_dword(rtlpriv, (FW_8192C_START_ADDRESS + offset),
70 *(pu4byteptr + i));
71 }
72 if (remainsize) {
73 offset = blockcount * blocksize;
74 bufferptr += offset;
75 for (i = 0; i < remainsize; i++) {
76 rtl_write_byte(rtlpriv,
77 (FW_8192C_START_ADDRESS + offset + i),
78 *(bufferptr + i));
79 }
80 }
81}
82EXPORT_SYMBOL_GPL(rtl8723_fw_block_write);
83
84void rtl8723_fw_page_write(struct ieee80211_hw *hw,
85 u32 page, const u8 *buffer, u32 size)
86{
87 struct rtl_priv *rtlpriv = rtl_priv(hw);
88 u8 value8;
89 u8 u8page = (u8) (page & 0x07);
90
91 value8 = (rtl_read_byte(rtlpriv, REG_MCUFWDL + 2) & 0xF8) | u8page;
92
93 rtl_write_byte(rtlpriv, (REG_MCUFWDL + 2), value8);
94 rtl8723_fw_block_write(hw, buffer, size);
95}
96EXPORT_SYMBOL_GPL(rtl8723_fw_page_write);
97
98static void rtl8723_fill_dummy(u8 *pfwbuf, u32 *pfwlen)
99{
100 u32 fwlen = *pfwlen;
101 u8 remain = (u8) (fwlen % 4);
102
103 remain = (remain == 0) ? 0 : (4 - remain);
104
105 while (remain > 0) {
106 pfwbuf[fwlen] = 0;
107 fwlen++;
108 remain--;
109 }
110 *pfwlen = fwlen;
111}
112
113void rtl8723_write_fw(struct ieee80211_hw *hw,
114 enum version_8723e version,
115 u8 *buffer, u32 size)
116{
117 struct rtl_priv *rtlpriv = rtl_priv(hw);
118 u8 *bufferptr = buffer;
119 u32 pagenums, remainsize;
120 u32 page, offset;
121
122 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD, "FW size is %d bytes,\n", size);
123
124 rtl8723_fill_dummy(bufferptr, &size);
125
126 pagenums = size / FW_8192C_PAGE_SIZE;
127 remainsize = size % FW_8192C_PAGE_SIZE;
128
129 if (pagenums > 8) {
130 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
131 "Page numbers should not greater then 8\n");
132 }
133 for (page = 0; page < pagenums; page++) {
134 offset = page * FW_8192C_PAGE_SIZE;
135 rtl8723_fw_page_write(hw, page, (bufferptr + offset),
136 FW_8192C_PAGE_SIZE);
137 }
138 if (remainsize) {
139 offset = pagenums * FW_8192C_PAGE_SIZE;
140 page = pagenums;
141 rtl8723_fw_page_write(hw, page, (bufferptr + offset),
142 remainsize);
143 }
144}
145EXPORT_SYMBOL_GPL(rtl8723_write_fw);
146
147void rtl8723ae_firmware_selfreset(struct ieee80211_hw *hw)
148{
149 u8 u1tmp;
150 u8 delay = 100;
151 struct rtl_priv *rtlpriv = rtl_priv(hw);
152
153 rtl_write_byte(rtlpriv, REG_HMETFR + 3, 0x20);
154 u1tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
155
156 while (u1tmp & BIT(2)) {
157 delay--;
158 if (delay == 0)
159 break;
160 udelay(50);
161 u1tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
162 }
163 if (delay == 0) {
164 u1tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
165 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, u1tmp&(~BIT(2)));
166 }
167}
168EXPORT_SYMBOL_GPL(rtl8723ae_firmware_selfreset);
169
170void rtl8723be_firmware_selfreset(struct ieee80211_hw *hw)
171{
172 u8 u1b_tmp;
173 struct rtl_priv *rtlpriv = rtl_priv(hw);
174
175 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
176 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp & (~BIT(0))));
177
178 u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
179 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, (u1b_tmp & (~BIT(2))));
180 udelay(50);
181
182 u1b_tmp = rtl_read_byte(rtlpriv, REG_RSV_CTRL + 1);
183 rtl_write_byte(rtlpriv, REG_RSV_CTRL + 1, (u1b_tmp | BIT(0)));
184
185 u1b_tmp = rtl_read_byte(rtlpriv, REG_SYS_FUNC_EN + 1);
186 rtl_write_byte(rtlpriv, REG_SYS_FUNC_EN + 1, (u1b_tmp | BIT(2)));
187
188 RT_TRACE(rtlpriv, COMP_INIT, DBG_LOUD,
189 " _8051Reset8723be(): 8051 reset success .\n");
190}
191EXPORT_SYMBOL_GPL(rtl8723be_firmware_selfreset);
192
193int rtl8723_fw_free_to_go(struct ieee80211_hw *hw, bool is_8723be)
194{
195 struct rtl_priv *rtlpriv = rtl_priv(hw);
196 int err = -EIO;
197 u32 counter = 0;
198 u32 value32;
199
200 do {
201 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL);
202 } while ((counter++ < FW_8192C_POLLING_TIMEOUT_COUNT) &&
203 (!(value32 & FWDL_CHKSUM_RPT)));
204
205 if (counter >= FW_8192C_POLLING_TIMEOUT_COUNT) {
206 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
207 "chksum report fail ! REG_MCUFWDL:0x%08x .\n",
208 value32);
209 goto exit;
210 }
211 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
212 "Checksum report OK ! REG_MCUFWDL:0x%08x .\n", value32);
213
214 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL) | MCUFWDL_RDY;
215 value32 &= ~WINTINI_RDY;
216 rtl_write_dword(rtlpriv, REG_MCUFWDL, value32);
217
218 if (is_8723be)
219 rtl8723be_firmware_selfreset(hw);
220 counter = 0;
221
222 do {
223 value32 = rtl_read_dword(rtlpriv, REG_MCUFWDL);
224 if (value32 & WINTINI_RDY) {
225 RT_TRACE(rtlpriv, COMP_FW, DBG_TRACE,
226 "Polling FW ready success!! "
227 "REG_MCUFWDL:0x%08x .\n",
228 value32);
229 err = 0;
230 goto exit;
231 }
232 udelay(FW_8192C_POLLING_DELAY);
233
234 } while (counter++ < FW_8192C_POLLING_TIMEOUT_COUNT);
235
236 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
237 "Polling FW ready fail!! REG_MCUFWDL:0x%08x .\n",
238 value32);
239
240exit:
241 return err;
242}
243EXPORT_SYMBOL_GPL(rtl8723_fw_free_to_go);
244
245int rtl8723_download_fw(struct ieee80211_hw *hw,
246 bool is_8723be)
247{
248 struct rtl_priv *rtlpriv = rtl_priv(hw);
249 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
250 struct rtl92c_firmware_header *pfwheader;
251 u8 *pfwdata;
252 u32 fwsize;
253 int err;
254 enum version_8723e version = rtlhal->version;
255
256 if (!rtlhal->pfirmware)
257 return 1;
258
259 pfwheader = (struct rtl92c_firmware_header *)rtlhal->pfirmware;
260 pfwdata = rtlhal->pfirmware;
261 fwsize = rtlhal->fwsize;
262 RT_TRACE(rtlpriv, COMP_FW, DBG_DMESG,
263 "normal Firmware SIZE %d\n", fwsize);
264
265 if (rtlpriv->cfg->ops->is_fw_header(pfwheader)) {
266 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD,
267 "Firmware Version(%d), Signature(%#x), Size(%d)\n",
268 pfwheader->version, pfwheader->signature,
269 (int)sizeof(struct rtl92c_firmware_header));
270
271 pfwdata = pfwdata + sizeof(struct rtl92c_firmware_header);
272 fwsize = fwsize - sizeof(struct rtl92c_firmware_header);
273 }
274 if (rtl_read_byte(rtlpriv, REG_MCUFWDL) & BIT(7)) {
275 rtl_write_byte(rtlpriv, REG_MCUFWDL, 0);
276 if (is_8723be)
277 rtl8723be_firmware_selfreset(hw);
278 else
279 rtl8723ae_firmware_selfreset(hw);
280 }
281 rtl8723_enable_fw_download(hw, true);
282 rtl8723_write_fw(hw, version, pfwdata, fwsize);
283 rtl8723_enable_fw_download(hw, false);
284
285 err = rtl8723_fw_free_to_go(hw, is_8723be);
286 if (err) {
287 RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
288 "Firmware is not ready to run!\n");
289 } else {
290 RT_TRACE(rtlpriv, COMP_FW, DBG_LOUD,
291 "Firmware is ready to run!\n");
292 }
293 return 0;
294}
295EXPORT_SYMBOL_GPL(rtl8723_download_fw);
296
297bool rtl8723_cmd_send_packet(struct ieee80211_hw *hw,
298 struct sk_buff *skb)
299{
300 struct rtl_priv *rtlpriv = rtl_priv(hw);
301 struct rtl_pci *rtlpci = rtl_pcidev(rtl_pcipriv(hw));
302 struct rtl8192_tx_ring *ring;
303 struct rtl_tx_desc *pdesc;
304 struct sk_buff *pskb = NULL;
305 u8 own;
306 unsigned long flags;
307
308 ring = &rtlpci->tx_ring[BEACON_QUEUE];
309
310 pskb = __skb_dequeue(&ring->queue);
311 if (pskb)
312 kfree_skb(pskb);
313
314 spin_lock_irqsave(&rtlpriv->locks.irq_th_lock, flags);
315
316 pdesc = &ring->desc[0];
317 own = (u8) rtlpriv->cfg->ops->get_desc((u8 *)pdesc, true, HW_DESC_OWN);
318
319 rtlpriv->cfg->ops->fill_tx_cmddesc(hw, (u8 *)pdesc, 1, 1, skb);
320
321 __skb_queue_tail(&ring->queue, skb);
322
323 spin_unlock_irqrestore(&rtlpriv->locks.irq_th_lock, flags);
324
325 rtlpriv->cfg->ops->tx_polling(hw, BEACON_QUEUE);
326
327 return true;
328}
329EXPORT_SYMBOL_GPL(rtl8723_cmd_send_packet);