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