?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Staging: rtl8192e: remove firmware header file not being used
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / staging / rtl8192e / r819xE_firmware.c
blob56d73193ef8d4556a904e061593454dcb77d8d4e
1 /**************************************************************************************************
2 * Procedure: Init boot code/firmware code/data session
3 *
4 * Description: This routine will intialize firmware. If any error occurs during the initialization
5 * process, the routine shall terminate immediately and return fail.
6 * NIC driver should call NdisOpenFile only from MiniportInitialize.
7 *
8 * Arguments: The pointer of the adapter
9
10 * Returns:
11 * NDIS_STATUS_FAILURE - the following initialization process should be terminated
12 * NDIS_STATUS_SUCCESS - if firmware initialization process success
13 **************************************************************************************************/
14 //#include "ieee80211.h"
15 #include "r8192E.h"
16 #include "r8192E_hw.h"
17 //#include "r819xE_firmware_img.h"
18 #include "r819xE_firmware.h"
19 #include <linux/firmware.h>
20
21 void firmware_init_param(struct net_device *dev)
22 {
23 struct r8192_priv *priv = ieee80211_priv(dev);
24 rt_firmware *pfirmware = priv->pFirmware;
25
26 pfirmware->cmdpacket_frag_thresold = GET_COMMAND_PACKET_FRAG_THRESHOLD(MAX_TRANSMIT_BUFFER_SIZE);
27 }
28
29 /*
30 * segment the img and use the ptr and length to remember info on each segment
31 *
32 */
33 static bool fw_download_code(struct net_device *dev, u8 *code_virtual_address, u32 buffer_len)
34 {
35 struct r8192_priv *priv = ieee80211_priv(dev);
36 bool rt_status = true;
37 u16 frag_threshold;
38 u16 frag_length, frag_offset = 0;
39 //u16 total_size;
40 int i;
41
42 rt_firmware *pfirmware = priv->pFirmware;
43 struct sk_buff *skb;
44 unsigned char *seg_ptr;
45 cb_desc *tcb_desc;
46 u8 bLastIniPkt;
47
48 firmware_init_param(dev);
49 //Fragmentation might be required
50 frag_threshold = pfirmware->cmdpacket_frag_thresold;
51 do {
52 if((buffer_len - frag_offset) > frag_threshold) {
53 frag_length = frag_threshold ;
54 bLastIniPkt = 0;
55
56 } else {
57 frag_length = buffer_len - frag_offset;
58 bLastIniPkt = 1;
59
60 }
61
62 /* Allocate skb buffer to contain firmware info and tx descriptor info
63 * add 4 to avoid packet appending overflow.
64 * */
65 //skb = dev_alloc_skb(USB_HWDESC_HEADER_LEN + frag_length + 4);
66 skb = dev_alloc_skb(frag_length + 4);
67 memcpy((unsigned char *)(skb->cb),&dev,sizeof(dev));
68 tcb_desc = (cb_desc*)(skb->cb + MAX_DEV_ADDR_SIZE);
69 tcb_desc->queue_index = TXCMD_QUEUE;
70 tcb_desc->bCmdOrInit = DESC_PACKET_TYPE_INIT;
71 tcb_desc->bLastIniPkt = bLastIniPkt;
72
73 //skb_reserve(skb, USB_HWDESC_HEADER_LEN);
74 seg_ptr = skb->data;
75 /*
76 * Transform from little endian to big endian
77 * and pending zero
78 */
79 for(i=0 ; i < frag_length; i+=4) {
80 *seg_ptr++ = ((i+0)<frag_length)?code_virtual_address[i+3]:0;
81 *seg_ptr++ = ((i+1)<frag_length)?code_virtual_address[i+2]:0;
82 *seg_ptr++ = ((i+2)<frag_length)?code_virtual_address[i+1]:0;
83 *seg_ptr++ = ((i+3)<frag_length)?code_virtual_address[i+0]:0;
84 }
85 tcb_desc->txbuf_size= (u16)i;
86 skb_put(skb, i);
87 priv->ieee80211->softmac_hard_start_xmit(skb,dev);
88
89 code_virtual_address += frag_length;
90 frag_offset += frag_length;
91
92 }while(frag_offset < buffer_len);
93
94 return rt_status;
95 }
96
97 //-----------------------------------------------------------------------------
98 // Procedure: Check whether main code is download OK. If OK, turn on CPU
99 //
100 // Description: CPU register locates in different page against general register.
101 // Switch to CPU register in the begin and switch back before return
102 //
103 //
104 // Arguments: The pointer of the adapter
105 //
106 // Returns:
107 // NDIS_STATUS_FAILURE - the following initialization process should be terminated
108 // NDIS_STATUS_SUCCESS - if firmware initialization process success
109 //-----------------------------------------------------------------------------
110 static bool CPUcheck_maincodeok_turnonCPU(struct net_device *dev)
111 {
112 bool rt_status = true;
113 int check_putcodeOK_time = 200000, check_bootOk_time = 200000;
114 u32 CPU_status = 0;
115
116 /* Check whether put code OK */
117 do {
118 CPU_status = read_nic_dword(dev, CPU_GEN);
119
120 if(CPU_status&CPU_GEN_PUT_CODE_OK)
121 break;
122
123 }while(check_putcodeOK_time--);
124
125 if(!(CPU_status&CPU_GEN_PUT_CODE_OK)) {
126 RT_TRACE(COMP_ERR, "Download Firmware: Put code fail!\n");
127 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
128 } else {
129 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Put code ok!\n");
130 }
131
132 /* Turn On CPU */
133 CPU_status = read_nic_dword(dev, CPU_GEN);
134 write_nic_byte(dev, CPU_GEN, (u8)((CPU_status|CPU_GEN_PWR_STB_CPU)&0xff));
135 mdelay(1);
136
137 /* Check whether CPU boot OK */
138 do {
139 CPU_status = read_nic_dword(dev, CPU_GEN);
140
141 if(CPU_status&CPU_GEN_BOOT_RDY)
142 break;
143 }while(check_bootOk_time--);
144
145 if(!(CPU_status&CPU_GEN_BOOT_RDY)) {
146 goto CPUCheckMainCodeOKAndTurnOnCPU_Fail;
147 } else {
148 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Boot ready!\n");
149 }
150
151 return rt_status;
152
153 CPUCheckMainCodeOKAndTurnOnCPU_Fail:
154 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
155 rt_status = FALSE;
156 return rt_status;
157 }
158
159 static bool CPUcheck_firmware_ready(struct net_device *dev)
160 {
161
162 bool rt_status = true;
163 int check_time = 200000;
164 u32 CPU_status = 0;
165
166 /* Check Firmware Ready */
167 do {
168 CPU_status = read_nic_dword(dev, CPU_GEN);
169
170 if(CPU_status&CPU_GEN_FIRM_RDY)
171 break;
172
173 }while(check_time--);
174
175 if(!(CPU_status&CPU_GEN_FIRM_RDY))
176 goto CPUCheckFirmwareReady_Fail;
177 else
178 RT_TRACE(COMP_FIRMWARE, "Download Firmware: Firmware ready!\n");
179
180 return rt_status;
181
182 CPUCheckFirmwareReady_Fail:
183 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
184 rt_status = false;
185 return rt_status;
186
187 }
188
189 bool init_firmware(struct net_device *dev)
190 {
191 struct r8192_priv *priv = ieee80211_priv(dev);
192 bool rt_status = TRUE;
193
194 u8 *firmware_img_buf[3] = { &rtl8192e_fwboot_array[0],
195 &rtl8192e_fwmain_array[0],
196 &rtl8192e_fwdata_array[0]};
197
198 u32 firmware_img_len[3] = { sizeof(rtl8192e_fwboot_array),
199 sizeof(rtl8192e_fwmain_array),
200 sizeof(rtl8192e_fwdata_array)};
201 u32 file_length = 0;
202 u8 *mapped_file = NULL;
203 u32 init_step = 0;
204 opt_rst_type_e rst_opt = OPT_SYSTEM_RESET;
205 firmware_init_step_e starting_state = FW_INIT_STEP0_BOOT;
206
207 rt_firmware *pfirmware = priv->pFirmware;
208 const struct firmware *fw_entry;
209 const char *fw_name[3] = { "RTL8192E/boot.img",
210 "RTL8192E/main.img",
211 "RTL8192E/data.img"};
212 int rc;
213
214 RT_TRACE(COMP_FIRMWARE, " PlatformInitFirmware()==>\n");
215
216 if (pfirmware->firmware_status == FW_STATUS_0_INIT ) {
217 /* it is called by reset */
218 rst_opt = OPT_SYSTEM_RESET;
219 starting_state = FW_INIT_STEP0_BOOT;
220 // TODO: system reset
221
222 }else if(pfirmware->firmware_status == FW_STATUS_5_READY) {
223 /* it is called by Initialize */
224 rst_opt = OPT_FIRMWARE_RESET;
225 starting_state = FW_INIT_STEP2_DATA;
226 }else {
227 RT_TRACE(COMP_FIRMWARE, "PlatformInitFirmware: undefined firmware state\n");
228 }
229
230 /*
231 * Download boot, main, and data image for System reset.
232 * Download data image for firmware reseta
233 */
234 priv->firmware_source = FW_SOURCE_IMG_FILE;
235 for(init_step = starting_state; init_step <= FW_INIT_STEP2_DATA; init_step++) {
236 /*
237 * Open Image file, and map file to contineous memory if open file success.
238 * or read image file from array. Default load from IMG file
239 */
240 if(rst_opt == OPT_SYSTEM_RESET) {
241 switch(priv->firmware_source) {
242 case FW_SOURCE_IMG_FILE:
243 {
244 if(pfirmware->firmware_buf_size[init_step] == 0) {
245 rc = request_firmware(&fw_entry, fw_name[init_step],&priv->pdev->dev);
246 if(rc < 0 ) {
247 RT_TRACE(COMP_FIRMWARE, "request firmware fail!\n");
248 goto download_firmware_fail;
249 }
250
251 if(fw_entry->size > sizeof(pfirmware->firmware_buf[init_step])) {
252 RT_TRACE(COMP_FIRMWARE, "img file size exceed the container buffer fail!\n");
253 goto download_firmware_fail;
254 }
255
256 if(init_step != FW_INIT_STEP1_MAIN) {
257 memcpy(pfirmware->firmware_buf[init_step],fw_entry->data,fw_entry->size);
258 pfirmware->firmware_buf_size[init_step] = fw_entry->size;
259
260 } else {
261 memset(pfirmware->firmware_buf[init_step],0,128);
262 memcpy(&pfirmware->firmware_buf[init_step][128],fw_entry->data,fw_entry->size);
263 //mapped_file = pfirmware->firmware_buf[init_step];
264 pfirmware->firmware_buf_size[init_step] = fw_entry->size+128;
265 //file_length = fw_entry->size + 128;
266 }
267 //pfirmware->firmware_buf_size = file_length;
268
269 if(rst_opt == OPT_SYSTEM_RESET) {
270 release_firmware(fw_entry);
271 }
272 }
273 mapped_file = pfirmware->firmware_buf[init_step];
274 file_length = pfirmware->firmware_buf_size[init_step];
275 break;
276 }
277 case FW_SOURCE_HEADER_FILE:
278 mapped_file = firmware_img_buf[init_step];
279 file_length = firmware_img_len[init_step];
280 if(init_step == FW_INIT_STEP2_DATA) {
281 memcpy(pfirmware->firmware_buf[init_step], mapped_file, file_length);
282 pfirmware->firmware_buf_size[init_step] = file_length;
283 }
284 break;
285
286 default:
287 break;
288 }
289
290
291 }else if(rst_opt == OPT_FIRMWARE_RESET ) {
292 /* we only need to download data.img here */
293 mapped_file = pfirmware->firmware_buf[init_step];
294 file_length = pfirmware->firmware_buf_size[init_step];
295 }
296
297 /* Download image file */
298 /* The firmware download process is just as following,
299 * 1. that is each packet will be segmented and inserted to the wait queue.
300 * 2. each packet segment will be put in the skb_buff packet.
301 * 3. each skb_buff packet data content will already include the firmware info
302 * and Tx descriptor info
303 * */
304 rt_status = fw_download_code(dev,mapped_file,file_length);
305 if(rt_status != TRUE) {
306 goto download_firmware_fail;
307 }
308
309 switch(init_step) {
310 case FW_INIT_STEP0_BOOT:
311 /* Download boot
312 * initialize command descriptor.
313 * will set polling bit when firmware code is also configured
314 */
315 pfirmware->firmware_status = FW_STATUS_1_MOVE_BOOT_CODE;
316 //mdelay(1000);
317 /*
318 * To initialize IMEM, CPU move code from 0x80000080,
319 * hence, we send 0x80 byte packet
320 */
321 break;
322
323 case FW_INIT_STEP1_MAIN:
324 /* Download firmware code. Wait until Boot Ready and Turn on CPU */
325 pfirmware->firmware_status = FW_STATUS_2_MOVE_MAIN_CODE;
326
327 /* Check Put Code OK and Turn On CPU */
328 rt_status = CPUcheck_maincodeok_turnonCPU(dev);
329 if(rt_status != TRUE) {
330 RT_TRACE(COMP_FIRMWARE, "CPUcheck_maincodeok_turnonCPU fail!\n");
331 goto download_firmware_fail;
332 }
333
334 pfirmware->firmware_status = FW_STATUS_3_TURNON_CPU;
335 break;
336
337 case FW_INIT_STEP2_DATA:
338 /* download initial data code */
339 pfirmware->firmware_status = FW_STATUS_4_MOVE_DATA_CODE;
340 mdelay(1);
341
342 rt_status = CPUcheck_firmware_ready(dev);
343 if(rt_status != TRUE) {
344 RT_TRACE(COMP_FIRMWARE, "CPUcheck_firmware_ready fail(%d)!\n",rt_status);
345 goto download_firmware_fail;
346 }
347
348 /* wait until data code is initialized ready.*/
349 pfirmware->firmware_status = FW_STATUS_5_READY;
350 break;
351 }
352 }
353
354 RT_TRACE(COMP_FIRMWARE, "Firmware Download Success\n");
355 //assert(pfirmware->firmware_status == FW_STATUS_5_READY, ("Firmware Download Fail\n"));
356
357 return rt_status;
358
359 download_firmware_fail:
360 RT_TRACE(COMP_ERR, "ERR in %s()\n", __FUNCTION__);
361 rt_status = FALSE;
362 return rt_status;
363
364 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree