?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-btrfs-devel.git] / drivers / staging / rtl8192e / r8192E_firmware.c
blob37719859bdae6dd3e6613b9179ec432d3ee6e481
1 /******************************************************************************
2 * Copyright(c) 2008 - 2010 Realtek Corporation. All rights reserved.
3 *
4 * This program is distributed in the hope that it will be useful, but WITHOUT
5 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
6 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
7 * more details.
8 *
9 * You should have received a copy of the GNU General Public License along with
10 * this program; if not, write to the Free Software Foundation, Inc.,
11 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
12 *
13 * The full GNU General Public License is included in this distribution in the
14 * file called LICENSE.
15 *
16 * Contact Information:
17 * wlanfae <wlanfae@realtek.com>
18 ******************************************************************************/
19
20 #include "rtl_core.h"
21 #include "r8192E_hw.h"
22 #include "r8192E_hwimg.h"
23 #include "r8192E_firmware.h"
24 #include <linux/firmware.h>
25
26 void firmware_init_param(struct net_device *dev)
27 {
28 struct r8192_priv *priv = rtllib_priv(dev);
29 struct rt_firmware *pfirmware = priv->pFirmware;
30
31 pfirmware->cmdpacket_frag_thresold = GET_COMMAND_PACKET_FRAG_THRESHOLD(
32 MAX_TRANSMIT_BUFFER_SIZE);
33 }
34
35 static bool fw_download_code(struct net_device *dev, u8 *code_virtual_address,
36 u32 buffer_len)
37 {
38 struct r8192_priv *priv = rtllib_priv(dev);
39 bool rt_status = true;
40 u16 frag_threshold;
41 u16 frag_length, frag_offset = 0;
42 int i;
43
44 struct rt_firmware *pfirmware = priv->pFirmware;
45 struct sk_buff *skb;
46 unsigned char *seg_ptr;
47 struct cb_desc *tcb_desc;
48 u8 bLastIniPkt;
49
50 firmware_init_param(dev);
51 frag_threshold = pfirmware->cmdpacket_frag_thresold;
52 do {
53 if ((buffer_len - frag_offset) > frag_threshold) {
54 frag_length = frag_threshold ;
55 bLastIniPkt = 0;
56
57 } else {
58 frag_length = buffer_len - frag_offset;
59 bLastIniPkt = 1;
60
61 }
62
63 skb = dev_alloc_skb(frag_length + 4);
64 memcpy((unsigned char *)(skb->cb), &dev, sizeof(dev));
65 tcb_desc = (struct cb_desc *)(skb->cb + MAX_DEV_ADDR_SIZE);
66 tcb_desc->queue_index = TXCMD_QUEUE;
67 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
68 tcb_desc->bLastIniPkt = bLastIniPkt;
69
70 seg_ptr = skb->data;
71 for (i = 0; i < frag_length; i += 4) {
72 *seg_ptr++ = ((i+0) < frag_length) ?
73 code_virtual_address[i+3] : 0;
74 *seg_ptr++ = ((i+1) < frag_length) ?
75 code_virtual_address[i+2] : 0;
76 *seg_ptr++ = ((i+2) < frag_length) ?
77 code_virtual_address[i+1] : 0;
78 *seg_ptr++ = ((i+3) < frag_length) ?
79 code_virtual_address[i+0] : 0;
80 }
81 tcb_desc->txbuf_size = (u16)i;
82 skb_put(skb, i);
83
84 if (!priv->rtllib->check_nic_enough_desc(dev, tcb_desc->queue_index) ||
85 (!skb_queue_empty(&priv->rtllib->skb_waitQ[tcb_desc->queue_index])) ||
86 (priv->rtllib->queue_stop)) {
87 RT_TRACE(COMP_FIRMWARE, "===================> tx "
88 "full!\n");
89 skb_queue_tail(&priv->rtllib->skb_waitQ
90 [tcb_desc->queue_index], skb);
91 } else {
92 priv->rtllib->softmac_hard_start_xmit(skb, dev);
93 }
94
95 code_virtual_address += frag_length;
96 frag_offset += frag_length;
97
98 } while (frag_offset < buffer_len);
99
100 write_nic_byte(dev, TPPoll, TPPoll_CQ);
101
102 return rt_status;
103 }
104
105 static bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev)
106 {
107 bool rt_status = true;
108 u32 CPU_status = 0;
109 unsigned long timeout;
110
111 timeout = jiffies + MSECS(200);
112 while (time_before(jiffies, timeout)) {
113 CPU_status = read_nic_dword(dev, CPU_GEN);
114 if (CPU_status & CPU_GEN_PUT_CODE_OK)
115 break;
116 mdelay(2);
117 }
118
119 if (!(CPU_status&CPU_GEN_PUT_CODE_OK)) {
120 RT_TRACE(COMP_ERR, "Download Firmware: Put code fail!\n");
121 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
122 } else {
123 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
124 }
125
126 CPU_status = read_nic_dword(dev, CPU_GEN);
127 write_nic_byte(dev, CPU_GEN,
128 (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
129 mdelay(1);
130
131 timeout = jiffies + MSECS(200);
132 while (time_before(jiffies, timeout)) {
133 CPU_status = read_nic_dword(dev, CPU_GEN);
134 if (CPU_status&CPU_GEN_BOOT_RDY)
135 break;
136 mdelay(2);
137 }
138
139 if (!(CPU_status&CPU_GEN_BOOT_RDY))
140 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
141 else
142 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
143
144 return rt_status;
145
146 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
147 RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
148 rt_status = false;
149 return rt_status;
150 }
151
152 static bool CPUcheck_firmware_ready(struct net_device *dev)
153 {
154
155 bool rt_status = true;
156 u32 CPU_status = 0;
157 unsigned long timeout;
158
159 timeout = jiffies + MSECS(20);
160 while (time_before(jiffies, timeout)) {
161 CPU_status = read_nic_dword(dev, CPU_GEN);
162 if (CPU_status&CPU_GEN_FIRM_RDY)
163 break;
164 mdelay(2);
165 }
166
167 if (!(CPU_status&CPU_GEN_FIRM_RDY))
168 goto CPUCheckFirmwareReady_Fail;
169 else
170 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Firmware ready!\n");
171
172 return rt_status;
173
174 CPUCheckFirmwareReady_Fail:
175 RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
176 rt_status = false;
177 return rt_status;
178
179 }
180
181 static bool firmware_check_ready(struct net_device *dev,
182 u8 load_fw_status)
183 {
184 struct r8192_priv *priv = rtllib_priv(dev);
185 struct rt_firmware *pfirmware = priv->pFirmware;
186 bool rt_status = true;
187
188 switch (load_fw_status) {
189 case FW_INIT_STEP0_BOOT:
190 pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE;
191 break;
192
193 case FW_INIT_STEP1_MAIN:
194 pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE;
195
196 rt_status = CPUcheck_maincodeok_turnonCPU(dev);
197 if (rt_status)
198 pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU;
199 else
200 RT_TRACE(COMP_FIRMWARE, "CPUcheck_maincodeok_turnon"
201 "CPU fail!\n");
202
203 break;
204
205 case FW_INIT_STEP2_DATA:
206 pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE;
207 mdelay(1);
208
209 rt_status = CPUcheck_firmware_ready(dev);
210 if (rt_status)
211 pfirmware->firmware_status = FW_STATUS_5_READY;
212 else
213 RT_TRACE(COMP_FIRMWARE, "CPUcheck_firmware_ready fail"
214 "(%d)!\n", rt_status);
215
216 break;
217 default:
218 rt_status = false;
219 RT_TRACE(COMP_FIRMWARE, "Unknown firware status");
220 break;
221 }
222
223 return rt_status;
224 }
225
226 bool init_firmware(struct net_device *dev)
227 {
228 struct r8192_priv *priv = rtllib_priv(dev);
229 bool rt_status = true;
230
231 u8 *firmware_img_buf[3] = { &Rtl8192PciEFwBootArray[0],
232 &Rtl8192PciEFwMainArray[0],
233 &Rtl8192PciEFwDataArray[0]};
234
235 u32 firmware_img_len[3] = { sizeof(Rtl8192PciEFwBootArray),
236 sizeof(Rtl8192PciEFwMainArray),
237 sizeof(Rtl8192PciEFwDataArray)};
238 u32 file_length = 0;
239 u8 *mapped_file = NULL;
240 u8 init_step = 0;
241 enum opt_rst_type rst_opt = OPT_SYSTEM_RESET;
242 enum firmware_init_step starting_state = FW_INIT_STEP0_BOOT;
243
244 struct rt_firmware *pfirmware = priv->pFirmware;
245
246 RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
247
248 if (pfirmware->firmware_status == FW_STATUS_0_INIT) {
249 rst_opt = OPT_SYSTEM_RESET;
250 starting_state = FW_INIT_STEP0_BOOT;
251
252 } else if (pfirmware->firmware_status == FW_STATUS_5_READY) {
253 rst_opt = OPT_FIRMWARE_RESET;
254 starting_state = FW_INIT_STEP2_DATA;
255 } else {
256 RT_TRACE(COMP_FIRMWARE, "PlatformInitFirmware: undefined"
257 " firmware state\n");
258 }
259
260 priv->firmware_source = FW_SOURCE_IMG_FILE;
261 for (init_step = starting_state; init_step <= FW_INIT_STEP2_DATA;
262 init_step++) {
263 if (rst_opt == OPT_SYSTEM_RESET) {
264 switch (priv->firmware_source) {
265 case FW_SOURCE_IMG_FILE:
266 {
267 if (pfirmware->firmware_buf_size[init_step] == 0) {
268 const char *fw_name[3] = { "RTL8192E/boot.img",
269 "RTL8192E/main.img",
270 "RTL8192E/data.img"
271 };
272 const struct firmware *fw_entry;
273 int rc;
274 rc = request_firmware(&fw_entry,
275 fw_name[init_step], &priv->pdev->dev);
276 if (rc < 0) {
277 RT_TRACE(COMP_FIRMWARE, "request firm"
278 "ware fail!\n");
279 goto download_firmware_fail;
280 }
281 if (fw_entry->size >
282 sizeof(pfirmware->firmware_buf[init_step])) {
283 RT_TRACE(COMP_FIRMWARE, "img file size "
284 "exceed the container struct "
285 "buffer fail!\n");
286 goto download_firmware_fail;
287 }
288
289 if (init_step != FW_INIT_STEP1_MAIN) {
290 memcpy(pfirmware->firmware_buf[init_step],
291 fw_entry->data, fw_entry->size);
292 pfirmware->firmware_buf_size[init_step] =
293 fw_entry->size;
294
295 } else {
296 memset(pfirmware->firmware_buf[init_step],
297 0, 128);
298 memcpy(&pfirmware->firmware_buf[init_step][128],
299 fw_entry->data, fw_entry->size);
300 pfirmware->firmware_buf_size[init_step] =
301 fw_entry->size + 128;
302 }
303
304 if (rst_opt == OPT_SYSTEM_RESET)
305 release_firmware(fw_entry);
306 }
307 mapped_file = pfirmware->firmware_buf[init_step];
308 file_length = pfirmware->firmware_buf_size[init_step];
309 break;
310 }
311 case FW_SOURCE_HEADER_FILE:
312 mapped_file = firmware_img_buf[init_step];
313 file_length = firmware_img_len[init_step];
314 if (init_step == FW_INIT_STEP2_DATA) {
315 memcpy(pfirmware->firmware_buf[init_step], mapped_file, file_length);
316 pfirmware->firmware_buf_size[init_step] = file_length;
317 }
318 break;
319
320 default:
321 break;
322 }
323
324
325 } else if (rst_opt == OPT_FIRMWARE_RESET) {
326 mapped_file = pfirmware->firmware_buf[init_step];
327 file_length = pfirmware->firmware_buf_size[init_step];
328 }
329
330 rt_status = fw_download_code(dev, mapped_file, file_length);
331 if (rt_status != true) {
332 goto download_firmware_fail;
333 }
334
335 if (!firmware_check_ready(dev, init_step)) {
336 goto download_firmware_fail;
337 }
338 }
339
340 RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
341 return rt_status;
342
343 download_firmware_fail:
344 RT_TRACE(COMP_ERR, "ERR in %s()\n", __func__);
345 rt_status = false;
346 return rt_status;
347
348 }
Linux Btrfs Development