Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 40332e5fd3fff3cb4ab3ceb173033dcfab4d48d5

Authored by Larry Finger
Committed by John W. Linville
1 parent 0985dfbc51
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

rtlwifi: rtl8192c: Convert driver to use private dm structs 

Convert rtl8192c to use the dm_digtable struct in the common header file
instead of the global variable. Without this change, every instance of
rtl8192ce and rtl8192cu will be using the same global arrays.

Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

Showing 4 changed files with 123 additions and 112 deletions Side-by-side Diff

drivers/net/wireless/rtlwifi/rtl8192c/dm_common.c
Diff comments   View file @ 40332e5
... ... @@ -33,7 +33,6 @@
33 33 #include "../pci.h"
34 34 #include "../base.h"
35 35  
36   -struct dig_t dm_digtable;
37 36 static struct ps_t dm_pstable;
38 37  
39 38 #define BT_RSSI_STATE_NORMAL_POWER BIT_OFFSET_LEN_MASK_32(0, 1)
40 39  
41 40  
... ... @@ -163,33 +162,37 @@
163 162  
164 163 static void rtl92c_dm_diginit(struct ieee80211_hw *hw)
165 164 {
166   - dm_digtable.dig_enable_flag = true;
167   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
168   - dm_digtable.cur_igvalue = 0x20;
169   - dm_digtable.pre_igvalue = 0x0;
170   - dm_digtable.cursta_connectctate = DIG_STA_DISCONNECT;
171   - dm_digtable.presta_connectstate = DIG_STA_DISCONNECT;
172   - dm_digtable.curmultista_connectstate = DIG_MULTISTA_DISCONNECT;
173   - dm_digtable.rssi_lowthresh = DM_DIG_THRESH_LOW;
174   - dm_digtable.rssi_highthresh = DM_DIG_THRESH_HIGH;
175   - dm_digtable.fa_lowthresh = DM_FALSEALARM_THRESH_LOW;
176   - dm_digtable.fa_highthresh = DM_FALSEALARM_THRESH_HIGH;
177   - dm_digtable.rx_gain_range_max = DM_DIG_MAX;
178   - dm_digtable.rx_gain_range_min = DM_DIG_MIN;
179   - dm_digtable.backoff_val = DM_DIG_BACKOFF_DEFAULT;
180   - dm_digtable.backoff_val_range_max = DM_DIG_BACKOFF_MAX;
181   - dm_digtable.backoff_val_range_min = DM_DIG_BACKOFF_MIN;
182   - dm_digtable.pre_cck_pd_state = CCK_PD_STAGE_MAX;
183   - dm_digtable.cur_cck_pd_state = CCK_PD_STAGE_MAX;
  165 + struct rtl_priv *rtlpriv = rtl_priv(hw);
  166 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
  167 +
  168 + dm_digtable->dig_enable_flag = true;
  169 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
  170 + dm_digtable->cur_igvalue = 0x20;
  171 + dm_digtable->pre_igvalue = 0x0;
  172 + dm_digtable->cursta_connectctate = DIG_STA_DISCONNECT;
  173 + dm_digtable->presta_connectstate = DIG_STA_DISCONNECT;
  174 + dm_digtable->curmultista_connectstate = DIG_MULTISTA_DISCONNECT;
  175 + dm_digtable->rssi_lowthresh = DM_DIG_THRESH_LOW;
  176 + dm_digtable->rssi_highthresh = DM_DIG_THRESH_HIGH;
  177 + dm_digtable->fa_lowthresh = DM_FALSEALARM_THRESH_LOW;
  178 + dm_digtable->fa_highthresh = DM_FALSEALARM_THRESH_HIGH;
  179 + dm_digtable->rx_gain_range_max = DM_DIG_MAX;
  180 + dm_digtable->rx_gain_range_min = DM_DIG_MIN;
  181 + dm_digtable->backoff_val = DM_DIG_BACKOFF_DEFAULT;
  182 + dm_digtable->backoff_val_range_max = DM_DIG_BACKOFF_MAX;
  183 + dm_digtable->backoff_val_range_min = DM_DIG_BACKOFF_MIN;
  184 + dm_digtable->pre_cck_pd_state = CCK_PD_STAGE_MAX;
  185 + dm_digtable->cur_cck_pd_state = CCK_PD_STAGE_MAX;
184 186 }
185 187  
186 188 static u8 rtl92c_dm_initial_gain_min_pwdb(struct ieee80211_hw *hw)
187 189 {
188 190 struct rtl_priv *rtlpriv = rtl_priv(hw);
  191 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
189 192 long rssi_val_min = 0;
190 193  
191   - if ((dm_digtable.curmultista_connectstate == DIG_MULTISTA_CONNECT) &&
192   - (dm_digtable.cursta_connectctate == DIG_STA_CONNECT)) {
  194 + if ((dm_digtable->curmultista_connectstate == DIG_MULTISTA_CONNECT) &&
  195 + (dm_digtable->cursta_connectctate == DIG_STA_CONNECT)) {
193 196 if (rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb != 0)
194 197 rssi_val_min =
195 198 (rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb >
196 199  
... ... @@ -198,10 +201,10 @@
198 201 rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
199 202 else
200 203 rssi_val_min = rtlpriv->dm.undecorated_smoothed_pwdb;
201   - } else if (dm_digtable.cursta_connectctate == DIG_STA_CONNECT ||
202   - dm_digtable.cursta_connectctate == DIG_STA_BEFORE_CONNECT) {
  204 + } else if (dm_digtable->cursta_connectctate == DIG_STA_CONNECT ||
  205 + dm_digtable->cursta_connectctate == DIG_STA_BEFORE_CONNECT) {
203 206 rssi_val_min = rtlpriv->dm.undecorated_smoothed_pwdb;
204   - } else if (dm_digtable.curmultista_connectstate ==
  207 + } else if (dm_digtable->curmultista_connectstate ==
205 208 DIG_MULTISTA_CONNECT) {
206 209 rssi_val_min = rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
207 210 }
... ... @@ -260,7 +263,8 @@
260 263 static void rtl92c_dm_ctrl_initgain_by_fa(struct ieee80211_hw *hw)
261 264 {
262 265 struct rtl_priv *rtlpriv = rtl_priv(hw);
263   - u8 value_igi = dm_digtable.cur_igvalue;
  266 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
  267 + u8 value_igi = dm_digtable->cur_igvalue;
264 268  
265 269 if (rtlpriv->falsealm_cnt.cnt_all < DM_DIG_FA_TH0)
266 270 value_igi--;
267 271  
268 272  
269 273  
270 274  
271 275  
272 276  
273 277  
... ... @@ -277,43 +281,44 @@
277 281 if (rtlpriv->falsealm_cnt.cnt_all > 10000)
278 282 value_igi = 0x32;
279 283  
280   - dm_digtable.cur_igvalue = value_igi;
  284 + dm_digtable->cur_igvalue = value_igi;
281 285 rtl92c_dm_write_dig(hw);
282 286 }
283 287  
284 288 static void rtl92c_dm_ctrl_initgain_by_rssi(struct ieee80211_hw *hw)
285 289 {
286 290 struct rtl_priv *rtlpriv = rtl_priv(hw);
  291 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
287 292  
288   - if (rtlpriv->falsealm_cnt.cnt_all > dm_digtable.fa_highthresh) {
289   - if ((dm_digtable.backoff_val - 2) <
290   - dm_digtable.backoff_val_range_min)
291   - dm_digtable.backoff_val =
292   - dm_digtable.backoff_val_range_min;
  293 + if (rtlpriv->falsealm_cnt.cnt_all > dm_digtable->fa_highthresh) {
  294 + if ((dm_digtable->backoff_val - 2) <
  295 + dm_digtable->backoff_val_range_min)
  296 + dm_digtable->backoff_val =
  297 + dm_digtable->backoff_val_range_min;
293 298 else
294   - dm_digtable.backoff_val -= 2;
295   - } else if (rtlpriv->falsealm_cnt.cnt_all < dm_digtable.fa_lowthresh) {
296   - if ((dm_digtable.backoff_val + 2) >
297   - dm_digtable.backoff_val_range_max)
298   - dm_digtable.backoff_val =
299   - dm_digtable.backoff_val_range_max;
  299 + dm_digtable->backoff_val -= 2;
  300 + } else if (rtlpriv->falsealm_cnt.cnt_all < dm_digtable->fa_lowthresh) {
  301 + if ((dm_digtable->backoff_val + 2) >
  302 + dm_digtable->backoff_val_range_max)
  303 + dm_digtable->backoff_val =
  304 + dm_digtable->backoff_val_range_max;
300 305 else
301   - dm_digtable.backoff_val += 2;
  306 + dm_digtable->backoff_val += 2;
302 307 }
303 308  
304   - if ((dm_digtable.rssi_val_min + 10 - dm_digtable.backoff_val) >
305   - dm_digtable.rx_gain_range_max)
306   - dm_digtable.cur_igvalue = dm_digtable.rx_gain_range_max;
307   - else if ((dm_digtable.rssi_val_min + 10 -
308   - dm_digtable.backoff_val) < dm_digtable.rx_gain_range_min)
309   - dm_digtable.cur_igvalue = dm_digtable.rx_gain_range_min;
  309 + if ((dm_digtable->rssi_val_min + 10 - dm_digtable->backoff_val) >
  310 + dm_digtable->rx_gain_range_max)
  311 + dm_digtable->cur_igvalue = dm_digtable->rx_gain_range_max;
  312 + else if ((dm_digtable->rssi_val_min + 10 -
  313 + dm_digtable->backoff_val) < dm_digtable->rx_gain_range_min)
  314 + dm_digtable->cur_igvalue = dm_digtable->rx_gain_range_min;
310 315 else
311   - dm_digtable.cur_igvalue = dm_digtable.rssi_val_min + 10 -
312   - dm_digtable.backoff_val;
  316 + dm_digtable->cur_igvalue = dm_digtable->rssi_val_min + 10 -
  317 + dm_digtable->backoff_val;
313 318  
314 319 RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE,
315 320 "rssi_val_min = %x backoff_val %x\n",
316   - dm_digtable.rssi_val_min, dm_digtable.backoff_val);
  321 + dm_digtable->rssi_val_min, dm_digtable->backoff_val);
317 322  
318 323 rtl92c_dm_write_dig(hw);
319 324 }
... ... @@ -322,6 +327,7 @@
322 327 {
323 328 static u8 initialized; /* initialized to false */
324 329 struct rtl_priv *rtlpriv = rtl_priv(hw);
  330 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
325 331 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
326 332 long rssi_strength = rtlpriv->dm.entry_min_undecoratedsmoothed_pwdb;
327 333 bool multi_sta = false;
328 334  
329 335  
330 336  
331 337  
332 338  
333 339  
334 340  
335 341  
336 342  
337 343  
338 344  
339 345  
340 346  
... ... @@ -330,68 +336,69 @@
330 336 multi_sta = true;
331 337  
332 338 if (!multi_sta ||
333   - dm_digtable.cursta_connectctate != DIG_STA_DISCONNECT) {
  339 + dm_digtable->cursta_connectctate != DIG_STA_DISCONNECT) {
334 340 initialized = false;
335   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
  341 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
336 342 return;
337 343 } else if (initialized == false) {
338 344 initialized = true;
339   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_0;
340   - dm_digtable.cur_igvalue = 0x20;
  345 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_0;
  346 + dm_digtable->cur_igvalue = 0x20;
341 347 rtl92c_dm_write_dig(hw);
342 348 }
343 349  
344   - if (dm_digtable.curmultista_connectstate == DIG_MULTISTA_CONNECT) {
345   - if ((rssi_strength < dm_digtable.rssi_lowthresh) &&
346   - (dm_digtable.dig_ext_port_stage != DIG_EXT_PORT_STAGE_1)) {
  350 + if (dm_digtable->curmultista_connectstate == DIG_MULTISTA_CONNECT) {
  351 + if ((rssi_strength < dm_digtable->rssi_lowthresh) &&
  352 + (dm_digtable->dig_ext_port_stage != DIG_EXT_PORT_STAGE_1)) {
347 353  
348   - if (dm_digtable.dig_ext_port_stage ==
  354 + if (dm_digtable->dig_ext_port_stage ==
349 355 DIG_EXT_PORT_STAGE_2) {
350   - dm_digtable.cur_igvalue = 0x20;
  356 + dm_digtable->cur_igvalue = 0x20;
351 357 rtl92c_dm_write_dig(hw);
352 358 }
353 359  
354   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_1;
355   - } else if (rssi_strength > dm_digtable.rssi_highthresh) {
356   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_2;
  360 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_1;
  361 + } else if (rssi_strength > dm_digtable->rssi_highthresh) {
  362 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_2;
357 363 rtl92c_dm_ctrl_initgain_by_fa(hw);
358 364 }
359   - } else if (dm_digtable.dig_ext_port_stage != DIG_EXT_PORT_STAGE_0) {
360   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_0;
361   - dm_digtable.cur_igvalue = 0x20;
  365 + } else if (dm_digtable->dig_ext_port_stage != DIG_EXT_PORT_STAGE_0) {
  366 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_0;
  367 + dm_digtable->cur_igvalue = 0x20;
362 368 rtl92c_dm_write_dig(hw);
363 369 }
364 370  
365 371 RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE,
366 372 "curmultista_connectstate = %x dig_ext_port_stage %x\n",
367   - dm_digtable.curmultista_connectstate,
368   - dm_digtable.dig_ext_port_stage);
  373 + dm_digtable->curmultista_connectstate,
  374 + dm_digtable->dig_ext_port_stage);
369 375 }
370 376  
371 377 static void rtl92c_dm_initial_gain_sta(struct ieee80211_hw *hw)
372 378 {
373 379 struct rtl_priv *rtlpriv = rtl_priv(hw);
  380 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
374 381  
375 382 RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE,
376 383 "presta_connectstate = %x, cursta_connectctate = %x\n",
377   - dm_digtable.presta_connectstate,
378   - dm_digtable.cursta_connectctate);
  384 + dm_digtable->presta_connectstate,
  385 + dm_digtable->cursta_connectctate);
379 386  
380   - if (dm_digtable.presta_connectstate == dm_digtable.cursta_connectctate
381   - || dm_digtable.cursta_connectctate == DIG_STA_BEFORE_CONNECT
382   - || dm_digtable.cursta_connectctate == DIG_STA_CONNECT) {
  387 + if (dm_digtable->presta_connectstate == dm_digtable->cursta_connectctate
  388 + || dm_digtable->cursta_connectctate == DIG_STA_BEFORE_CONNECT
  389 + || dm_digtable->cursta_connectctate == DIG_STA_CONNECT) {
383 390  
384   - if (dm_digtable.cursta_connectctate != DIG_STA_DISCONNECT) {
385   - dm_digtable.rssi_val_min =
  391 + if (dm_digtable->cursta_connectctate != DIG_STA_DISCONNECT) {
  392 + dm_digtable->rssi_val_min =
386 393 rtl92c_dm_initial_gain_min_pwdb(hw);
387 394 rtl92c_dm_ctrl_initgain_by_rssi(hw);
388 395 }
389 396 } else {
390   - dm_digtable.rssi_val_min = 0;
391   - dm_digtable.dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
392   - dm_digtable.backoff_val = DM_DIG_BACKOFF_DEFAULT;
393   - dm_digtable.cur_igvalue = 0x20;
394   - dm_digtable.pre_igvalue = 0;
  397 + dm_digtable->rssi_val_min = 0;
  398 + dm_digtable->dig_ext_port_stage = DIG_EXT_PORT_STAGE_MAX;
  399 + dm_digtable->backoff_val = DM_DIG_BACKOFF_DEFAULT;
  400 + dm_digtable->cur_igvalue = 0x20;
  401 + dm_digtable->pre_igvalue = 0;
395 402 rtl92c_dm_write_dig(hw);
396 403 }
397 404 }
398 405  
399 406  
400 407  
401 408  
402 409  
403 410  
404 411  
405 412  
406 413  
407 414  
... ... @@ -400,40 +407,41 @@
400 407 {
401 408 struct rtl_priv *rtlpriv = rtl_priv(hw);
402 409 struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
  410 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
403 411  
404   - if (dm_digtable.cursta_connectctate == DIG_STA_CONNECT) {
405   - dm_digtable.rssi_val_min = rtl92c_dm_initial_gain_min_pwdb(hw);
  412 + if (dm_digtable->cursta_connectctate == DIG_STA_CONNECT) {
  413 + dm_digtable->rssi_val_min = rtl92c_dm_initial_gain_min_pwdb(hw);
406 414  
407   - if (dm_digtable.pre_cck_pd_state == CCK_PD_STAGE_LowRssi) {
408   - if (dm_digtable.rssi_val_min <= 25)
409   - dm_digtable.cur_cck_pd_state =
  415 + if (dm_digtable->pre_cck_pd_state == CCK_PD_STAGE_LowRssi) {
  416 + if (dm_digtable->rssi_val_min <= 25)
  417 + dm_digtable->cur_cck_pd_state =
410 418 CCK_PD_STAGE_LowRssi;
411 419 else
412   - dm_digtable.cur_cck_pd_state =
  420 + dm_digtable->cur_cck_pd_state =
413 421 CCK_PD_STAGE_HighRssi;
414 422 } else {
415   - if (dm_digtable.rssi_val_min <= 20)
416   - dm_digtable.cur_cck_pd_state =
  423 + if (dm_digtable->rssi_val_min <= 20)
  424 + dm_digtable->cur_cck_pd_state =
417 425 CCK_PD_STAGE_LowRssi;
418 426 else
419   - dm_digtable.cur_cck_pd_state =
  427 + dm_digtable->cur_cck_pd_state =
420 428 CCK_PD_STAGE_HighRssi;
421 429 }
422 430 } else {
423   - dm_digtable.cur_cck_pd_state = CCK_PD_STAGE_MAX;
  431 + dm_digtable->cur_cck_pd_state = CCK_PD_STAGE_MAX;
424 432 }
425 433  
426   - if (dm_digtable.pre_cck_pd_state != dm_digtable.cur_cck_pd_state) {
427   - if (dm_digtable.cur_cck_pd_state == CCK_PD_STAGE_LowRssi) {
  434 + if (dm_digtable->pre_cck_pd_state != dm_digtable->cur_cck_pd_state) {
  435 + if (dm_digtable->cur_cck_pd_state == CCK_PD_STAGE_LowRssi) {
428 436 if (rtlpriv->falsealm_cnt.cnt_cck_fail > 800)
429   - dm_digtable.cur_cck_fa_state =
  437 + dm_digtable->cur_cck_fa_state =
430 438 CCK_FA_STAGE_High;
431 439 else
432   - dm_digtable.cur_cck_fa_state = CCK_FA_STAGE_Low;
  440 + dm_digtable->cur_cck_fa_state = CCK_FA_STAGE_Low;
433 441  
434   - if (dm_digtable.pre_cck_fa_state !=
435   - dm_digtable.cur_cck_fa_state) {
436   - if (dm_digtable.cur_cck_fa_state ==
  442 + if (dm_digtable->pre_cck_fa_state !=
  443 + dm_digtable->cur_cck_fa_state) {
  444 + if (dm_digtable->cur_cck_fa_state ==
437 445 CCK_FA_STAGE_Low)
438 446 rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2,
439 447 0x83);
... ... @@ -441,8 +449,8 @@
441 449 rtl_set_bbreg(hw, RCCK0_CCA, MASKBYTE2,
442 450 0xcd);
443 451  
444   - dm_digtable.pre_cck_fa_state =
445   - dm_digtable.cur_cck_fa_state;
  452 + dm_digtable->pre_cck_fa_state =
  453 + dm_digtable->cur_cck_fa_state;
446 454 }
447 455  
448 456 rtl_set_bbreg(hw, RCCK0_SYSTEM, MASKBYTE1, 0x40);
449 457  
... ... @@ -458,11 +466,11 @@
458 466 rtl_set_bbreg(hw, RCCK0_FALSEALARMREPORT,
459 467 MASKBYTE2, 0xd3);
460 468 }
461   - dm_digtable.pre_cck_pd_state = dm_digtable.cur_cck_pd_state;
  469 + dm_digtable->pre_cck_pd_state = dm_digtable->cur_cck_pd_state;
462 470 }
463 471  
464 472 RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, "CCKPDStage=%x\n",
465   - dm_digtable.cur_cck_pd_state);
  473 + dm_digtable->cur_cck_pd_state);
466 474  
467 475 RT_TRACE(rtlpriv, COMP_DIG, DBG_TRACE, "is92C=%x\n",
468 476 IS_92C_SERIAL(rtlhal->version));
469 477  
470 478  
471 479  
472 480  
473 481  
... ... @@ -470,31 +478,34 @@
470 478  
471 479 static void rtl92c_dm_ctrl_initgain_by_twoport(struct ieee80211_hw *hw)
472 480 {
  481 + struct rtl_priv *rtlpriv = rtl_priv(hw);
  482 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
473 483 struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
474 484  
475 485 if (mac->act_scanning)
476 486 return;
477 487  
478 488 if (mac->link_state >= MAC80211_LINKED)
479   - dm_digtable.cursta_connectctate = DIG_STA_CONNECT;
  489 + dm_digtable->cursta_connectctate = DIG_STA_CONNECT;
480 490 else
481   - dm_digtable.cursta_connectctate = DIG_STA_DISCONNECT;
  491 + dm_digtable->cursta_connectctate = DIG_STA_DISCONNECT;
482 492  
483 493 rtl92c_dm_initial_gain_sta(hw);
484 494 rtl92c_dm_initial_gain_multi_sta(hw);
485 495 rtl92c_dm_cck_packet_detection_thresh(hw);
486 496  
487   - dm_digtable.presta_connectstate = dm_digtable.cursta_connectctate;
  497 + dm_digtable->presta_connectstate = dm_digtable->cursta_connectctate;
488 498  
489 499 }
490 500  
491 501 static void rtl92c_dm_dig(struct ieee80211_hw *hw)
492 502 {
493 503 struct rtl_priv *rtlpriv = rtl_priv(hw);
  504 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
494 505  
495 506 if (rtlpriv->dm.dm_initialgain_enable == false)
496 507 return;
497   - if (dm_digtable.dig_enable_flag == false)
  508 + if (dm_digtable->dig_enable_flag == false)
498 509 return;
499 510  
500 511 rtl92c_dm_ctrl_initgain_by_twoport(hw);
501 512  
502 513  
503 514  
504 515  
505 516  
506 517  
... ... @@ -514,23 +525,24 @@
514 525 void rtl92c_dm_write_dig(struct ieee80211_hw *hw)
515 526 {
516 527 struct rtl_priv *rtlpriv = rtl_priv(hw);
  528 + struct dig_t *dm_digtable = &rtlpriv->dm_digtable;
517 529  
518 530 RT_TRACE(rtlpriv, COMP_DIG, DBG_LOUD,
519 531 "cur_igvalue = 0x%x, pre_igvalue = 0x%x, backoff_val = %d\n",
520   - dm_digtable.cur_igvalue, dm_digtable.pre_igvalue,
521   - dm_digtable.backoff_val);
  532 + dm_digtable->cur_igvalue, dm_digtable->pre_igvalue,
  533 + dm_digtable->backoff_val);
522 534  
523   - dm_digtable.cur_igvalue += 2;
524   - if (dm_digtable.cur_igvalue > 0x3f)
525   - dm_digtable.cur_igvalue = 0x3f;
  535 + dm_digtable->cur_igvalue += 2;
  536 + if (dm_digtable->cur_igvalue > 0x3f)
  537 + dm_digtable->cur_igvalue = 0x3f;
526 538  
527   - if (dm_digtable.pre_igvalue != dm_digtable.cur_igvalue) {
  539 + if (dm_digtable->pre_igvalue != dm_digtable->cur_igvalue) {
528 540 rtl_set_bbreg(hw, ROFDM0_XAAGCCORE1, 0x7f,
529   - dm_digtable.cur_igvalue);
  541 + dm_digtable->cur_igvalue);
530 542 rtl_set_bbreg(hw, ROFDM0_XBAGCCORE1, 0x7f,
531   - dm_digtable.cur_igvalue);
  543 + dm_digtable->cur_igvalue);
532 544  
533   - dm_digtable.pre_igvalue = dm_digtable.cur_igvalue;
  545 + dm_digtable->pre_igvalue = dm_digtable->cur_igvalue;
534 546 }
535 547 }
536 548 EXPORT_SYMBOL(rtl92c_dm_write_dig);
drivers/net/wireless/rtlwifi/rtl8192c/dm_common.h
Diff comments   View file @ 40332e5
... ... @@ -155,7 +155,6 @@
155 155 DIG_CONNECT_MAX
156 156 };
157 157  
158   -extern struct dig_t dm_digtable;
159 158 void rtl92c_dm_init(struct ieee80211_hw *hw);
160 159 void rtl92c_dm_watchdog(struct ieee80211_hw *hw);
161 160 void rtl92c_dm_write_dig(struct ieee80211_hw *hw);
drivers/net/wireless/rtlwifi/rtl8192c/phy_common.c
Diff comments   View file @ 40332e5
... ... @@ -1881,6 +1881,7 @@
1881 1881 {
1882 1882 struct rtl_priv *rtlpriv = rtl_priv(hw);
1883 1883 struct rtl_phy *rtlphy = &(rtlpriv->phy);
  1884 + struct dig_t dm_digtable = rtlpriv->dm_digtable;
1884 1885  
1885 1886 RT_TRACE(rtlpriv, COMP_CMD, DBG_TRACE,
1886 1887 "--->Cmd(%#x), set_io_inprogress(%d)\n",
drivers/net/wireless/rtlwifi/rtl8192ce/dm.h
Diff comments   View file @ 40332e5
... ... @@ -150,7 +150,6 @@
150 150 DIG_CONNECT_MAX
151 151 };
152 152  
153   -extern struct dig_t dm_digtable;
154 153 void rtl92c_dm_init(struct ieee80211_hw *hw);
155 154 void rtl92c_dm_watchdog(struct ieee80211_hw *hw);
156 155 void rtl92c_dm_write_dig(struct ieee80211_hw *hw);