Gitiles
Code Review Sign In
192.168.1.100 / T800_MD_V1.6 / c33b3079c38f91561c2f84f1ebed20ad8c60532a / . / mcu / l1 / gl1 / l1d_ext / m12191.c
blob: d1fd6f6e7650285330f72b9deb31236626d75fd6 [file] [log] [blame]
yu.dongc33b3072024-08-21 23:14:49 -0700[diff] [blame^]1/*****************************************************************************
2* Copyright Statement:
3* --------------------
4* This software is protected by Copyright and the information contained
5* herein is confidential. The software may not be copied and the information
6* contained herein may not be used or disclosed except with the written
7* permission of MediaTek Inc. (C) 2005
8*
9* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
10* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
11* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
12* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
13* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
14* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
15* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
16* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
17* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
18* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
19* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
20* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
21*
22* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
23* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
24* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
25* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
26* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
27*
28* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
29* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
30* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
31* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
32* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
33*
34*****************************************************************************/
35
36/*******************************************************************************
37 *
38 * Filename:
39 * ---------
40 * m12191.c
41 *
42 * Project:
43 * --------
44 * MT6208
45 *
46 * Description:
47 * ------------
48 * Setup Synthesizer
49 *
50 * Author:
51 * -------
52 * -------
53 *
54 *------------------------------------------------------------------------------
55 * $Revision: 1.30 $
56 * $Modtime: Jul 29 2005 13:44:06 $
57 * $Log: //mtkvs01/vmdata/Maui_sw/archives/mcu/l1/l1d/m12191.c-arc $
58 *
59 * 12 17 2018 yw.lee
60 * [MOLY00372594] [2GL1D] CT2 gain update, OBB close MLNA, ELT trace
61 * .
62 *
63 * 10 01 2018 tim.tsai
64 * [MOLY00356374] [Gen97][GL1D] 2G RFD porting
65 * .[Vmoly] Or RF option MT6190T
66 *
67 * 09 20 2018 rick.lee
68 * [MOLY00346462] [GL1D][RF]merge UMOLYE patch back to VMOLY
69 *
70 * 09 10 2018 rick.lee
71 * [MOLY00346462] [GL1D][RF][Gen95] Trinity2L 2G porting
72 * .Trinity2L patch back to UMOLYE
73 *
74 * 08 06 2018 rick.lee
75 * [MOLY00340337] [GL1D][RFD][Gen95] TrinityL-E2 2G porting
76 * .TrinityLE2 Dev patch back to UMOLYE
77 *
78 * 08 02 2018 rick.lee
79 * [MOLY00340337][GL1D][RF] TrinityLE2 Dev patch back to UMOLYE
80 *
81 * 07 20 2018 rick.lee
82 * [MOLY00340337] [GL1D][RFD][Gen95] TrinityL-E2 2G porting
83 * [GL1D][RFD][Gen95] TrinityL-E2 2G RF porting
84 *
85 * 06 13 2018 yw.lee
86 * [MOLY00332889] [2GL1D][TrinityL] TPD control
87 * .
88 *
89 * 02 21 2018 tim.tsai
90 * [MOLY00305636] [Trinity][GL1D] 2G LNA port and if_sel and change float point to fix point
91 * .
92 *
93 * 12 26 2017 tim.tsai
94 * [MOLY00296149] [MT6295][GL1D] 2G Trinity L porting
95 * .
96 *
97 * 12 15 2017 tim.tsai
98 * [MOLY00293063] [TRINITY_DEV][L1D] 2G Trinity E1 2G RFD porting
99 * .
100 *
101 * 11 10 2017 tim.tsai
102 * [MOLY00288931] [MT6295][L1D] 2G TRINITY E1 RFD
103 * .
104 *
105 * 06 12 2017 tim.tsai
106 * [MOLY00256723] [UMOLYA][ZION][L1D] MT6177M 2G RF Driver
107 * .
108 *
109 * 01 06 2017 silvers.peng
110 * [MOLY00223254] [L1D]Bianco BB RF Driver check in 1st wave
111 * .
112 *
113 * 03 15 2016 yw.chen
114 * [MOLY00169087] [L1D] MT6179 2G RF Driver Modification
115 * .
116 *
117 * 03 10 2016 siyu.li
118 * [MOLY00168264] UMOLY 2G MIPI support three pa data
119 * .
120 *
121 * 01 20 2016 wiley.li
122 * [MOLY00150655] [L1D][Modify] KDCO patch to improve GMSK peak phase error
123 *
124 * .
125 *
126 * 09 10 2015 wiley.li
127 * [MOLY00141314] [L1D][Modify] Fix GL1D build warning & add API for Low pcl subband cal.
128 * .
129 *
130 * 07 10 2015 wiley.li
131 * [MOLY00127251] [L1D][Modify] Update 2G Driver(Update E3 CW & remove IF_state)
132 * .
133 *
134 * 04 09 2015 ola.lee
135 * [MOLY00091988] [L1D] Update MT6176 2G RF Driver
136 * Update 2G SRX_DOUBLER_EN Setting.
137 *
138 * 02 10 2015 ola.lee
139 * [MOLY00091988] [L1D] Update MT6176 2G RF Driver
140 * .
141 *
142 * 02 10 2015 yi-ying.lin
143 * [MOLY00095496] [L1D][Modify] TK6291 CC NVRAM and custom data modification L1D part
144 * .
145 *
146 * 02 02 2015 ola.lee
147 * [MOLY00091988] [L1D] Update MT6176 2G RF Driver
148 *
149 * 10 06 2014 ola.lee
150 * [MOLY00080299] [L1D] Check in 2G Fix AFC for MT6169
151 * .
152 *
153 * 10 28 2013 vend_sherman.chung
154 * [MOLY00043231] [MT6290] Add 2G MIPI Control table store at NVRAM feature
155 * .
156 *
157 * 10 24 2013 vend_sherman.chung
158 * [MOLY00043231] [MT6290] Add 2G MIPI Control table store at NVRAM feature
159 * .
160 *
161 * 10 02 2013 ola.lee
162 * [MOLY00039576] [MT6165] Merget MT6165 to MOLY for Dual Talk
163 * .
164 *
165 * 08 14 2013 yi-ying.lin
166 * [MOLY00028415] [82LTE.SMT.DEV] 6166/6169 2G calibration feature development
167 * .
168 *
169 * 07 17 2013 chunyen.wu
170 * [MOLY00030116] [L1D][Modify] MIPI load on MT6290
171 * .
172 *
173 * 04 15 2013 yuyang.hsiao
174 * [MOLY00016402] [L1D][Modify] Update MT6169 RF final parameter
175 * .
176 *
177 * 03 28 2013 yuyang.hsiao
178 * [MOLY00012979] [L1D][Modify] Add MT6169 RF Driver
179 * .
180 *
181 * 12 06 2012 sean.yang
182 * [MOLY00007140] [L1D][Modify] Modify the flow to set the RX settings for integer and non-integer channels on OthelloT
183 * .
184 *
185 * 03 29 2012 samuel.yang
186 * removed!
187 * .
188 *
189 * 03 15 2012 yuyang.hsiao
190 * removed!
191 * .
192 *
193 * 11 17 2011 chang-kuan.lin
194 * removed!
195 * .
196 *
197 * 10 21 2011 th.yeh
198 * removed!
199 * .
200 *
201 * 08 24 2011 victo.chen
202 * removed!
203 * .
204 *
205 * 07 21 2011 weining.chien
206 * removed!
207 * .
208 *
209 * 07 19 2011 victo.chen
210 * removed!
211 * .
212 *
213 * 06 18 2011 victo.chen
214 * removed!
215 * .
216 *
217 * 04 15 2011 weining.chien
218 * removed!
219 * .
220 *
221 * 04 14 2011 sean.yang
222 * removed!
223 * .
224 *
225 * 03 16 2011 victo.chen
226 * removed!
227 * .
228 *
229 * 03 11 2011 sean.yang
230 * removed!
231 * .
232 *
233 * 01 25 2011 victo.chen
234 * removed!
235 * .
236 *
237 * 01 16 2011 chuwei.lo
238 * removed!
239 * .
240 *
241 * 01 05 2011 chuwei.lo
242 * removed!
243 * .
244 *
245 * 01 04 2011 sean.yang
246 * removed!
247 * .
248 *
249 * 12 20 2010 sean.yang
250 * removed!
251 * .
252 *
253 * 12 15 2010 chang-kuan.lin
254 * removed!
255 * .
256 *
257 * 12 08 2010 chuwei.lo
258 * removed!
259 * .
260 *
261 * 11 24 2010 sean.yang
262 * removed!
263 * .
264 *
265 * 11 18 2010 max.weng
266 * removed!
267 * .
268 *
269 * 11 16 2010 victo.chen
270 * removed!
271 * .
272 *
273 * 11 12 2010 max.weng
274 * removed!
275 * .
276 *
277 * 11 10 2010 yr.chiang
278 * removed!
279 * .
280 *
281 * 11 09 2010 max.weng
282 * removed!
283 * .
284 *
285 * 09 05 2010 victo.chen
286 * removed!
287 * .
288 *
289 * 08 12 2010 victo.chen
290 * removed!
291 * .
292 *
293 * 08 07 2010 samuel.yang
294 * removed!
295 * .
296 *
297 * removed!
298 * removed!
299 * Merge MT6251 DVT branch back to MAUI
300 *
301 * removed!
302 * removed!
303 *
304 *
305 * removed!
306 * removed!
307 *
308 *
309 * removed!
310 * removed!
311 *
312 *
313 * removed!
314 * removed!
315 *
316 *
317 * removed!
318 * removed!
319 *
320 *
321 * removed!
322 * removed!
323 *
324 *
325 * removed!
326 * removed!
327 * [L1D][Modify]Check in AD6546 RF Driver #if IS_RF_AD6546
328 *
329 * removed!
330 * removed!
331 * Remove compile warning of may be used before being set
332 *
333 * removed!
334 * removed!
335 * local variable f_vco is not used
336 *
337 * removed!
338 * removed!
339 *
340 *
341 * removed!
342 * removed!
343 *
344 *
345 * removed!
346 * removed!
347 *
348 *
349 * removed!
350 * removed!
351 *
352 *
353 * removed!
354 * removed!
355 *
356 *
357 * removed!
358 * removed!
359 *
360 *
361 * removed!
362 * removed!
363 *
364 *
365 * removed!
366 * removed!
367 *
368 *
369 * removed!
370 * removed!
371 * < Triple850>
372 * RF chip gets GSM900 signal from GSm850 input pins to avoid getting GSM900 signal
373 *
374 * removed!
375 * removed!
376 * Add code to support GSM850 signal received through GSM900 path
377 *
378 * removed!
379 * removed!
380 * Add RF driver of IRFS3001
381 *
382 * removed!
383 * removed!
384 *
385 *
386 * removed!
387 * removed!
388 *
389 *
390 * removed!
391 * removed!
392 *
393 *
394 * removed!
395 * removed!
396 *
397 *
398 * removed!
399 * removed!
400 *
401 *
402 * removed!
403 * removed!
404 *
405 *
406 * removed!
407 * removed!
408 *
409 *
410 * removed!
411 * removed!
412 *
413 *
414 * removed!
415 * removed!
416 *
417 *
418 * Rev 1.30 Jul 29 2005 14:01:24 mtk00773
419 * [L1D][Enhence] Support RF SKY74117
420 * Resolution for 12111: [L1D][Enhence] Support RF SKY74117
421 *
422 * Rev 1.29 Jul 08 2005 16:53:04 mtk00939
423 * [L1D][Modify]L1D add code for MT6139C and META related code
424 *
425 * Rev 1.28 May 17 2005 00:34:36 BM_Trunk
426 * Karlos:
427 * add copyright and disclaimer statement
428 *
429 * Rev 1.27 Jan 18 2005 00:38:08 BM
430 * append new line in W05.04
431 *
432 * Rev 1.26 Jul 30 2004 17:37:06 mtk00240
433 * L1D add code to support AERO1Plus RF chip
434 * Resolution for 6925: [L1D][Enhance] L1D add code to support AERO1Plus RF chip
435 *
436 * Rev 1.25 Jul 05 2004 15:49:42 mtk00773
437 * Add RF POLARIS1 setting
438 *
439 * Rev 1.24 May 21 2004 19:01:58 mtk00240
440 * Add code to support MT6129D
441 * Resolution for 5565: [L1D][Add Feature] Add code to support MT6129D
442 *
443 * Rev 1.23 Jan 27 2004 15:33:12 mtk00585
444 * [L1D][Add] L1D Add code for MT6129C RF Driver.
445 *
446 * Rev 1.22 Oct 23 2003 14:22:18 mtk00585
447 * [L1D][Add] L1D Add code for MT6129B RF Driver.
448 * Resolution for 3177: [L1D][Add] L1D Add code for MT6129B RF Driver.
449 *
450 * Rev 1.21 Jul 11 2003 17:41:30 mtk00489
451 * [L1D][Enhanced]L1D supports MT6129A
452 * Resolution for 2241: [L1D][Enhanced]L1D supports MT6129A
453 *
454 * Rev 1.20 May 16 2003 13:09:24 mtk00489
455 * [L1D][New Feature]L1D supports MT6119C
456 * Resolution for 1794: [L1D][New Feature]L1D supports MT6119C
457 *
458 * Rev 1.19 Mar 07 2003 18:47:32 mtk00474
459 * modify the coding error for decision tx arfcn value of MT6119
460 * Resolution for 1182: modify the coding error for decision tx arfcn value of MT6119
461 *
462 * Rev 1.18 14 Feb 2003 11:42:54 mtk00240
463 * L1D modify the synthesizer setting of Bright4 to support PCS band
464 * Resolution for 652: L1D modify the synthesizer setting of Bright4 to support PCS band
465 *
466 * Rev 1.17 Nov 11 2002 18:04:58 mtk00474
467 * Update MT6119 and AERO RF parameters
468 * Resolution for 557: Update MT6119 and AERO RF parameters
469 *
470 * Rev 1.16 01 Nov 2002 11:11:24 mtk00240
471 * L1D modify TX PLL evaulation for new MT6119 chip
472 * Resolution for 547: L1D modify TX PLL evaulation for new MT6119 chip
473 *
474 * Rev 1.15 22 Oct 2002 08:18:00 mtk00240
475 * L1D modified some control data of mt6119
476 * Resolution for 439: L1D add code to support MT6119 RF Module
477 *
478 * Rev 1.14 01 Oct 2002 09:41:12 mtk00240
479 * L1D modified GSM RX frequency evaluation of MT6119
480 * Resolution for 515: L1D modified GSM RX frequency evaluation of MT6119
481 *
482 * Rev 1.13 01 Sep 2002 15:35:30 mtk00240
483 * L1D fix the bug that max ARFCN of GSM is 1023 not 1024
484 * Resolution for 473: L1D fix the bug that max ARFCN of GSM is 1023 not 1024
485 *
486 * Rev 1.12 27 Aug 2002 12:04:22 admin
487 * change file header
488 *
489 * Rev 1.11 26 Aug 2002 14:34:14 admin
490 * remove modification notice
491 * add copyright statement.
492 *
493 * Rev 1.10 24 Aug 2002 14:10:46 mtk00240
494 * L1D add code to support AERO RF Module
495 * Resolution for 464: L1D add code to support AERO RF Module
496 *
497 * Rev 1.9 23 Jul 2002 15:49:12 mtk00240
498 * L1D add code to support MT6119 RF Module
499 * Resolution for 439: L1D add code to support MT6119 RF Module
500 *
501 * Rev 1.8 03 Jul 2002 21:43:48 mtk00240
502 * L1D extrract RF setting code to let customer setup new RF module more easily
503 * Resolution for 418: L1D extrract RF setting code to let customer setup new RF module more easily
504 *
505 * Rev 1.7 01 May 2002 22:45:58 mtk00240
506 * Extract GSM code from L1D
507 * Resolution for 384: Extract GSM code from L1D
508 *
509 * Rev 1.6 30 Mar 2002 13:04:16 mtk00240
510 * 1) Modify L1D code to support both Bright2 & Bright4 RF board
511 * 2) L1D add Audio interface to support Voice Memo & Melody
512 * 3) Add L1D code to support RAM-based chip
513 * Resolution for 341: Modify L1D code to support both Bright2 & Bright4 RF board
514 * Resolution for 342: L1D add Audio interface to support Voice Memo & Melody
515 * Resolution for 343: Add L1D code to support RAM-based chip
516 *
517 * Rev 1.5 03 Mar 2002 23:07:10 mtk00240
518 * L1D modified Tx synthesizer setting of DCS band
519 * Resolution for 306: L1D modified Tx synthesizer setting of DCS band
520 *
521 * Rev 1.4 17 Feb 2002 20:15:42 mtk00240
522 * Update L1D code for solving HandOver test item
523 * Resolution for 275: Update L1D code for solving HandOver test item
524 *
525 * Rev 1.3 03 Jan 2002 12:19:50 mtk00240
526 * Merge B.L1.20011225 to Main V1.XX
527 *
528 * Rev 1.2.1.0 Dec 25 2001 14:32:56 mtk00210
529 * Update for High resolution RSSI, multiband AFC,
530 * update L1C/L1D interface for CSD
531 *
532 * Rev 1.1 Dec 10 2001 16:43:56 mtk00240
533 * Add copyright header of MediaTek
534 *
535 *******************************************************************************/
536
537
538/*===============================================================================*/
539/* */
540/* void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN ) */
541/* void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN ) */
542/* */
543/*===============================================================================*/
544/* */
545/* arfcn : the request ARFCN number. */
546/* *rfN : returned RF N counter setting */
547/* *ifN : returned IF N counter setting */
548/* */
549/* ----------------------------------------------------------------------------- */
550/* */
551/* This program evaluates the PLL setting value by the request arfcn for Si4133. */
552/* If the PLL component is changed, this file shall be modified by vendor */
553/* */
554/* ----------------------------------------------------------------------------- */
555
556#include "l1d_cid.h"
557#include "m12190_l1core.h"
558
559/*================================================================================================*/
560
561#if IS_RF_BRIGHT2
562/*BRIGHT2*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
563/*BRIGHT2*/ { long setting = 0;
564/*BRIGHT2*/
565/*BRIGHT2*/ switch(rf_band)
566/*BRIGHT2*/ {
567/*BRIGHT2*/ case FrequencyBand900 :
568/*BRIGHT2*/ {
569/*BRIGHT2*/ if( arfcn<=124 ) /* GSM( 0~ 124), */
570/*BRIGHT2*/ setting = (5800L<<4)|4;
571/*BRIGHT2*/ else /* GSM(975~1023), */
572/*BRIGHT2*/ setting = (4776L<<4)|4;
573/*BRIGHT2*/ break;
574/*BRIGHT2*/ }
575/*BRIGHT2*/ case FrequencyBand1800 :
576/*BRIGHT2*/ {
577/*BRIGHT2*/ setting = (7389L<<4)|3; /* DCS(512~ 885), */
578/*BRIGHT2*/ break;
579/*BRIGHT2*/ }
580/*BRIGHT2*/ default :
581/*BRIGHT2*/ {
582/*BRIGHT2*/ break;
583/*BRIGHT2*/ }
584/*BRIGHT2*/ }
585/*BRIGHT2*/ *rfN = setting + (arfcn<<4);
586/*BRIGHT2*/ *ifN = (2700L<<4) | 5;
587/*BRIGHT2*/ }
588/*BRIGHT2*/ /* =========================================================================== */
589/*BRIGHT2*/
590/*BRIGHT2*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
591/*BRIGHT2*/ { long setting = 0;
592/*BRIGHT2*/
593/*BRIGHT2*/ switch(rf_band)
594/*BRIGHT2*/ {
595/*BRIGHT2*/ case FrequencyBand900 :
596/*BRIGHT2*/ {
597/*BRIGHT2*/ if( arfcn<=124 ) /* GSM( 0~ 124), */
598/*BRIGHT2*/ { setting = (5800L<<4)|4; }
599/*BRIGHT2*/ else /* GSM(975~1023), */
600/*BRIGHT2*/ { setting = (4776L<<4)|4; }
601/*BRIGHT2*/ *ifN = (2700L<<4)|5; /* 54M/200K */
602/*BRIGHT2*/ break;
603/*BRIGHT2*/ }
604/*BRIGHT2*/ case FrequencyBand1800 :
605/*BRIGHT2*/ {
606/*BRIGHT2*/ setting = (7389L<<4)|3; /* DCS(512~ 885), */
607/*BRIGHT2*/ *ifN = (2600L<<4)|5; /* 52M/200K */
608/*BRIGHT2*/ break;
609/*BRIGHT2*/ }
610/*BRIGHT2*/ default :
611/*BRIGHT2*/ { break;
612/*BRIGHT2*/ }
613/*BRIGHT2*/ }
614/*BRIGHT2*/ *rfN = setting + (arfcn<<4);
615/*BRIGHT2*/ }
616/*BRIGHT2*/ /* =========================================================================== */
617#endif
618
619#if IS_RF_BRIGHT4
620/*BRIGHT4*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
621/*BRIGHT4*/ {
622/*BRIGHT4*/ switch(rf_band)
623/*BRIGHT4*/ {
624/*BRIGHT4*/ case FrequencyBand900 :
625/*BRIGHT4*/ {
626/*BRIGHT4*/ if(arfcn<=50)
627/*BRIGHT4*/ { *rfN = 0x0490C9 + (arfcn<<6); } /* ARFCN : 1~ 50 */
628/*BRIGHT4*/ else if(arfcn<=124)
629/*BRIGHT4*/ { *rfN = 0x4490C9 + (arfcn<<6); } /* ARFCN : 51~ 124 */
630/*BRIGHT4*/ else
631/*BRIGHT4*/ { *rfN = 0x0390C9 + (arfcn<<6); } /* ARFCN : 975~1023 */
632/*BRIGHT4*/ break;
633/*BRIGHT4*/ }
634/*BRIGHT4*/ case FrequencyBand1800 :
635/*BRIGHT4*/ {
636/*BRIGHT4*/ *rfN = 0x042851 + (arfcn<<5); /* ARFCN : 512~ 885 */
637/*BRIGHT4*/ break;
638/*BRIGHT4*/ }
639/*BRIGHT4*/ case FrequencyBand1900 :
640/*BRIGHT4*/ {
641/*BRIGHT4*/ *rfN = 0x447679 + (arfcn<<5); /* ARFCN : 512~ 810 */
642/*BRIGHT4*/ break;
643/*BRIGHT4*/ }
644/*BRIGHT4*/ default :
645/*BRIGHT4*/ {
646/*BRIGHT4*/ break;
647/*BRIGHT4*/ }
648/*BRIGHT4*/ }
649/*BRIGHT4*/ *ifN = 0;
650/*BRIGHT4*/ }
651/*BRIGHT4*/ /* =========================================================================== */
652/*BRIGHT4*/
653/*BRIGHT4*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
654/*BRIGHT4*/ {
655/*BRIGHT4*/ switch(rf_band)
656/*BRIGHT4*/ {
657/*BRIGHT4*/ case FrequencyBand900 :
658/*BRIGHT4*/ {
659/*BRIGHT4*/ if(arfcn<=10)
660/*BRIGHT4*/ { *rfN = 0xD4BF09 + (arfcn<<6); } /* ARFCN : 1~ 10 */
661/*BRIGHT4*/ else if(arfcn<=124)
662/*BRIGHT4*/ { *rfN = 0xC4BC89 + (arfcn<<6); } /* ARFCN : 11~ 124 */
663/*BRIGHT4*/ else
664/*BRIGHT4*/ { *rfN = 0xD3BF09 + (arfcn<<6); } /* ARFCN : 975~1023 */
665/*BRIGHT4*/ break;
666/*BRIGHT4*/ }
667/*BRIGHT4*/ case FrequencyBand1800 :
668/*BRIGHT4*/ {
669/*BRIGHT4*/ if(arfcn<=672)
670/*BRIGHT4*/ { *rfN = 0x841EF1 + (arfcn<<5); } /* ARFCN : 512~ 672 */
671/*BRIGHT4*/ else
672/*BRIGHT4*/ { *rfN = 0x942031 + (arfcn<<5); } /* ARFCN : 673~ 885 */
673/*BRIGHT4*/ break;
674/*BRIGHT4*/ }
675/*BRIGHT4*/ case FrequencyBand1900 :
676/*BRIGHT4*/ {
677/*BRIGHT4*/ *rfN = 0xC47679 + (arfcn<<5); /* ARFCN : 512~ 810 */
678/*BRIGHT4*/ break;
679/*BRIGHT4*/ }
680/*BRIGHT4*/ default :
681/*BRIGHT4*/ { break;
682/*BRIGHT4*/ }
683/*BRIGHT4*/ }
684/*BRIGHT4*/ *ifN = 0;
685/*BRIGHT4*/ }
686/*BRIGHT4*/ /* =========================================================================== */
687#endif
688
689#if IS_RF_BRIGHT5P
690/*BRIGHT5P*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
691/*BRIGHT5P*/ {
692/*BRIGHT5P*/ switch(rf_band)
693/*BRIGHT5P*/ {
694/*BRIGHT5P*/ case FrequencyBand850 :
695/*BRIGHT5P*/ {
696/*BRIGHT5P*/ if(arfcn<=133)
697/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-128) + 52)<<5) | (135<<11) | (0x080001) ); } /* ARFCN : 128~ 133 */
698/*BRIGHT5P*/ else if(arfcn<=165)
699/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-134))<<5) | (136<<11) | (0x080001) ); } /* ARFCN : 134~ 165 */
700/*BRIGHT5P*/ else if(arfcn<=197)
701/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-166))<<5) | (137<<11) | (0x080001) ); } /* ARFCN : 166~ 197 */
702/*BRIGHT5P*/ else if(arfcn<=229)
703/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-198))<<5) | (138<<11) | (0x080001) ); } /* ARFCN : 198~ 229 */
704/*BRIGHT5P*/ else
705/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-230))<<5) | (139<<11) | (0x080001) ); } /* ARFCN : 230~ 251 */
706/*BRIGHT5P*/ break;
707/*BRIGHT5P*/ }
708/*BRIGHT5P*/ case FrequencyBand900 :
709/*BRIGHT5P*/ {
710/*BRIGHT5P*/ if(arfcn<=28)
711/*BRIGHT5P*/ { *rfN = ( ((2*arfcn + 6)<<5) | (146<<11) | (0x080009) ); } /* ARFCN : 0~ 28 */
712/*BRIGHT5P*/ else if(arfcn<=60)
713/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-29))<<5) | (147<<11) | (0x080009) ); } /* ARFCN : 29~ 60 */
714/*BRIGHT5P*/ else if(arfcn<=92)
715/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-61))<<5) | (148<<11) | (0x080009) ); } /* ARFCN : 61~ 92 */
716/*BRIGHT5P*/ else if(arfcn<=124)
717/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-93))<<5) | (149<<11) | (0x080009) ); } /* ARFCN : 93~ 124 */
718/*BRIGHT5P*/ else if(arfcn<=988)
719/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-975)+36)<<5) | (144<<11) | (0x080009) ); } /* ARFCN : 975~ 988 */
720/*BRIGHT5P*/ else if(arfcn<=1020)
721/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-989))<<5) | (145<<11) | (0x080009) ); } /* ARFCN : 989~ 1020 */
722/*BRIGHT5P*/ else
723/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-1021))<<5) | (146<<11) | (0x080009) ); } /* ARFCN : 1021~ 1023 */
724/*BRIGHT5P*/ break;
725/*BRIGHT5P*/ }
726/*BRIGHT5P*/ case FrequencyBand1800 :
727/*BRIGHT5P*/ {
728/*BRIGHT5P*/ if(arfcn<=573)
729/*BRIGHT5P*/ { *rfN = ( (((arfcn-512) + 2)<<5) | (141<<11) | (0x080011) ); } /* ARFCN : 512~ 573 */
730/*BRIGHT5P*/ else if(arfcn<=637)
731/*BRIGHT5P*/ { *rfN = ( ((arfcn-574)<<5) | (142<<11) | (0x080011) ); } /* ARFCN : 574~ 637 */
732/*BRIGHT5P*/ else if(arfcn<=701)
733/*BRIGHT5P*/ { *rfN = ( ((arfcn-638)<<5) | (143<<11) | (0x080011) ); } /* ARFCN : 638~ 701 */
734/*BRIGHT5P*/ else if(arfcn<=765)
735/*BRIGHT5P*/ { *rfN = ( ((arfcn-702)<<5) | (144<<11) | (0x080011) ); } /* ARFCN : 702~ 765 */
736/*BRIGHT5P*/ else if(arfcn<=829)
737/*BRIGHT5P*/ { *rfN = ( ((arfcn-766)<<5) | (145<<11) | (0x080011) ); } /* ARFCN : 766~ 829 */
738/*BRIGHT5P*/ else
739/*BRIGHT5P*/ { *rfN = ( ((arfcn-830)<<5) | (146<<11) | (0x080011) ); } /* ARFCN : 830~ 885 */
740/*BRIGHT5P*/ break;
741/*BRIGHT5P*/ }
742/*BRIGHT5P*/ case FrequencyBand1900 :
743/*BRIGHT5P*/ {
744/*BRIGHT5P*/ if(arfcn<=524)
745/*BRIGHT5P*/ { *rfN = ( (((arfcn-512) + 51)<<5) | (150<<11) | (0x080019) ); } /* ARFCN : 512~ 524 */
746/*BRIGHT5P*/ else if(arfcn<=588)
747/*BRIGHT5P*/ { *rfN = ( ((arfcn-525)<<5) | (151<<11) | (0x080019) ); } /* ARFCN : 525~ 588 */
748/*BRIGHT5P*/ else if(arfcn<=652)
749/*BRIGHT5P*/ { *rfN = ( ((arfcn-589)<<5) | (152<<11) | (0x080019) ); } /* ARFCN : 589~ 652 */
750/*BRIGHT5P*/ else if(arfcn<=716)
751/*BRIGHT5P*/ { *rfN = ( ((arfcn-653)<<5) | (153<<11) | (0x080019) ); } /* ARFCN : 653~ 716 */
752/*BRIGHT5P*/ else if(arfcn<=780)
753/*BRIGHT5P*/ { *rfN = ( ((arfcn-717)<<5) | (154<<11) | (0x080019) ); } /* ARFCN : 717~ 780 */
754/*BRIGHT5P*/ else
755/*BRIGHT5P*/ { *rfN = ( ((arfcn-781)<<5) | (155<<11) | (0x080019) ); } /* ARFCN : 781~ 810 */
756/*BRIGHT5P*/ break;
757/*BRIGHT5P*/ }
758/*BRIGHT5P*/ default :
759/*BRIGHT5P*/ {
760/*BRIGHT5P*/ break;
761/*BRIGHT5P*/ }
762/*BRIGHT5P*/ }
763/*BRIGHT5P*/ *ifN = 0;
764/*BRIGHT5P*/ }
765/*BRIGHT5P*/ /* =========================================================================== */
766/*BRIGHT5P*/
767/*BRIGHT5P*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
768/*BRIGHT5P*/ {
769/*BRIGHT5P*/ switch(rf_band)
770/*BRIGHT5P*/ {
771/*BRIGHT5P*/ case FrequencyBand850 :
772/*BRIGHT5P*/ {
773/*BRIGHT5P*/ if(arfcn<=150)
774/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-128) + 18)<<5) | (141<<11) | (0x000001) ); } /* ARFCN : 128~ 150 */
775/*BRIGHT5P*/ else if(arfcn<=182)
776/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-151))<<5) | (142<<11) | (0x000001) ); } /* ARFCN : 151~ 182 */
777/*BRIGHT5P*/ else if(arfcn<=214)
778/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-183))<<5) | (143<<11) | (0x000001) ); } /* ARFCN : 183~ 214 */
779/*BRIGHT5P*/ else if(arfcn<=246)
780/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-215))<<5) | (144<<11) | (0x000001) ); } /* ARFCN : 215~ 246 */
781/*BRIGHT5P*/ else
782/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-247))<<5) | (145<<11) | (0x000001) ); } /* ARFCN : 247~ 251 */
783/*BRIGHT5P*/ break;
784/*BRIGHT5P*/ }
785/*BRIGHT5P*/ case FrequencyBand900 :
786/*BRIGHT5P*/ {
787/*BRIGHT5P*/ if(arfcn<=3)
788/*BRIGHT5P*/ { *rfN = ( ((2*arfcn+56)<<5) | (151<<11) | (0x200009) ); } /* ARFCN : 0~ 3 */
789/*BRIGHT5P*/ else if(arfcn<=9)
790/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-4))<<5) | (152<<11) | (0x200009) ); } /* ARFCN : 4~ 9 */
791/*BRIGHT5P*/ else if(arfcn<=13)
792/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-10)+56)<<5) | (151<<11) | (0x000009) ); } /* ARFCN : 10~ 13 */
793/*BRIGHT5P*/ else if(arfcn<=45)
794/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-14))<<5) | (152<<11) | (0x000009) ); } /* ARFCN : 14~ 45 */
795/*BRIGHT5P*/ else if(arfcn<=77)
796/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-46))<<5) | (153<<11) | (0x000009) ); } /* ARFCN : 46~ 77 */
797/*BRIGHT5P*/ else if(arfcn<=109)
798/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-78))<<5) | (154<<11) | (0x000009) ); } /* ARFCN : 78~ 109 */
799/*BRIGHT5P*/ else if(arfcn<=124)
800/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-110))<<5) | (155<<11) | (0x000009) ); } /* ARFCN : 110~ 124 */
801/*BRIGHT5P*/ else if(arfcn<=995)
802/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-975)+22)<<5) | (150<<11) | (0x200009) ); } /* ARFCN : 975~ 995 */
803/*BRIGHT5P*/ else
804/*BRIGHT5P*/ { *rfN = ( ((2*(arfcn-996))<<5) | (151<<11) | (0x200009) ); } /* ARFCN : 996~1023 */
805/*BRIGHT5P*/ break;
806/*BRIGHT5P*/ }
807/*BRIGHT5P*/ case FrequencyBand1800 :
808/*BRIGHT5P*/ {
809/*BRIGHT5P*/ if(arfcn<=520)
810/*BRIGHT5P*/ { *rfN = ( (((arfcn-512) + 55)<<5) | (139<<11) | (0x000011) ); } /* ARFCN : 512~ 520 */
811/*BRIGHT5P*/ else if(arfcn<=584)
812/*BRIGHT5P*/ { *rfN = ( ((arfcn-521)<<5) | (140<<11) | (0x000011) ); } /* ARFCN : 521~ 584 */
813/*BRIGHT5P*/ else if(arfcn<=648)
814/*BRIGHT5P*/ { *rfN = ( ((arfcn-585)<<5) | (141<<11) | (0x000011) ); } /* ARFCN : 585~ 648 */
815/*BRIGHT5P*/ else if(arfcn<=670)
816/*BRIGHT5P*/ { *rfN = ( ((arfcn-649)<<5) | (142<<11) | (0x000011) ); } /* ARFCN : 649~ 670 */
817/*BRIGHT5P*/ else if(arfcn<=702)
818/*BRIGHT5P*/ { *rfN = ( (((arfcn-671)+32)<<5) | (142<<11) | (0x200011) ); } /* ARFCN : 671~ 702 */
819/*BRIGHT5P*/ else if(arfcn<=766)
820/*BRIGHT5P*/ { *rfN = ( ((arfcn-703)<<5) | (143<<11) | (0x200011) ); } /* ARFCN : 703~ 766 */
821/*BRIGHT5P*/ else if(arfcn<=830)
822/*BRIGHT5P*/ { *rfN = ( ((arfcn-767)<<5) | (144<<11) | (0x200011) ); } /* ARFCN : 767~ 830 */
823/*BRIGHT5P*/ else
824/*BRIGHT5P*/ { *rfN = ( ((arfcn-831)<<5) | (145<<11) | (0x200011) ); } /* ARFCN : 831~ 885 */
825/*BRIGHT5P*/ break;
826/*BRIGHT5P*/ }
827/*BRIGHT5P*/ case FrequencyBand1900 :
828/*BRIGHT5P*/ {
829/*BRIGHT5P*/ if(arfcn<=524)
830/*BRIGHT5P*/ { *rfN = ( (((arfcn-512) + 51)<<5) | (150<<11) | (0x000019) ); } /* ARFCN : 512~ 524 */
831/*BRIGHT5P*/ else if(arfcn<=588)
832/*BRIGHT5P*/ { *rfN = ( ((arfcn-525)<<5) | (151<<11) | (0x000019) ); } /* ARFCN : 525~ 588 */
833/*BRIGHT5P*/ else if(arfcn<=652)
834/*BRIGHT5P*/ { *rfN = ( ((arfcn-589)<<5) | (152<<11) | (0x000019) ); } /* ARFCN : 589~ 652 */
835/*BRIGHT5P*/ else if(arfcn<=716)
836/*BRIGHT5P*/ { *rfN = ( ((arfcn-653)<<5) | (153<<11) | (0x000019) ); } /* ARFCN : 653~ 716 */
837/*BRIGHT5P*/ else if(arfcn<=780)
838/*BRIGHT5P*/ { *rfN = ( ((arfcn-717)<<5) | (154<<11) | (0x000019) ); } /* ARFCN : 717~ 780 */
839/*BRIGHT5P*/ else
840/*BRIGHT5P*/ { *rfN = ( ((arfcn-781)<<5) | (155<<11) | (0x000019) ); } /* ARFCN : 781~ 810 */
841/*BRIGHT5P*/ break;
842/*BRIGHT5P*/ }
843/*BRIGHT5P*/ default :
844/*BRIGHT5P*/ { break;
845/*BRIGHT5P*/ }
846/*BRIGHT5P*/ }
847/*BRIGHT5P*/ *ifN = 0;
848/*BRIGHT5P*/ }
849/*BRIGHT5P*/ /* =========================================================================== */
850#endif
851
852#if IS_RF_AERO
853/*AERO*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
854/*AERO*/ {
855/*AERO*/ switch(rf_band)
856/*AERO*/ {
857/*AERO*/ case FrequencyBand900 :
858/*AERO*/ {
859/*AERO*/ if(arfcn<=124)
860/*AERO*/ { *rfN = 0x092160 + (arfcn<<7); } /* ARFCN : 1~ 124 */
861/*AERO*/ else
862/*AERO*/ { *rfN = 0x072160 + (arfcn<<7); } /* ARFCN : 975~1023 */
863/*AERO*/ break;
864/*AERO*/ }
865/*AERO*/ case FrequencyBand1800 :
866/*AERO*/ {
867/*AERO*/ *rfN = 0x50A0E0 + (arfcn<<7); /* ARFCN : 512~ 885 */
868/*AERO*/ break;
869/*AERO*/ }
870/*AERO*/ case FrequencyBand1900 :
871/*AERO*/ {
872/*AERO*/ *rfN = 0x91D960 + (arfcn<<7); /* ARFCN : 512~ 810 */
873/*AERO*/ break;
874/*AERO*/ }
875/*AERO*/ default :
876/*AERO*/ {
877/*AERO*/ break;
878/*AERO*/ }
879/*AERO*/ }
880/*AERO*/ *ifN = 0;
881/*AERO*/ }
882/*AERO*/ /* =========================================================================== */
883/*AERO*/
884/*AERO*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
885/*AERO*/ {
886/*AERO*/ switch(rf_band)
887/*AERO*/ {
888/*AERO*/ case FrequencyBand900 :
889/*AERO*/ {
890/*AERO*/ if(arfcn<=49)
891/*AERO*/ {
892/*AERO*/ if(arfcn<=24) /* ARFCN : 0~ 24 */
893/*AERO*/ { *rfN = 0x064B63 + (arfcn<<6);
894/*AERO*/ *ifN = 0X73E5A4;
895/*AERO*/ }
896/*AERO*/ else /* ARFCN : 25~ 49 */
897/*AERO*/ { *rfN = 0x064663 + (arfcn<<6);
898/*AERO*/ *ifN = 0X73DBA4;
899/*AERO*/ }
900/*AERO*/ }
901/*AERO*/ else
902/*AERO*/ {
903/*AERO*/ if(arfcn<=124) /* ARFCN : 50~ 124 */
904/*AERO*/ { *rfN = 0x064B63 + (arfcn<<6);
905/*AERO*/ *ifN = 0X73E5A4;
906/*AERO*/ }
907/*AERO*/ else /* ARFCN : 975~1023 */
908/*AERO*/ { *rfN = 0x054B63 + (arfcn<<6);
909/*AERO*/ *ifN = 0X73E5A4;
910/*AERO*/ }
911/*AERO*/ }
912/*AERO*/ break;
913/*AERO*/ }
914/*AERO*/ case FrequencyBand1800 :
915/*AERO*/ {
916/*AERO*/ *rfN = 0x45FB23 + (arfcn<<6); /* ARFCN : 512~ 885 */
917/*AERO*/ *ifN = 0X63BDA4;
918/*AERO*/ break;
919/*AERO*/ }
920/*AERO*/ case FrequencyBand1900 :
921/*AERO*/ {
922/*AERO*/ *rfN = 0x867323 + (arfcn<<6); /* ARFCN : 512~ 810 */
923/*AERO*/ *ifN = 0X742BA4;
924/*AERO*/ break;
925/*AERO*/ }
926/*AERO*/ default :
927/*AERO*/ { break;
928/*AERO*/ }
929/*AERO*/ }
930/*AERO*/ }
931/*AERO*/ /* =========================================================================== */
932#endif
933
934#if IS_RF_AERO1PLUS
935/*AERO1+*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
936/*AERO1+*/ {
937/*AERO1+*/ switch(rf_band)
938/*AERO1+*/ {
939/*AERO1+*/ case FrequencyBand900 :
940/*AERO1+*/ {
941/*AERO1+*/ if(arfcn<=124)
942/*AERO1+*/ { *rfN = 0x092160 + (arfcn<<7); } /* ARFCN : 1~ 124 */
943/*AERO1+*/ else
944/*AERO1+*/ { *rfN = 0x072160 + (arfcn<<7); } /* ARFCN : 975~1023 */
945/*AERO1+*/ break;
946/*AERO1+*/ }
947/*AERO1+*/ case FrequencyBand1800 :
948/*AERO1+*/ {
949/*AERO1+*/ *rfN = 0x50A0E0 + (arfcn<<7); /* ARFCN : 512~ 885 */
950/*AERO1+*/ break;
951/*AERO1+*/ }
952/*AERO1+*/ case FrequencyBand1900 :
953/*AERO1+*/ {
954/*AERO1+*/ *rfN = 0x91D960 + (arfcn<<7); /* ARFCN : 512~ 810 */
955/*AERO1+*/ break;
956/*AERO1+*/ }
957/*AERO1+*/ default :
958/*AERO1+*/ {
959/*AERO1+*/ break;
960/*AERO1+*/ }
961/*AERO1+*/ }
962/*AERO1+*/ *ifN = 0;
963/*AERO1+*/ }
964/*AERO1+*/ /* =========================================================================== */
965/*AERO1+*/
966/*AERO1+*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
967/*AERO1+*/ {
968/*AERO1+*/ switch(rf_band)
969/*AERO1+*/ {
970/*AERO1+*/ case FrequencyBand900 :
971/*AERO1+*/ {
972/*AERO1+*/ if(arfcn<=49)
973/*AERO1+*/ {
974/*AERO1+*/ if(arfcn<=24) /* ARFCN : 0~ 24 */
975/*AERO1+*/ { *rfN = 0x064B63 + (arfcn<<6);
976/*AERO1+*/ *ifN = 0X73E5A4;
977/*AERO1+*/ }
978/*AERO1+*/ else /* ARFCN : 25~ 49 */
979/*AERO1+*/ { *rfN = 0x064663 + (arfcn<<6);
980/*AERO1+*/ *ifN = 0X73DBA4;
981/*AERO1+*/ }
982/*AERO1+*/ }
983/*AERO1+*/ else
984/*AERO1+*/ {
985/*AERO1+*/ if(arfcn<=124) /* ARFCN : 50~ 124 */
986/*AERO1+*/ { *rfN = 0x064B63 + (arfcn<<6);
987/*AERO1+*/ *ifN = 0X73E5A4;
988/*AERO1+*/ }
989/*AERO1+*/ else /* ARFCN : 975~1023 */
990/*AERO1+*/ { *rfN = 0x054B63 + (arfcn<<6);
991/*AERO1+*/ *ifN = 0X73E5A4;
992/*AERO1+*/ }
993/*AERO1+*/ }
994/*AERO1+*/ break;
995/*AERO1+*/ }
996/*AERO1+*/ case FrequencyBand1800 :
997/*AERO1+*/ {
998/*AERO1+*/ *rfN = 0x45FB23 + (arfcn<<6); /* ARFCN : 512~ 885 */
999/*AERO1+*/ *ifN = 0X63BDA4;
1000/*AERO1+*/ break;
1001/*AERO1+*/ }
1002/*AERO1+*/ case FrequencyBand1900 :
1003/*AERO1+*/ {
1004/*AERO1+*/ *rfN = 0x867323 + (arfcn<<6); /* ARFCN : 512~ 810 */
1005/*AERO1+*/ *ifN = 0X742BA4;
1006/*AERO1+*/ break;
1007/*AERO1+*/ }
1008/*AERO1+*/ default :
1009/*AERO1+*/ { break;
1010/*AERO1+*/ }
1011/*AERO1+*/ }
1012/*AERO1+*/ }
1013/*AERO1+*/ /* =========================================================================== */
1014#endif
1015
1016#if IS_RF_POLARIS1
1017/*RFMD*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1018/*RFMD*/ {
1019/*RFMD*/ int OFFS;
1020/*RFMD*/ switch(rf_band)
1021/*RFMD*/ {
1022/*RFMD*/ case FrequencyBand900 :
1023/*RFMD*/ {
1024/*RFMD*/ if(arfcn<=124) /* ARFCN : 0~ 124 */
1025/*RFMD*/ {
1026/*RFMD*/ OFFS = 80*arfcn + 41160;
1027/*RFMD*/ *rfN = 0x0C0000L | (OFFS);
1028/*RFMD*/ }
1029/*RFMD*/ else /* ARFCN : 975~1023 */
1030/*RFMD*/ {
1031/*RFMD*/ OFFS = 80*arfcn - 40760;
1032/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1033/*RFMD*/ }
1034/*RFMD*/ break;
1035/*RFMD*/ }
1036/*RFMD*/ case FrequencyBand1800 : /* ARFCN : 512~ 885 */
1037/*RFMD*/ {
1038/*RFMD*/ OFFS = 40*arfcn + 7740;
1039/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1040/*RFMD*/ break;
1041/*RFMD*/ }
1042/*RFMD*/ case FrequencyBand1900 : /* ARFCN : 512~ 810 */
1043/*RFMD*/ {
1044/*RFMD*/ OFFS = 40*arfcn + 32740;
1045/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1046/*RFMD*/ break;
1047/*RFMD*/ }
1048/*RFMD*/ default :
1049/*RFMD*/ {
1050/*RFMD*/ break;
1051/*RFMD*/ }
1052/*RFMD*/ }
1053/*RFMD*/ *ifN = 0;
1054/*RFMD*/ }
1055/*RFMD*/ /* =========================================================================== */
1056/*RFMD*/
1057/*RFMD*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1058/*RFMD*/ {
1059/*RFMD*/ int OFFS;
1060/*RFMD*/ switch(rf_band)
1061/*RFMD*/ {
1062/*RFMD*/ case FrequencyBand900 :
1063/*RFMD*/ {
1064/*RFMD*/ if(arfcn<=124) /* ARFCN : 0~ 124 */
1065/*RFMD*/ {
1066/*RFMD*/ OFFS = 40*arfcn + 178000;
1067/*RFMD*/ *rfN = 0x0C0000L | (OFFS);
1068/*RFMD*/ }
1069/*RFMD*/ else /* ARFCN : 975~1023 */
1070/*RFMD*/ { OFFS = 40*arfcn + 137040;
1071/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1072/*RFMD*/ }
1073/*RFMD*/ break;
1074/*RFMD*/ }
1075/*RFMD*/ case FrequencyBand1800 : /* ARFCN : 512~ 885 */
1076/*RFMD*/ {
1077/*RFMD*/ OFFS = 40*arfcn - 11240;
1078/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1079/*RFMD*/ break;
1080/*RFMD*/
1081/*RFMD*/ }
1082/*RFMD*/ case FrequencyBand1900 : /* ARFCN : 512~ 810 */
1083/*RFMD*/ {
1084/*RFMD*/ OFFS = 40*arfcn + 16760;
1085/*RFMD*/ *rfN = 0x0C0000L + (OFFS);
1086/*RFMD*/ break;
1087/*RFMD*/ }
1088/*RFMD*/ default :
1089/*RFMD*/ { break;
1090/*RFMD*/ }
1091/*RFMD*/ }
1092/*RFMD*/ *ifN = 0;
1093/*RFMD*/ }
1094/*RFMD*/ /* =========================================================================== */
1095#endif
1096
1097#if IS_RF_SKY74117
1098/*SKY74117*/ typedef struct
1099/*SKY74117*/ { short arfcn;
1100/*SKY74117*/ short Nint;
1101/*SKY74117*/ int Fbase;
1102/*SKY74117*/ int Fstep;
1103/*SKY74117*/ short Inj_Div;
1104/*SKY74117*/ } SKY74117_PLL_ELM;
1105/*SKY74117*/
1106/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_RX_850[] =
1107/*SKY74117*/ {
1108/*SKY74117*/ { 128 , 96 , 3323179, 3097332 },
1109/*SKY74117*/ { 137 , 97 , 0, 3097332 },
1110/*SKY74117*/ { 181 , 98 , 64527, 3097332 },
1111/*SKY74117*/ { 224 , 99 , 32263, 3097332 },
1112/*SKY74117*/ };
1113/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_RX_900[] =
1114/*SKY74117*/ {
1115/*SKY74117*/ { 0 , 104, 1613193, 3097332 },
1116/*SKY74117*/ { 27 , 105, 32263 , 3097332 },
1117/*SKY74117*/ { 70 , 106, 0 , 3097332 },
1118/*SKY74117*/ { 114 , 107, 64527 , 3097332 },
1119/*SKY74117*/ { 975 , 103, 1064707, 3097332 },
1120/*SKY74117*/ { 1008, 104, 64527 , 3097332 },
1121/*SKY74117*/ };
1122/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_RX_1800[] =
1123/*SKY74117*/ {
1124/*SKY74117*/ { 512 , 100, 2710165, 1548666 },
1125/*SKY74117*/ { 543 , 101, 16131 , 1548666 },
1126/*SKY74117*/ { 630 , 102, 32263 , 1548666 },
1127/*SKY74117*/ { 716 , 103, 0 , 1548666 },
1128/*SKY74117*/ { 803 , 104, 16131 , 1548666 },
1129/*SKY74117*/ };
1130/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_RX_1900[] =
1131/*SKY74117*/ {
1132/*SKY74117*/ { 512 , 107, 3597422, 1548666 },
1133/*SKY74117*/ { 525 , 108, 32263 , 1548666 },
1134/*SKY74117*/ { 611 , 109, 0 , 1548666 },
1135/*SKY74117*/ { 698 , 110, 16131 , 1548666 },
1136/*SKY74117*/ { 785 , 111, 32263 , 1548666 },
1137/*SKY74117*/ };
1138/*SKY74117*/ const SKY74117_PLL_ELM *const SKY74117_RXPLL_TBL[] =
1139/*SKY74117*/ {
1140/*SKY74117*/ 0, /* FrequencyBand400 (not support) */
1141/*SKY74117*/ SKY74117_RX_850, /* FrequencyBand850 */
1142/*SKY74117*/ SKY74117_RX_900, /* FrequencyBand900 */
1143/*SKY74117*/ SKY74117_RX_1800, /* FrequencyBand1800 */
1144/*SKY74117*/ SKY74117_RX_1900, /* FrequencyBand1900 */
1145/*SKY74117*/ };
1146/*SKY74117*/
1147/*SKY74117*/ short SKY74117_RXPLL_TBL_SIZE[5] =
1148/*SKY74117*/ {
1149/*SKY74117*/ 0, /* FrequencyBand400 (not support) */
1150/*SKY74117*/ sizeof(SKY74117_RX_850)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand850 */
1151/*SKY74117*/ sizeof(SKY74117_RX_900)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand900 */
1152/*SKY74117*/ sizeof(SKY74117_RX_1800)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand1800 */
1153/*SKY74117*/ sizeof(SKY74117_RX_1900)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand1900 */
1154/*SKY74117*/ };
1155/*SKY74117*/
1156/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_TX_850[] =
1157/*SKY74117*/ {
1158/*SKY74117*/ { 128 , 83 , 1881444, 2831846, 1 },
1159/*SKY74117*/ { 145 , 101, 3652493, 3417745, 3 },
1160/*SKY74117*/ { 149 , 83 , 3739844, 2831846, 1 },
1161/*SKY74117*/ { 152 , 102, 205821 , 3417745, 3 },
1162/*SKY74117*/ { 157 , 84 , 253501 , 2831846, 1 },
1163/*SKY74117*/ { 177 , 102, 2875935, 3417745, 3 },
1164/*SKY74117*/ { 190 , 103, 70090 , 3417745, 3 },
1165/*SKY74117*/ { 198 , 84 , 3881805, 2831846, 1 },
1166/*SKY74117*/ { 200 , 103, 1138136, 3417745, 3 },
1167/*SKY74117*/ { 209 , 85 , 660948 , 2831846, 1 },
1168/*SKY74117*/ { 211 , 103, 2312986, 3417745, 3 },
1169/*SKY74117*/ { 218 , 85 , 1457405, 2831846, 1 },
1170/*SKY74117*/ { 221 , 103, 3381031, 3417745, 3 },
1171/*SKY74117*/ { 227 , 85 , 2253862, 2831846, 1 },
1172/*SKY74117*/ { 249 , 104, 2177255, 0 , 3 },
1173/*SKY74117*/ { 250 , 86 , 94947 , 2831846, 1 },
1174/*SKY74117*/ };
1175/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_TX_900[] =
1176/*SKY74117*/ {
1177/*SKY74117*/ { 0 , 109, 3421083, 3417745 , 3 },
1178/*SKY74117*/ { 6 , 90 , 2167210, 2831846 , 1 },
1179/*SKY74117*/ { 19 , 110, 1256066, 3417745 , 3 },
1180/*SKY74117*/ { 25 , 90 , 3848619, 2831846 , 1 },
1181/*SKY74117*/ { 29 , 110, 2324111, 3417745 , 3 },
1182/*SKY74117*/ { 46 , 91 , 1512714, 2831846 , 1 },
1183/*SKY74117*/ { 48 , 111, 159094 , 3417745 , 3 },
1184/*SKY74117*/ { 64 , 91 , 3105628, 2831846 , 1 },
1185/*SKY74117*/ { 75 , 111, 3042817, 3417745 , 3 },
1186/*SKY74117*/ { 78 , 92 , 150257 , 2831846 , 1 },
1187/*SKY74117*/ { 87 , 112, 130168 , 3417745 , 3 },
1188/*SKY74117*/ { 104 , 92 , 2451132, 0 , 1 },
1189/*SKY74117*/ { 105 , 112, 2052650, 3417745 , 3 },
1190/*SKY74117*/ { 107 , 92 , 2716618, 2831846 , 1 },
1191/*SKY74117*/ { 124 , 93 , 26732 , 75367399, 1 },
1192/*SKY74117*/ { 975 , 108, 2381964, 3417745 , 3 },
1193/*SKY74117*/ { 991 , 89 , 2910201, 2831846 , 1 },
1194/*SKY74117*/ { 993 , 109, 110142 , 3417745 , 3 },
1195/*SKY74117*/ { 1010, 90 , 397306 , 52330164, 1 },
1196/*SKY74117*/ { 1011, 109, 2032624, 3417745 , 3 },
1197/*SKY74117*/ { 1013, 90 , 662792 , 2831846 , 1 },
1198/*SKY74117*/ { 1015, 109, 2459842, 3417745 , 3 },
1199/*SKY74117*/ { 1019, 90 , 1193763, 57603258, 1 },
1200/*SKY74117*/ { 1020, 109, 2993865, 3417745 , 3 },
1201/*SKY74117*/ };
1202/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_TX_1800[] =
1203/*SKY74117*/ {
1204/*SKY74117*/ { 512, 90 , 3135374, 1479322 , 1 },
1205/*SKY74117*/ { 516, 100, 277680 , 1624829 , 3 },
1206/*SKY74117*/ { 546, 91 , 512851 , 1479322 , 1 },
1207/*SKY74117*/ { 559, 100, 2461046, 1624829 , 3 },
1208/*SKY74117*/ { 567, 91 , 1483656, 1479322 , 1 },
1209/*SKY74117*/ { 576, 100, 3324237, 1624829 , 3 },
1210/*SKY74117*/ { 591, 91 , 2593148, 1479322 , 1 },
1211/*SKY74117*/ { 597, 101, 196227 , 1624829 , 3 },
1212/*SKY74117*/ { 630, 92 , 201769 , 1479322 , 1 },
1213/*SKY74117*/ { 641, 101, 2430369, 1624829 , 3 },
1214/*SKY74117*/ { 674, 88 , 1750545, 1415923 , 0 },
1215/*SKY74117*/ { 677, 102, 63998 , 1624829 , 3 },
1216/*SKY74117*/ { 681, 92 , 2559440, 1479322 , 1 },
1217/*SKY74117*/ { 691, 102, 774861 , 1624829 , 3 },
1218/*SKY74117*/ { 696, 88 , 2723993, 1415923 , 0 },
1219/*SKY74117*/ { 706, 102, 1536501, 1624829 , 3 },
1220/*SKY74117*/ { 712, 92 , 3992534, 1479322 , 1 },
1221/*SKY74117*/ { 714, 88 , 3520449, 1415923 , 0 },
1222/*SKY74117*/ { 719, 93 , 121832 , 1479322 , 1 },
1223/*SKY74117*/ { 723, 102, 2399691, 1624829 , 3 },
1224/*SKY74117*/ { 756, 89 , 1184545, 1415923 , 0 },
1225/*SKY74117*/ { 762, 103, 185649 , 1624829 , 3 },
1226/*SKY74117*/ { 788, 93 , 3311622, 1479322 , 1 },
1227/*SKY74117*/ { 806, 89 , 3396925, 1415923 , 0 },
1228/*SKY74117*/ { 812, 94 , 226810 , 1479322 , 1 },
1229/*SKY74117*/ { 821, 103, 3181429, 1624829 , 3 },
1230/*SKY74117*/ { 824, 94 , 781556 , 1479322 , 1 },
1231/*SKY74117*/ { 826, 103, 3435309, 1624829 , 3 },
1232/*SKY74117*/ { 839, 94 , 1474988, 1479322 , 1 },
1233/*SKY74117*/ { 844, 104, 154972 , 1624829 , 3 },
1234/*SKY74117*/ { 876, 94 , 3185455, 1479322 , 1 },
1235/*SKY74117*/ };
1236/*SKY74117*/ const SKY74117_PLL_ELM SKY74117_TX_1900[] =
1237/*SKY74117*/ {
1238/*SKY74117*/ { 512 , 94 , 389931 , 0 , 0 },
1239/*SKY74117*/ { 513 , 94 , 434179 , 1415923 , 0 },
1240/*SKY74117*/ { 518 , 108, 2367956, 1624829 , 3 },
1241/*SKY74117*/ { 522 , 98 , 2403418, 1479322 , 1 },
1242/*SKY74117*/ { 558 , 109, 204690 , 1624829 , 3 },
1243/*SKY74117*/ { 581 , 99 , 936615 , 1479322 , 1 },
1244/*SKY74117*/ { 601 , 109, 2388055, 1624829 , 3 },
1245/*SKY74117*/ { 614 , 99 , 2462167, 1479322 , 1 },
1246/*SKY74117*/ { 645 , 110, 427893 , 1624829 , 3 },
1247/*SKY74117*/ { 652 , 95 , 2390292, 1415923 , 0 },
1248/*SKY74117*/ { 671 , 100, 902907 , 1479322 , 1 },
1249/*SKY74117*/ { 683 , 110, 2357378, 1624829 , 3 },
1250/*SKY74117*/ { 701 , 100, 2289772, 1479322 , 1 },
1251/*SKY74117*/ { 719 , 96 , 1160577, 1415923 , 0 },
1252/*SKY74117*/ { 728 , 100, 3537950, 1479322 , 1 },
1253/*SKY74117*/ { 740 , 111, 1057303, 1624829 , 3 },
1254/*SKY74117*/ { 746 , 101, 175765 , 1479322 , 1 },
1255/*SKY74117*/ { 781 , 111, 3139116, 1624829 , 3 },
1256/*SKY74117*/ { 796 , 101, 2487207, 1479322 , 1 },
1257/*SKY74117*/ };
1258/*SKY74117*/
1259/*SKY74117*/ const SKY74117_PLL_ELM *const SKY74117_TXPLL_TBL[] =
1260/*SKY74117*/ {
1261/*SKY74117*/ 0, /* FrequencyBand400 (not support) */
1262/*SKY74117*/ SKY74117_TX_850, /* FrequencyBand850 */
1263/*SKY74117*/ SKY74117_TX_900, /* FrequencyBand900 */
1264/*SKY74117*/ SKY74117_TX_1800, /* FrequencyBand1800 */
1265/*SKY74117*/ SKY74117_TX_1900, /* FrequencyBand1900 */
1266/*SKY74117*/ };
1267/*SKY74117*/
1268/*SKY74117*/ short SKY74117_TXPLL_TBL_SIZE[5] =
1269/*SKY74117*/ {
1270/*SKY74117*/ 0, /* FrequencyBand400 (not support) */
1271/*SKY74117*/ sizeof(SKY74117_TX_850)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand850 */
1272/*SKY74117*/ sizeof(SKY74117_TX_900)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand900 */
1273/*SKY74117*/ sizeof(SKY74117_TX_1800)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand1800 */
1274/*SKY74117*/ sizeof(SKY74117_TX_1900)/sizeof(SKY74117_PLL_ELM)-1, /* FrequencyBand1900 */
1275/*SKY74117*/ };
1276/*SKY74117*/
1277/*SKY74117*/ short SKY74117_TXPLL_INJECTIN_TBL[5] =
1278/*SKY74117*/ {
1279/*SKY74117*/ 0, /* FrequencyBand400 (not support) */
1280/*SKY74117*/ 90, /* FrequencyBand850 (not support) */
1281/*SKY74117*/ 95, /* FrequencyBand900 (not support) */
1282/*SKY74117*/ 98, /* FrequencyBand1800 (not support) */
1283/*SKY74117*/ 105, /* FrequencyBand1900 (not support) */
1284/*SKY74117*/ };
1285/*SKY74117*/
1286/*SKY74117*/ const unsigned long SDATA_TX_TABLE[5] =
1287/*SKY74117*/ {
1288/*SKY74117*/ 0L , /* FrequencyBand400 (not support) */
1289/*SKY74117*/ 0x040004L , /* FrequencyBand850 */
1290/*SKY74117*/ 0x050004L , /* FrequencyBand900 */
1291/*SKY74117*/ 0x060004L , /* FrequencyBand1800 */
1292/*SKY74117*/ 0x070004L , /* FrequencyBand1900 */
1293/*SKY74117*/ };
1294/*SKY74117*/ const unsigned long SDATA_TX_Div_TABLE[2] = { 0x100000, 0x200000 }; // 0: /8 1: /16
1295/*SKY74117*/ const unsigned long SDATA_TX_Inj_TABLE[2] = { 0x000000, 0x080000 }; // 0: Low 1: High
1296/*SKY74117*/ unsigned long SKY74117_TxCtrl = 0;
1297/*SKY74117*/ unsigned long SKY74117_TxCtrl_Mask = 0;
1298/*SKY74117*/
1299/*SKY74117*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1300/*SKY74117*/ { int Nfrac;
1301/*SKY74117*/ const SKY74117_PLL_ELM* elmptr;
1302/*SKY74117*/ int left, right, middle;
1303/*SKY74117*/
1304/*SKY74117*/ /*binary search*/
1305/*SKY74117*/ elmptr = SKY74117_RXPLL_TBL[rf_band];
1306/*SKY74117*/ left = 0; right = SKY74117_RXPLL_TBL_SIZE[rf_band];
1307/*SKY74117*/ while (left <= right)
1308/*SKY74117*/ { middle = (left + right)/2;
1309/*SKY74117*/ if ( arfcn<(elmptr+middle)->arfcn )
1310/*SKY74117*/ right = middle - 1;
1311/*SKY74117*/ else
1312/*SKY74117*/ left = middle + 1;
1313/*SKY74117*/ }
1314/*SKY74117*/ elmptr = (elmptr+left-1);
1315/*SKY74117*/
1316/*SKY74117*/ Nfrac = elmptr->Fbase + (((arfcn-elmptr->arfcn)*elmptr->Fstep)>>5);
1317/*SKY74117*/ *rfN = (elmptr->Nint<<6) | 0xC40000;
1318/*SKY74117*/ *ifN = (Nfrac<<2) | 3;
1319/*SKY74117*/ // *rfN = elmptr->Nint;
1320/*SKY74117*/ // *ifN = Nfrac;
1321/*SKY74117*/ }
1322/*SKY74117*/ /* =========================================================================== */
1323/*SKY74117*/
1324/*SKY74117*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1325/*SKY74117*/ { int Nfrac;
1326/*SKY74117*/ const SKY74117_PLL_ELM* elmptr;
1327/*SKY74117*/ int left, right, middle;
1328/*SKY74117*/ int div;
1329/*SKY74117*/
1330/*SKY74117*/ /*binary search*/
1331/*SKY74117*/ elmptr = SKY74117_TXPLL_TBL[rf_band];
1332/*SKY74117*/ left = 0; right = SKY74117_TXPLL_TBL_SIZE[rf_band];
1333/*SKY74117*/ while (left <= right)
1334/*SKY74117*/ { middle = (left + right)/2;
1335/*SKY74117*/ if ( arfcn<(elmptr+middle)->arfcn )
1336/*SKY74117*/ right = middle - 1;
1337/*SKY74117*/ else
1338/*SKY74117*/ left = middle + 1;
1339/*SKY74117*/ }
1340/*SKY74117*/ elmptr = (elmptr+left-1);
1341/*SKY74117*/ Nfrac = elmptr->Fbase + (((arfcn-elmptr->arfcn)*elmptr->Fstep)>>5);
1342/*SKY74117*/ *rfN = (elmptr->Nint<<6) | 0xC40000;
1343/*SKY74117*/ *ifN = (Nfrac<<2) | 3;
1344/*SKY74117*/ // *rfN = elmptr->Nint;
1345/*SKY74117*/ // *ifN = Nfrac;
1346/*SKY74117*/
1347/*SKY74117*/ l1d_rf.next_inj = (elmptr->Inj_Div>>1)&0x01;
1348/*SKY74117*/ div = (elmptr->Inj_Div>>0)&0x01;
1349/*SKY74117*/ SKY74117_TxCtrl_Mask = SDATA_TX_Div_TABLE[div] | SDATA_TX_Inj_TABLE[l1d_rf.next_inj];
1350/*SKY74117*/ SKY74117_TxCtrl = SDATA_TX_TABLE[rf_band] | SDATA_TX_Div_TABLE[div] | SDATA_TX_Inj_TABLE[l1d_rf.next_inj];
1351/*SKY74117*/ }
1352/*SKY74117*/ /* =========================================================================== */
1353#endif
1354
1355#if IS_RF_SKY74400
1356/*SKY74400*/ typedef struct
1357/*SKY74400*/ { short arfcn;
1358/*SKY74400*/ short Nint;
1359/*SKY74400*/ int Fbase;
1360/*SKY74400*/ int Fstep;
1361/*SKY74400*/ short Inj_Div;
1362/*SKY74400*/ } SKY74400_PLL_ELM;
1363/*SKY74400*/
1364/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_RX_850[] =
1365/*SKY74400*/ {
1366/*SKY74400*/ { 128 , 96 , 3323179, 3097332 },
1367/*SKY74400*/ { 137 , 97 , 0, 3097332 },
1368/*SKY74400*/ { 181 , 98 , 64527, 3097332 },
1369/*SKY74400*/ { 224 , 99 , 32263, 3097332 },
1370/*SKY74400*/ };
1371/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_RX_900[] =
1372/*SKY74400*/ {
1373/*SKY74400*/ { 0 , 104, 1613193, 3097332 },
1374/*SKY74400*/ { 27 , 105, 32263 , 3097332 },
1375/*SKY74400*/ { 70 , 106, 0 , 3097332 },
1376/*SKY74400*/ { 114 , 107, 64527 , 3097332 },
1377/*SKY74400*/ { 975 , 103, 1064707, 3097332 },
1378/*SKY74400*/ { 1008, 104, 64527 , 3097332 },
1379/*SKY74400*/ };
1380/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_RX_1800[] =
1381/*SKY74400*/ {
1382/*SKY74400*/ { 512 , 100, 2710165, 1548666 },
1383/*SKY74400*/ { 543 , 101, 16131 , 1548666 },
1384/*SKY74400*/ { 630 , 102, 32263 , 1548666 },
1385/*SKY74400*/ { 716 , 103, 0 , 1548666 },
1386/*SKY74400*/ { 803 , 104, 16131 , 1548666 },
1387/*SKY74400*/ };
1388/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_RX_1900[] =
1389/*SKY74400*/ {
1390/*SKY74400*/ { 512 , 107, 3597422, 1548666 },
1391/*SKY74400*/ { 525 , 108, 32263 , 1548666 },
1392/*SKY74400*/ { 611 , 109, 0 , 1548666 },
1393/*SKY74400*/ { 698 , 110, 16131 , 1548666 },
1394/*SKY74400*/ { 785 , 111, 32263 , 1548666 },
1395/*SKY74400*/ };
1396/*SKY74400*/ const SKY74400_PLL_ELM *const SKY74400_RXPLL_TBL[] =
1397/*SKY74400*/ {
1398/*SKY74400*/ 0, /* FrequencyBand400 (not support) */
1399/*SKY74400*/ SKY74400_RX_850, /* FrequencyBand850 */
1400/*SKY74400*/ SKY74400_RX_900, /* FrequencyBand900 */
1401/*SKY74400*/ SKY74400_RX_1800, /* FrequencyBand1800 */
1402/*SKY74400*/ SKY74400_RX_1900, /* FrequencyBand1900 */
1403/*SKY74400*/ };
1404/*SKY74400*/
1405/*SKY74400*/ short SKY74400_RXPLL_TBL_SIZE[5] =
1406/*SKY74400*/ {
1407/*SKY74400*/ 0, /* FrequencyBand400 (not support) */
1408/*SKY74400*/ sizeof(SKY74400_RX_850)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand850 */
1409/*SKY74400*/ sizeof(SKY74400_RX_900)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand900 */
1410/*SKY74400*/ sizeof(SKY74400_RX_1800)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand1800 */
1411/*SKY74400*/ sizeof(SKY74400_RX_1900)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand1900 */
1412/*SKY74400*/ };
1413/*SKY74400*/
1414/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_TX_850[] =
1415/*SKY74400*/ {
1416/*SKY74400*/ { 128 , 83 , 1881444, 2831846, 1 },
1417/*SKY74400*/ { 145 , 101, 3652493, 3417745, 3 },
1418/*SKY74400*/ { 149 , 83 , 3739844, 2831846, 1 },
1419/*SKY74400*/ { 152 , 102, 205821 , 3417745, 3 },
1420/*SKY74400*/ { 157 , 84 , 253501 , 2831846, 1 },
1421/*SKY74400*/ { 177 , 102, 2875935, 3417745, 3 },
1422/*SKY74400*/ { 190 , 103, 70090 , 3417745, 3 },
1423/*SKY74400*/ { 198 , 84 , 3881805, 2831846, 1 },
1424/*SKY74400*/ { 200 , 103, 1138136, 3417745, 3 },
1425/*SKY74400*/ { 209 , 85 , 660948 , 2831846, 1 },
1426/*SKY74400*/ { 211 , 103, 2312986, 3417745, 3 },
1427/*SKY74400*/ { 218 , 85 , 1457405, 2831846, 1 },
1428/*SKY74400*/ { 221 , 103, 3381031, 3417745, 3 },
1429/*SKY74400*/ { 227 , 85 , 2253862, 2831846, 1 },
1430/*SKY74400*/ { 249 , 104, 2177255, 0 , 3 },
1431/*SKY74400*/ { 250 , 86 , 94947 , 2831846, 1 },
1432/*SKY74400*/ };
1433/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_TX_900[] =
1434/*SKY74400*/ {
1435/*SKY74400*/ { 0 , 109, 3421083, 3417745 , 3 },
1436/*SKY74400*/ { 6 , 90 , 2167210, 2831846 , 1 },
1437/*SKY74400*/ { 19 , 110, 1256066, 3417745 , 3 },
1438/*SKY74400*/ { 25 , 90 , 3848619, 2831846 , 1 },
1439/*SKY74400*/ { 29 , 110, 2324111, 3417745 , 3 },
1440/*SKY74400*/ { 46 , 91 , 1512714, 2831846 , 1 },
1441/*SKY74400*/ { 48 , 111, 159094 , 3417745 , 3 },
1442/*SKY74400*/ { 64 , 91 , 3105628, 2831846 , 1 },
1443/*SKY74400*/ { 75 , 111, 3042817, 3417745 , 3 },
1444/*SKY74400*/ { 78 , 92 , 150257 , 2831846 , 1 },
1445/*SKY74400*/ { 87 , 112, 130168 , 3417745 , 3 },
1446/*SKY74400*/ { 104 , 92 , 2451132, 0 , 1 },
1447/*SKY74400*/ { 105 , 112, 2052650, 3417745 , 3 },
1448/*SKY74400*/ { 107 , 92 , 2716618, 2831846 , 1 },
1449/*SKY74400*/ { 124 , 93 , 26732 , 75367399, 1 },
1450/*SKY74400*/ { 975 , 108, 2381964, 3417745 , 3 },
1451/*SKY74400*/ { 991 , 89 , 2910201, 2831846 , 1 },
1452/*SKY74400*/ { 993 , 109, 110142 , 3417745 , 3 },
1453/*SKY74400*/ { 1010, 90 , 397306 , 52330164, 1 },
1454/*SKY74400*/ { 1011, 109, 2032624, 3417745 , 3 },
1455/*SKY74400*/ { 1013, 90 , 662792 , 2831846 , 1 },
1456/*SKY74400*/ { 1015, 109, 2459842, 3417745 , 3 },
1457/*SKY74400*/ { 1019, 90 , 1193763, 57603258, 1 },
1458/*SKY74400*/ { 1020, 109, 2993865, 3417745 , 3 },
1459/*SKY74400*/ };
1460/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_TX_1800[] =
1461/*SKY74400*/ {
1462/*SKY74400*/ { 512, 90 , 3135374, 1479322 , 1 },
1463/*SKY74400*/ { 516, 100, 277680 , 1624829 , 3 },
1464/*SKY74400*/ { 546, 91 , 512851 , 1479322 , 1 },
1465/*SKY74400*/ { 559, 100, 2461046, 1624829 , 3 },
1466/*SKY74400*/ { 567, 91 , 1483656, 1479322 , 1 },
1467/*SKY74400*/ { 576, 100, 3324237, 1624829 , 3 },
1468/*SKY74400*/ { 591, 91 , 2593148, 1479322 , 1 },
1469/*SKY74400*/ { 597, 101, 196227 , 1624829 , 3 },
1470/*SKY74400*/ { 630, 92 , 201769 , 1479322 , 1 },
1471/*SKY74400*/ { 641, 101, 2430369, 1624829 , 3 },
1472/*SKY74400*/ { 674, 88 , 1750545, 1415923 , 0 },
1473/*SKY74400*/ { 677, 102, 63998 , 1624829 , 3 },
1474/*SKY74400*/ { 681, 92 , 2559440, 1479322 , 1 },
1475/*SKY74400*/ { 691, 102, 774861 , 1624829 , 3 },
1476/*SKY74400*/ { 696, 88 , 2723993, 1415923 , 0 },
1477/*SKY74400*/ { 706, 102, 1536501, 1624829 , 3 },
1478/*SKY74400*/ { 712, 92 , 3992534, 1479322 , 1 },
1479/*SKY74400*/ { 714, 88 , 3520449, 1415923 , 0 },
1480/*SKY74400*/ { 719, 93 , 121832 , 1479322 , 1 },
1481/*SKY74400*/ { 723, 102, 2399691, 1624829 , 3 },
1482/*SKY74400*/ { 756, 89 , 1184545, 1415923 , 0 },
1483/*SKY74400*/ { 762, 103, 185649 , 1624829 , 3 },
1484/*SKY74400*/ { 788, 93 , 3311622, 1479322 , 1 },
1485/*SKY74400*/ { 806, 89 , 3396925, 1415923 , 0 },
1486/*SKY74400*/ { 812, 94 , 226810 , 1479322 , 1 },
1487/*SKY74400*/ { 821, 103, 3181429, 1624829 , 3 },
1488/*SKY74400*/ { 824, 94 , 781556 , 1479322 , 1 },
1489/*SKY74400*/ { 826, 103, 3435309, 1624829 , 3 },
1490/*SKY74400*/ { 839, 94 , 1474988, 1479322 , 1 },
1491/*SKY74400*/ { 844, 104, 154972 , 1624829 , 3 },
1492/*SKY74400*/ { 876, 94 , 3185455, 1479322 , 1 },
1493/*SKY74400*/ };
1494/*SKY74400*/ const SKY74400_PLL_ELM SKY74400_TX_1900[] =
1495/*SKY74400*/ {
1496/*SKY74400*/ { 512 , 94 , 389931 , 0 , 0 },
1497/*SKY74400*/ { 513 , 94 , 434179 , 1415923 , 0 },
1498/*SKY74400*/ { 518 , 108, 2367956, 1624829 , 3 },
1499/*SKY74400*/ { 522 , 98 , 2403418, 1479322 , 1 },
1500/*SKY74400*/ { 558 , 109, 204690 , 1624829 , 3 },
1501/*SKY74400*/ { 581 , 99 , 936615 , 1479322 , 1 },
1502/*SKY74400*/ { 601 , 109, 2388055, 1624829 , 3 },
1503/*SKY74400*/ { 614 , 99 , 2462167, 1479322 , 1 },
1504/*SKY74400*/ { 645 , 110, 427893 , 1624829 , 3 },
1505/*SKY74400*/ { 652 , 95 , 2390292, 1415923 , 0 },
1506/*SKY74400*/ { 671 , 100, 902907 , 1479322 , 1 },
1507/*SKY74400*/ { 683 , 110, 2357378, 1624829 , 3 },
1508/*SKY74400*/ { 701 , 100, 2289772, 1479322 , 1 },
1509/*SKY74400*/ { 719 , 96 , 1160577, 1415923 , 0 },
1510/*SKY74400*/ { 728 , 100, 3537950, 1479322 , 1 },
1511/*SKY74400*/ { 740 , 111, 1057303, 1624829 , 3 },
1512/*SKY74400*/ { 746 , 101, 175765 , 1479322 , 1 },
1513/*SKY74400*/ { 781 , 111, 3139116, 1624829 , 3 },
1514/*SKY74400*/ { 796 , 101, 2487207, 1479322 , 1 },
1515/*SKY74400*/ };
1516/*SKY74400*/
1517/*SKY74400*/ const SKY74400_PLL_ELM *const SKY74400_TXPLL_TBL[] =
1518/*SKY74400*/ {
1519/*SKY74400*/ 0, /* FrequencyBand400 (not support) */
1520/*SKY74400*/ SKY74400_TX_850, /* FrequencyBand850 */
1521/*SKY74400*/ SKY74400_TX_900, /* FrequencyBand900 */
1522/*SKY74400*/ SKY74400_TX_1800, /* FrequencyBand1800 */
1523/*SKY74400*/ SKY74400_TX_1900, /* FrequencyBand1900 */
1524/*SKY74400*/ };
1525/*SKY74400*/
1526/*SKY74400*/ short SKY74400_TXPLL_TBL_SIZE[5] =
1527/*SKY74400*/ {
1528/*SKY74400*/ 0, /* FrequencyBand400 (not support) */
1529/*SKY74400*/ sizeof(SKY74400_TX_850)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand850 */
1530/*SKY74400*/ sizeof(SKY74400_TX_900)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand900 */
1531/*SKY74400*/ sizeof(SKY74400_TX_1800)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand1800 */
1532/*SKY74400*/ sizeof(SKY74400_TX_1900)/sizeof(SKY74400_PLL_ELM)-1, /* FrequencyBand1900 */
1533/*SKY74400*/ };
1534/*SKY74400*/
1535/*SKY74400*/ short SKY74400_TXPLL_INJECTIN_TBL[5] =
1536/*SKY74400*/ {
1537/*SKY74400*/ 0, /* FrequencyBand400 (not support) */
1538/*SKY74400*/ 90, /* FrequencyBand850 (not support) */
1539/*SKY74400*/ 95, /* FrequencyBand900 (not support) */
1540/*SKY74400*/ 98, /* FrequencyBand1800 (not support) */
1541/*SKY74400*/ 105, /* FrequencyBand1900 (not support) */
1542/*SKY74400*/ };
1543/*SKY74400*/
1544/*SKY74400*/ const unsigned long SDATA_TX_TABLE[5] =
1545/*SKY74400*/ {
1546/*SKY74400*/ 0L , /* FrequencyBand400 (not support) */
1547/*SKY74400*/ 0x040004L , /* FrequencyBand850 */
1548/*SKY74400*/ 0x050004L , /* FrequencyBand900 */
1549/*SKY74400*/ 0x060004L , /* FrequencyBand1800 */
1550/*SKY74400*/ 0x070004L , /* FrequencyBand1900 */
1551/*SKY74400*/ };
1552/*SKY74400*/ const unsigned long SDATA_TX_Div_TABLE[2] = { 0x100000, 0x200000 }; // 0: /8 1: /16
1553/*SKY74400*/ const unsigned long SDATA_TX_Inj_TABLE[2] = { 0x000000, 0x080000 }; // 0: Low 1: High
1554/*SKY74400*/ unsigned long SKY74400_TxCtrl = 0;
1555/*SKY74400*/ unsigned long SKY74400_TxCtrl_Mask = 0;
1556/*SKY74400*/
1557/*SKY74400*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1558/*SKY74400*/ { int Nfrac;
1559/*SKY74400*/ const SKY74400_PLL_ELM* elmptr;
1560/*SKY74400*/ int left, right, middle;
1561/*SKY74400*/
1562/*SKY74400*/ /*binary search*/
1563/*SKY74400*/ elmptr = SKY74400_RXPLL_TBL[rf_band];
1564/*SKY74400*/ left = 0; right = SKY74400_RXPLL_TBL_SIZE[rf_band];
1565/*SKY74400*/ while (left <= right)
1566/*SKY74400*/ { middle = (left + right)/2;
1567/*SKY74400*/ if ( arfcn<(elmptr+middle)->arfcn )
1568/*SKY74400*/ right = middle - 1;
1569/*SKY74400*/ else
1570/*SKY74400*/ left = middle + 1;
1571/*SKY74400*/ }
1572/*SKY74400*/ elmptr = (elmptr+left-1);
1573/*SKY74400*/
1574/*SKY74400*/ Nfrac = elmptr->Fbase + (((arfcn-elmptr->arfcn)*elmptr->Fstep)>>5);
1575/*SKY74400*/ *rfN = (elmptr->Nint<<6) | 0xC40000;
1576/*SKY74400*/ *ifN = (Nfrac<<2) | 3;
1577/*SKY74400*/ // *rfN = elmptr->Nint;
1578/*SKY74400*/ // *ifN = Nfrac;
1579/*SKY74400*/ }
1580/*SKY74400*/ /* =========================================================================== */
1581/*SKY74400*/
1582/*SKY74400*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1583/*SKY74400*/ { int Nfrac;
1584/*SKY74400*/ const SKY74400_PLL_ELM* elmptr;
1585/*SKY74400*/ int left, right, middle;
1586/*SKY74400*/ int div;
1587/*SKY74400*/
1588/*SKY74400*/ /*binary search*/
1589/*SKY74400*/ elmptr = SKY74400_TXPLL_TBL[rf_band];
1590/*SKY74400*/ left = 0; right = SKY74400_TXPLL_TBL_SIZE[rf_band];
1591/*SKY74400*/ while (left <= right)
1592/*SKY74400*/ { middle = (left + right)/2;
1593/*SKY74400*/ if ( arfcn<(elmptr+middle)->arfcn )
1594/*SKY74400*/ right = middle - 1;
1595/*SKY74400*/ else
1596/*SKY74400*/ left = middle + 1;
1597/*SKY74400*/ }
1598/*SKY74400*/ elmptr = (elmptr+left-1);
1599/*SKY74400*/ Nfrac = elmptr->Fbase + (((arfcn-elmptr->arfcn)*elmptr->Fstep)>>5);
1600/*SKY74400*/ *rfN = (elmptr->Nint<<6) | 0xC40000;
1601/*SKY74400*/ *ifN = (Nfrac<<2) | 3;
1602/*SKY74400*/ // *rfN = elmptr->Nint;
1603/*SKY74400*/ // *ifN = Nfrac;
1604/*SKY74400*/
1605/*SKY74400*/ l1d_rf.next_inj = (elmptr->Inj_Div>>1)&0x01;
1606/*SKY74400*/ div = (elmptr->Inj_Div>>0)&0x01;
1607/*SKY74400*/ SKY74400_TxCtrl_Mask = SDATA_TX_Div_TABLE[div] | SDATA_TX_Inj_TABLE[l1d_rf.next_inj];
1608/*SKY74400*/ SKY74400_TxCtrl = SDATA_TX_TABLE[rf_band] | SDATA_TX_Div_TABLE[div] | SDATA_TX_Inj_TABLE[l1d_rf.next_inj];
1609/*SKY74400*/ }
1610/*SKY74400*/ /* =========================================================================== */
1611#endif
1612
1613#if IS_RF_MT6119
1614/*MT6119*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1615/*MT6119*/ { int Nfrac;
1616/*MT6119*/
1617/*MT6119*/ switch(rf_band)
1618/*MT6119*/ {
1619/*MT6119*/ case FrequencyBand900 :
1620/*MT6119*/ {
1621/*MT6119*/ if(arfcn<=70)
1622/*MT6119*/ { if(arfcn<=5) /* ARFCN : 0~5 */
1623/*MT6119*/ { Nfrac = 80*(arfcn-0)+4760;
1624/*MT6119*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1625/*MT6119*/ }
1626/*MT6119*/ else /* ARFCN : 6~70 */
1627/*MT6119*/ { Nfrac = 80*(arfcn-6)+40;
1628/*MT6119*/ *rfN = (8L<<16) | (Nfrac<<3) | 1;
1629/*MT6119*/ }
1630/*MT6119*/ }
1631/*MT6119*/ else
1632/*MT6119*/ { if(arfcn<=124) /* ARFCN : 71~124 */
1633/*MT6119*/ { Nfrac = 80*(arfcn-71)+40;
1634/*MT6119*/ *rfN = (9L<<16) | (Nfrac<<3) | 1;
1635/*MT6119*/ }
1636/*MT6119*/ else
1637/*MT6119*/ { Nfrac = 80*(arfcn-975)+840; /* ARFCN : 975~1023 */
1638/*MT6119*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1639/*MT6119*/ }
1640/*MT6119*/ }
1641/*MT6119*/ break;
1642/*MT6119*/ }
1643/*MT6119*/ case FrequencyBand1800 :
1644/*MT6119*/ {
1645/*MT6119*/ if(arfcn<=716)
1646/*MT6119*/ { if(arfcn<=586) /* ARFCN : 512~586 */
1647/*MT6119*/ { Nfrac = 40*(arfcn-512)+2220;
1648/*MT6119*/ *rfN = (5L<<16) | (Nfrac<<3) | 1;
1649/*MT6119*/ }
1650/*MT6119*/ else /* ARFCN : 587~716 */
1651/*MT6119*/ { Nfrac = 40*(arfcn-587)+20;
1652/*MT6119*/ *rfN = (6L<<16) | (Nfrac<<3) | 1;
1653/*MT6119*/ }
1654/*MT6119*/ }
1655/*MT6119*/ else
1656/*MT6119*/ { if(arfcn<=846) /* ARFCN : 717~846 */
1657/*MT6119*/ { Nfrac = 40*(arfcn-717)+20;
1658/*MT6119*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1659/*MT6119*/ }
1660/*MT6119*/ else /* ARFCN : 847~885 */
1661/*MT6119*/ { Nfrac = 40*(arfcn-847)+20;
1662/*MT6119*/ *rfN = (8L<<16) | (Nfrac<<3) | 1;
1663/*MT6119*/ }
1664/*MT6119*/ }
1665/*MT6119*/ break;
1666/*MT6119*/ }
1667/*MT6119*/ case FrequencyBand1900 :
1668/*MT6119*/ {
1669/*MT6119*/ if(arfcn<=741)
1670/*MT6119*/ { if(arfcn<=611) /* ARFCN : 512~611 */
1671/*MT6119*/ { Nfrac = 40*(arfcn-512)+1220;
1672/*MT6119*/ *rfN = (10L<<16) | (Nfrac<<3) | 1;
1673/*MT6119*/ }
1674/*MT6119*/ else /* ARFCN : 612~741 */
1675/*MT6119*/ { Nfrac = 40*(arfcn-612)+20;
1676/*MT6119*/ *rfN = (11L<<16) | (Nfrac<<3) | 1;
1677/*MT6119*/ }
1678/*MT6119*/ }
1679/*MT6119*/ else
1680/*MT6119*/ { Nfrac = 40*(arfcn-742)+20; /* ARFCN : 742~810 */
1681/*MT6119*/ *rfN = (12L<<16) | (Nfrac<<3) | 1;
1682/*MT6119*/ }
1683/*MT6119*/ break;
1684/*MT6119*/ }
1685/*MT6119*/ default :
1686/*MT6119*/ {
1687/*MT6119*/ break;
1688/*MT6119*/ }
1689/*MT6119*/ }
1690/*MT6119*/ *ifN = 0;
1691/*MT6119*/ }
1692/*MT6119*/ /* =========================================================================== */
1693/*MT6119*/
1694/*MT6119*/ char mt6119_d_flag = 0;
1695/*MT6119*/
1696/*MT6119*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1697/*MT6119*/ { int Nfrac;
1698/*MT6119*/
1699/*MT6119*/ switch(rf_band)
1700/*MT6119*/ {
1701/*MT6119*/ case FrequencyBand900 :
1702/*MT6119*/ {
1703/*MT6119*/ if(arfcn<=110)
1704/*MT6119*/ { if(arfcn<=52)
1705/*MT6119*/ { if(arfcn<=3) /* ARFCN : 0~3 */
1706/*MT6119*/ { Nfrac = 88*(arfcn-0)+1600;
1707/*MT6119*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
1708/*MT6119*/ mt6119_d_flag = 1;
1709/*MT6119*/ }
1710/*MT6119*/ else /* ARFCN : 4~52 */
1711/*MT6119*/ { Nfrac = 90*(arfcn-4)+460;
1712/*MT6119*/ *rfN = (13L<<16) | (Nfrac<<3) | 0x400001L;
1713/*MT6119*/ mt6119_d_flag = 0;
1714/*MT6119*/ }
1715/*MT6119*/ }
1716/*MT6119*/ else
1717/*MT6119*/ { if(arfcn<=61) /* ARFCN : 53~61 */
1718/*MT6119*/ { Nfrac = 88*(arfcn-53)+1064;
1719/*MT6119*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
1720/*MT6119*/ mt6119_d_flag = 1;
1721/*MT6119*/ }
1722/*MT6119*/ else /* ARFCN : 62~110 */
1723/*MT6119*/ { Nfrac = 90*(arfcn-62)+480;
1724/*MT6119*/ *rfN = (14L<<16) | (Nfrac<<3) | 0x400001L;
1725/*MT6119*/ mt6119_d_flag = 0;
1726/*MT6119*/ }
1727/*MT6119*/ }
1728/*MT6119*/ }
1729/*MT6119*/ else
1730/*MT6119*/ { if(arfcn<=124)
1731/*MT6119*/ { if(arfcn<=118) /* ARFCN : 111~118 */
1732/*MT6119*/ { Nfrac = 88*(arfcn-111)+968;
1733/*MT6119*/ *rfN = (13L<<16) | (Nfrac<<3) | 0x400001L;
1734/*MT6119*/ mt6119_d_flag = 1;
1735/*MT6119*/ }
1736/*MT6119*/ else /* ARFCN : 119~124 */
1737/*MT6119*/ { Nfrac = 90*(arfcn-119)+410;
1738/*MT6119*/ *rfN = (15L<<16) | (Nfrac<<3) | 0x400001L;
1739/*MT6119*/ mt6119_d_flag = 0;
1740/*MT6119*/ }
1741/*MT6119*/ }
1742/*MT6119*/ else
1743/*MT6119*/ { if(arfcn<=1018) /* ARFCN : 975~1018 */
1744/*MT6119*/ { Nfrac = 90*(arfcn-975)+890;
1745/*MT6119*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
1746/*MT6119*/ mt6119_d_flag = 0;
1747/*MT6119*/ }
1748/*MT6119*/ else /* ARFCN : 1019~1023 */
1749/*MT6119*/ { Nfrac = 88*(arfcn-1019)+1160;
1750/*MT6119*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
1751/*MT6119*/ mt6119_d_flag = 1;
1752/*MT6119*/ }
1753/*MT6119*/ }
1754/*MT6119*/ }
1755/*MT6119*/ break;
1756/*MT6119*/ }
1757/*MT6119*/ case FrequencyBand1800 :
1758/*MT6119*/ {
1759/*MT6119*/ if(arfcn<=734)
1760/*MT6119*/ { if(arfcn<=618)
1761/*MT6119*/ { if(arfcn<=520) /* ARFCN : 512~520 */
1762/*MT6119*/ { Nfrac = 44*(arfcn-512)+1844;
1763/*MT6119*/ *rfN = (8L<<16) | (Nfrac<<3) | 0x400001L;
1764/*MT6119*/ mt6119_d_flag = 1;
1765/*MT6119*/ }
1766/*MT6119*/ else /* ARFCN : 521~618 */
1767/*MT6119*/ { Nfrac = 45*(arfcn-521)+400;
1768/*MT6119*/ *rfN = (10L<<16) | (Nfrac<<3) | 0x400001L;
1769/*MT6119*/ mt6119_d_flag = 0;
1770/*MT6119*/ }
1771/*MT6119*/ }
1772/*MT6119*/ else
1773/*MT6119*/ { if(arfcn<=636) /* ARFCN : 619~636 */
1774/*MT6119*/ { Nfrac = 44*(arfcn-619)+1352;
1775/*MT6119*/ *rfN = (9L<<16) | (Nfrac<<3) | 0x400001L;
1776/*MT6119*/ mt6119_d_flag = 1;
1777/*MT6119*/ }
1778/*MT6119*/ else /* ARFCN : 637~734 */
1779/*MT6119*/ { Nfrac = 45*(arfcn-637)+420;
1780/*MT6119*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
1781/*MT6119*/ mt6119_d_flag = 0;
1782/*MT6119*/ }
1783/*MT6119*/ }
1784/*MT6119*/ }
1785/*MT6119*/ else
1786/*MT6119*/ { if(arfcn<=849)
1787/*MT6119*/ { if(arfcn<=752) /* ARFCN : 735~752 */
1788/*MT6119*/ { Nfrac = 44*(arfcn-735)+1256;
1789/*MT6119*/ *rfN = (10L<<16) | (Nfrac<<3) | 0x400001L;
1790/*MT6119*/ mt6119_d_flag = 1;
1791/*MT6119*/ }
1792/*MT6119*/ else /* ARFCN : 753~849 */
1793/*MT6119*/ { Nfrac = 45*(arfcn-753)+440;
1794/*MT6119*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
1795/*MT6119*/ mt6119_d_flag = 0;
1796/*MT6119*/ }
1797/*MT6119*/ }
1798/*MT6119*/ else /* ARFCN : 850~867 */
1799/*MT6119*/ { if(arfcn<=867)
1800/*MT6119*/ { Nfrac = 44*(arfcn-850)+1116;
1801/*MT6119*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
1802/*MT6119*/ mt6119_d_flag = 1;
1803/*MT6119*/ }
1804/*MT6119*/ else /* ARFCN : 868~885 */
1805/*MT6119*/ { Nfrac = 45*(arfcn-868)+415;
1806/*MT6119*/ *rfN = (13L<<16) | (Nfrac<<3) | 0x400001L;
1807/*MT6119*/ mt6119_d_flag = 0;
1808/*MT6119*/ }
1809/*MT6119*/ }
1810/*MT6119*/ }
1811/*MT6119*/ break;
1812/*MT6119*/ }
1813/*MT6119*/ case FrequencyBand1900 :
1814/*MT6119*/ {
1815/*MT6119*/ if(arfcn<=727)
1816/*MT6119*/ { if(arfcn<=612)
1817/*MT6119*/ { if(arfcn<=514) /* ARFCN : 512~514 */
1818/*MT6119*/ { Nfrac = 44*(arfcn-512)+1444;
1819/*MT6119*/ *rfN = (14L<<16) | (Nfrac<<3) | 0x400001L;
1820/*MT6119*/ mt6119_d_flag = 1;
1821/*MT6119*/ }
1822/*MT6119*/ else
1823/*MT6119*/ { Nfrac = 45*(arfcn-515)+430; /* ARFCN : 515~612 */
1824/*MT6119*/ *rfN = (16L<<16) | (Nfrac<<3) | 0x400001L;
1825/*MT6119*/ mt6119_d_flag = 0;
1826/*MT6119*/ }
1827/*MT6119*/ }
1828/*MT6119*/ else
1829/*MT6119*/ { if(arfcn<=629) /* ARFCN : 613~629 */
1830/*MT6119*/ { Nfrac = 44*(arfcn-613)+688;
1831/*MT6119*/ *rfN = (15L<<16) | (Nfrac<<3) | 0x400001L;
1832/*MT6119*/ mt6119_d_flag = 1;
1833/*MT6119*/ }
1834/*MT6119*/ else
1835/*MT6119*/ { Nfrac = 45*(arfcn-630)+405; /* ARFCN : 630~727 */
1836/*MT6119*/ *rfN = (17L<<16) | (Nfrac<<3) | 0x400001L;
1837/*MT6119*/ mt6119_d_flag = 0;
1838/*MT6119*/ }
1839/*MT6119*/ }
1840/*MT6119*/ }
1841/*MT6119*/ else
1842/*MT6119*/ { if(arfcn<=745) /* ARFCN : 728~745 */
1843/*MT6119*/ { Nfrac = 44*(arfcn-728)+548;
1844/*MT6119*/ *rfN = (16L<<16) | (Nfrac<<3) | 0x400001L;
1845/*MT6119*/ mt6119_d_flag = 1;
1846/*MT6119*/ }
1847/*MT6119*/ else /* ARFCN : 746~810 */
1848/*MT6119*/ { Nfrac = 45*(arfcn-746)+425;
1849/*MT6119*/ *rfN = (18L<<16) | (Nfrac<<3) | 0x400001L;
1850/*MT6119*/ mt6119_d_flag = 0;
1851/*MT6119*/ }
1852/*MT6119*/ }
1853/*MT6119*/ break;
1854/*MT6119*/ }
1855/*MT6119*/ default :
1856/*MT6119*/ {
1857/*MT6119*/ break;
1858/*MT6119*/ }
1859/*MT6119*/ }
1860/*MT6119*/ *ifN = 0;
1861/*MT6119*/ }
1862/*MT6119*/ /* =========================================================================== */
1863#endif
1864
1865#if IS_RF_MT6119C
1866/*MT6119C*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1867/*MT6119C*/{ int Nfrac;
1868/*MT6119C*/
1869/*MT6119C*/ switch(rf_band)
1870/*MT6119C*/ {
1871/*MT6119C*/ case FrequencyBand900 :
1872/*MT6119C*/ {
1873/*MT6119C*/ if(arfcn<=70)
1874/*MT6119C*/ { if(arfcn<=5) /* ARFCN : 0~5 */
1875/*MT6119C*/ { Nfrac = 80*(arfcn-0)+4760;
1876/*MT6119C*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1877/*MT6119C*/ }
1878/*MT6119C*/ else /* ARFCN : 6~70 */
1879/*MT6119C*/ { Nfrac = 80*(arfcn-6)+40;
1880/*MT6119C*/ *rfN = (8L<<16) | (Nfrac<<3) | 1;
1881/*MT6119C*/ }
1882/*MT6119C*/ }
1883/*MT6119C*/ else
1884/*MT6119C*/ { if(arfcn<=124) /* ARFCN : 71~124 */
1885/*MT6119C*/ { Nfrac = 80*(arfcn-71)+40;
1886/*MT6119C*/ *rfN = (9L<<16) | (Nfrac<<3) | 1;
1887/*MT6119C*/ }
1888/*MT6119C*/ else
1889/*MT6119C*/ { Nfrac = 80*(arfcn-975)+840; /* ARFCN : 975~1023 */
1890/*MT6119C*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1891/*MT6119C*/ }
1892/*MT6119C*/ }
1893/*MT6119C*/ break;
1894/*MT6119C*/ }
1895/*MT6119C*/ case FrequencyBand1800 :
1896/*MT6119C*/ {
1897/*MT6119C*/ if(arfcn<=716)
1898/*MT6119C*/ { if(arfcn<=586) /* ARFCN : 512~586 */
1899/*MT6119C*/ { Nfrac = 40*(arfcn-512)+2220;
1900/*MT6119C*/ *rfN = (5L<<16) | (Nfrac<<3) | 1;
1901/*MT6119C*/ }
1902/*MT6119C*/ else /* ARFCN : 587~716 */
1903/*MT6119C*/ { Nfrac = 40*(arfcn-587)+20;
1904/*MT6119C*/ *rfN = (6L<<16) | (Nfrac<<3) | 1;
1905/*MT6119C*/ }
1906/*MT6119C*/ }
1907/*MT6119C*/ else
1908/*MT6119C*/ { if(arfcn<=846) /* ARFCN : 717~846 */
1909/*MT6119C*/ { Nfrac = 40*(arfcn-717)+20;
1910/*MT6119C*/ *rfN = (7L<<16) | (Nfrac<<3) | 1;
1911/*MT6119C*/ }
1912/*MT6119C*/ else /* ARFCN : 847~885 */
1913/*MT6119C*/ { Nfrac = 40*(arfcn-847)+20;
1914/*MT6119C*/ *rfN = (8L<<16) | (Nfrac<<3) | 1;
1915/*MT6119C*/ }
1916/*MT6119C*/ }
1917/*MT6119C*/ break;
1918/*MT6119C*/ }
1919/*MT6119C*/ case FrequencyBand1900 :
1920/*MT6119C*/ {
1921/*MT6119C*/ if(arfcn<=741)
1922/*MT6119C*/ { if(arfcn<=611) /* ARFCN : 512~611 */
1923/*MT6119C*/ { Nfrac = 40*(arfcn-512)+1220;
1924/*MT6119C*/ *rfN = (10L<<16) | (Nfrac<<3) | 1;
1925/*MT6119C*/ }
1926/*MT6119C*/ else /* ARFCN : 612~741 */
1927/*MT6119C*/ { Nfrac = 40*(arfcn-612)+20;
1928/*MT6119C*/ *rfN = (11L<<16) | (Nfrac<<3) | 1;
1929/*MT6119C*/ }
1930/*MT6119C*/ }
1931/*MT6119C*/ else
1932/*MT6119C*/ { Nfrac = 40*(arfcn-742)+20; /* ARFCN : 742~810 */
1933/*MT6119C*/ *rfN = (12L<<16) | (Nfrac<<3) | 1;
1934/*MT6119C*/ }
1935/*MT6119C*/ break;
1936/*MT6119C*/ }
1937/*MT6119C*/ default :
1938/*MT6119C*/ {
1939/*MT6119C*/ break;
1940/*MT6119C*/ }
1941/*MT6119C*/ }
1942/*MT6119C*/ *ifN = 0;
1943/*MT6119C*/}
1944/*MT6119C*//* =========================================================================== */
1945/*MT6119C*/
1946/*MT6119C*/char mt6119_d_flag = 0;
1947/*MT6119C*/
1948/*MT6119C*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
1949/*MT6119C*/{ int Nfrac;
1950/*MT6119C*/
1951/*MT6119C*/ switch(rf_band)
1952/*MT6119C*/ {
1953/*MT6119C*/ case FrequencyBand900 :
1954/*MT6119C*/ {
1955/*MT6119C*/ if(arfcn<=104)
1956/*MT6119C*/ { if(arfcn<=45)
1957/*MT6119C*/ { if(arfcn<=36) /* ARFCN : 0~36 */
1958/*MT6119C*/ { Nfrac = 88*(arfcn-0)+1600;
1959/*MT6119C*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
1960/*MT6119C*/ mt6119_d_flag = 1;
1961/*MT6119C*/ }
1962/*MT6119C*/ else /* ARFCN : 37~45 */
1963/*MT6119C*/ { Nfrac = 90*(arfcn-37)+3430;
1964/*MT6119C*/ *rfN = (13L<<16) | (Nfrac<<3) | 0x400001L;
1965/*MT6119C*/ mt6119_d_flag = 0;
1966/*MT6119C*/ }
1967/*MT6119C*/ }
1968/*MT6119C*/ else
1969/*MT6119C*/ { if(arfcn<=95) /* ARFCN : 46~95 */
1970/*MT6119C*/ { Nfrac = 88*(arfcn-46)+448;
1971/*MT6119C*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
1972/*MT6119C*/ mt6119_d_flag = 1;
1973/*MT6119C*/ }
1974/*MT6119C*/ else /* ARFCN : 96~104 */
1975/*MT6119C*/ { Nfrac = 90*(arfcn-96)+3540;
1976/*MT6119C*/ *rfN = (14L<<16) | (Nfrac<<3) | 0x400001L;
1977/*MT6119C*/ mt6119_d_flag = 0;
1978/*MT6119C*/ }
1979/*MT6119C*/ }
1980/*MT6119C*/ }
1981/*MT6119C*/ else
1982/*MT6119C*/ { if(arfcn<=1001)
1983/*MT6119C*/ { if(arfcn<=124) /* ARFCN : 105~124 */
1984/*MT6119C*/ { Nfrac = 88*(arfcn-105)+440;
1985/*MT6119C*/ *rfN = (13L<<16) | (Nfrac<<3) | 0x400001L;
1986/*MT6119C*/ mt6119_d_flag = 1;
1987/*MT6119C*/ }
1988/*MT6119C*/ else /* ARFCN : 975~1001 */
1989/*MT6119C*/ { Nfrac = 88*(arfcn-975)+2488;
1990/*MT6119C*/ *rfN = (10L<<16) | (Nfrac<<3) | 0x400001L;
1991/*MT6119C*/ mt6119_d_flag = 1;
1992/*MT6119C*/ }
1993/*MT6119C*/ }
1994/*MT6119C*/ else
1995/*MT6119C*/ { if(arfcn<=1010) /* ARFCN : 1002~1010 */
1996/*MT6119C*/ { Nfrac = 90*(arfcn-1002)+3320;
1997/*MT6119C*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
1998/*MT6119C*/ mt6119_d_flag = 0;
1999/*MT6119C*/ }
2000/*MT6119C*/ else /* ARFCN : 1011~1023 */
2001/*MT6119C*/ { Nfrac = 88*(arfcn-1011)+456;
2002/*MT6119C*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
2003/*MT6119C*/ mt6119_d_flag = 1;
2004/*MT6119C*/ }
2005/*MT6119C*/ }
2006/*MT6119C*/ }
2007/*MT6119C*/ break;
2008/*MT6119C*/ }
2009/*MT6119C*/ case FrequencyBand1800 :
2010/*MT6119C*/ {
2011/*MT6119C*/ if(arfcn<=715)
2012/*MT6119C*/ { if(arfcn<=597)
2013/*MT6119C*/ { if(arfcn<=579) /* ARFCN : 512~579 */
2014/*MT6119C*/ { Nfrac = 44*(arfcn-512)+1844;
2015/*MT6119C*/ *rfN = (8L<<16) | (Nfrac<<3) | 0x400001L;
2016/*MT6119C*/ mt6119_d_flag = 1;
2017/*MT6119C*/ }
2018/*MT6119C*/ else /* ARFCN : 580~597 */
2019/*MT6119C*/ { Nfrac = 45*(arfcn-580)+3055;
2020/*MT6119C*/ *rfN = (10L<<16) | (Nfrac<<3) | 0x400001L;
2021/*MT6119C*/ mt6119_d_flag = 0;
2022/*MT6119C*/ }
2023/*MT6119C*/ }
2024/*MT6119C*/ else
2025/*MT6119C*/ { if(arfcn<=697) /* ARFCN : 598~697 */
2026/*MT6119C*/ { Nfrac = 44*(arfcn-598)+428;
2027/*MT6119C*/ *rfN = (9L<<16) | (Nfrac<<3) | 0x400001L;
2028/*MT6119C*/ mt6119_d_flag = 1;
2029/*MT6119C*/ }
2030/*MT6119C*/ else /* ARFCN : 698~715 */
2031/*MT6119C*/ { Nfrac = 45*(arfcn-698)+3165;
2032/*MT6119C*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
2033/*MT6119C*/ mt6119_d_flag = 0;
2034/*MT6119C*/ }
2035/*MT6119C*/ }
2036/*MT6119C*/ }
2037/*MT6119C*/ else
2038/*MT6119C*/ { if(arfcn<=833)
2039/*MT6119C*/ { if(arfcn<=815) /* ARFCN : 716~815 */
2040/*MT6119C*/ { Nfrac = 44*(arfcn-716)+420;
2041/*MT6119C*/ *rfN = (10L<<16) | (Nfrac<<3) | 0x400001L;
2042/*MT6119C*/ mt6119_d_flag = 1;
2043/*MT6119C*/ }
2044/*MT6119C*/ else /* ARFCN : 816~833 */
2045/*MT6119C*/ { Nfrac = 45*(arfcn-816)+3275;
2046/*MT6119C*/ *rfN = (12L<<16) | (Nfrac<<3) | 0x400001L;
2047/*MT6119C*/ mt6119_d_flag = 0;
2048/*MT6119C*/ }
2049/*MT6119C*/ }
2050/*MT6119C*/ else /* ARFCN : 834~885 */
2051/*MT6119C*/ { Nfrac = 44*(arfcn-834)+412;
2052/*MT6119C*/ *rfN = (11L<<16) | (Nfrac<<3) | 0x400001L;
2053/*MT6119C*/ mt6119_d_flag = 1;
2054/*MT6119C*/ }
2055/*MT6119C*/ }
2056/*MT6119C*/ break;
2057/*MT6119C*/ }
2058/*MT6119C*/ case FrequencyBand1900 :
2059/*MT6119C*/ {
2060/*MT6119C*/ if(arfcn<=706)
2061/*MT6119C*/ { if(arfcn<=606)
2062/*MT6119C*/ { if(arfcn<=588) /* ARFCN : 512~588 */
2063/*MT6119C*/ { Nfrac = 44*(arfcn-512)+1444;
2064/*MT6119C*/ *rfN = (14L<<16) | (Nfrac<<3) | 0x400001L;
2065/*MT6119C*/ mt6119_d_flag = 1;
2066/*MT6119C*/ }
2067/*MT6119C*/ else
2068/*MT6119C*/ { Nfrac = 45*(arfcn-589)+3760; /* ARFCN : 589~606 */
2069/*MT6119C*/ *rfN = (16L<<16) | (Nfrac<<3) | 0x400001L;
2070/*MT6119C*/ mt6119_d_flag = 0;
2071/*MT6119C*/ }
2072/*MT6119C*/ }
2073/*MT6119C*/ else /* ARFCN : 607~706 */
2074/*MT6119C*/ { Nfrac = 44*(arfcn-607)+424;
2075/*MT6119C*/ *rfN = (15L<<16) | (Nfrac<<3) | 0x400001L;
2076/*MT6119C*/ mt6119_d_flag = 1;
2077/*MT6119C*/ }
2078/*MT6119C*/ }
2079/*MT6119C*/ else
2080/*MT6119C*/ { if(arfcn<=724) /* ARFCN : 707~724 */
2081/*MT6119C*/ { Nfrac = 45*(arfcn-707)+3870;
2082/*MT6119C*/ *rfN = (17L<<16) | (Nfrac<<3) | 0x400001L;
2083/*MT6119C*/ mt6119_d_flag = 0;
2084/*MT6119C*/ }
2085/*MT6119C*/ else /* ARFCN : 725~810 */
2086/*MT6119C*/ { Nfrac = 44*(arfcn-725)+416;
2087/*MT6119C*/ *rfN = (16L<<16) | (Nfrac<<3) | 0x400001L;
2088/*MT6119C*/ mt6119_d_flag = 1;
2089/*MT6119C*/ }
2090/*MT6119C*/ }
2091/*MT6119C*/ break;
2092/*MT6119C*/ }
2093/*MT6119C*/ default :
2094/*MT6119C*/ {
2095/*MT6119C*/ break;
2096/*MT6119C*/ }
2097/*MT6119C*/ }
2098/*MT6119C*/ *ifN = 0;
2099/*MT6119C*/}
2100/*MT6119C*//* =========================================================================== */
2101#endif
2102
2103#if IS_RF_MT6129A
2104/*MT6129A*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2105/*MT6129A*/{ int Nfrac;
2106/*MT6129A*/
2107/*MT6129A*/ switch(rf_band)
2108/*MT6129A*/ {
2109/*MT6129A*/ case FrequencyBand900 :
2110/*MT6129A*/ {
2111/*MT6129A*/ if(arfcn<=70)
2112/*MT6129A*/ { if(arfcn<=5) /* ARFCN : 0~5 */
2113/*MT6129A*/ { Nfrac = 80*(arfcn-0)+4760;
2114/*MT6129A*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2115/*MT6129A*/ }
2116/*MT6129A*/ else /* ARFCN : 6~70 */
2117/*MT6129A*/ { Nfrac = 80*(arfcn-6)+40;
2118/*MT6129A*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2119/*MT6129A*/ }
2120/*MT6129A*/ }
2121/*MT6129A*/ else
2122/*MT6129A*/ { if(arfcn<=124) /* ARFCN : 71~124 */
2123/*MT6129A*/ { Nfrac = 80*(arfcn-71)+40;
2124/*MT6129A*/ *rfN = (9L<<17) | (Nfrac<<4) | 1;
2125/*MT6129A*/ }
2126/*MT6129A*/ else
2127/*MT6129A*/ { Nfrac = 80*(arfcn-975)+840; /* ARFCN : 975~1023 */
2128/*MT6129A*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2129/*MT6129A*/ }
2130/*MT6129A*/ }
2131/*MT6129A*/ break;
2132/*MT6129A*/ }
2133/*MT6129A*/ case FrequencyBand1800 :
2134/*MT6129A*/ {
2135/*MT6129A*/ if(arfcn<=716)
2136/*MT6129A*/ { if(arfcn<=586) /* ARFCN : 512~586 */
2137/*MT6129A*/ { Nfrac = 40*(arfcn-512)+2220;
2138/*MT6129A*/ *rfN = (5L<<17) | (Nfrac<<4) | 1;
2139/*MT6129A*/ }
2140/*MT6129A*/ else /* ARFCN : 587~716 */
2141/*MT6129A*/ { Nfrac = 40*(arfcn-587)+20;
2142/*MT6129A*/ *rfN = (6L<<17) | (Nfrac<<4) | 1;
2143/*MT6129A*/ }
2144/*MT6129A*/ }
2145/*MT6129A*/ else
2146/*MT6129A*/ { if(arfcn<=846) /* ARFCN : 717~846 */
2147/*MT6129A*/ { Nfrac = 40*(arfcn-717)+20;
2148/*MT6129A*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2149/*MT6129A*/ }
2150/*MT6129A*/ else /* ARFCN : 847~885 */
2151/*MT6129A*/ { Nfrac = 40*(arfcn-847)+20;
2152/*MT6129A*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2153/*MT6129A*/ }
2154/*MT6129A*/ }
2155/*MT6129A*/ break;
2156/*MT6129A*/ }
2157/*MT6129A*/ case FrequencyBand1900 :
2158/*MT6129A*/ {
2159/*MT6129A*/ if(arfcn<=741)
2160/*MT6129A*/ { if(arfcn<=611) /* ARFCN : 512~611 */
2161/*MT6129A*/ { Nfrac = 40*(arfcn-512)+1220;
2162/*MT6129A*/ *rfN = (10L<<17) | (Nfrac<<4) | 1;
2163/*MT6129A*/ }
2164/*MT6129A*/ else /* ARFCN : 612~741 */
2165/*MT6129A*/ { Nfrac = 40*(arfcn-612)+20;
2166/*MT6129A*/ *rfN = (11L<<17) | (Nfrac<<4) | 1;
2167/*MT6129A*/ }
2168/*MT6129A*/ }
2169/*MT6129A*/ else
2170/*MT6129A*/ { Nfrac = 40*(arfcn-742)+20; /* ARFCN : 742~810 */
2171/*MT6129A*/ *rfN = (12L<<17) | (Nfrac<<4) | 1;
2172/*MT6129A*/ }
2173/*MT6129A*/ break;
2174/*MT6129A*/ }
2175/*MT6129A*/ default :
2176/*MT6129A*/ {
2177/*MT6129A*/ break;
2178/*MT6129A*/ }
2179/*MT6129A*/ }
2180/*MT6129A*/ *ifN = 0;
2181/*MT6129A*/}
2182/*MT6129A*//* =========================================================================== */
2183/*MT6129A*/
2184/*MT6129A*/char mt6119_d_flag = 0;
2185/*MT6129A*/
2186/*MT6129A*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2187/*MT6129A*/{ int Nfrac;
2188/*MT6129A*/
2189/*MT6129A*/ switch(rf_band)
2190/*MT6129A*/ {
2191/*MT6129A*/ case FrequencyBand900 :
2192/*MT6129A*/ {
2193/*MT6129A*/ if(arfcn<=104)
2194/*MT6129A*/ { if(arfcn<=45)
2195/*MT6129A*/ { if(arfcn<=36) /* ARFCN : 0~36 */
2196/*MT6129A*/ { Nfrac = 88*(arfcn-0)+1600;
2197/*MT6129A*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2198/*MT6129A*/ mt6119_d_flag = 1;
2199/*MT6129A*/ }
2200/*MT6129A*/ else /* ARFCN : 37~45 */
2201/*MT6129A*/ { Nfrac = 90*(arfcn-37)+3430;
2202/*MT6129A*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2203/*MT6129A*/ mt6119_d_flag = 0;
2204/*MT6129A*/ }
2205/*MT6129A*/ }
2206/*MT6129A*/ else
2207/*MT6129A*/ { if(arfcn<=95) /* ARFCN : 46~95 */
2208/*MT6129A*/ { Nfrac = 88*(arfcn-46)+448;
2209/*MT6129A*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2210/*MT6129A*/ mt6119_d_flag = 1;
2211/*MT6129A*/ }
2212/*MT6129A*/ else /* ARFCN : 96~104 */
2213/*MT6129A*/ { Nfrac = 90*(arfcn-96)+3540;
2214/*MT6129A*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2215/*MT6129A*/ mt6119_d_flag = 0;
2216/*MT6129A*/ }
2217/*MT6129A*/ }
2218/*MT6129A*/ }
2219/*MT6129A*/ else
2220/*MT6129A*/ { if(arfcn<=1001)
2221/*MT6129A*/ { if(arfcn<=124) /* ARFCN : 105~124 */
2222/*MT6129A*/ { Nfrac = 88*(arfcn-105)+440;
2223/*MT6129A*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2224/*MT6129A*/ mt6119_d_flag = 1;
2225/*MT6129A*/ }
2226/*MT6129A*/ else /* ARFCN : 975~1001 */
2227/*MT6129A*/ { Nfrac = 88*(arfcn-975)+2488;
2228/*MT6129A*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2229/*MT6129A*/ mt6119_d_flag = 1;
2230/*MT6129A*/ }
2231/*MT6129A*/ }
2232/*MT6129A*/ else
2233/*MT6129A*/ { if(arfcn<=1010) /* ARFCN : 1002~1010 */
2234/*MT6129A*/ { Nfrac = 90*(arfcn-1002)+3320;
2235/*MT6129A*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2236/*MT6129A*/ mt6119_d_flag = 0;
2237/*MT6129A*/ }
2238/*MT6129A*/ else /* ARFCN : 1011~1023 */
2239/*MT6129A*/ { Nfrac = 88*(arfcn-1011)+456;
2240/*MT6129A*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2241/*MT6129A*/ mt6119_d_flag = 1;
2242/*MT6129A*/ }
2243/*MT6129A*/ }
2244/*MT6129A*/ }
2245/*MT6129A*/ break;
2246/*MT6129A*/ }
2247/*MT6129A*/ case FrequencyBand1800 :
2248/*MT6129A*/ {
2249/*MT6129A*/ if(arfcn<=715)
2250/*MT6129A*/ { if(arfcn<=597)
2251/*MT6129A*/ { if(arfcn<=579) /* ARFCN : 512~579 */
2252/*MT6129A*/ { Nfrac = 44*(arfcn-512)+1844;
2253/*MT6129A*/ *rfN = (8L<<17) | (Nfrac<<4) | 0x800001L;
2254/*MT6129A*/ mt6119_d_flag = 1;
2255/*MT6129A*/ }
2256/*MT6129A*/ else /* ARFCN : 580~597 */
2257/*MT6129A*/ { Nfrac = 45*(arfcn-580)+3055;
2258/*MT6129A*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2259/*MT6129A*/ mt6119_d_flag = 0;
2260/*MT6129A*/ }
2261/*MT6129A*/ }
2262/*MT6129A*/ else
2263/*MT6129A*/ { if(arfcn<=697) /* ARFCN : 598~697 */
2264/*MT6129A*/ { Nfrac = 44*(arfcn-598)+428;
2265/*MT6129A*/ *rfN = (9L<<17) | (Nfrac<<4) | 0x800001L;
2266/*MT6129A*/ mt6119_d_flag = 1;
2267/*MT6129A*/ }
2268/*MT6129A*/ else /* ARFCN : 698~715 */
2269/*MT6129A*/ { Nfrac = 45*(arfcn-698)+3165;
2270/*MT6129A*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2271/*MT6129A*/ mt6119_d_flag = 0;
2272/*MT6129A*/ }
2273/*MT6129A*/ }
2274/*MT6129A*/ }
2275/*MT6129A*/ else
2276/*MT6129A*/ { if(arfcn<=833)
2277/*MT6129A*/ { if(arfcn<=815) /* ARFCN : 716~815 */
2278/*MT6129A*/ { Nfrac = 44*(arfcn-716)+420;
2279/*MT6129A*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2280/*MT6129A*/ mt6119_d_flag = 1;
2281/*MT6129A*/ }
2282/*MT6129A*/ else /* ARFCN : 816~833 */
2283/*MT6129A*/ { Nfrac = 45*(arfcn-816)+3275;
2284/*MT6129A*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2285/*MT6129A*/ mt6119_d_flag = 0;
2286/*MT6129A*/ }
2287/*MT6129A*/ }
2288/*MT6129A*/ else /* ARFCN : 834~885 */
2289/*MT6129A*/ { Nfrac = 44*(arfcn-834)+412;
2290/*MT6129A*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2291/*MT6129A*/ mt6119_d_flag = 1;
2292/*MT6129A*/ }
2293/*MT6129A*/ }
2294/*MT6129A*/ break;
2295/*MT6129A*/ }
2296/*MT6129A*/ case FrequencyBand1900 :
2297/*MT6129A*/ {
2298/*MT6129A*/ if(arfcn<=706)
2299/*MT6129A*/ { if(arfcn<=606)
2300/*MT6129A*/ { if(arfcn<=588) /* ARFCN : 512~588 */
2301/*MT6129A*/ { Nfrac = 44*(arfcn-512)+1444;
2302/*MT6129A*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2303/*MT6129A*/ mt6119_d_flag = 1;
2304/*MT6129A*/ }
2305/*MT6129A*/ else
2306/*MT6129A*/ { Nfrac = 45*(arfcn-589)+3760; /* ARFCN : 589~606 */
2307/*MT6129A*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2308/*MT6129A*/ mt6119_d_flag = 0;
2309/*MT6129A*/ }
2310/*MT6129A*/ }
2311/*MT6129A*/ else /* ARFCN : 607~706 */
2312/*MT6129A*/ { Nfrac = 44*(arfcn-607)+424;
2313/*MT6129A*/ *rfN = (15L<<17) | (Nfrac<<4) | 0x800001L;
2314/*MT6129A*/ mt6119_d_flag = 1;
2315/*MT6129A*/ }
2316/*MT6129A*/ }
2317/*MT6129A*/ else
2318/*MT6129A*/ { if(arfcn<=724) /* ARFCN : 707~724 */
2319/*MT6129A*/ { Nfrac = 45*(arfcn-707)+3870;
2320/*MT6129A*/ *rfN = (17L<<17) | (Nfrac<<4) | 0x800001L;
2321/*MT6129A*/ mt6119_d_flag = 0;
2322/*MT6129A*/ }
2323/*MT6129A*/ else /* ARFCN : 725~810 */
2324/*MT6129A*/ { Nfrac = 44*(arfcn-725)+416;
2325/*MT6129A*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2326/*MT6129A*/ mt6119_d_flag = 1;
2327/*MT6129A*/ }
2328/*MT6129A*/ }
2329/*MT6129A*/ break;
2330/*MT6129A*/ }
2331/*MT6129A*/ default :
2332/*MT6129A*/ {
2333/*MT6129A*/ break;
2334/*MT6129A*/ }
2335/*MT6129A*/ }
2336/*MT6129A*/ *ifN = 0;
2337/*MT6129A*/}
2338/*MT6129A*//* =========================================================================== */
2339#endif
2340
2341#if IS_RF_MT6129B
2342/*MT6129B*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2343/*MT6129B*/{ int Nfrac;
2344/*MT6129B*/
2345/*MT6129B*/ switch(rf_band)
2346/*MT6129B*/ {
2347/*MT6129B*/ case FrequencyBand850 :
2348/*MT6129B*/ {
2349/*MT6129B*/ if(arfcn<=202)
2350/*MT6129B*/ { if(arfcn<=137) /* ARFCN : 128~137 */
2351/*MT6129B*/ { Nfrac = 80*(arfcn-128)+4440;
2352/*MT6129B*/ *rfN = (2L<<17) | (Nfrac<<4) | 1;
2353/*MT6129B*/ }
2354/*MT6129B*/ else /* ARFCN : 138~202 */
2355/*MT6129B*/ { Nfrac = 80*(arfcn-138)+40;
2356/*MT6129B*/ *rfN = (3L<<17) | (Nfrac<<4) | 1;
2357/*MT6129B*/ }
2358/*MT6129B*/ }
2359/*MT6129B*/ else
2360/*MT6129B*/ { /* ARFCN : 203~251 */
2361/*MT6129B*/ Nfrac = 80*(arfcn-203)+40;
2362/*MT6129B*/ *rfN = (4L<<17) | (Nfrac<<4) | 1;
2363/*MT6129B*/ }
2364/*MT6129B*/ break;
2365/*MT6129B*/ }
2366/*MT6129B*/ case FrequencyBand900 :
2367/*MT6129B*/ {
2368/*MT6129B*/ if(arfcn<=70)
2369/*MT6129B*/ { if(arfcn<=5) /* ARFCN : 0~5 */
2370/*MT6129B*/ { Nfrac = 80*(arfcn-0)+4760;
2371/*MT6129B*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2372/*MT6129B*/ }
2373/*MT6129B*/ else /* ARFCN : 6~70 */
2374/*MT6129B*/ { Nfrac = 80*(arfcn-6)+40;
2375/*MT6129B*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2376/*MT6129B*/ }
2377/*MT6129B*/ }
2378/*MT6129B*/ else
2379/*MT6129B*/ { if(arfcn<=124) /* ARFCN : 71~124 */
2380/*MT6129B*/ { Nfrac = 80*(arfcn-71)+40;
2381/*MT6129B*/ *rfN = (9L<<17) | (Nfrac<<4) | 1;
2382/*MT6129B*/ }
2383/*MT6129B*/ else
2384/*MT6129B*/ { Nfrac = 80*(arfcn-975)+840; /* ARFCN : 975~1023 */
2385/*MT6129B*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2386/*MT6129B*/ }
2387/*MT6129B*/ }
2388/*MT6129B*/ break;
2389/*MT6129B*/ }
2390/*MT6129B*/ case FrequencyBand1800 :
2391/*MT6129B*/ {
2392/*MT6129B*/ if(arfcn<=716)
2393/*MT6129B*/ { if(arfcn<=586) /* ARFCN : 512~586 */
2394/*MT6129B*/ { Nfrac = 40*(arfcn-512)+2220;
2395/*MT6129B*/ *rfN = (5L<<17) | (Nfrac<<4) | 1;
2396/*MT6129B*/ }
2397/*MT6129B*/ else /* ARFCN : 587~716 */
2398/*MT6129B*/ { Nfrac = 40*(arfcn-587)+20;
2399/*MT6129B*/ *rfN = (6L<<17) | (Nfrac<<4) | 1;
2400/*MT6129B*/ }
2401/*MT6129B*/ }
2402/*MT6129B*/ else
2403/*MT6129B*/ { if(arfcn<=846) /* ARFCN : 717~846 */
2404/*MT6129B*/ { Nfrac = 40*(arfcn-717)+20;
2405/*MT6129B*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2406/*MT6129B*/ }
2407/*MT6129B*/ else /* ARFCN : 847~885 */
2408/*MT6129B*/ { Nfrac = 40*(arfcn-847)+20;
2409/*MT6129B*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2410/*MT6129B*/ }
2411/*MT6129B*/ }
2412/*MT6129B*/ break;
2413/*MT6129B*/ }
2414/*MT6129B*/ case FrequencyBand1900 :
2415/*MT6129B*/ {
2416/*MT6129B*/ if(arfcn<=741)
2417/*MT6129B*/ { if(arfcn<=611) /* ARFCN : 512~611 */
2418/*MT6129B*/ { Nfrac = 40*(arfcn-512)+1220;
2419/*MT6129B*/ *rfN = (10L<<17) | (Nfrac<<4) | 1;
2420/*MT6129B*/ }
2421/*MT6129B*/ else /* ARFCN : 612~741 */
2422/*MT6129B*/ { Nfrac = 40*(arfcn-612)+20;
2423/*MT6129B*/ *rfN = (11L<<17) | (Nfrac<<4) | 1;
2424/*MT6129B*/ }
2425/*MT6129B*/ }
2426/*MT6129B*/ else
2427/*MT6129B*/ { Nfrac = 40*(arfcn-742)+20; /* ARFCN : 742~810 */
2428/*MT6129B*/ *rfN = (12L<<17) | (Nfrac<<4) | 1;
2429/*MT6129B*/ }
2430/*MT6129B*/ break;
2431/*MT6129B*/ }
2432/*MT6129B*/ default :
2433/*MT6129B*/ {
2434/*MT6129B*/ break;
2435/*MT6129B*/ }
2436/*MT6129B*/ }
2437/*MT6129B*/ *ifN = 0;
2438/*MT6129B*/}
2439/*MT6129B*//* =========================================================================== */
2440/*MT6129B*/
2441/*MT6129B*/char mt6119_d_flag = 0;
2442/*MT6129B*/
2443/*MT6129B*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2444/*MT6129B*/{ int Nfrac;
2445/*MT6129B*/
2446/*MT6129B*/ switch(rf_band)
2447/*MT6129B*/ {
2448/*MT6129B*/ case FrequencyBand850 :
2449/*MT6129B*/ {
2450/*MT6129B*/ if(arfcn<=197)
2451/*MT6129B*/ { if(arfcn<=147)
2452/*MT6129B*/ { if(arfcn<=138)
2453/*MT6129B*/ { /* ARFCN : 128~138 */
2454/*MT6129B*/ Nfrac = 88*(arfcn-128)+3848;
2455/*MT6129B*/ *rfN = (5L<<17) | (Nfrac<<4) | 0x800001L;
2456/*MT6129B*/ mt6119_d_flag = 1;
2457/*MT6129B*/ }
2458/*MT6129B*/ else
2459/*MT6129B*/ { /* ARFCN : 139~147 */
2460/*MT6129B*/ Nfrac = 90*(arfcn-139)+2680;
2461/*MT6129B*/ *rfN = (7L<<17) | (Nfrac<<4) | 0x800001L;
2462/*MT6129B*/ mt6119_d_flag = 0;
2463/*MT6129B*/ }
2464/*MT6129B*/ }
2465/*MT6129B*/ else
2466/*MT6129B*/ { /* ARFCN : 148~197 */
2467/*MT6129B*/ Nfrac = 88*(arfcn-148)+408;
2468/*MT6129B*/ *rfN = (6L<<17) | (Nfrac<<4) | 0x800001L;
2469/*MT6129B*/ mt6119_d_flag = 1;
2470/*MT6129B*/ }
2471/*MT6129B*/ }
2472/*MT6129B*/ else
2473/*MT6129B*/ { if(arfcn<=206)
2474/*MT6129B*/ { /* ARFCN : 198~206 */
2475/*MT6129B*/ Nfrac = 90*(arfcn-198)+2790;
2476/*MT6129B*/ *rfN = (8L<<17) | (Nfrac<<4) | 0x800001L;
2477/*MT6129B*/ mt6119_d_flag = 0;
2478/*MT6129B*/ }
2479/*MT6129B*/ else
2480/*MT6129B*/ { /* ARFCN : 207~251 */
2481/*MT6129B*/ Nfrac = 88*(arfcn-207)+400;
2482/*MT6129B*/ *rfN = (7L<<17) | (Nfrac<<4) | 0x800001L;
2483/*MT6129B*/ mt6119_d_flag = 1;
2484/*MT6129B*/ }
2485/*MT6129B*/ }
2486/*MT6129B*/ break;
2487/*MT6129B*/ }
2488/*MT6129B*/ case FrequencyBand900 :
2489/*MT6129B*/ {
2490/*MT6129B*/ if(arfcn<=104)
2491/*MT6129B*/ { if(arfcn<=45)
2492/*MT6129B*/ { if(arfcn<=36) /* ARFCN : 0~36 */
2493/*MT6129B*/ { Nfrac = 88*(arfcn-0)+1600;
2494/*MT6129B*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2495/*MT6129B*/ mt6119_d_flag = 1;
2496/*MT6129B*/ }
2497/*MT6129B*/ else /* ARFCN : 37~45 */
2498/*MT6129B*/ { Nfrac = 90*(arfcn-37)+3430;
2499/*MT6129B*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2500/*MT6129B*/ mt6119_d_flag = 0;
2501/*MT6129B*/ }
2502/*MT6129B*/ }
2503/*MT6129B*/ else
2504/*MT6129B*/ { if(arfcn<=95) /* ARFCN : 46~95 */
2505/*MT6129B*/ { Nfrac = 88*(arfcn-46)+448;
2506/*MT6129B*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2507/*MT6129B*/ mt6119_d_flag = 1;
2508/*MT6129B*/ }
2509/*MT6129B*/ else /* ARFCN : 96~104 */
2510/*MT6129B*/ { Nfrac = 90*(arfcn-96)+3540;
2511/*MT6129B*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2512/*MT6129B*/ mt6119_d_flag = 0;
2513/*MT6129B*/ }
2514/*MT6129B*/ }
2515/*MT6129B*/ }
2516/*MT6129B*/ else
2517/*MT6129B*/ { if(arfcn<=1001)
2518/*MT6129B*/ { if(arfcn<=124) /* ARFCN : 105~124 */
2519/*MT6129B*/ { Nfrac = 88*(arfcn-105)+440;
2520/*MT6129B*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2521/*MT6129B*/ mt6119_d_flag = 1;
2522/*MT6129B*/ }
2523/*MT6129B*/ else /* ARFCN : 975~1001 */
2524/*MT6129B*/ { Nfrac = 88*(arfcn-975)+2488;
2525/*MT6129B*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2526/*MT6129B*/ mt6119_d_flag = 1;
2527/*MT6129B*/ }
2528/*MT6129B*/ }
2529/*MT6129B*/ else
2530/*MT6129B*/ { if(arfcn<=1010) /* ARFCN : 1002~1010 */
2531/*MT6129B*/ { Nfrac = 90*(arfcn-1002)+3320;
2532/*MT6129B*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2533/*MT6129B*/ mt6119_d_flag = 0;
2534/*MT6129B*/ }
2535/*MT6129B*/ else /* ARFCN : 1011~1023 */
2536/*MT6129B*/ { Nfrac = 88*(arfcn-1011)+456;
2537/*MT6129B*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2538/*MT6129B*/ mt6119_d_flag = 1;
2539/*MT6129B*/ }
2540/*MT6129B*/ }
2541/*MT6129B*/ }
2542/*MT6129B*/ break;
2543/*MT6129B*/ }
2544/*MT6129B*/ case FrequencyBand1800 :
2545/*MT6129B*/ {
2546/*MT6129B*/ if(arfcn<=715)
2547/*MT6129B*/ { if(arfcn<=597)
2548/*MT6129B*/ { if(arfcn<=579) /* ARFCN : 512~579 */
2549/*MT6129B*/ { Nfrac = 44*(arfcn-512)+1844;
2550/*MT6129B*/ *rfN = (8L<<17) | (Nfrac<<4) | 0x800001L;
2551/*MT6129B*/ mt6119_d_flag = 1;
2552/*MT6129B*/ }
2553/*MT6129B*/ else /* ARFCN : 580~597 */
2554/*MT6129B*/ { Nfrac = 45*(arfcn-580)+3055;
2555/*MT6129B*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2556/*MT6129B*/ mt6119_d_flag = 0;
2557/*MT6129B*/ }
2558/*MT6129B*/ }
2559/*MT6129B*/ else
2560/*MT6129B*/ { if(arfcn<=697) /* ARFCN : 598~697 */
2561/*MT6129B*/ { Nfrac = 44*(arfcn-598)+428;
2562/*MT6129B*/ *rfN = (9L<<17) | (Nfrac<<4) | 0x800001L;
2563/*MT6129B*/ mt6119_d_flag = 1;
2564/*MT6129B*/ }
2565/*MT6129B*/ else /* ARFCN : 698~715 */
2566/*MT6129B*/ { Nfrac = 45*(arfcn-698)+3165;
2567/*MT6129B*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2568/*MT6129B*/ mt6119_d_flag = 0;
2569/*MT6129B*/ }
2570/*MT6129B*/ }
2571/*MT6129B*/ }
2572/*MT6129B*/ else
2573/*MT6129B*/ { if(arfcn<=833)
2574/*MT6129B*/ { if(arfcn<=815) /* ARFCN : 716~815 */
2575/*MT6129B*/ { Nfrac = 44*(arfcn-716)+420;
2576/*MT6129B*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2577/*MT6129B*/ mt6119_d_flag = 1;
2578/*MT6129B*/ }
2579/*MT6129B*/ else /* ARFCN : 816~833 */
2580/*MT6129B*/ { Nfrac = 45*(arfcn-816)+3275;
2581/*MT6129B*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2582/*MT6129B*/ mt6119_d_flag = 0;
2583/*MT6129B*/ }
2584/*MT6129B*/ }
2585/*MT6129B*/ else /* ARFCN : 834~885 */
2586/*MT6129B*/ { Nfrac = 44*(arfcn-834)+412;
2587/*MT6129B*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2588/*MT6129B*/ mt6119_d_flag = 1;
2589/*MT6129B*/ }
2590/*MT6129B*/ }
2591/*MT6129B*/ break;
2592/*MT6129B*/ }
2593/*MT6129B*/ case FrequencyBand1900 :
2594/*MT6129B*/ {
2595/*MT6129B*/ if(arfcn<=706)
2596/*MT6129B*/ { if(arfcn<=606)
2597/*MT6129B*/ { if(arfcn<=588) /* ARFCN : 512~588 */
2598/*MT6129B*/ { Nfrac = 44*(arfcn-512)+1444;
2599/*MT6129B*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2600/*MT6129B*/ mt6119_d_flag = 1;
2601/*MT6129B*/ }
2602/*MT6129B*/ else
2603/*MT6129B*/ { Nfrac = 45*(arfcn-589)+3760; /* ARFCN : 589~606 */
2604/*MT6129B*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2605/*MT6129B*/ mt6119_d_flag = 0;
2606/*MT6129B*/ }
2607/*MT6129B*/ }
2608/*MT6129B*/ else /* ARFCN : 607~706 */
2609/*MT6129B*/ { Nfrac = 44*(arfcn-607)+424;
2610/*MT6129B*/ *rfN = (15L<<17) | (Nfrac<<4) | 0x800001L;
2611/*MT6129B*/ mt6119_d_flag = 1;
2612/*MT6129B*/ }
2613/*MT6129B*/ }
2614/*MT6129B*/ else
2615/*MT6129B*/ { if(arfcn<=724) /* ARFCN : 707~724 */
2616/*MT6129B*/ { Nfrac = 45*(arfcn-707)+3870;
2617/*MT6129B*/ *rfN = (17L<<17) | (Nfrac<<4) | 0x800001L;
2618/*MT6129B*/ mt6119_d_flag = 0;
2619/*MT6129B*/ }
2620/*MT6129B*/ else /* ARFCN : 725~810 */
2621/*MT6129B*/ { Nfrac = 44*(arfcn-725)+416;
2622/*MT6129B*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2623/*MT6129B*/ mt6119_d_flag = 1;
2624/*MT6129B*/ }
2625/*MT6129B*/ }
2626/*MT6129B*/ break;
2627/*MT6129B*/ }
2628/*MT6129B*/ default :
2629/*MT6129B*/ {
2630/*MT6129B*/ break;
2631/*MT6129B*/ }
2632/*MT6129B*/ }
2633/*MT6129B*/ *ifN = 0;
2634/*MT6129B*/}
2635/*MT6129B*//* =========================================================================== */
2636#endif
2637
2638#if (IS_RF_MT6129C)||(IS_RF_MT6129D)
2639/*MT6129C,D*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2640/*MT6129C,D*/{ int Nfrac;
2641/*MT6129C,D*/
2642/*MT6129C,D*/ switch(rf_band)
2643/*MT6129C,D*/ {
2644/*MT6129C,D*/ case FrequencyBand850 :
2645/*MT6129C,D*/ {
2646/*MT6129C,D*/ if(arfcn<=202)
2647/*MT6129C,D*/ { if(arfcn<=137) /* ARFCN : 128~137 */
2648/*MT6129C,D*/ { Nfrac = 80*(arfcn-128)+4440;
2649/*MT6129C,D*/ *rfN = (2L<<17) | (Nfrac<<4) | 1;
2650/*MT6129C,D*/ }
2651/*MT6129C,D*/ else /* ARFCN : 138~202 */
2652/*MT6129C,D*/ { Nfrac = 80*(arfcn-138)+40;
2653/*MT6129C,D*/ *rfN = (3L<<17) | (Nfrac<<4) | 1;
2654/*MT6129C,D*/ }
2655/*MT6129C,D*/ }
2656/*MT6129C,D*/ else
2657/*MT6129C,D*/ { /* ARFCN : 203~251 */
2658/*MT6129C,D*/ Nfrac = 80*(arfcn-203)+40;
2659/*MT6129C,D*/ *rfN = (4L<<17) | (Nfrac<<4) | 1;
2660/*MT6129C,D*/ }
2661/*MT6129C,D*/ break;
2662/*MT6129C,D*/ }
2663/*MT6129C,D*/ case FrequencyBand900 :
2664/*MT6129C,D*/ {
2665/*MT6129C,D*/ if(arfcn<=70)
2666/*MT6129C,D*/ { if(arfcn<=5) /* ARFCN : 0~5 */
2667/*MT6129C,D*/ { Nfrac = 80*(arfcn-0)+4760;
2668/*MT6129C,D*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2669/*MT6129C,D*/ }
2670/*MT6129C,D*/ else /* ARFCN : 6~70 */
2671/*MT6129C,D*/ { Nfrac = 80*(arfcn-6)+40;
2672/*MT6129C,D*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2673/*MT6129C,D*/ }
2674/*MT6129C,D*/ }
2675/*MT6129C,D*/ else
2676/*MT6129C,D*/ { if(arfcn<=124) /* ARFCN : 71~124 */
2677/*MT6129C,D*/ { Nfrac = 80*(arfcn-71)+40;
2678/*MT6129C,D*/ *rfN = (9L<<17) | (Nfrac<<4) | 1;
2679/*MT6129C,D*/ }
2680/*MT6129C,D*/ else
2681/*MT6129C,D*/ { Nfrac = 80*(arfcn-975)+840; /* ARFCN : 975~1023 */
2682/*MT6129C,D*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2683/*MT6129C,D*/ }
2684/*MT6129C,D*/ }
2685/*MT6129C,D*/ break;
2686/*MT6129C,D*/ }
2687/*MT6129C,D*/ case FrequencyBand1800 :
2688/*MT6129C,D*/ {
2689/*MT6129C,D*/ if(arfcn<=716)
2690/*MT6129C,D*/ { if(arfcn<=586) /* ARFCN : 512~586 */
2691/*MT6129C,D*/ { Nfrac = 40*(arfcn-512)+2220;
2692/*MT6129C,D*/ *rfN = (5L<<17) | (Nfrac<<4) | 1;
2693/*MT6129C,D*/ }
2694/*MT6129C,D*/ else /* ARFCN : 587~716 */
2695/*MT6129C,D*/ { Nfrac = 40*(arfcn-587)+20;
2696/*MT6129C,D*/ *rfN = (6L<<17) | (Nfrac<<4) | 1;
2697/*MT6129C,D*/ }
2698/*MT6129C,D*/ }
2699/*MT6129C,D*/ else
2700/*MT6129C,D*/ { if(arfcn<=846) /* ARFCN : 717~846 */
2701/*MT6129C,D*/ { Nfrac = 40*(arfcn-717)+20;
2702/*MT6129C,D*/ *rfN = (7L<<17) | (Nfrac<<4) | 1;
2703/*MT6129C,D*/ }
2704/*MT6129C,D*/ else /* ARFCN : 847~885 */
2705/*MT6129C,D*/ { Nfrac = 40*(arfcn-847)+20;
2706/*MT6129C,D*/ *rfN = (8L<<17) | (Nfrac<<4) | 1;
2707/*MT6129C,D*/ }
2708/*MT6129C,D*/ }
2709/*MT6129C,D*/ break;
2710/*MT6129C,D*/ }
2711/*MT6129C,D*/ case FrequencyBand1900 :
2712/*MT6129C,D*/ {
2713/*MT6129C,D*/ if(arfcn<=741)
2714/*MT6129C,D*/ { if(arfcn<=611) /* ARFCN : 512~611 */
2715/*MT6129C,D*/ { Nfrac = 40*(arfcn-512)+1220;
2716/*MT6129C,D*/ *rfN = (10L<<17) | (Nfrac<<4) | 1;
2717/*MT6129C,D*/ }
2718/*MT6129C,D*/ else /* ARFCN : 612~741 */
2719/*MT6129C,D*/ { Nfrac = 40*(arfcn-612)+20;
2720/*MT6129C,D*/ *rfN = (11L<<17) | (Nfrac<<4) | 1;
2721/*MT6129C,D*/ }
2722/*MT6129C,D*/ }
2723/*MT6129C,D*/ else
2724/*MT6129C,D*/ { Nfrac = 40*(arfcn-742)+20; /* ARFCN : 742~810 */
2725/*MT6129C,D*/ *rfN = (12L<<17) | (Nfrac<<4) | 1;
2726/*MT6129C,D*/ }
2727/*MT6129C,D*/ break;
2728/*MT6129C,D*/ }
2729/*MT6129C,D*/ default :
2730/*MT6129C,D*/ {
2731/*MT6129C,D*/ break;
2732/*MT6129C,D*/ }
2733/*MT6129C,D*/ }
2734/*MT6129C,D*/ *ifN = 0;
2735/*MT6129C,D*/}
2736/*MT6129C,D*//* =========================================================================== */
2737/*MT6129C,D*/
2738/*MT6129C,D*/char mt6119_d_flag = 0;
2739/*MT6129C,D*/
2740/*MT6129C,D*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2741/*MT6129C,D*/{ int Nfrac;
2742/*MT6129C,D*/
2743/*MT6129C,D*/ switch(rf_band)
2744/*MT6129C,D*/ {
2745/*MT6129C,D*/ case FrequencyBand850 :
2746/*MT6129C,D*/ {
2747/*MT6129C,D*/ if(arfcn<=197)
2748/*MT6129C,D*/ { if(arfcn<=147)
2749/*MT6129C,D*/ { if(arfcn<=138)
2750/*MT6129C,D*/ { /* ARFCN : 128~138 */
2751/*MT6129C,D*/ Nfrac = 88*(arfcn-128)+3848;
2752/*MT6129C,D*/ *rfN = (5L<<17) | (Nfrac<<4) | 0x800001L;
2753/*MT6129C,D*/ mt6119_d_flag = 1;
2754/*MT6129C,D*/ }
2755/*MT6129C,D*/ else
2756/*MT6129C,D*/ { /* ARFCN : 139~147 */
2757/*MT6129C,D*/ Nfrac = 90*(arfcn-139)+2680;
2758/*MT6129C,D*/ *rfN = (7L<<17) | (Nfrac<<4) | 0x800001L;
2759/*MT6129C,D*/ mt6119_d_flag = 0;
2760/*MT6129C,D*/ }
2761/*MT6129C,D*/ }
2762/*MT6129C,D*/ else
2763/*MT6129C,D*/ { /* ARFCN : 148~197 */
2764/*MT6129C,D*/ Nfrac = 88*(arfcn-148)+408;
2765/*MT6129C,D*/ *rfN = (6L<<17) | (Nfrac<<4) | 0x800001L;
2766/*MT6129C,D*/ mt6119_d_flag = 1;
2767/*MT6129C,D*/ }
2768/*MT6129C,D*/ }
2769/*MT6129C,D*/ else
2770/*MT6129C,D*/ { if(arfcn<=206)
2771/*MT6129C,D*/ { /* ARFCN : 198~206 */
2772/*MT6129C,D*/ Nfrac = 90*(arfcn-198)+2790;
2773/*MT6129C,D*/ *rfN = (8L<<17) | (Nfrac<<4) | 0x800001L;
2774/*MT6129C,D*/ mt6119_d_flag = 0;
2775/*MT6129C,D*/ }
2776/*MT6129C,D*/ else
2777/*MT6129C,D*/ { /* ARFCN : 207~251 */
2778/*MT6129C,D*/ Nfrac = 88*(arfcn-207)+400;
2779/*MT6129C,D*/ *rfN = (7L<<17) | (Nfrac<<4) | 0x800001L;
2780/*MT6129C,D*/ mt6119_d_flag = 1;
2781/*MT6129C,D*/ }
2782/*MT6129C,D*/ }
2783/*MT6129C,D*/ break;
2784/*MT6129C,D*/ }
2785/*MT6129C,D*/ case FrequencyBand900 :
2786/*MT6129C,D*/ {
2787/*MT6129C,D*/ if(arfcn<=104)
2788/*MT6129C,D*/ { if(arfcn<=45)
2789/*MT6129C,D*/ { if(arfcn<=36) /* ARFCN : 0~36 */
2790/*MT6129C,D*/ { Nfrac = 88*(arfcn-0)+1600;
2791/*MT6129C,D*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2792/*MT6129C,D*/ mt6119_d_flag = 1;
2793/*MT6129C,D*/ }
2794/*MT6129C,D*/ else /* ARFCN : 37~45 */
2795/*MT6129C,D*/ { Nfrac = 90*(arfcn-37)+3430;
2796/*MT6129C,D*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2797/*MT6129C,D*/ mt6119_d_flag = 0;
2798/*MT6129C,D*/ }
2799/*MT6129C,D*/ }
2800/*MT6129C,D*/ else
2801/*MT6129C,D*/ { if(arfcn<=95) /* ARFCN : 46~95 */
2802/*MT6129C,D*/ { Nfrac = 88*(arfcn-46)+448;
2803/*MT6129C,D*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2804/*MT6129C,D*/ mt6119_d_flag = 1;
2805/*MT6129C,D*/ }
2806/*MT6129C,D*/ else /* ARFCN : 96~104 */
2807/*MT6129C,D*/ { Nfrac = 90*(arfcn-96)+3540;
2808/*MT6129C,D*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2809/*MT6129C,D*/ mt6119_d_flag = 0;
2810/*MT6129C,D*/ }
2811/*MT6129C,D*/ }
2812/*MT6129C,D*/ }
2813/*MT6129C,D*/ else
2814/*MT6129C,D*/ { if(arfcn<=1001)
2815/*MT6129C,D*/ { if(arfcn<=124) /* ARFCN : 105~124 */
2816/*MT6129C,D*/ { Nfrac = 88*(arfcn-105)+440;
2817/*MT6129C,D*/ *rfN = (13L<<17) | (Nfrac<<4) | 0x800001L;
2818/*MT6129C,D*/ mt6119_d_flag = 1;
2819/*MT6129C,D*/ }
2820/*MT6129C,D*/ else /* ARFCN : 975~1001 */
2821/*MT6129C,D*/ { Nfrac = 88*(arfcn-975)+2488;
2822/*MT6129C,D*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2823/*MT6129C,D*/ mt6119_d_flag = 1;
2824/*MT6129C,D*/ }
2825/*MT6129C,D*/ }
2826/*MT6129C,D*/ else
2827/*MT6129C,D*/ { if(arfcn<=1010) /* ARFCN : 1002~1010 */
2828/*MT6129C,D*/ { Nfrac = 90*(arfcn-1002)+3320;
2829/*MT6129C,D*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2830/*MT6129C,D*/ mt6119_d_flag = 0;
2831/*MT6129C,D*/ }
2832/*MT6129C,D*/ else /* ARFCN : 1011~1023 */
2833/*MT6129C,D*/ { Nfrac = 88*(arfcn-1011)+456;
2834/*MT6129C,D*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2835/*MT6129C,D*/ mt6119_d_flag = 1;
2836/*MT6129C,D*/ }
2837/*MT6129C,D*/ }
2838/*MT6129C,D*/ }
2839/*MT6129C,D*/ break;
2840/*MT6129C,D*/ }
2841/*MT6129C,D*/ case FrequencyBand1800 :
2842/*MT6129C,D*/ {
2843/*MT6129C,D*/ if(arfcn<=715)
2844/*MT6129C,D*/ { if(arfcn<=597)
2845/*MT6129C,D*/ { if(arfcn<=579) /* ARFCN : 512~579 */
2846/*MT6129C,D*/ { Nfrac = 44*(arfcn-512)+1844;
2847/*MT6129C,D*/ *rfN = (8L<<17) | (Nfrac<<4) | 0x800001L;
2848/*MT6129C,D*/ mt6119_d_flag = 1;
2849/*MT6129C,D*/ }
2850/*MT6129C,D*/ else /* ARFCN : 580~597 */
2851/*MT6129C,D*/ { Nfrac = 45*(arfcn-580)+3055;
2852/*MT6129C,D*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2853/*MT6129C,D*/ mt6119_d_flag = 0;
2854/*MT6129C,D*/ }
2855/*MT6129C,D*/ }
2856/*MT6129C,D*/ else
2857/*MT6129C,D*/ { if(arfcn<=697) /* ARFCN : 598~697 */
2858/*MT6129C,D*/ { Nfrac = 44*(arfcn-598)+428;
2859/*MT6129C,D*/ *rfN = (9L<<17) | (Nfrac<<4) | 0x800001L;
2860/*MT6129C,D*/ mt6119_d_flag = 1;
2861/*MT6129C,D*/ }
2862/*MT6129C,D*/ else /* ARFCN : 698~715 */
2863/*MT6129C,D*/ { Nfrac = 45*(arfcn-698)+3165;
2864/*MT6129C,D*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2865/*MT6129C,D*/ mt6119_d_flag = 0;
2866/*MT6129C,D*/ }
2867/*MT6129C,D*/ }
2868/*MT6129C,D*/ }
2869/*MT6129C,D*/ else
2870/*MT6129C,D*/ { if(arfcn<=833)
2871/*MT6129C,D*/ { if(arfcn<=815) /* ARFCN : 716~815 */
2872/*MT6129C,D*/ { Nfrac = 44*(arfcn-716)+420;
2873/*MT6129C,D*/ *rfN = (10L<<17) | (Nfrac<<4) | 0x800001L;
2874/*MT6129C,D*/ mt6119_d_flag = 1;
2875/*MT6129C,D*/ }
2876/*MT6129C,D*/ else /* ARFCN : 816~833 */
2877/*MT6129C,D*/ { Nfrac = 45*(arfcn-816)+3275;
2878/*MT6129C,D*/ *rfN = (12L<<17) | (Nfrac<<4) | 0x800001L;
2879/*MT6129C,D*/ mt6119_d_flag = 0;
2880/*MT6129C,D*/ }
2881/*MT6129C,D*/ }
2882/*MT6129C,D*/ else /* ARFCN : 834~885 */
2883/*MT6129C,D*/ { Nfrac = 44*(arfcn-834)+412;
2884/*MT6129C,D*/ *rfN = (11L<<17) | (Nfrac<<4) | 0x800001L;
2885/*MT6129C,D*/ mt6119_d_flag = 1;
2886/*MT6129C,D*/ }
2887/*MT6129C,D*/ }
2888/*MT6129C,D*/ break;
2889/*MT6129C,D*/ }
2890/*MT6129C,D*/ case FrequencyBand1900 :
2891/*MT6129C,D*/ {
2892/*MT6129C,D*/ if(arfcn<=706)
2893/*MT6129C,D*/ { if(arfcn<=606)
2894/*MT6129C,D*/ { if(arfcn<=588) /* ARFCN : 512~588 */
2895/*MT6129C,D*/ { Nfrac = 44*(arfcn-512)+1444;
2896/*MT6129C,D*/ *rfN = (14L<<17) | (Nfrac<<4) | 0x800001L;
2897/*MT6129C,D*/ mt6119_d_flag = 1;
2898/*MT6129C,D*/ }
2899/*MT6129C,D*/ else
2900/*MT6129C,D*/ { Nfrac = 45*(arfcn-589)+3760; /* ARFCN : 589~606 */
2901/*MT6129C,D*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2902/*MT6129C,D*/ mt6119_d_flag = 0;
2903/*MT6129C,D*/ }
2904/*MT6129C,D*/ }
2905/*MT6129C,D*/ else /* ARFCN : 607~706 */
2906/*MT6129C,D*/ { Nfrac = 44*(arfcn-607)+424;
2907/*MT6129C,D*/ *rfN = (15L<<17) | (Nfrac<<4) | 0x800001L;
2908/*MT6129C,D*/ mt6119_d_flag = 1;
2909/*MT6129C,D*/ }
2910/*MT6129C,D*/ }
2911/*MT6129C,D*/ else
2912/*MT6129C,D*/ { if(arfcn<=724) /* ARFCN : 707~724 */
2913/*MT6129C,D*/ { Nfrac = 45*(arfcn-707)+3870;
2914/*MT6129C,D*/ *rfN = (17L<<17) | (Nfrac<<4) | 0x800001L;
2915/*MT6129C,D*/ mt6119_d_flag = 0;
2916/*MT6129C,D*/ }
2917/*MT6129C,D*/ else /* ARFCN : 725~810 */
2918/*MT6129C,D*/ { Nfrac = 44*(arfcn-725)+416;
2919/*MT6129C,D*/ *rfN = (16L<<17) | (Nfrac<<4) | 0x800001L;
2920/*MT6129C,D*/ mt6119_d_flag = 1;
2921/*MT6129C,D*/ }
2922/*MT6129C,D*/ }
2923/*MT6129C,D*/ break;
2924/*MT6129C,D*/ }
2925/*MT6129C,D*/ default :
2926/*MT6129C,D*/ {
2927/*MT6129C,D*/ break;
2928/*MT6129C,D*/ }
2929/*MT6129C,D*/ }
2930/*MT6129C,D*/ *ifN = 0;
2931/*MT6129C,D*/}
2932/*MT6129C,D*//* =========================================================================== */
2933#endif
2934
2935#if (IS_RF_MT6139B)
2936/*MT6139B*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
2937/*MT6139B*/{
2938/*MT6139B*/ switch(rf_band)
2939/*MT6139B*/ {
2940/*MT6139B*/ case FrequencyBand850 :
2941/*MT6139B*/ {
2942/*MT6139B*/ if(arfcn<=201)
2943/*MT6139B*/ { if(arfcn<=136)
2944/*MT6139B*/ { /* ARFCN : 128~136 */
2945/*MT6139B*/ // Nfrac = (arfcn-128)<<1+112;
2946/*MT6139B*/ // *rfN = (66L<<12) | (Nfrac<<4) | 0x00001L;
2947/*MT6139B*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
2948/*MT6139B*/ }
2949/*MT6139B*/ else
2950/*MT6139B*/ { /* ARFCN : 137~201 */
2951/*MT6139B*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
2952/*MT6139B*/ }
2953/*MT6139B*/ }
2954/*MT6139B*/ else
2955/*MT6139B*/ { /* ARFCN : 202~251 */
2956/*MT6139B*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
2957/*MT6139B*/ }
2958/*MT6139B*/
2959/*MT6139B*/ break;
2960/*MT6139B*/ }
2961/*MT6139B*/ case FrequencyBand900 :
2962/*MT6139B*/ {
2963/*MT6139B*/ if(arfcn<=69)
2964/*MT6139B*/ { if(arfcn<=4)
2965/*MT6139B*/ { /* ARFCN : 0~4 */
2966/*MT6139B*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
2967/*MT6139B*/ }
2968/*MT6139B*/ else
2969/*MT6139B*/ { /* ARFCN : 5~69 */
2970/*MT6139B*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
2971/*MT6139B*/ }
2972/*MT6139B*/ }
2973/*MT6139B*/ else
2974/*MT6139B*/ { if(arfcn<=124)
2975/*MT6139B*/ { /* ARFCN : 70~124 */
2976/*MT6139B*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
2977/*MT6139B*/ }
2978/*MT6139B*/ else
2979/*MT6139B*/ { /* ARFCN : 975~1023 */
2980/*MT6139B*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
2981/*MT6139B*/ }
2982/*MT6139B*/ }
2983/*MT6139B*/
2984/*MT6139B*/ break;
2985/*MT6139B*/ }
2986/*MT6139B*/ case FrequencyBand1800 :
2987/*MT6139B*/ {
2988/*MT6139B*/ if(arfcn<=715)
2989/*MT6139B*/ { if(arfcn<=585)
2990/*MT6139B*/ { /* ARFCN : 512~585 */
2991/*MT6139B*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
2992/*MT6139B*/ }
2993/*MT6139B*/ else
2994/*MT6139B*/ { /* ARFCN : 586~715 */
2995/*MT6139B*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
2996/*MT6139B*/ }
2997/*MT6139B*/ }
2998/*MT6139B*/ else
2999/*MT6139B*/ { if(arfcn<=845)
3000/*MT6139B*/ { /* ARFCN : 716~845 */
3001/*MT6139B*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
3002/*MT6139B*/ }
3003/*MT6139B*/ else
3004/*MT6139B*/ { /* ARFCN : 846~885 */
3005/*MT6139B*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
3006/*MT6139B*/ }
3007/*MT6139B*/ }
3008/*MT6139B*/
3009/*MT6139B*/ break;
3010/*MT6139B*/ }
3011/*MT6139B*/ case FrequencyBand1900 :
3012/*MT6139B*/ {
3013/*MT6139B*/ if(arfcn<=740)
3014/*MT6139B*/ { if(arfcn<=610)
3015/*MT6139B*/ { /* ARFCN : 512~610 */
3016/*MT6139B*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
3017/*MT6139B*/ }
3018/*MT6139B*/ else
3019/*MT6139B*/ { /* ARFCN : 611~740 */
3020/*MT6139B*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
3021/*MT6139B*/ }
3022/*MT6139B*/ }
3023/*MT6139B*/ else
3024/*MT6139B*/ {
3025/*MT6139B*/ /* ARFCN : 741~810 */
3026/*MT6139B*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
3027/*MT6139B*/
3028/*MT6139B*/ }
3029/*MT6139B*/
3030/*MT6139B*/ break;
3031/*MT6139B*/ }
3032/*MT6139B*/ default :
3033/*MT6139B*/ {
3034/*MT6139B*/ break;
3035/*MT6139B*/ }
3036/*MT6139B*/ }
3037/*MT6139B*/ *ifN = 0;
3038/*MT6139B*/}
3039/*MT6139B*//* =========================================================================== */
3040/*MT6139B*/
3041/*MT6139B*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3042/*MT6139B*/{
3043/*MT6139B*/ switch(rf_band)
3044/*MT6139B*/ {
3045/*MT6139B*/ case FrequencyBand850 :
3046/*MT6139B*/ {
3047/*MT6139B*/ if(arfcn<=231)
3048/*MT6139B*/ { if(arfcn<=166)
3049/*MT6139B*/ { /* ARFCN : 128~166 */
3050/*MT6139B*/ // Nfrac = (arfcn-128)<<1+52;
3051/*MT6139B*/ // *rfN = (63L<<12) | (Nfrac<<4) | 0x80001L;
3052/*MT6139B*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x080001L; /* 0x080001L; */
3053/*MT6139B*/ }
3054/*MT6139B*/ else
3055/*MT6139B*/ { /* ARFCN : 167~231 */
3056/*MT6139B*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x080001L; /* 0x080001L; */
3057/*MT6139B*/ }
3058/*MT6139B*/ }
3059/*MT6139B*/ else
3060/*MT6139B*/ { /* ARFCN : 232~251 */
3061/*MT6139B*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x080001L; /* 0x080001L; */
3062/*MT6139B*/ }
3063/*MT6139B*/
3064/*MT6139B*/ break;
3065/*MT6139B*/ }
3066/*MT6139B*/ case FrequencyBand900 :
3067/*MT6139B*/ {
3068/*MT6139B*/ if(arfcn<=124)
3069/*MT6139B*/ { if(arfcn<=99)
3070/*MT6139B*/ { if(arfcn<=34)
3071/*MT6139B*/ { /* ARFCN : 0~34 */
3072/*MT6139B*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x180001L; /* 0x180001L; */
3073/*MT6139B*/ }
3074/*MT6139B*/ else
3075/*MT6139B*/ { /* ARFCN : 35~99 */
3076/*MT6139B*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x180001L; /* 0x180001L; */
3077/*MT6139B*/ }
3078/*MT6139B*/ }
3079/*MT6139B*/ else
3080/*MT6139B*/ { /* ARFCN : 100~124 */
3081/*MT6139B*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x180001L; /* 0x180001L; */
3082/*MT6139B*/ }
3083/*MT6139B*/ }
3084/*MT6139B*/ else
3085/*MT6139B*/ { if(arfcn<=993)
3086/*MT6139B*/ { /* ARFCN : 975~993 */
3087/*MT6139B*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x180001L; /* 0x180001L; */
3088/*MT6139B*/ }
3089/*MT6139B*/ else
3090/*MT6139B*/ { /* ARFCN : 994~1023 */
3091/*MT6139B*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x180001L; /* 0x080001L; */
3092/*MT6139B*/ }
3093/*MT6139B*/ }
3094/*MT6139B*/
3095/*MT6139B*/ break;
3096/*MT6139B*/ }
3097/*MT6139B*/ case FrequencyBand1800 :
3098/*MT6139B*/ {
3099/*MT6139B*/ if(arfcn<=670)
3100/*MT6139B*/ { if(arfcn<=540)
3101/*MT6139B*/ { /* ARFCN : 512~540 */
3102/*MT6139B*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x200001L; /* 0x280001L; */
3103/*MT6139B*/ }
3104/*MT6139B*/ else
3105/*MT6139B*/ { /* ARFCN : 541~670 */
3106/*MT6139B*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x200001L; /* 0x280001L; */
3107/*MT6139B*/ }
3108/*MT6139B*/ }
3109/*MT6139B*/ else
3110/*MT6139B*/ { if(arfcn<=800)
3111/*MT6139B*/ { /* ARFCN : 671~800 */
3112/*MT6139B*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x200001L; /* 0x280001L; */
3113/*MT6139B*/ }
3114/*MT6139B*/ else
3115/*MT6139B*/ { /* ARFCN : 801~885 */
3116/*MT6139B*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x200001L; /* 0x280001L; */
3117/*MT6139B*/ }
3118/*MT6139B*/ }
3119/*MT6139B*/
3120/*MT6139B*/ break;
3121/*MT6139B*/ }
3122/*MT6139B*/ case FrequencyBand1900 :
3123/*MT6139B*/ {
3124/*MT6139B*/ if(arfcn<=750)
3125/*MT6139B*/ { if(arfcn<=620)
3126/*MT6139B*/ { /* ARFCN : 512~620 */
3127/*MT6139B*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x300001L; /* 0x380001L; */
3128/*MT6139B*/ }
3129/*MT6139B*/ else
3130/*MT6139B*/ { /* ARFCN : 621~750 */
3131/*MT6139B*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x300001L; /* 0x380001L; */
3132/*MT6139B*/ }
3133/*MT6139B*/ }
3134/*MT6139B*/ else
3135/*MT6139B*/ {
3136/*MT6139B*/ /* ARFCN : 751~810 */
3137/*MT6139B*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x300001L; /* 0x380001L; */
3138/*MT6139B*/
3139/*MT6139B*/ }
3140/*MT6139B*/
3141/*MT6139B*/ break;
3142/*MT6139B*/ }
3143/*MT6139B*/ default :
3144/*MT6139B*/ {
3145/*MT6139B*/ break;
3146/*MT6139B*/ }
3147/*MT6139B*/ }
3148/*MT6139B*/ *ifN = 0;
3149/*MT6139B*/}
3150/*MT6139B*//* =========================================================================== */
3151#endif
3152
3153#if IS_RF_MT6139C
3154/*MT6139C*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3155/*MT6139C*/{
3156/*MT6139C*/ switch(rf_band)
3157/*MT6139C*/ {
3158/*MT6139C*/ case FrequencyBand850 :
3159/*MT6139C*/ {
3160/*MT6139C*/ if(arfcn<=201)
3161/*MT6139C*/ { if(arfcn<=136)
3162/*MT6139C*/ { /* ARFCN : 128~136 */
3163/*MT6139C*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
3164/*MT6139C*/ }
3165/*MT6139C*/ else
3166/*MT6139C*/ { /* ARFCN : 137~201 */
3167/*MT6139C*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
3168/*MT6139C*/ }
3169/*MT6139C*/ }
3170/*MT6139C*/ else
3171/*MT6139C*/ { /* ARFCN : 202~251 */
3172/*MT6139C*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
3173/*MT6139C*/ }
3174/*MT6139C*/
3175/*MT6139C*/ break;
3176/*MT6139C*/ }
3177/*MT6139C*/ case FrequencyBand900 :
3178/*MT6139C*/ {
3179/*MT6139C*/ if(arfcn<=69)
3180/*MT6139C*/ { if(arfcn<=4)
3181/*MT6139C*/ { /* ARFCN : 0~4 */
3182/*MT6139C*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
3183/*MT6139C*/ }
3184/*MT6139C*/ else
3185/*MT6139C*/ { /* ARFCN : 5~69 */
3186/*MT6139C*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
3187/*MT6139C*/ }
3188/*MT6139C*/ }
3189/*MT6139C*/ else
3190/*MT6139C*/ { if(arfcn<=124)
3191/*MT6139C*/ { /* ARFCN : 70~124 */
3192/*MT6139C*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
3193/*MT6139C*/ }
3194/*MT6139C*/ else
3195/*MT6139C*/ { /* ARFCN : 975~1023 */
3196/*MT6139C*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
3197/*MT6139C*/ }
3198/*MT6139C*/ }
3199/*MT6139C*/
3200/*MT6139C*/ break;
3201/*MT6139C*/ }
3202/*MT6139C*/ case FrequencyBand1800 :
3203/*MT6139C*/ {
3204/*MT6139C*/ if(arfcn<=715)
3205/*MT6139C*/ { if(arfcn<=585)
3206/*MT6139C*/ { /* ARFCN : 512~585 */
3207/*MT6139C*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
3208/*MT6139C*/ }
3209/*MT6139C*/ else
3210/*MT6139C*/ { /* ARFCN : 586~715 */
3211/*MT6139C*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
3212/*MT6139C*/ }
3213/*MT6139C*/ }
3214/*MT6139C*/ else
3215/*MT6139C*/ { if(arfcn<=845)
3216/*MT6139C*/ { /* ARFCN : 716~845 */
3217/*MT6139C*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
3218/*MT6139C*/ }
3219/*MT6139C*/ else
3220/*MT6139C*/ { /* ARFCN : 846~885 */
3221/*MT6139C*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
3222/*MT6139C*/ }
3223/*MT6139C*/ }
3224/*MT6139C*/
3225/*MT6139C*/ break;
3226/*MT6139C*/ }
3227/*MT6139C*/ case FrequencyBand1900 :
3228/*MT6139C*/ {
3229/*MT6139C*/ if(arfcn<=740)
3230/*MT6139C*/ { if(arfcn<=610)
3231/*MT6139C*/ { /* ARFCN : 512~610 */
3232/*MT6139C*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
3233/*MT6139C*/ }
3234/*MT6139C*/ else
3235/*MT6139C*/ { /* ARFCN : 611~740 */
3236/*MT6139C*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
3237/*MT6139C*/ }
3238/*MT6139C*/ }
3239/*MT6139C*/ else
3240/*MT6139C*/ {
3241/*MT6139C*/ /* ARFCN : 741~810 */
3242/*MT6139C*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
3243/*MT6139C*/
3244/*MT6139C*/ }
3245/*MT6139C*/
3246/*MT6139C*/ break;
3247/*MT6139C*/ }
3248/*MT6139C*/ default :
3249/*MT6139C*/ {
3250/*MT6139C*/ break;
3251/*MT6139C*/ }
3252/*MT6139C*/ }
3253/*MT6139C*/ *ifN = 0;
3254/*MT6139C*/}
3255/*MT6139C*//* =========================================================================== */
3256/*MT6139C*/
3257/*MT6139C*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3258/*MT6139C*/{
3259/*MT6139C*/ switch(rf_band)
3260/*MT6139C*/ {
3261/*MT6139C*/ case FrequencyBand850 :
3262/*MT6139C*/ {
3263/*MT6139C*/ if(arfcn<=231)
3264/*MT6139C*/ { if(arfcn<=166)
3265/*MT6139C*/ { /* ARFCN : 128~166 */
3266/*MT6139C*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x480001L; /* 0x080001L; */
3267/*MT6139C*/ }
3268/*MT6139C*/ else
3269/*MT6139C*/ { /* ARFCN : 167~231 */
3270/*MT6139C*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x480001L; /* 0x080001L; */
3271/*MT6139C*/ }
3272/*MT6139C*/ }
3273/*MT6139C*/ else
3274/*MT6139C*/ { /* ARFCN : 232~251 */
3275/*MT6139C*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x480001L; /* 0x080001L; */
3276/*MT6139C*/ }
3277/*MT6139C*/
3278/*MT6139C*/ break;
3279/*MT6139C*/ }
3280/*MT6139C*/ case FrequencyBand900 :
3281/*MT6139C*/ {
3282/*MT6139C*/ if(arfcn<=124)
3283/*MT6139C*/ { if(arfcn<=99)
3284/*MT6139C*/ { if(arfcn<=34)
3285/*MT6139C*/ { /* ARFCN : 0~34 */
3286/*MT6139C*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x580001L; /* 0x180001L; */
3287/*MT6139C*/ }
3288/*MT6139C*/ else
3289/*MT6139C*/ { /* ARFCN : 35~99 */
3290/*MT6139C*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x580001L; /* 0x180001L; */
3291/*MT6139C*/ }
3292/*MT6139C*/ }
3293/*MT6139C*/ else
3294/*MT6139C*/ { /* ARFCN : 100~124 */
3295/*MT6139C*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x580001L; /* 0x180001L; */
3296/*MT6139C*/ }
3297/*MT6139C*/ }
3298/*MT6139C*/ else
3299/*MT6139C*/ { if(arfcn<=993)
3300/*MT6139C*/ { /* ARFCN : 975~993 */
3301/*MT6139C*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x580001L; /* 0x180001L; */
3302/*MT6139C*/ }
3303/*MT6139C*/ else
3304/*MT6139C*/ { /* ARFCN : 994~1023 */
3305/*MT6139C*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x580001L; /* 0x080001L; */
3306/*MT6139C*/ }
3307/*MT6139C*/ }
3308/*MT6139C*/
3309/*MT6139C*/ break;
3310/*MT6139C*/ }
3311/*MT6139C*/ case FrequencyBand1800 :
3312/*MT6139C*/ {
3313/*MT6139C*/ if(arfcn<=670)
3314/*MT6139C*/ { if(arfcn<=540)
3315/*MT6139C*/ { /* ARFCN : 512~540 */
3316/*MT6139C*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x680001L; /* 0x280001L; */
3317/*MT6139C*/ }
3318/*MT6139C*/ else
3319/*MT6139C*/ { /* ARFCN : 541~670 */
3320/*MT6139C*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x680001L; /* 0x280001L; */
3321/*MT6139C*/ }
3322/*MT6139C*/ }
3323/*MT6139C*/ else
3324/*MT6139C*/ { if(arfcn<=800)
3325/*MT6139C*/ { /* ARFCN : 671~800 */
3326/*MT6139C*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x680001L; /* 0x280001L; */
3327/*MT6139C*/ }
3328/*MT6139C*/ else
3329/*MT6139C*/ { /* ARFCN : 801~885 */
3330/*MT6139C*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x680001L; /* 0x280001L; */
3331/*MT6139C*/ }
3332/*MT6139C*/ }
3333/*MT6139C*/
3334/*MT6139C*/ break;
3335/*MT6139C*/ }
3336/*MT6139C*/ case FrequencyBand1900 :
3337/*MT6139C*/ {
3338/*MT6139C*/ if(arfcn<=750)
3339/*MT6139C*/ { if(arfcn<=620)
3340/*MT6139C*/ { /* ARFCN : 512~620 */
3341/*MT6139C*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x780001L; /* 0x380001L; */
3342/*MT6139C*/ }
3343/*MT6139C*/ else
3344/*MT6139C*/ { /* ARFCN : 621~750 */
3345/*MT6139C*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x780001L; /* 0x380001L; */
3346/*MT6139C*/ }
3347/*MT6139C*/ }
3348/*MT6139C*/ else
3349/*MT6139C*/ {
3350/*MT6139C*/ /* ARFCN : 751~810 */
3351/*MT6139C*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x780001L; /* 0x380001L; */
3352/*MT6139C*/
3353/*MT6139C*/ }
3354/*MT6139C*/
3355/*MT6139C*/ break;
3356/*MT6139C*/ }
3357/*MT6139C*/ default :
3358/*MT6139C*/ {
3359/*MT6139C*/ break;
3360/*MT6139C*/ }
3361/*MT6139C*/ }
3362/*MT6139C*/ *ifN = 0;
3363/*MT6139C*/}
3364/*MT6139C*//* =========================================================================== */
3365#endif
3366
3367#if IS_RF_MT6139E
3368/*MT6139E*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3369/*MT6139E*/{
3370/*MT6139E*/ switch(rf_band)
3371/*MT6139E*/ {
3372/*MT6139E*/ case FrequencyBand850 :
3373/*MT6139E*/ {
3374/*MT6139E*/ if(arfcn<=201)
3375/*MT6139E*/ { if(arfcn<=136)
3376/*MT6139E*/ { /* ARFCN : 128~136 */
3377/*MT6139E*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x400001L;
3378/*MT6139E*/ }
3379/*MT6139E*/ else
3380/*MT6139E*/ { /* ARFCN : 137~201 */
3381/*MT6139E*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x400001L;
3382/*MT6139E*/ }
3383/*MT6139E*/ }
3384/*MT6139E*/ else
3385/*MT6139E*/ { /* ARFCN : 202~251 */
3386/*MT6139E*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x400001L;
3387/*MT6139E*/ }
3388/*MT6139E*/
3389/*MT6139E*/ // Get GSM850 signal from GSM900 input pins if flag=1
3390/*MT6139E*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *rfN |= 0x100000L;
3391/*MT6139E*/ break;
3392/*MT6139E*/ }
3393/*MT6139E*/ case FrequencyBand900 :
3394/*MT6139E*/ {
3395/*MT6139E*/ if(arfcn<=69)
3396/*MT6139E*/ { if(arfcn<=4)
3397/*MT6139E*/ { /* ARFCN : 0~4 */
3398/*MT6139E*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
3399/*MT6139E*/ }
3400/*MT6139E*/ else
3401/*MT6139E*/ { /* ARFCN : 5~69 */
3402/*MT6139E*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
3403/*MT6139E*/ }
3404/*MT6139E*/ }
3405/*MT6139E*/ else
3406/*MT6139E*/ { if(arfcn<=124)
3407/*MT6139E*/ { /* ARFCN : 70~124 */
3408/*MT6139E*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
3409/*MT6139E*/ }
3410/*MT6139E*/ else
3411/*MT6139E*/ { /* ARFCN : 975~1023 */
3412/*MT6139E*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
3413/*MT6139E*/ }
3414/*MT6139E*/ }
3415/*MT6139E*/
3416/*MT6139E*/ // Get GSM900 signal from GSM850 input pins if flag=1
3417/*MT6139E*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *rfN &= (~(0x100000L));
3418/*MT6139E*/
3419/*MT6139E*/ break;
3420/*MT6139E*/ }
3421/*MT6139E*/ case FrequencyBand1800 :
3422/*MT6139E*/ {
3423/*MT6139E*/ if(arfcn<=715)
3424/*MT6139E*/ { if(arfcn<=585)
3425/*MT6139E*/ { /* ARFCN : 512~585 */
3426/*MT6139E*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
3427/*MT6139E*/ }
3428/*MT6139E*/ else
3429/*MT6139E*/ { /* ARFCN : 586~715 */
3430/*MT6139E*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
3431/*MT6139E*/ }
3432/*MT6139E*/ }
3433/*MT6139E*/ else
3434/*MT6139E*/ { if(arfcn<=845)
3435/*MT6139E*/ { /* ARFCN : 716~845 */
3436/*MT6139E*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
3437/*MT6139E*/ }
3438/*MT6139E*/ else
3439/*MT6139E*/ { /* ARFCN : 846~885 */
3440/*MT6139E*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
3441/*MT6139E*/ }
3442/*MT6139E*/ }
3443/*MT6139E*/
3444/*MT6139E*/ // Get PCS1900 signal from DCS1800 input pins if flag=1
3445/*MT6139E*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *rfN |= 0x100000L;
3446/*MT6139E*/ break;
3447/*MT6139E*/ }
3448/*MT6139E*/ case FrequencyBand1900 :
3449/*MT6139E*/ {
3450/*MT6139E*/ if(arfcn<=740)
3451/*MT6139E*/ { if(arfcn<=610)
3452/*MT6139E*/ { /* ARFCN : 512~610 */
3453/*MT6139E*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
3454/*MT6139E*/ }
3455/*MT6139E*/ else
3456/*MT6139E*/ { /* ARFCN : 611~740 */
3457/*MT6139E*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
3458/*MT6139E*/ }
3459/*MT6139E*/ }
3460/*MT6139E*/ else
3461/*MT6139E*/ {
3462/*MT6139E*/ /* ARFCN : 741~810 */
3463/*MT6139E*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
3464/*MT6139E*/
3465/*MT6139E*/ }
3466/*MT6139E*/
3467/*MT6139E*/ // Get DCS1800 signal from PCS1900 input pins if flag=1
3468/*MT6139E*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *rfN &= (~(0x100000L));
3469/*MT6139E*/ break;
3470/*MT6139E*/ }
3471/*MT6139E*/ default :
3472/*MT6139E*/ {
3473/*MT6139E*/ break;
3474/*MT6139E*/ }
3475/*MT6139E*/ }
3476/*MT6139E*/ *ifN = 0;
3477/*MT6139E*/}
3478/*MT6139E*//* =========================================================================== */
3479/*MT6139E*/
3480/*MT6139E*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3481/*MT6139E*/{
3482/*MT6139E*/ switch(rf_band)
3483/*MT6139E*/ {
3484/*MT6139E*/ case FrequencyBand850 :
3485/*MT6139E*/ {
3486/*MT6139E*/ if(arfcn<=231)
3487/*MT6139E*/ { if(arfcn<=166)
3488/*MT6139E*/ { /* ARFCN : 128~166 */
3489/*MT6139E*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x080001L; /* 0x080001L; */
3490/*MT6139E*/ }
3491/*MT6139E*/ else
3492/*MT6139E*/ { /* ARFCN : 167~231 */
3493/*MT6139E*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x080001L; /* 0x080001L; */
3494/*MT6139E*/ }
3495/*MT6139E*/ }
3496/*MT6139E*/ else
3497/*MT6139E*/ { /* ARFCN : 232~251 */
3498/*MT6139E*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x080001L; /* 0x080001L; */
3499/*MT6139E*/ }
3500/*MT6139E*/
3501/*MT6139E*/ break;
3502/*MT6139E*/ }
3503/*MT6139E*/ case FrequencyBand900 :
3504/*MT6139E*/ {
3505/*MT6139E*/ if(arfcn<=124)
3506/*MT6139E*/ { if(arfcn<=99)
3507/*MT6139E*/ { if(arfcn<=34)
3508/*MT6139E*/ { /* ARFCN : 0~34 */
3509/*MT6139E*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x180001L; /* 0x180001L; */
3510/*MT6139E*/ }
3511/*MT6139E*/ else
3512/*MT6139E*/ { /* ARFCN : 35~99 */
3513/*MT6139E*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x180001L; /* 0x180001L; */
3514/*MT6139E*/ }
3515/*MT6139E*/ }
3516/*MT6139E*/ else
3517/*MT6139E*/ { /* ARFCN : 100~124 */
3518/*MT6139E*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x180001L; /* 0x180001L; */
3519/*MT6139E*/ }
3520/*MT6139E*/ }
3521/*MT6139E*/ else
3522/*MT6139E*/ { if(arfcn<=993)
3523/*MT6139E*/ { /* ARFCN : 975~993 */
3524/*MT6139E*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x180001L; /* 0x180001L; */
3525/*MT6139E*/ }
3526/*MT6139E*/ else
3527/*MT6139E*/ { /* ARFCN : 994~1023 */
3528/*MT6139E*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x180001L; /* 0x080001L; */
3529/*MT6139E*/ }
3530/*MT6139E*/ }
3531/*MT6139E*/
3532/*MT6139E*/ break;
3533/*MT6139E*/ }
3534/*MT6139E*/ case FrequencyBand1800 :
3535/*MT6139E*/ {
3536/*MT6139E*/ if(arfcn<=670)
3537/*MT6139E*/ { if(arfcn<=540)
3538/*MT6139E*/ { /* ARFCN : 512~540 */
3539/*MT6139E*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x680001L; /* 0x280001L; */
3540/*MT6139E*/ }
3541/*MT6139E*/ else
3542/*MT6139E*/ { /* ARFCN : 541~670 */
3543/*MT6139E*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x680001L; /* 0x280001L; */
3544/*MT6139E*/ }
3545/*MT6139E*/ }
3546/*MT6139E*/ else
3547/*MT6139E*/ { if(arfcn<=800)
3548/*MT6139E*/ { /* ARFCN : 671~800 */
3549/*MT6139E*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x680001L; /* 0x280001L; */
3550/*MT6139E*/ }
3551/*MT6139E*/ else
3552/*MT6139E*/ { /* ARFCN : 801~885 */
3553/*MT6139E*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x680001L; /* 0x280001L; */
3554/*MT6139E*/ }
3555/*MT6139E*/ }
3556/*MT6139E*/
3557/*MT6139E*/ break;
3558/*MT6139E*/ }
3559/*MT6139E*/ case FrequencyBand1900 :
3560/*MT6139E*/ {
3561/*MT6139E*/ if(arfcn<=750)
3562/*MT6139E*/ { if(arfcn<=620)
3563/*MT6139E*/ { /* ARFCN : 512~620 */
3564/*MT6139E*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x780001L; /* 0x380001L; */
3565/*MT6139E*/ }
3566/*MT6139E*/ else
3567/*MT6139E*/ { /* ARFCN : 621~750 */
3568/*MT6139E*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x780001L; /* 0x380001L; */
3569/*MT6139E*/ }
3570/*MT6139E*/ }
3571/*MT6139E*/ else
3572/*MT6139E*/ {
3573/*MT6139E*/ /* ARFCN : 751~810 */
3574/*MT6139E*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x780001L; /* 0x380001L; */
3575/*MT6139E*/
3576/*MT6139E*/ }
3577/*MT6139E*/
3578/*MT6139E*/ break;
3579/*MT6139E*/ }
3580/*MT6139E*/ default :
3581/*MT6139E*/ {
3582/*MT6139E*/ break;
3583/*MT6139E*/ }
3584/*MT6139E*/ }
3585/*MT6139E*/ *ifN = 0;
3586/*MT6139E*/}
3587/*MT6139E*//* =========================================================================== */
3588#endif
3589
3590#if IS_RF_MT6140A
3591/*MT6140A*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3592/*MT6140A*/{
3593/*MT6140A*/ switch(rf_band)
3594/*MT6140A*/ {
3595/*MT6140A*/ case FrequencyBand850 :
3596/*MT6140A*/ {
3597/*MT6140A*/ if(arfcn<=201)
3598/*MT6140A*/ { if(arfcn<=136)
3599/*MT6140A*/ { /* ARFCN : 128~136 */
3600/*MT6140A*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
3601/*MT6140A*/ }
3602/*MT6140A*/ else
3603/*MT6140A*/ { /* ARFCN : 137~201 */
3604/*MT6140A*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
3605/*MT6140A*/ }
3606/*MT6140A*/ }
3607/*MT6140A*/ else
3608/*MT6140A*/ { /* ARFCN : 202~251 */
3609/*MT6140A*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
3610/*MT6140A*/ }
3611/*MT6140A*/
3612/*MT6140A*/ break;
3613/*MT6140A*/ }
3614/*MT6140A*/ case FrequencyBand900 :
3615/*MT6140A*/ {
3616/*MT6140A*/ if(arfcn<=69)
3617/*MT6140A*/ { if(arfcn<=4)
3618/*MT6140A*/ { /* ARFCN : 0~4 */
3619/*MT6140A*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
3620/*MT6140A*/ }
3621/*MT6140A*/ else
3622/*MT6140A*/ { /* ARFCN : 5~69 */
3623/*MT6140A*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
3624/*MT6140A*/ }
3625/*MT6140A*/ }
3626/*MT6140A*/ else
3627/*MT6140A*/ { if(arfcn<=124)
3628/*MT6140A*/ { /* ARFCN : 70~124 */
3629/*MT6140A*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
3630/*MT6140A*/ }
3631/*MT6140A*/ else
3632/*MT6140A*/ { /* ARFCN : 975~1023 */
3633/*MT6140A*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
3634/*MT6140A*/ }
3635/*MT6140A*/ }
3636/*MT6140A*/
3637/*MT6140A*/ break;
3638/*MT6140A*/ }
3639/*MT6140A*/ case FrequencyBand1800 :
3640/*MT6140A*/ {
3641/*MT6140A*/ if(arfcn<=715)
3642/*MT6140A*/ { if(arfcn<=585)
3643/*MT6140A*/ { /* ARFCN : 512~585 */
3644/*MT6140A*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
3645/*MT6140A*/ }
3646/*MT6140A*/ else
3647/*MT6140A*/ { /* ARFCN : 586~715 */
3648/*MT6140A*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
3649/*MT6140A*/ }
3650/*MT6140A*/ }
3651/*MT6140A*/ else
3652/*MT6140A*/ { if(arfcn<=845)
3653/*MT6140A*/ { /* ARFCN : 716~845 */
3654/*MT6140A*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
3655/*MT6140A*/ }
3656/*MT6140A*/ else
3657/*MT6140A*/ { /* ARFCN : 846~885 */
3658/*MT6140A*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
3659/*MT6140A*/ }
3660/*MT6140A*/ }
3661/*MT6140A*/
3662/*MT6140A*/ break;
3663/*MT6140A*/ }
3664/*MT6140A*/ case FrequencyBand1900 :
3665/*MT6140A*/ {
3666/*MT6140A*/ if(arfcn<=740)
3667/*MT6140A*/ { if(arfcn<=610)
3668/*MT6140A*/ { /* ARFCN : 512~610 */
3669/*MT6140A*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
3670/*MT6140A*/ }
3671/*MT6140A*/ else
3672/*MT6140A*/ { /* ARFCN : 611~740 */
3673/*MT6140A*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
3674/*MT6140A*/ }
3675/*MT6140A*/ }
3676/*MT6140A*/ else
3677/*MT6140A*/ {
3678/*MT6140A*/ /* ARFCN : 741~810 */
3679/*MT6140A*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
3680/*MT6140A*/
3681/*MT6140A*/ }
3682/*MT6140A*/
3683/*MT6140A*/ break;
3684/*MT6140A*/ }
3685/*MT6140A*/ default :
3686/*MT6140A*/ {
3687/*MT6140A*/ break;
3688/*MT6140A*/ }
3689/*MT6140A*/ }
3690/*MT6140A*/ *ifN = 0;
3691/*MT6140A*/}
3692/*MT6140A*//* =========================================================================== */
3693/*MT6140A*/
3694/*MT6140A*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3695/*MT6140A*/{
3696/*MT6140A*/ switch(rf_band)
3697/*MT6140A*/ {
3698/*MT6140A*/ case FrequencyBand850 :
3699/*MT6140A*/ {
3700/*MT6140A*/ if(arfcn<=231)
3701/*MT6140A*/ { if(arfcn<=166)
3702/*MT6140A*/ { /* ARFCN : 128~166 */
3703/*MT6140A*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x480001L; /* 0x080001L; */
3704/*MT6140A*/ }
3705/*MT6140A*/ else
3706/*MT6140A*/ { /* ARFCN : 167~231 */
3707/*MT6140A*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x480001L; /* 0x080001L; */
3708/*MT6140A*/ }
3709/*MT6140A*/ }
3710/*MT6140A*/ else
3711/*MT6140A*/ { /* ARFCN : 232~251 */
3712/*MT6140A*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x480001L; /* 0x080001L; */
3713/*MT6140A*/ }
3714/*MT6140A*/
3715/*MT6140A*/ break;
3716/*MT6140A*/ }
3717/*MT6140A*/ case FrequencyBand900 :
3718/*MT6140A*/ {
3719/*MT6140A*/ if(arfcn<=124)
3720/*MT6140A*/ { if(arfcn<=99)
3721/*MT6140A*/ { if(arfcn<=34)
3722/*MT6140A*/ { /* ARFCN : 0~34 */
3723/*MT6140A*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x580001L; /* 0x180001L; */
3724/*MT6140A*/ }
3725/*MT6140A*/ else
3726/*MT6140A*/ { /* ARFCN : 35~99 */
3727/*MT6140A*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x580001L; /* 0x180001L; */
3728/*MT6140A*/ }
3729/*MT6140A*/ }
3730/*MT6140A*/ else
3731/*MT6140A*/ { /* ARFCN : 100~124 */
3732/*MT6140A*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x580001L; /* 0x180001L; */
3733/*MT6140A*/ }
3734/*MT6140A*/ }
3735/*MT6140A*/ else
3736/*MT6140A*/ { if(arfcn<=993)
3737/*MT6140A*/ { /* ARFCN : 975~993 */
3738/*MT6140A*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x580001L; /* 0x180001L; */
3739/*MT6140A*/ }
3740/*MT6140A*/ else
3741/*MT6140A*/ { /* ARFCN : 994~1023 */
3742/*MT6140A*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x580001L; /* 0x080001L; */
3743/*MT6140A*/ }
3744/*MT6140A*/ }
3745/*MT6140A*/
3746/*MT6140A*/ break;
3747/*MT6140A*/ }
3748/*MT6140A*/ case FrequencyBand1800 :
3749/*MT6140A*/ {
3750/*MT6140A*/ if(arfcn<=670)
3751/*MT6140A*/ { if(arfcn<=540)
3752/*MT6140A*/ { /* ARFCN : 512~540 */
3753/*MT6140A*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x600001L; /* 0x280001L; */
3754/*MT6140A*/ }
3755/*MT6140A*/ else
3756/*MT6140A*/ { /* ARFCN : 541~670 */
3757/*MT6140A*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x600001L; /* 0x280001L; */
3758/*MT6140A*/ }
3759/*MT6140A*/ }
3760/*MT6140A*/ else
3761/*MT6140A*/ { if(arfcn<=800)
3762/*MT6140A*/ { /* ARFCN : 671~800 */
3763/*MT6140A*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x600001L; /* 0x280001L; */
3764/*MT6140A*/ }
3765/*MT6140A*/ else
3766/*MT6140A*/ { /* ARFCN : 801~885 */
3767/*MT6140A*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x600001L; /* 0x280001L; */
3768/*MT6140A*/ }
3769/*MT6140A*/ }
3770/*MT6140A*/
3771/*MT6140A*/ break;
3772/*MT6140A*/ }
3773/*MT6140A*/ case FrequencyBand1900 :
3774/*MT6140A*/ {
3775/*MT6140A*/ if(arfcn<=750)
3776/*MT6140A*/ { if(arfcn<=620)
3777/*MT6140A*/ { /* ARFCN : 512~620 */
3778/*MT6140A*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x700001L; /* 0x380001L; */
3779/*MT6140A*/ }
3780/*MT6140A*/ else
3781/*MT6140A*/ { /* ARFCN : 621~750 */
3782/*MT6140A*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x700001L; /* 0x380001L; */
3783/*MT6140A*/ }
3784/*MT6140A*/ }
3785/*MT6140A*/ else
3786/*MT6140A*/ {
3787/*MT6140A*/ /* ARFCN : 751~810 */
3788/*MT6140A*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x700001L; /* 0x380001L; */
3789/*MT6140A*/
3790/*MT6140A*/ }
3791/*MT6140A*/
3792/*MT6140A*/ break;
3793/*MT6140A*/ }
3794/*MT6140A*/ default :
3795/*MT6140A*/ {
3796/*MT6140A*/ break;
3797/*MT6140A*/ }
3798/*MT6140A*/ }
3799/*MT6140A*/ *ifN = 0;
3800/*MT6140A*/}
3801/*MT6140A*//* =========================================================================== */
3802#endif
3803
3804#if IS_RF_MT6140B
3805/*MT6140B*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3806/*MT6140B*/{
3807/*MT6140B*/ switch(rf_band)
3808/*MT6140B*/ {
3809/*MT6140B*/ case FrequencyBand850 :
3810/*MT6140B*/ {
3811/*MT6140B*/ if(arfcn<=201)
3812/*MT6140B*/ { if(arfcn<=136)
3813/*MT6140B*/ { /* ARFCN : 128~136 */
3814/*MT6140B*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
3815/*MT6140B*/ }
3816/*MT6140B*/ else
3817/*MT6140B*/ { /* ARFCN : 137~201 */
3818/*MT6140B*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
3819/*MT6140B*/ }
3820/*MT6140B*/ }
3821/*MT6140B*/ else
3822/*MT6140B*/ { /* ARFCN : 202~251 */
3823/*MT6140B*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
3824/*MT6140B*/ }
3825/*MT6140B*/
3826/*MT6140B*/ break;
3827/*MT6140B*/ }
3828/*MT6140B*/ case FrequencyBand900 :
3829/*MT6140B*/ {
3830/*MT6140B*/ if(arfcn<=69)
3831/*MT6140B*/ { if(arfcn<=4)
3832/*MT6140B*/ { /* ARFCN : 0~4 */
3833/*MT6140B*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
3834/*MT6140B*/ }
3835/*MT6140B*/ else
3836/*MT6140B*/ { /* ARFCN : 5~69 */
3837/*MT6140B*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
3838/*MT6140B*/ }
3839/*MT6140B*/ }
3840/*MT6140B*/ else
3841/*MT6140B*/ { if(arfcn<=124)
3842/*MT6140B*/ { /* ARFCN : 70~124 */
3843/*MT6140B*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
3844/*MT6140B*/ }
3845/*MT6140B*/ else
3846/*MT6140B*/ { /* ARFCN : 975~1023 */
3847/*MT6140B*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
3848/*MT6140B*/ }
3849/*MT6140B*/ }
3850/*MT6140B*/
3851/*MT6140B*/ break;
3852/*MT6140B*/ }
3853/*MT6140B*/ case FrequencyBand1800 :
3854/*MT6140B*/ {
3855/*MT6140B*/ if(arfcn<=715)
3856/*MT6140B*/ { if(arfcn<=585)
3857/*MT6140B*/ { /* ARFCN : 512~585 */
3858/*MT6140B*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
3859/*MT6140B*/ }
3860/*MT6140B*/ else
3861/*MT6140B*/ { /* ARFCN : 586~715 */
3862/*MT6140B*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
3863/*MT6140B*/ }
3864/*MT6140B*/ }
3865/*MT6140B*/ else
3866/*MT6140B*/ { if(arfcn<=845)
3867/*MT6140B*/ { /* ARFCN : 716~845 */
3868/*MT6140B*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
3869/*MT6140B*/ }
3870/*MT6140B*/ else
3871/*MT6140B*/ { /* ARFCN : 846~885 */
3872/*MT6140B*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
3873/*MT6140B*/ }
3874/*MT6140B*/ }
3875/*MT6140B*/
3876/*MT6140B*/ break;
3877/*MT6140B*/ }
3878/*MT6140B*/ case FrequencyBand1900 :
3879/*MT6140B*/ {
3880/*MT6140B*/ if(arfcn<=740)
3881/*MT6140B*/ { if(arfcn<=610)
3882/*MT6140B*/ { /* ARFCN : 512~610 */
3883/*MT6140B*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
3884/*MT6140B*/ }
3885/*MT6140B*/ else
3886/*MT6140B*/ { /* ARFCN : 611~740 */
3887/*MT6140B*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
3888/*MT6140B*/ }
3889/*MT6140B*/ }
3890/*MT6140B*/ else
3891/*MT6140B*/ {
3892/*MT6140B*/ /* ARFCN : 741~810 */
3893/*MT6140B*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
3894/*MT6140B*/
3895/*MT6140B*/ }
3896/*MT6140B*/
3897/*MT6140B*/ break;
3898/*MT6140B*/ }
3899/*MT6140B*/ default :
3900/*MT6140B*/ {
3901/*MT6140B*/ break;
3902/*MT6140B*/ }
3903/*MT6140B*/ }
3904/*MT6140B*/ *ifN = 0;
3905/*MT6140B*/}
3906/*MT6140B*//* =========================================================================== */
3907/*MT6140B*/
3908/*MT6140B*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
3909/*MT6140B*/{
3910/*MT6140B*/ switch(rf_band)
3911/*MT6140B*/ {
3912/*MT6140B*/ case FrequencyBand850 :
3913/*MT6140B*/ {
3914/*MT6140B*/ if(arfcn<=231)
3915/*MT6140B*/ { if(arfcn<=166)
3916/*MT6140B*/ { /* ARFCN : 128~166 */
3917/*MT6140B*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x480001L; /* 0x080001L; */
3918/*MT6140B*/ }
3919/*MT6140B*/ else
3920/*MT6140B*/ { /* ARFCN : 167~231 */
3921/*MT6140B*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x480001L; /* 0x080001L; */
3922/*MT6140B*/ }
3923/*MT6140B*/ }
3924/*MT6140B*/ else
3925/*MT6140B*/ { /* ARFCN : 232~251 */
3926/*MT6140B*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x480001L; /* 0x080001L; */
3927/*MT6140B*/ }
3928/*MT6140B*/
3929/*MT6140B*/ break;
3930/*MT6140B*/ }
3931/*MT6140B*/ case FrequencyBand900 :
3932/*MT6140B*/ {
3933/*MT6140B*/ if(arfcn<=124)
3934/*MT6140B*/ { if(arfcn<=99)
3935/*MT6140B*/ { if(arfcn<=34)
3936/*MT6140B*/ { /* ARFCN : 0~34 */
3937/*MT6140B*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x580001L; /* 0x180001L; */
3938/*MT6140B*/ }
3939/*MT6140B*/ else
3940/*MT6140B*/ { /* ARFCN : 35~99 */
3941/*MT6140B*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x580001L; /* 0x180001L; */
3942/*MT6140B*/ }
3943/*MT6140B*/ }
3944/*MT6140B*/ else
3945/*MT6140B*/ { /* ARFCN : 100~124 */
3946/*MT6140B*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x580001L; /* 0x180001L; */
3947/*MT6140B*/ }
3948/*MT6140B*/ }
3949/*MT6140B*/ else
3950/*MT6140B*/ { if(arfcn<=993)
3951/*MT6140B*/ { /* ARFCN : 975~993 */
3952/*MT6140B*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x580001L; /* 0x180001L; */
3953/*MT6140B*/ }
3954/*MT6140B*/ else
3955/*MT6140B*/ { /* ARFCN : 994~1023 */
3956/*MT6140B*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x580001L; /* 0x080001L; */
3957/*MT6140B*/ }
3958/*MT6140B*/ }
3959/*MT6140B*/
3960/*MT6140B*/ break;
3961/*MT6140B*/ }
3962/*MT6140B*/ case FrequencyBand1800 :
3963/*MT6140B*/ {
3964/*MT6140B*/ if(arfcn<=670)
3965/*MT6140B*/ { if(arfcn<=540)
3966/*MT6140B*/ { /* ARFCN : 512~540 */
3967/*MT6140B*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x680001L; /* 0x280001L; */
3968/*MT6140B*/ }
3969/*MT6140B*/ else
3970/*MT6140B*/ { /* ARFCN : 541~670 */
3971/*MT6140B*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x680001L; /* 0x280001L; */
3972/*MT6140B*/ }
3973/*MT6140B*/ }
3974/*MT6140B*/ else
3975/*MT6140B*/ { if(arfcn<=800)
3976/*MT6140B*/ { /* ARFCN : 671~800 */
3977/*MT6140B*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x680001L; /* 0x280001L; */
3978/*MT6140B*/ }
3979/*MT6140B*/ else
3980/*MT6140B*/ { /* ARFCN : 801~885 */
3981/*MT6140B*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x680001L; /* 0x280001L; */
3982/*MT6140B*/ }
3983/*MT6140B*/ }
3984/*MT6140B*/
3985/*MT6140B*/ break;
3986/*MT6140B*/ }
3987/*MT6140B*/ case FrequencyBand1900 :
3988/*MT6140B*/ {
3989/*MT6140B*/ if(arfcn<=750)
3990/*MT6140B*/ { if(arfcn<=620)
3991/*MT6140B*/ { /* ARFCN : 512~620 */
3992/*MT6140B*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x780001L; /* 0x380001L; */
3993/*MT6140B*/ }
3994/*MT6140B*/ else
3995/*MT6140B*/ { /* ARFCN : 621~750 */
3996/*MT6140B*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x780001L; /* 0x380001L; */
3997/*MT6140B*/ }
3998/*MT6140B*/ }
3999/*MT6140B*/ else
4000/*MT6140B*/ {
4001/*MT6140B*/ /* ARFCN : 751~810 */
4002/*MT6140B*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x780001L; /* 0x380001L; */
4003/*MT6140B*/
4004/*MT6140B*/ }
4005/*MT6140B*/
4006/*MT6140B*/ break;
4007/*MT6140B*/ }
4008/*MT6140B*/ default :
4009/*MT6140B*/ {
4010/*MT6140B*/ break;
4011/*MT6140B*/ }
4012/*MT6140B*/ }
4013/*MT6140B*/ *ifN = 0;
4014/*MT6140B*/}
4015/*MT6140B*//* =========================================================================== */
4016#endif
4017
4018#if IS_RF_MT6140C
4019/*MT6140C*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4020/*MT6140C*/{
4021/*MT6140C*/ switch(rf_band)
4022/*MT6140C*/ {
4023/*MT6140C*/ case FrequencyBand850 :
4024/*MT6140C*/ {
4025/*MT6140C*/ if(arfcn<=201)
4026/*MT6140C*/ { if(arfcn<=136)
4027/*MT6140C*/ { /* ARFCN : 128~136 */
4028/*MT6140C*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
4029/*MT6140C*/ }
4030/*MT6140C*/ else
4031/*MT6140C*/ { /* ARFCN : 137~201 */
4032/*MT6140C*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
4033/*MT6140C*/ }
4034/*MT6140C*/ }
4035/*MT6140C*/ else
4036/*MT6140C*/ { /* ARFCN : 202~251 */
4037/*MT6140C*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
4038/*MT6140C*/ }
4039/*MT6140C*/
4040/*MT6140C*/ break;
4041/*MT6140C*/ }
4042/*MT6140C*/ case FrequencyBand900 :
4043/*MT6140C*/ {
4044/*MT6140C*/ if(arfcn<=69)
4045/*MT6140C*/ { if(arfcn<=4)
4046/*MT6140C*/ { /* ARFCN : 0~4 */
4047/*MT6140C*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
4048/*MT6140C*/ }
4049/*MT6140C*/ else
4050/*MT6140C*/ { /* ARFCN : 5~69 */
4051/*MT6140C*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
4052/*MT6140C*/ }
4053/*MT6140C*/ }
4054/*MT6140C*/ else
4055/*MT6140C*/ { if(arfcn<=124)
4056/*MT6140C*/ { /* ARFCN : 70~124 */
4057/*MT6140C*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
4058/*MT6140C*/ }
4059/*MT6140C*/ else
4060/*MT6140C*/ { /* ARFCN : 975~1023 */
4061/*MT6140C*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
4062/*MT6140C*/ }
4063/*MT6140C*/ }
4064/*MT6140C*/
4065/*MT6140C*/ break;
4066/*MT6140C*/ }
4067/*MT6140C*/ case FrequencyBand1800 :
4068/*MT6140C*/ {
4069/*MT6140C*/ if(arfcn<=715)
4070/*MT6140C*/ { if(arfcn<=585)
4071/*MT6140C*/ { /* ARFCN : 512~585 */
4072/*MT6140C*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
4073/*MT6140C*/ }
4074/*MT6140C*/ else
4075/*MT6140C*/ { /* ARFCN : 586~715 */
4076/*MT6140C*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
4077/*MT6140C*/ }
4078/*MT6140C*/ }
4079/*MT6140C*/ else
4080/*MT6140C*/ { if(arfcn<=845)
4081/*MT6140C*/ { /* ARFCN : 716~845 */
4082/*MT6140C*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
4083/*MT6140C*/ }
4084/*MT6140C*/ else
4085/*MT6140C*/ { /* ARFCN : 846~885 */
4086/*MT6140C*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
4087/*MT6140C*/ }
4088/*MT6140C*/ }
4089/*MT6140C*/
4090/*MT6140C*/ break;
4091/*MT6140C*/ }
4092/*MT6140C*/ case FrequencyBand1900 :
4093/*MT6140C*/ {
4094/*MT6140C*/ if(arfcn<=740)
4095/*MT6140C*/ { if(arfcn<=610)
4096/*MT6140C*/ { /* ARFCN : 512~610 */
4097/*MT6140C*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
4098/*MT6140C*/ }
4099/*MT6140C*/ else
4100/*MT6140C*/ { /* ARFCN : 611~740 */
4101/*MT6140C*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
4102/*MT6140C*/ }
4103/*MT6140C*/ }
4104/*MT6140C*/ else
4105/*MT6140C*/ {
4106/*MT6140C*/ /* ARFCN : 741~810 */
4107/*MT6140C*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
4108/*MT6140C*/
4109/*MT6140C*/ }
4110/*MT6140C*/
4111/*MT6140C*/ break;
4112/*MT6140C*/ }
4113/*MT6140C*/ default :
4114/*MT6140C*/ {
4115/*MT6140C*/ break;
4116/*MT6140C*/ }
4117/*MT6140C*/ }
4118/*MT6140C*/ *ifN = 0;
4119/*MT6140C*/}
4120/*MT6140C*//* =========================================================================== */
4121/*MT6140C*/
4122/*MT6140C*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4123/*MT6140C*/{
4124/*MT6140C*/ switch(rf_band)
4125/*MT6140C*/ {
4126/*MT6140C*/ case FrequencyBand850 :
4127/*MT6140C*/ {
4128/*MT6140C*/ if(arfcn<=231)
4129/*MT6140C*/ { if(arfcn<=166)
4130/*MT6140C*/ { /* ARFCN : 128~166 */
4131/*MT6140C*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x480001L; /* 0x080001L; */
4132/*MT6140C*/ }
4133/*MT6140C*/ else
4134/*MT6140C*/ { /* ARFCN : 167~231 */
4135/*MT6140C*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x480001L; /* 0x080001L; */
4136/*MT6140C*/ }
4137/*MT6140C*/ }
4138/*MT6140C*/ else
4139/*MT6140C*/ { /* ARFCN : 232~251 */
4140/*MT6140C*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x480001L; /* 0x080001L; */
4141/*MT6140C*/ }
4142/*MT6140C*/
4143/*MT6140C*/ break;
4144/*MT6140C*/ }
4145/*MT6140C*/ case FrequencyBand900 :
4146/*MT6140C*/ {
4147/*MT6140C*/ if(arfcn<=124)
4148/*MT6140C*/ { if(arfcn<=99)
4149/*MT6140C*/ { if(arfcn<=34)
4150/*MT6140C*/ { /* ARFCN : 0~34 */
4151/*MT6140C*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x580001L; /* 0x180001L; */
4152/*MT6140C*/ }
4153/*MT6140C*/ else
4154/*MT6140C*/ { /* ARFCN : 35~99 */
4155/*MT6140C*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x580001L; /* 0x180001L; */
4156/*MT6140C*/ }
4157/*MT6140C*/ }
4158/*MT6140C*/ else
4159/*MT6140C*/ { /* ARFCN : 100~124 */
4160/*MT6140C*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x580001L; /* 0x180001L; */
4161/*MT6140C*/ }
4162/*MT6140C*/ }
4163/*MT6140C*/ else
4164/*MT6140C*/ { if(arfcn<=993)
4165/*MT6140C*/ { /* ARFCN : 975~993 */
4166/*MT6140C*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x580001L; /* 0x180001L; */
4167/*MT6140C*/ }
4168/*MT6140C*/ else
4169/*MT6140C*/ { /* ARFCN : 994~1023 */
4170/*MT6140C*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x580001L; /* 0x080001L; */
4171/*MT6140C*/ }
4172/*MT6140C*/ }
4173/*MT6140C*/
4174/*MT6140C*/ break;
4175/*MT6140C*/ }
4176/*MT6140C*/ case FrequencyBand1800 :
4177/*MT6140C*/ {
4178/*MT6140C*/ if(arfcn<=670)
4179/*MT6140C*/ { if(arfcn<=540)
4180/*MT6140C*/ { /* ARFCN : 512~540 */
4181/*MT6140C*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x680001L; /* 0x280001L; */
4182/*MT6140C*/ }
4183/*MT6140C*/ else
4184/*MT6140C*/ { /* ARFCN : 541~670 */
4185/*MT6140C*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x680001L; /* 0x280001L; */
4186/*MT6140C*/ }
4187/*MT6140C*/ }
4188/*MT6140C*/ else
4189/*MT6140C*/ { if(arfcn<=800)
4190/*MT6140C*/ { /* ARFCN : 671~800 */
4191/*MT6140C*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x680001L; /* 0x280001L; */
4192/*MT6140C*/ }
4193/*MT6140C*/ else
4194/*MT6140C*/ { /* ARFCN : 801~885 */
4195/*MT6140C*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x680001L; /* 0x280001L; */
4196/*MT6140C*/ }
4197/*MT6140C*/ }
4198/*MT6140C*/
4199/*MT6140C*/ break;
4200/*MT6140C*/ }
4201/*MT6140C*/ case FrequencyBand1900 :
4202/*MT6140C*/ {
4203/*MT6140C*/ if(arfcn<=750)
4204/*MT6140C*/ { if(arfcn<=620)
4205/*MT6140C*/ { /* ARFCN : 512~620 */
4206/*MT6140C*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x780001L; /* 0x380001L; */
4207/*MT6140C*/ }
4208/*MT6140C*/ else
4209/*MT6140C*/ { /* ARFCN : 621~750 */
4210/*MT6140C*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x780001L; /* 0x380001L; */
4211/*MT6140C*/ }
4212/*MT6140C*/ }
4213/*MT6140C*/ else
4214/*MT6140C*/ {
4215/*MT6140C*/ /* ARFCN : 751~810 */
4216/*MT6140C*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x780001L; /* 0x380001L; */
4217/*MT6140C*/
4218/*MT6140C*/ }
4219/*MT6140C*/
4220/*MT6140C*/ break;
4221/*MT6140C*/ }
4222/*MT6140C*/ default :
4223/*MT6140C*/ {
4224/*MT6140C*/ break;
4225/*MT6140C*/ }
4226/*MT6140C*/ }
4227/*MT6140C*/ *ifN = 0;
4228/*MT6140C*/}
4229/*MT6140C*//* =========================================================================== */
4230#endif
4231
4232#if IS_RF_MT6140D
4233/*MT6140D*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4234/*MT6140D*/{
4235/*MT6140D*/ switch(rf_band)
4236/*MT6140D*/ {
4237/*MT6140D*/ case FrequencyBand850 :
4238/*MT6140D*/ {
4239/*MT6140D*/ if(arfcn<=201)
4240/*MT6140D*/ { if(arfcn<=136)
4241/*MT6140D*/ { /* ARFCN : 128~136 */
4242/*MT6140D*/ *rfN = (66L<<12) | ((arfcn-72)<<5) | 0x000001L;
4243/*MT6140D*/ }
4244/*MT6140D*/ else
4245/*MT6140D*/ { /* ARFCN : 137~201 */
4246/*MT6140D*/ *rfN = (67L<<12) | ((arfcn-137)<<5) | 0x000001L;
4247/*MT6140D*/ }
4248/*MT6140D*/ }
4249/*MT6140D*/ else
4250/*MT6140D*/ { /* ARFCN : 202~251 */
4251/*MT6140D*/ *rfN = (68L<<12) | ((arfcn-202)<<5) | 0x000001L;
4252/*MT6140D*/ }
4253/*MT6140D*/
4254/*MT6140D*/ // Get GSM850 signal from GSM900 input pins if flag=1
4255/*MT6140D*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *rfN |= 0x100000L;
4256/*MT6140D*/ break;
4257/*MT6140D*/ }
4258/*MT6140D*/ case FrequencyBand900 :
4259/*MT6140D*/ {
4260/*MT6140D*/ if(arfcn<=69)
4261/*MT6140D*/ { if(arfcn<=4)
4262/*MT6140D*/ { /* ARFCN : 0~4 */
4263/*MT6140D*/ *rfN = (71L<<12) | ((arfcn+60)<<5) | 0x100001L;
4264/*MT6140D*/ }
4265/*MT6140D*/ else
4266/*MT6140D*/ { /* ARFCN : 5~69 */
4267/*MT6140D*/ *rfN = (72L<<12) | ((arfcn-5)<<5) | 0x100001L;
4268/*MT6140D*/ }
4269/*MT6140D*/ }
4270/*MT6140D*/ else
4271/*MT6140D*/ { if(arfcn<=124)
4272/*MT6140D*/ { /* ARFCN : 70~124 */
4273/*MT6140D*/ *rfN = (73L<<12) | ((arfcn-70)<<5) | 0x100001L;
4274/*MT6140D*/ }
4275/*MT6140D*/ else
4276/*MT6140D*/ { /* ARFCN : 975~1023 */
4277/*MT6140D*/ *rfN = (71L<<12) | ((arfcn-964)<<5) | 0x100001L;
4278/*MT6140D*/ }
4279/*MT6140D*/ }
4280/*MT6140D*/
4281/*MT6140D*/ // Get GSM900 signal from GSM850 input pins if flag=1
4282/*MT6140D*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *rfN &= (~(0x100000L));
4283/*MT6140D*/ break;
4284/*MT6140D*/ }
4285/*MT6140D*/ case FrequencyBand1800 :
4286/*MT6140D*/ {
4287/*MT6140D*/ if(arfcn<=715)
4288/*MT6140D*/ { if(arfcn<=585)
4289/*MT6140D*/ { /* ARFCN : 512~585 */
4290/*MT6140D*/ *rfN = (69L<<12) | ((arfcn-456)<<4) | 0x200001L;
4291/*MT6140D*/ }
4292/*MT6140D*/ else
4293/*MT6140D*/ { /* ARFCN : 586~715 */
4294/*MT6140D*/ *rfN = (70L<<12) | ((arfcn-586)<<4) | 0x200001L;
4295/*MT6140D*/ }
4296/*MT6140D*/ }
4297/*MT6140D*/ else
4298/*MT6140D*/ { if(arfcn<=845)
4299/*MT6140D*/ { /* ARFCN : 716~845 */
4300/*MT6140D*/ *rfN = (71L<<12) | ((arfcn-716)<<4) | 0x200001L;
4301/*MT6140D*/ }
4302/*MT6140D*/ else
4303/*MT6140D*/ { /* ARFCN : 846~885 */
4304/*MT6140D*/ *rfN = (72L<<12) | ((arfcn-846)<<4) | 0x200001L;
4305/*MT6140D*/ }
4306/*MT6140D*/ }
4307/*MT6140D*/
4308/*MT6140D*/ // Get PCS1900 signal from DCS1800 input pins if flag=1
4309/*MT6140D*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *rfN |= 0x100000L;
4310/*MT6140D*/ break;
4311/*MT6140D*/ }
4312/*MT6140D*/ case FrequencyBand1900 :
4313/*MT6140D*/ {
4314/*MT6140D*/ if(arfcn<=740)
4315/*MT6140D*/ { if(arfcn<=610)
4316/*MT6140D*/ { /* ARFCN : 512~610 */
4317/*MT6140D*/ *rfN = (74L<<12) | ((arfcn-481)<<4) | 0x300001L;
4318/*MT6140D*/ }
4319/*MT6140D*/ else
4320/*MT6140D*/ { /* ARFCN : 611~740 */
4321/*MT6140D*/ *rfN = (75L<<12) | ((arfcn-611)<<4) | 0x300001L;
4322/*MT6140D*/ }
4323/*MT6140D*/ }
4324/*MT6140D*/ else
4325/*MT6140D*/ {
4326/*MT6140D*/ /* ARFCN : 741~810 */
4327/*MT6140D*/ *rfN = (76L<<12) | ((arfcn-741)<<4) | 0x300001L;
4328/*MT6140D*/
4329/*MT6140D*/ }
4330/*MT6140D*/
4331/*MT6140D*/ // Get DCS1800 signal from PCS1900 input pins if flag=1
4332/*MT6140D*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *rfN &= (~(0x100000L));
4333/*MT6140D*/ break;
4334/*MT6140D*/ }
4335/*MT6140D*/ default :
4336/*MT6140D*/ {
4337/*MT6140D*/ break;
4338/*MT6140D*/ }
4339/*MT6140D*/ }
4340/*MT6140D*/ *ifN = 0;
4341/*MT6140D*/}
4342/*MT6140D*//* =========================================================================== */
4343/*MT6140D*/
4344/*MT6140D*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4345/*MT6140D*/{
4346/*MT6140D*/ switch(rf_band)
4347/*MT6140D*/ {
4348/*MT6140D*/ case FrequencyBand850 :
4349/*MT6140D*/ {
4350/*MT6140D*/ if(arfcn<=231)
4351/*MT6140D*/ { if(arfcn<=166)
4352/*MT6140D*/ { /* ARFCN : 128~166 */
4353/*MT6140D*/ *rfN = (63L<<12) | ((arfcn-102)<<5) | 0x480001L; /* 0x080001L; */
4354/*MT6140D*/ }
4355/*MT6140D*/ else
4356/*MT6140D*/ { /* ARFCN : 167~231 */
4357/*MT6140D*/ *rfN = (64L<<12) | ((arfcn-167)<<5) | 0x480001L; /* 0x080001L; */
4358/*MT6140D*/ }
4359/*MT6140D*/ }
4360/*MT6140D*/ else
4361/*MT6140D*/ { /* ARFCN : 232~251 */
4362/*MT6140D*/ *rfN = (65L<<12) | ((arfcn-232)<<5) | 0x480001L; /* 0x080001L; */
4363/*MT6140D*/ }
4364/*MT6140D*/
4365/*MT6140D*/ break;
4366/*MT6140D*/ }
4367/*MT6140D*/ case FrequencyBand900 :
4368/*MT6140D*/ {
4369/*MT6140D*/ if(arfcn<=124)
4370/*MT6140D*/ { if(arfcn<=99)
4371/*MT6140D*/ { if(arfcn<=34)
4372/*MT6140D*/ { /* ARFCN : 0~34 */
4373/*MT6140D*/ *rfN = (68L<<12) | ((arfcn+30)<<5) | 0x580001L; /* 0x180001L; */
4374/*MT6140D*/ }
4375/*MT6140D*/ else
4376/*MT6140D*/ { /* ARFCN : 35~99 */
4377/*MT6140D*/ *rfN = (69L<<12) | ((arfcn-35)<<5) | 0x580001L; /* 0x180001L; */
4378/*MT6140D*/ }
4379/*MT6140D*/ }
4380/*MT6140D*/ else
4381/*MT6140D*/ { /* ARFCN : 100~124 */
4382/*MT6140D*/ *rfN = (70L<<12) | ((arfcn-100)<<5) | 0x580001L; /* 0x180001L; */
4383/*MT6140D*/ }
4384/*MT6140D*/ }
4385/*MT6140D*/ else
4386/*MT6140D*/ { if(arfcn<=993)
4387/*MT6140D*/ { /* ARFCN : 975~993 */
4388/*MT6140D*/ *rfN = (67L<<12) | ((arfcn-929)<<5) | 0x580001L; /* 0x180001L; */
4389/*MT6140D*/ }
4390/*MT6140D*/ else
4391/*MT6140D*/ { /* ARFCN : 994~1023 */
4392/*MT6140D*/ *rfN = (68L<<12) | ((arfcn-994)<<5) | 0x580001L; /* 0x080001L; */
4393/*MT6140D*/ }
4394/*MT6140D*/ }
4395/*MT6140D*/
4396/*MT6140D*/ break;
4397/*MT6140D*/ }
4398/*MT6140D*/ case FrequencyBand1800 :
4399/*MT6140D*/ {
4400/*MT6140D*/ if(arfcn<=670)
4401/*MT6140D*/ { if(arfcn<=540)
4402/*MT6140D*/ { /* ARFCN : 512~540 */
4403/*MT6140D*/ *rfN = (65L<<12) | ((arfcn-411)<<4) | 0x680001L; /* 0x280001L; */
4404/*MT6140D*/ }
4405/*MT6140D*/ else
4406/*MT6140D*/ { /* ARFCN : 541~670 */
4407/*MT6140D*/ *rfN = (66L<<12) | ((arfcn-541)<<4) | 0x680001L; /* 0x280001L; */
4408/*MT6140D*/ }
4409/*MT6140D*/ }
4410/*MT6140D*/ else
4411/*MT6140D*/ { if(arfcn<=800)
4412/*MT6140D*/ { /* ARFCN : 671~800 */
4413/*MT6140D*/ *rfN = (67L<<12) | ((arfcn-671)<<4) | 0x680001L; /* 0x280001L; */
4414/*MT6140D*/ }
4415/*MT6140D*/ else
4416/*MT6140D*/ { /* ARFCN : 801~885 */
4417/*MT6140D*/ *rfN = (68L<<12) | ((arfcn-801)<<4) | 0x680001L; /* 0x280001L; */
4418/*MT6140D*/ }
4419/*MT6140D*/ }
4420/*MT6140D*/
4421/*MT6140D*/ break;
4422/*MT6140D*/ }
4423/*MT6140D*/ case FrequencyBand1900 :
4424/*MT6140D*/ {
4425/*MT6140D*/ if(arfcn<=750)
4426/*MT6140D*/ { if(arfcn<=620)
4427/*MT6140D*/ { /* ARFCN : 512~620 */
4428/*MT6140D*/ *rfN = (71L<<12) | ((arfcn-491)<<4) | 0x780001L; /* 0x380001L; */
4429/*MT6140D*/ }
4430/*MT6140D*/ else
4431/*MT6140D*/ { /* ARFCN : 621~750 */
4432/*MT6140D*/ *rfN = (72L<<12) | ((arfcn-621)<<4) | 0x780001L; /* 0x380001L; */
4433/*MT6140D*/ }
4434/*MT6140D*/ }
4435/*MT6140D*/ else
4436/*MT6140D*/ {
4437/*MT6140D*/ /* ARFCN : 751~810 */
4438/*MT6140D*/ *rfN = (73L<<12) | ((arfcn-751)<<4) | 0x780001L; /* 0x380001L; */
4439/*MT6140D*/
4440/*MT6140D*/ }
4441/*MT6140D*/
4442/*MT6140D*/ break;
4443/*MT6140D*/ }
4444/*MT6140D*/ default :
4445/*MT6140D*/ {
4446/*MT6140D*/ break;
4447/*MT6140D*/ }
4448/*MT6140D*/ }
4449/*MT6140D*/ *ifN = 0;
4450/*MT6140D*/}
4451/*MT6140D*//* =========================================================================== */
4452#endif
4453
4454#if IS_RF_CMOSEDGE
4455/*CMOSEDGE*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4456/*CMOSEDGE*/{ int Nfrac;
4457/*CMOSEDGE*/ switch(rf_band)
4458/*CMOSEDGE*/ {
4459/*CMOSEDGE*/ case FrequencyBand850 :
4460/*CMOSEDGE*/ {
4461/*CMOSEDGE*/ if(arfcn<=201)
4462/*CMOSEDGE*/ { if(arfcn<=169)
4463/*CMOSEDGE*/ { if(arfcn<=136)
4464/*CMOSEDGE*/ { /* ARFCN : 128~136 */
4465/*CMOSEDGE*/ Nfrac = (arfcn-128)*258111+6065609;
4466/*CMOSEDGE*/ *rfN = (133L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4467/*CMOSEDGE*/ }
4468/*CMOSEDGE*/ else
4469/*CMOSEDGE*/ { /* ARFCN : 137~169 */
4470/*CMOSEDGE*/ Nfrac = (arfcn-137)*258111;
4471/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4472/*CMOSEDGE*/ *rfN = (134L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4473/*CMOSEDGE*/ }
4474/*CMOSEDGE*/ }
4475/*CMOSEDGE*/ else
4476/*CMOSEDGE*/ { /* ARFCN : 170~201 */
4477/*CMOSEDGE*/ Nfrac = (arfcn-170)*258111+129056;
4478/*CMOSEDGE*/ *rfN = (135L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4479/*CMOSEDGE*/ }
4480/*CMOSEDGE*/ }
4481/*CMOSEDGE*/ else
4482/*CMOSEDGE*/ { if(arfcn<=234)
4483/*CMOSEDGE*/ { /* ARFCN : 202~234 */
4484/*CMOSEDGE*/ Nfrac = (arfcn-202)*258111;
4485/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4486/*CMOSEDGE*/ *rfN = (136L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4487/*CMOSEDGE*/ }
4488/*CMOSEDGE*/ else
4489/*CMOSEDGE*/ { /* ARFCN : 235~251 */
4490/*CMOSEDGE*/ Nfrac = (arfcn-235)*258111+129056;
4491/*CMOSEDGE*/ *rfN = (137L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4492/*CMOSEDGE*/ }
4493/*CMOSEDGE*/ }
4494/*CMOSEDGE*/ *ifN = (Nfrac>>10);
4495/*CMOSEDGE*/
4496/*CMOSEDGE*/ // Get GSM850 signal from GSM900 input pins if flag=1
4497/*CMOSEDGE*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN |=0x0010000L ;
4498/*CMOSEDGE*/ break;
4499/*CMOSEDGE*/ }
4500/*CMOSEDGE*/ case FrequencyBand900 :
4501/*CMOSEDGE*/ {
4502/*CMOSEDGE*/ if(arfcn<=124)
4503/*CMOSEDGE*/ { if(arfcn<=69)
4504/*CMOSEDGE*/ { if(arfcn<=37)
4505/*CMOSEDGE*/ { if(arfcn<=4)
4506/*CMOSEDGE*/ { /* ARFCN : 0~4 */
4507/*CMOSEDGE*/ Nfrac = arfcn*258111+7098053;
4508/*CMOSEDGE*/ *rfN = (143L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4509/*CMOSEDGE*/ }
4510/*CMOSEDGE*/ else
4511/*CMOSEDGE*/ { /* ARFCN : 5~37 */
4512/*CMOSEDGE*/ Nfrac = (arfcn-5)*258111;
4513/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4514/*CMOSEDGE*/ *rfN = (144L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4515/*CMOSEDGE*/ }
4516/*CMOSEDGE*/ }
4517/*CMOSEDGE*/ else
4518/*CMOSEDGE*/ { /* ARFCN : 38~69 */
4519/*CMOSEDGE*/ Nfrac = (arfcn-38)*258111+129056;
4520/*CMOSEDGE*/ *rfN = (145L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4521/*CMOSEDGE*/ }
4522/*CMOSEDGE*/ }
4523/*CMOSEDGE*/ else
4524/*CMOSEDGE*/ { if(arfcn<=102)
4525/*CMOSEDGE*/ { /* ARFCN : 70~102 */
4526/*CMOSEDGE*/ Nfrac = (arfcn-70)*258111;
4527/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4528/*CMOSEDGE*/ *rfN = (146L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4529/*CMOSEDGE*/ }
4530/*CMOSEDGE*/ else
4531/*CMOSEDGE*/ { /* ARFCN : 103~124 */
4532/*CMOSEDGE*/ Nfrac = (arfcn-103)*258111+129056;
4533/*CMOSEDGE*/ *rfN = (147L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4534/*CMOSEDGE*/ }
4535/*CMOSEDGE*/ }
4536/*CMOSEDGE*/ }
4537/*CMOSEDGE*/ else
4538/*CMOSEDGE*/ { if(arfcn<=996)
4539/*CMOSEDGE*/ { /* ARFCN : 975~996 */
4540/*CMOSEDGE*/ Nfrac = (arfcn-975)*258111+2839221;
4541/*CMOSEDGE*/ *rfN = (142L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4542/*CMOSEDGE*/ }
4543/*CMOSEDGE*/ else
4544/*CMOSEDGE*/ { /* ARFCN : 997~1023 */
4545/*CMOSEDGE*/ Nfrac = (arfcn-997)*258111+129056;
4546/*CMOSEDGE*/ *rfN = (143L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4547/*CMOSEDGE*/ }
4548/*CMOSEDGE*/ }
4549/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0010000L;
4550/*CMOSEDGE*/
4551/*CMOSEDGE*/ // Get GSM900 signal from GSM850 input pins if flag=1
4552/*CMOSEDGE*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN &= (~(0x0010000L));
4553/*CMOSEDGE*/ break;
4554/*CMOSEDGE*/ }
4555/*CMOSEDGE*/ case FrequencyBand1800 :
4556/*CMOSEDGE*/ {
4557/*CMOSEDGE*/ if(arfcn<=715)
4558/*CMOSEDGE*/ { if(arfcn<=585)
4559/*CMOSEDGE*/ { if(arfcn<=520)
4560/*CMOSEDGE*/ { /* ARFCN : 512~520 */
4561/*CMOSEDGE*/ Nfrac=((arfcn-512)&0x1) ? ((arfcn-513)>>1)*258111+7356164:((arfcn-512)>>1)*258111+7227108;
4562/*CMOSEDGE*/ *rfN = (138L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4563/*CMOSEDGE*/ }
4564/*CMOSEDGE*/ else
4565/*CMOSEDGE*/ { /* ARFCN : 521~585 */
4566/*CMOSEDGE*/ Nfrac=((arfcn-521)&0x1) ? ((arfcn-522)>>1)*258111+129056:((arfcn-521)>>1)*258111;
4567/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4568/*CMOSEDGE*/ *rfN = (139L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4569/*CMOSEDGE*/ }
4570/*CMOSEDGE*/ }
4571/*CMOSEDGE*/ else
4572/*CMOSEDGE*/ { if(arfcn<=650)
4573/*CMOSEDGE*/ { /* ARFCN : 586~650 */
4574/*CMOSEDGE*/ Nfrac=((arfcn-586)&0x1) ? ((arfcn-587)>>1)*258111+129056:((arfcn-586)>>1)*258111;
4575/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4576/*CMOSEDGE*/ *rfN = (140L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4577/*CMOSEDGE*/ }
4578/*CMOSEDGE*/ else
4579/*CMOSEDGE*/ { /* ARFCN : 651~715 */
4580/*CMOSEDGE*/ Nfrac=((arfcn-651)&0x1) ? ((arfcn-652)>>1)*258111+129056:((arfcn-651)>>1)*258111;
4581/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4582/*CMOSEDGE*/ *rfN = (141L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4583/*CMOSEDGE*/ }
4584/*CMOSEDGE*/ }
4585/*CMOSEDGE*/ }
4586/*CMOSEDGE*/ else
4587/*CMOSEDGE*/ { if(arfcn<=845)
4588/*CMOSEDGE*/ { if(arfcn<=780)
4589/*CMOSEDGE*/ { /* ARFCN : 716~780 */
4590/*CMOSEDGE*/ Nfrac=((arfcn-716)&0x1) ? ((arfcn-717)>>1)*258111+129056:((arfcn-716)>>1)*258111;
4591/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4592/*CMOSEDGE*/ *rfN = (142L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4593/*CMOSEDGE*/ }
4594/*CMOSEDGE*/ else
4595/*CMOSEDGE*/ { /* ARFCN : 781~845 */
4596/*CMOSEDGE*/ Nfrac=((arfcn-781)&0x1) ? ((arfcn-782)>>1)*258111+129056:((arfcn-781)>>1)*258111;
4597/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4598/*CMOSEDGE*/ *rfN = (143L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4599/*CMOSEDGE*/ }
4600/*CMOSEDGE*/ }
4601/*CMOSEDGE*/ else
4602/*CMOSEDGE*/ { /* ARFCN : 846~885 */
4603/*CMOSEDGE*/ Nfrac=((arfcn-846)&0x1) ? ((arfcn-847)>>1)*258111+129056:((arfcn-846)>>1)*258111;
4604/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4605/*CMOSEDGE*/ *rfN = (144L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4606/*CMOSEDGE*/ }
4607/*CMOSEDGE*/ }
4608/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0020000L;
4609/*CMOSEDGE*/
4610/*CMOSEDGE*/ // Get PCS1900 signal from DCS1800 input pins if flag=1
4611/*CMOSEDGE*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *ifN |=0x0010000L ;
4612/*CMOSEDGE*/ break;
4613/*CMOSEDGE*/ }
4614/*CMOSEDGE*/ case FrequencyBand1900 :
4615/*CMOSEDGE*/ {
4616/*CMOSEDGE*/ if(arfcn<=675)
4617/*CMOSEDGE*/ { if(arfcn<=610)
4618/*CMOSEDGE*/ { if(arfcn<=545)
4619/*CMOSEDGE*/ { /* ARFCN : 512~545 */
4620/*CMOSEDGE*/ Nfrac=((arfcn-512)&0x1) ? ((arfcn-513)>>1)*258111+4129776:((arfcn-512)>>1)*258111+4000721;
4621/*CMOSEDGE*/ *rfN = (148L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4622/*CMOSEDGE*/ }
4623/*CMOSEDGE*/ else
4624/*CMOSEDGE*/ { /* ARFCN : 546~610 */
4625/*CMOSEDGE*/ Nfrac=((arfcn-546)&0x1) ? ((arfcn-547)>>1)*258111+129056:((arfcn-546)>>1)*258111;;
4626/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4627/*CMOSEDGE*/ *rfN = (149L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4628/*CMOSEDGE*/ }
4629/*CMOSEDGE*/ }
4630/*CMOSEDGE*/ else
4631/*CMOSEDGE*/ { /* ARFCN : 611~675 */
4632/*CMOSEDGE*/ Nfrac=((arfcn-611)&0x1) ? ((arfcn-612)>>1)*258111+129056:((arfcn-611)>>1)*258111;
4633/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4634/*CMOSEDGE*/ *rfN = (150L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4635/*CMOSEDGE*/ }
4636/*CMOSEDGE*/ }
4637/*CMOSEDGE*/ else
4638/*CMOSEDGE*/ { if(arfcn<=805)
4639/*CMOSEDGE*/ { if(arfcn<=740)
4640/*CMOSEDGE*/ { /* ARFCN : 676~740 */
4641/*CMOSEDGE*/ Nfrac=((arfcn-676)&0x1) ? ((arfcn-677)>>1)*258111+129056:((arfcn-676)>>1)*258111;
4642/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4643/*CMOSEDGE*/ *rfN = (151L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4644/*CMOSEDGE*/ }
4645/*CMOSEDGE*/ else
4646/*CMOSEDGE*/ { /* ARFCN : 741~805 */
4647/*CMOSEDGE*/ Nfrac=((arfcn-741)&0x1) ? ((arfcn-742)>>1)*258111+129056:((arfcn-741)>>1)*258111;
4648/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4649/*CMOSEDGE*/ *rfN = (152L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4650/*CMOSEDGE*/ }
4651/*CMOSEDGE*/ }
4652/*CMOSEDGE*/ else
4653/*CMOSEDGE*/ { /* ARFCN : 806~810 */
4654/*CMOSEDGE*/ Nfrac=((arfcn-806)&0x1) ? ((arfcn-807)>>1)*258111+129056:((arfcn-806)>>1)*258111;
4655/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4656/*CMOSEDGE*/ *rfN = (153L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4657/*CMOSEDGE*/ }
4658/*CMOSEDGE*/ }
4659/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0030000L;
4660/*CMOSEDGE*/
4661/*CMOSEDGE*/ // Get DCS1800 signal from PCS1900 input pins if flag=1
4662/*CMOSEDGE*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *ifN &= (~(0x0010000L));
4663/*CMOSEDGE*/ break;
4664/*CMOSEDGE*/ }
4665/*CMOSEDGE*/ default :
4666/*CMOSEDGE*/ {
4667/*CMOSEDGE*/ break;
4668/*CMOSEDGE*/ }
4669/*CMOSEDGE*/ }
4670/*CMOSEDGE*/}
4671/*CMOSEDGE*//* =========================================================================== */
4672/*CMOSEDGE*/
4673/*CMOSEDGE*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4674/*CMOSEDGE*/{ int Nfrac;
4675/*CMOSEDGE*/ switch(rf_band)
4676/*CMOSEDGE*/ {
4677/*CMOSEDGE*/ case FrequencyBand850 :
4678/*CMOSEDGE*/ {
4679/*CMOSEDGE*/ if(arfcn<=199)
4680/*CMOSEDGE*/ { if(arfcn<=166)
4681/*CMOSEDGE*/ { if(arfcn<=134)
4682/*CMOSEDGE*/ { /* ARFCN : 128~134 */
4683/*CMOSEDGE*/ Nfrac = (arfcn-128)*258111+6710886;
4684/*CMOSEDGE*/ *rfN = (126L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4685/*CMOSEDGE*/ }
4686/*CMOSEDGE*/ else
4687/*CMOSEDGE*/ { /* ARFCN : 135~166 */
4688/*CMOSEDGE*/ Nfrac = (arfcn-135)*258111+129056;
4689/*CMOSEDGE*/ *rfN = (127L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4690/*CMOSEDGE*/ }
4691/*CMOSEDGE*/ }
4692/*CMOSEDGE*/ else
4693/*CMOSEDGE*/ { /* ARFCN : 167~199 */
4694/*CMOSEDGE*/ Nfrac = (arfcn-167)*258111;
4695/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4696/*CMOSEDGE*/ *rfN = (128L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4697/*CMOSEDGE*/ }
4698/*CMOSEDGE*/ }
4699/*CMOSEDGE*/ else
4700/*CMOSEDGE*/ { if(arfcn<=231)
4701/*CMOSEDGE*/ { /* ARFCN : 200~231 */
4702/*CMOSEDGE*/ Nfrac = (arfcn-200)*258111+129056;
4703/*CMOSEDGE*/ *rfN = (129L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4704/*CMOSEDGE*/ }
4705/*CMOSEDGE*/ else
4706/*CMOSEDGE*/ { /* ARFCN : 232~251 */
4707/*CMOSEDGE*/ Nfrac = (arfcn-232)*258111;
4708/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4709/*CMOSEDGE*/ *rfN = (130L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4710/*CMOSEDGE*/ }
4711/*CMOSEDGE*/ }
4712/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0040000L |(arfcn<<20);
4713/*CMOSEDGE*/
4714/*CMOSEDGE*/ break;
4715/*CMOSEDGE*/ }
4716/*CMOSEDGE*/ case FrequencyBand900 :
4717/*CMOSEDGE*/ {
4718/*CMOSEDGE*/ if(arfcn<=124)
4719/*CMOSEDGE*/ { if(arfcn<=67)
4720/*CMOSEDGE*/ { if(arfcn<=34)
4721/*CMOSEDGE*/ { if(arfcn<=2)
4722/*CMOSEDGE*/ { /* ARFCN : 0~2 */
4723/*CMOSEDGE*/ Nfrac =arfcn*258111+7743330;
4724/*CMOSEDGE*/ *rfN = (136L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4725/*CMOSEDGE*/ }
4726/*CMOSEDGE*/ else
4727/*CMOSEDGE*/ { /* ARFCN : 3~34 */
4728/*CMOSEDGE*/ Nfrac =(arfcn-3)*258111+129056;
4729/*CMOSEDGE*/ *rfN = (137L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4730/*CMOSEDGE*/ }
4731/*CMOSEDGE*/ }
4732/*CMOSEDGE*/ else
4733/*CMOSEDGE*/ { /* ARFCN : 35~67 */
4734/*CMOSEDGE*/ Nfrac =(arfcn-35)*258111;
4735/*CMOSEDGE*/ // if (Nfrac==0) Nfrac=1;
4736/*CMOSEDGE*/ *rfN = (138L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4737/*CMOSEDGE*/ }
4738/*CMOSEDGE*/ }
4739/*CMOSEDGE*/ else
4740/*CMOSEDGE*/ { if(arfcn<=99)
4741/*CMOSEDGE*/ { /* ARFCN : 68~99 */
4742/*CMOSEDGE*/ Nfrac =(arfcn-68)*258111+129056;
4743/*CMOSEDGE*/ *rfN = (139L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4744/*CMOSEDGE*/ }
4745/*CMOSEDGE*/ else
4746/*CMOSEDGE*/ { /* ARFCN : 100~124 */
4747/*CMOSEDGE*/ Nfrac =(arfcn-100)*258111;
4748/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4749/*CMOSEDGE*/ *rfN = (140L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4750/*CMOSEDGE*/ }
4751/*CMOSEDGE*/ }
4752/*CMOSEDGE*/ }
4753/*CMOSEDGE*/ else
4754/*CMOSEDGE*/ { if(arfcn<=993)
4755/*CMOSEDGE*/ { /* ARFCN : 975~993 */
4756/*CMOSEDGE*/ Nfrac = (arfcn-975)*258111+3484499;
4757/*CMOSEDGE*/ *rfN = (135L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4758/*CMOSEDGE*/ }
4759/*CMOSEDGE*/ else
4760/*CMOSEDGE*/ { /* ARFCN : 994~1023 */
4761/*CMOSEDGE*/ Nfrac = (arfcn-994)*258111;
4762/*CMOSEDGE*/ // if (Nfrac==0) Nfrac=1;
4763/*CMOSEDGE*/ *rfN = (136L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4764/*CMOSEDGE*/ }
4765/*CMOSEDGE*/ }
4766/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0050000L |(arfcn<<20);
4767/*CMOSEDGE*/
4768/*CMOSEDGE*/ break;
4769/*CMOSEDGE*/ }
4770/*CMOSEDGE*/ case FrequencyBand1800 :
4771/*CMOSEDGE*/ {
4772/*CMOSEDGE*/ if(arfcn<=735)
4773/*CMOSEDGE*/ { if(arfcn<=605)
4774/*CMOSEDGE*/ { if(arfcn<=540)
4775/*CMOSEDGE*/ { /* ARFCN : 512~540 */
4776/*CMOSEDGE*/ Nfrac=((arfcn-512)&0x1) ? ((arfcn-513)>>1)*258111+4775054:((arfcn-512)>>1)*258111+4645998;
4777/*CMOSEDGE*/ *rfN = (131L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4778/*CMOSEDGE*/ }
4779/*CMOSEDGE*/ else
4780/*CMOSEDGE*/ { /* ARFCN : 541~605 */
4781/*CMOSEDGE*/ Nfrac=((arfcn-541)&0x1) ? ((arfcn-542)>>1)*258111+129056:((arfcn-541)>>1)*258111;
4782/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4783/*CMOSEDGE*/ *rfN = (132L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4784/*CMOSEDGE*/ }
4785/*CMOSEDGE*/ }
4786/*CMOSEDGE*/ else
4787/*CMOSEDGE*/ { if(arfcn<=670)
4788/*CMOSEDGE*/ { /* ARFCN : 606~670 */
4789/*CMOSEDGE*/ Nfrac=((arfcn-606)&0x1) ? ((arfcn-607)>>1)*258111+129056:((arfcn-606)>>1)*258111;
4790/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4791/*CMOSEDGE*/ *rfN = (133L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4792/*CMOSEDGE*/ }
4793/*CMOSEDGE*/ else
4794/*CMOSEDGE*/ { /* ARFCN : 671~735 */
4795/*CMOSEDGE*/ Nfrac=((arfcn-671)&0x1) ? ((arfcn-672)>>1)*258111+129056:((arfcn-671)>>1)*258111;
4796/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4797/*CMOSEDGE*/ *rfN = (134L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4798/*CMOSEDGE*/ }
4799/*CMOSEDGE*/ }
4800/*CMOSEDGE*/ }
4801/*CMOSEDGE*/ else
4802/*CMOSEDGE*/ { if(arfcn<=865)
4803/*CMOSEDGE*/ { if(arfcn<=800)
4804/*CMOSEDGE*/ { /* ARFCN : 736~800 */
4805/*CMOSEDGE*/ Nfrac=((arfcn-736)&0x1) ? ((arfcn-737)>>1)*258111+129056:((arfcn-736)>>1)*258111;
4806/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4807/*CMOSEDGE*/ *rfN = (135L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4808/*CMOSEDGE*/ }
4809/*CMOSEDGE*/ else
4810/*CMOSEDGE*/ { /* ARFCN : 801~865 */
4811/*CMOSEDGE*/ Nfrac=((arfcn-801)&0x1) ? ((arfcn-802)>>1)*258111+129056:((arfcn-801)>>1)*258111;
4812/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4813/*CMOSEDGE*/ *rfN = (136L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4814/*CMOSEDGE*/ }
4815/*CMOSEDGE*/ }
4816/*CMOSEDGE*/ else
4817/*CMOSEDGE*/ { /* ARFCN : 866~885 */
4818/*CMOSEDGE*/ Nfrac=((arfcn-866)&0x1) ? ((arfcn-867)>>1)*258111+129056:((arfcn-866)>>1)*258111;
4819/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4820/*CMOSEDGE*/ *rfN = (137L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4821/*CMOSEDGE*/ }
4822/*CMOSEDGE*/ }
4823/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0060000L |(arfcn<<20);
4824/*CMOSEDGE*/
4825/*CMOSEDGE*/ break;
4826/*CMOSEDGE*/ }
4827/*CMOSEDGE*/ case FrequencyBand1900 :
4828/*CMOSEDGE*/ {
4829/*CMOSEDGE*/ if(arfcn<=685)
4830/*CMOSEDGE*/ { if(arfcn<=620)
4831/*CMOSEDGE*/ { if(arfcn<=555)
4832/*CMOSEDGE*/ { /* ARFCN : 512~555 */
4833/*CMOSEDGE*/ Nfrac=((arfcn-512)&0x1) ? ((arfcn-513)>>1)*258111+2839221:((arfcn-512)>>1)*258111+2710166;
4834/*CMOSEDGE*/ *rfN = (142L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4835/*CMOSEDGE*/ }
4836/*CMOSEDGE*/ else
4837/*CMOSEDGE*/ { /* ARFCN : 556~620 */
4838/*CMOSEDGE*/ Nfrac=((arfcn-556)&0x1) ? ((arfcn-557)>>1)*258111+129056:((arfcn-556)>>1)*258111;
4839/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4840/*CMOSEDGE*/ *rfN = (143L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4841/*CMOSEDGE*/ }
4842/*CMOSEDGE*/ }
4843/*CMOSEDGE*/ else
4844/*CMOSEDGE*/ { /* ARFCN : 621~685 */
4845/*CMOSEDGE*/ Nfrac=((arfcn-621)&0x1) ? ((arfcn-622)>>1)*258111+129056:((arfcn-621)>>1)*258111;
4846/*CMOSEDGE*/ //if (Nfrac==0) Nfrac=1;
4847/*CMOSEDGE*/ *rfN = (144L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4848/*CMOSEDGE*/ }
4849/*CMOSEDGE*/ }
4850/*CMOSEDGE*/ else
4851/*CMOSEDGE*/ { if(arfcn<=750)
4852/*CMOSEDGE*/ { /* ARFCN : 686~750 */
4853/*CMOSEDGE*/ Nfrac=((arfcn-686)&0x1) ? ((arfcn-687)>>1)*258111+129056:((arfcn-686)>>1)*258111;
4854/*CMOSEDGE*/ // if (Nfrac==0) Nfrac=1;
4855/*CMOSEDGE*/ *rfN = (145L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4856/*CMOSEDGE*/ }
4857/*CMOSEDGE*/ else
4858/*CMOSEDGE*/ { /* ARFCN : 751~810 */
4859/*CMOSEDGE*/ Nfrac=((arfcn-751)&0x1) ? ((arfcn-752)>>1)*258111+129056:((arfcn-751)>>1)*258111;
4860/*CMOSEDGE*/ // if (Nfrac==0) Nfrac=1;
4861/*CMOSEDGE*/ *rfN = (146L<<10) | (Nfrac&0x3FF) | 0x0100000L;
4862/*CMOSEDGE*/ }
4863/*CMOSEDGE*/ }
4864/*CMOSEDGE*/ *ifN = (Nfrac>>10) | 0x0070000L |(arfcn<<20);
4865/*CMOSEDGE*/
4866/*CMOSEDGE*/ break;
4867/*CMOSEDGE*/ }
4868/*CMOSEDGE*/ default :
4869/*CMOSEDGE*/ {
4870/*CMOSEDGE*/ break;
4871/*CMOSEDGE*/ }
4872/*CMOSEDGE*/ }
4873/*CMOSEDGE*/}
4874/*CMOSEDGE*//* =========================================================================== */
4875#endif
4876
4877#if IS_RF_MTKSOC1T
4878/*MTKSOC1T*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
4879/*MTKSOC1T*/{
4880/*MTKSOC1T*/ int Nfrac, SDM_IFM = 1, OPLL_DIV4O5_DIV4 = 0;
4881/*MTKSOC1T*/ long cw27 =0;
4882/*MTKSOC1T*/ switch(rf_band)
4883/*MTKSOC1T*/ {
4884/*MTKSOC1T*/ case FrequencyBand850 :
4885/*MTKSOC1T*/ {
4886/*MTKSOC1T*/ if(arfcn<=189)
4887/*MTKSOC1T*/ {
4888/*MTKSOC1T*/ if(arfcn<=160)
4889/*MTKSOC1T*/ {
4890/*MTKSOC1T*/ if(arfcn<=131)
4891/*MTKSOC1T*/ { /* ARFCN : 128~131 */
4892/*MTKSOC1T*/ Nfrac = (arfcn-128)*286790 + 7456540;
4893/*MTKSOC1T*/ *rfN = (140L<<10); /* N_INT[7:0]*/
4894/*MTKSOC1T*/ }
4895/*MTKSOC1T*/ else
4896/*MTKSOC1T*/ { /* ARFCN : 132~160 */
4897/*MTKSOC1T*/ Nfrac = (arfcn-132)*286790 + 215093;
4898/*MTKSOC1T*/ *rfN = (141L<<10); /* N_INT[7:0]*/
4899/*MTKSOC1T*/ }
4900/*MTKSOC1T*/ }
4901/*MTKSOC1T*/ else
4902/*MTKSOC1T*/ { /* ARFCN : 161~189 */
4903/*MTKSOC1T*/ Nfrac = (arfcn-161)*286790 + 143395;
4904/*MTKSOC1T*/ *rfN = (142L<<10); /* N_INT[7:0]*/
4905/*MTKSOC1T*/ }
4906/*MTKSOC1T*/ }
4907/*MTKSOC1T*/ else
4908/*MTKSOC1T*/ {
4909/*MTKSOC1T*/ if(arfcn<=218)
4910/*MTKSOC1T*/ { /* ARFCN : 190~218 */
4911/*MTKSOC1T*/ Nfrac = (arfcn-190)*286790 + 71698;
4912/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
4913/*MTKSOC1T*/ }
4914/*MTKSOC1T*/ else
4915/*MTKSOC1T*/ {
4916/*MTKSOC1T*/ if(arfcn<=248)
4917/*MTKSOC1T*/ { /* ARFCN : 219~248 */
4918/*MTKSOC1T*/ Nfrac = (arfcn-219)*286790;
4919/*MTKSOC1T*/ *rfN = (144L<<10); /* N_INT[7:0]*/
4920/*MTKSOC1T*/
4921/*MTKSOC1T*/ if(arfcn == 219)
4922/*MTKSOC1T*/ SDM_IFM = 0;
4923/*MTKSOC1T*/ }
4924/*MTKSOC1T*/ else
4925/*MTKSOC1T*/ { /* ARFCN : 249~251 */
4926/*MTKSOC1T*/ Nfrac = (arfcn-249)*286790 + 215093;
4927/*MTKSOC1T*/ *rfN = (145L<<10); /* N_INT[7:0]*/
4928/*MTKSOC1T*/ }
4929/*MTKSOC1T*/ }
4930/*MTKSOC1T*/ }
4931/*MTKSOC1T*/
4932/*MTKSOC1T*/ *ifN = (Nfrac>>10) | 0x0242000L; /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
4933/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
4934/*MTKSOC1T*/
4935/*MTKSOC1T*/ break;
4936/*MTKSOC1T*/ }
4937/*MTKSOC1T*/ case FrequencyBand900 :
4938/*MTKSOC1T*/ {
4939/*MTKSOC1T*/ if(arfcn<=112)
4940/*MTKSOC1T*/ {
4941/*MTKSOC1T*/ if(arfcn<=54)
4942/*MTKSOC1T*/ {
4943/*MTKSOC1T*/ if(arfcn<=25)
4944/*MTKSOC1T*/ { /* ARFCN : 0~25 */
4945/*MTKSOC1T*/ Nfrac = (arfcn)*286790 + 1147160;
4946/*MTKSOC1T*/ *rfN = (152L<<10); /* N_INT[7:0]*/
4947/*MTKSOC1T*/ }
4948/*MTKSOC1T*/ else
4949/*MTKSOC1T*/ { /* ARFCN : 26~54 */
4950/*MTKSOC1T*/ Nfrac = (arfcn-26)*286790 + 215093;
4951/*MTKSOC1T*/ *rfN = (153L<<10); /* N_INT[7:0]*/
4952/*MTKSOC1T*/ }
4953/*MTKSOC1T*/ }
4954/*MTKSOC1T*/ else
4955/*MTKSOC1T*/ {
4956/*MTKSOC1T*/ if(arfcn<=83)
4957/*MTKSOC1T*/ { /* ARFCN : 55~83 */
4958/*MTKSOC1T*/ Nfrac = (arfcn-55)*286790 + 143395;
4959/*MTKSOC1T*/ *rfN = (154L<<10); /* N_INT[7:0]*/
4960/*MTKSOC1T*/ }
4961/*MTKSOC1T*/ else
4962/*MTKSOC1T*/ { /* ARFCN : 84~112 */
4963/*MTKSOC1T*/ Nfrac = (arfcn-84)*286790 + 71698;
4964/*MTKSOC1T*/ *rfN = (155L<<10); /* N_INT[7:0]*/
4965/*MTKSOC1T*/ }
4966/*MTKSOC1T*/ }
4967/*MTKSOC1T*/ }
4968/*MTKSOC1T*/ else
4969/*MTKSOC1T*/ {
4970/*MTKSOC1T*/ if(arfcn<=990)
4971/*MTKSOC1T*/ {
4972/*MTKSOC1T*/ if(arfcn<=124)
4973/*MTKSOC1T*/ { /* ARFCN : 113~124 */
4974/*MTKSOC1T*/ Nfrac = (arfcn-113)*286790;
4975/*MTKSOC1T*/ *rfN = (156L<<10);
4976/*MTKSOC1T*/
4977/*MTKSOC1T*/ if(arfcn == 113)
4978/*MTKSOC1T*/ SDM_IFM = 0;
4979/*MTKSOC1T*/
4980/*MTKSOC1T*/ }
4981/*MTKSOC1T*/ else
4982/*MTKSOC1T*/ { /* ARFCN : 975~990 */
4983/*MTKSOC1T*/ Nfrac = (arfcn-975)*286790 + 3871665;
4984/*MTKSOC1T*/ *rfN = (150L<<10); /* N_INT[7:0]*/
4985/*MTKSOC1T*/ }
4986/*MTKSOC1T*/ }
4987/*MTKSOC1T*/ else
4988/*MTKSOC1T*/ {
4989/*MTKSOC1T*/ if(arfcn<=1019)
4990/*MTKSOC1T*/ { /* ARFCN : 991~1019 */
4991/*MTKSOC1T*/ Nfrac = (arfcn-991)*286790 + 71698;
4992/*MTKSOC1T*/ *rfN = (151L<<10); /* N_INT[7:0]*/
4993/*MTKSOC1T*/ }
4994/*MTKSOC1T*/ else
4995/*MTKSOC1T*/ { /* ARFCN : 1020~1023 */
4996/*MTKSOC1T*/ Nfrac = (arfcn-1020)*286790;
4997/*MTKSOC1T*/ *rfN = (152L<<10);
4998/*MTKSOC1T*/
4999/*MTKSOC1T*/ if(arfcn == 1020)
5000/*MTKSOC1T*/ SDM_IFM = 0;
5001/*MTKSOC1T*/ }
5002/*MTKSOC1T*/ }
5003/*MTKSOC1T*/ }
5004/*MTKSOC1T*/ *ifN = (Nfrac>>10) | 0x0252000L; /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
5005/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5006/*MTKSOC1T*/
5007/*MTKSOC1T*/ break;
5008/*MTKSOC1T*/ }
5009/*MTKSOC1T*/ case FrequencyBand1800 :
5010/*MTKSOC1T*/ {
5011/*MTKSOC1T*/ if(arfcn<=670)
5012/*MTKSOC1T*/ {
5013/*MTKSOC1T*/ if(arfcn<=603)
5014/*MTKSOC1T*/ {
5015/*MTKSOC1T*/ if(arfcn<=547)
5016/*MTKSOC1T*/ {
5017/*MTKSOC1T*/ if(arfcn<=541)
5018/*MTKSOC1T*/ { /* ARFCN : 512~541 */
5019/*MTKSOC1T*/ Nfrac = (arfcn-529)*135848 + 6316927;
5020/*MTKSOC1T*/ *rfN = (138L<<10); /* N_INT[7:0]*/
5021/*MTKSOC1T*/
5022/*MTKSOC1T*/ /*error compensation*/
5023/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 0, 0, 519, 529, 540, 542);
5024/*MTKSOC1T*/ /*End: error compensation*/
5025/*MTKSOC1T*/
5026/*MTKSOC1T*/ }
5027/*MTKSOC1T*/ else
5028/*MTKSOC1T*/ { /* ARFCN : 542~547 */
5029/*MTKSOC1T*/ Nfrac = (arfcn-542)*137659 + 6848546;
5030/*MTKSOC1T*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5031/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5032/*MTKSOC1T*/
5033/*MTKSOC1T*/ /*error compensation*/
5034/*MTKSOC1T*/ if(arfcn>=547)
5035/*MTKSOC1T*/ Nfrac++;
5036/*MTKSOC1T*/ /*End: error compensation*/
5037/*MTKSOC1T*/
5038/*MTKSOC1T*/ }
5039/*MTKSOC1T*/
5040/*MTKSOC1T*/ }
5041/*MTKSOC1T*/ else
5042/*MTKSOC1T*/ { /* ARFCN : 548~603 */
5043/*MTKSOC1T*/ Nfrac = (arfcn-581)*135848 + 4992410;
5044/*MTKSOC1T*/ *rfN = (139L<<10); /* N_INT[7:0]*/
5045/*MTKSOC1T*/
5046/*MTKSOC1T*/ /*error compensation*/
5047/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 550, 560, 570, 581, 591, 601);
5048/*MTKSOC1T*/ /*End: error compensation*/
5049/*MTKSOC1T*/
5050/*MTKSOC1T*/ }
5051/*MTKSOC1T*/ }
5052/*MTKSOC1T*/ else
5053/*MTKSOC1T*/ {
5054/*MTKSOC1T*/ if(arfcn<=665)
5055/*MTKSOC1T*/ {
5056/*MTKSOC1T*/ if(arfcn<=608)
5057/*MTKSOC1T*/ { /* ARFCN : 604~608 */
5058/*MTKSOC1T*/ Nfrac = (arfcn-604)*137659 + 6994809;
5059/*MTKSOC1T*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5060/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5061/*MTKSOC1T*/
5062/*MTKSOC1T*/ /*error compensation*/
5063/*MTKSOC1T*/ /*End: error compensation*/
5064/*MTKSOC1T*/ }
5065/*MTKSOC1T*/ else
5066/*MTKSOC1T*/ { /* ARFCN : 609~665 */
5067/*MTKSOC1T*/ Nfrac = (arfcn-643)*135848 + 5026372;
5068/*MTKSOC1T*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5069/*MTKSOC1T*/
5070/*MTKSOC1T*/ /*error compensation*/
5071/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 612, 622, 632, 643, 653, 663);
5072/*MTKSOC1T*/ /*End: error compensation*/
5073/*MTKSOC1T*/ }
5074/*MTKSOC1T*/ }
5075/*MTKSOC1T*/ else
5076/*MTKSOC1T*/ { /* ARFCN : 666~670 */
5077/*MTKSOC1T*/ Nfrac = (arfcn-666)*137659 + 7141071;
5078/*MTKSOC1T*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5079/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5080/*MTKSOC1T*/
5081/*MTKSOC1T*/ /*error compensation*/
5082/*MTKSOC1T*/ if(arfcn>=667)
5083/*MTKSOC1T*/ Nfrac++;
5084/*MTKSOC1T*/ /*End: error compensation*/
5085/*MTKSOC1T*/ }
5086/*MTKSOC1T*/ }
5087/*MTKSOC1T*/ }
5088/*MTKSOC1T*/ else
5089/*MTKSOC1T*/ {
5090/*MTKSOC1T*/ if(arfcn<=788)
5091/*MTKSOC1T*/ {
5092/*MTKSOC1T*/ if(arfcn<=732)
5093/*MTKSOC1T*/ {
5094/*MTKSOC1T*/ if(arfcn<=726)
5095/*MTKSOC1T*/ {/* ARFCN : 671~726 */
5096/*MTKSOC1T*/ Nfrac = (arfcn-704)*135848 + 4924486;
5097/*MTKSOC1T*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5098/*MTKSOC1T*/
5099/*MTKSOC1T*/ /*error compensation*/
5100/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 673, 684, 694, 704, 715, 725);
5101/*MTKSOC1T*/ /*End: error compensation*/
5102/*MTKSOC1T*/ }
5103/*MTKSOC1T*/ else
5104/*MTKSOC1T*/ {/*ARFCN:727~732*/
5105/*MTKSOC1T*/ Nfrac = (arfcn-727)*137659 + 7149675;
5106/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5107/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5108/*MTKSOC1T*/
5109/*MTKSOC1T*/ /*error compensation*/
5110/*MTKSOC1T*/ if(arfcn>=729)
5111/*MTKSOC1T*/ Nfrac++;
5112/*MTKSOC1T*/ /*End: error compensation*/
5113/*MTKSOC1T*/
5114/*MTKSOC1T*/ }
5115/*MTKSOC1T*/ }
5116/*MTKSOC1T*/ else
5117/*MTKSOC1T*/ {/*ARFCN:733~788*/
5118/*MTKSOC1T*/ Nfrac = (arfcn-766)*135848 + 4958448;
5119/*MTKSOC1T*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5120/*MTKSOC1T*/
5121/*MTKSOC1T*/ /*error compensation*/
5122/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 735, 745, 756, 766, 776, 786);
5123/*MTKSOC1T*/ /*End: error compensation*/
5124/*MTKSOC1T*/ }
5125/*MTKSOC1T*/ }
5126/*MTKSOC1T*/ else
5127/*MTKSOC1T*/ {
5128/*MTKSOC1T*/ if(arfcn<=850)
5129/*MTKSOC1T*/ {
5130/*MTKSOC1T*/ if(arfcn<=794)
5131/*MTKSOC1T*/ {/*ARFCN:789~794*/
5132/*MTKSOC1T*/ Nfrac = (arfcn-789)*137659 + 7295938;
5133/*MTKSOC1T*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5134/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5135/*MTKSOC1T*/
5136/*MTKSOC1T*/ /*error compensation*/
5137/*MTKSOC1T*/ if(arfcn>=792)
5138/*MTKSOC1T*/ Nfrac++;
5139/*MTKSOC1T*/ /*End: error compensation*/
5140/*MTKSOC1T*/ }
5141/*MTKSOC1T*/ else
5142/*MTKSOC1T*/ {/*ARFCN:795~850*/
5143/*MTKSOC1T*/ Nfrac = (arfcn-828)*135848 + 4992410;
5144/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5145/*MTKSOC1T*/ /*error compensation*/
5146/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 797, 806, 817, 828, 838, 848);
5147/*MTKSOC1T*/ /*End:*error compensation*/
5148/*MTKSOC1T*/ }
5149/*MTKSOC1T*/ }
5150/*MTKSOC1T*/ else
5151/*MTKSOC1T*/ {
5152/*MTKSOC1T*/ if(arfcn<=855)
5153/*MTKSOC1T*/ {/*ARFCN:851~855*/
5154/*MTKSOC1T*/ Nfrac = (arfcn-851)*137659 + 7442201;
5155/*MTKSOC1T*/ *rfN = (145L<<10); /* N_INT[7:0]*/
5156/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5157/*MTKSOC1T*/
5158/*MTKSOC1T*/ /*error compensation*/
5159/*MTKSOC1T*/ if(arfcn>=854)
5160/*MTKSOC1T*/ Nfrac++;
5161/*MTKSOC1T*/ /*End: error compensation*/
5162/*MTKSOC1T*/ }
5163/*MTKSOC1T*/ else
5164/*MTKSOC1T*/ {/*ARFCN:856~885*/
5165/*MTKSOC1T*/ Nfrac = (arfcn-869)*135848 + 2173566;
5166/*MTKSOC1T*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5167/*MTKSOC1T*/
5168/*MTKSOC1T*/ /*error compensation*/
5169/*MTKSOC1T*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 0, 0, 859, 869, 879, 885);
5170/*MTKSOC1T*/ /*End: error compensation*/
5171/*MTKSOC1T*/ }
5172/*MTKSOC1T*/ }
5173/*MTKSOC1T*/ }
5174/*MTKSOC1T*/ }
5175/*MTKSOC1T*/ *ifN = (Nfrac>>10) | 0x0262000L | (OPLL_DIV4O5_DIV4<<19); /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
5176/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x01C0000L); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5177/*MTKSOC1T*/ break;
5178/*MTKSOC1T*/ }
5179/*MTKSOC1T*/ case FrequencyBand1900 :
5180/*MTKSOC1T*/ {
5181/*MTKSOC1T*/ if(arfcn<=676)
5182/*MTKSOC1T*/ {
5183/*MTKSOC1T*/ if(arfcn<=546)
5184/*MTKSOC1T*/ {
5185/*MTKSOC1T*/ if(arfcn<=540)
5186/*MTKSOC1T*/ { /*ARFCN:512~540*/
5187/*MTKSOC1T*/ Nfrac = (arfcn-512)*122910 + 4578398;
5188/*MTKSOC1T*/ *rfN = (135L<<10); /* N_INT[7:0]*/
5189/*MTKSOC1T*/ }
5190/*MTKSOC1T*/ else
5191/*MTKSOC1T*/ { /*ARFCN:541~546*/
5192/*MTKSOC1T*/ Nfrac = (arfcn-541)*121464 + 3112515;
5193/*MTKSOC1T*/ *rfN = (134L<<10); /* N_INT[7:0]*/
5194/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5195/*MTKSOC1T*/ }
5196/*MTKSOC1T*/ }
5197/*MTKSOC1T*/ else
5198/*MTKSOC1T*/ {
5199/*MTKSOC1T*/ if(arfcn<=614)
5200/*MTKSOC1T*/ {
5201/*MTKSOC1T*/ if(arfcn<=608)
5202/*MTKSOC1T*/ { /*ARFCN:547~608*/
5203/*MTKSOC1T*/ Nfrac = (arfcn-547)*122910 + 491640;
5204/*MTKSOC1T*/ *rfN = (136L<<10); /* N_INT[7:0]*/
5205/*MTKSOC1T*/ }
5206/*MTKSOC1T*/ else
5207/*MTKSOC1T*/ { /*ARFCN:609~614*/
5208/*MTKSOC1T*/ Nfrac = (arfcn-609)*121464 + 2983460;
5209/*MTKSOC1T*/ *rfN = (135L<<10); /* N_INT[7:0]*/
5210/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5211/*MTKSOC1T*/ }
5212/*MTKSOC1T*/ }
5213/*MTKSOC1T*/ else
5214/*MTKSOC1T*/ { /*ARFCN:615~676*/
5215/*MTKSOC1T*/ Nfrac = (arfcn-615)*122910 + 460913;
5216/*MTKSOC1T*/ *rfN = (137L<<10); /* N_INT[7:0]*/
5217/*MTKSOC1T*/ }
5218/*MTKSOC1T*/ }
5219/*MTKSOC1T*/ }
5220/*MTKSOC1T*/ else
5221/*MTKSOC1T*/ {
5222/*MTKSOC1T*/ if(arfcn<=744)
5223/*MTKSOC1T*/ {
5224/*MTKSOC1T*/ if(arfcn<=682)
5225/*MTKSOC1T*/ {/*ARFCN:677~682*/
5226/*MTKSOC1T*/ Nfrac = (arfcn-677)*121464 + 2854404;
5227/*MTKSOC1T*/ *rfN = (136L<<10); /* N_INT[7:0]*/
5228/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5229/*MTKSOC1T*/ }
5230/*MTKSOC1T*/ else
5231/*MTKSOC1T*/ { /*ARFCN:683~744*/
5232/*MTKSOC1T*/ Nfrac = (arfcn-683)*122910 + 430185;
5233/*MTKSOC1T*/ *rfN = (138L<<10); /* N_INT[7:0]*/
5234/*MTKSOC1T*/ }
5235/*MTKSOC1T*/ }
5236/*MTKSOC1T*/ else
5237/*MTKSOC1T*/ {
5238/*MTKSOC1T*/ if(arfcn<=750)
5239/*MTKSOC1T*/ {/*ARFCN:745~750*/
5240/*MTKSOC1T*/ Nfrac = (arfcn-745)*121464 + 2725349;
5241/*MTKSOC1T*/ *rfN = (137L<<10); /* N_INT[7:0]*/
5242/*MTKSOC1T*/ OPLL_DIV4O5_DIV4 = 1;
5243/*MTKSOC1T*/ }
5244/*MTKSOC1T*/ else
5245/*MTKSOC1T*/ { /*ARFCN:751~810*/
5246/*MTKSOC1T*/ Nfrac = (arfcn-751)*122910 + 399458;
5247/*MTKSOC1T*/ *rfN = (139L<<10); /* N_INT[7:0]*/
5248/*MTKSOC1T*/ }
5249/*MTKSOC1T*/ }
5250/*MTKSOC1T*/ }
5251/*MTKSOC1T*/
5252/*MTKSOC1T*/ *ifN = (Nfrac>>10) | 0x0272000L | (OPLL_DIV4O5_DIV4<<19); /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
5253/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0140000L); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5254/*MTKSOC1T*/ break;
5255/*MTKSOC1T*/ }
5256/*MTKSOC1T*/ default :
5257/*MTKSOC1T*/ {
5258/*MTKSOC1T*/ break;
5259/*MTKSOC1T*/ }
5260/*MTKSOC1T*/ }
5261/*MTKSOC1T*/ /*For CW27*/
5262/*MTKSOC1T*/ L1D_RF_GetTX_SX_CAL_FBX_Setting(arfcn, rf_band, &cw27, MTKSOC1_SX_CAL_DMD_T, ((*ifN>>19) & 0x1) );
5263/*MTKSOC1T*/ *ifN |= ( ( cw27 & 0x7F) << 25);
5264/*MTKSOC1T*/ *rfN |= ( ((cw27>>7) & 0x3F) << 25);
5265/*MTKSOC1T*/}
5266/*MTKSOC1T*//* =============================================================== */
5267/*MTKSOC1T*/
5268/*MTKSOC1T*/void L1D_RF_Band1800_FrequecyFractionPartCompensation(int arfcn, int *Nfrac, short arfcn1, short arfcn2, short arfcn3, short arfcn4, short arfcn5, short arfcn6)
5269/*MTKSOC1T*/{
5270/*MTKSOC1T*/ if(arfcn<arfcn4)
5271/*MTKSOC1T*/ {
5272/*MTKSOC1T*/ if(arfcn<arfcn2)
5273/*MTKSOC1T*/ {
5274/*MTKSOC1T*/ if(arfcn<arfcn1)
5275/*MTKSOC1T*/ *Nfrac+=4;
5276/*MTKSOC1T*/ else
5277/*MTKSOC1T*/ *Nfrac+=3;
5278/*MTKSOC1T*/ }
5279/*MTKSOC1T*/ else
5280/*MTKSOC1T*/ {
5281/*MTKSOC1T*/ if(arfcn<arfcn3)
5282/*MTKSOC1T*/ *Nfrac+=2;
5283/*MTKSOC1T*/ else
5284/*MTKSOC1T*/ *Nfrac+=1;
5285/*MTKSOC1T*/ }
5286/*MTKSOC1T*/ }
5287/*MTKSOC1T*/ else if (arfcn>=arfcn5)
5288/*MTKSOC1T*/ {
5289/*MTKSOC1T*/ if(arfcn<arfcn6)
5290/*MTKSOC1T*/ {
5291/*MTKSOC1T*/ *Nfrac-=1;
5292/*MTKSOC1T*/ }
5293/*MTKSOC1T*/ else
5294/*MTKSOC1T*/ {
5295/*MTKSOC1T*/ *Nfrac-=2;
5296/*MTKSOC1T*/ }
5297/*MTKSOC1T*/ }
5298/*MTKSOC1T*/}
5299/*MTKSOC1T*/
5300/*MTKSOC1T*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
5301/*MTKSOC1T*/{
5302/*MTKSOC1T*/ int Nfrac, SDM_IFM = 1;
5303/*MTKSOC1T*/ long cw27 = 0;
5304/*MTKSOC1T*/ switch(rf_band)
5305/*MTKSOC1T*/ {
5306/*MTKSOC1T*/ case FrequencyBand850 :
5307/*MTKSOC1T*/ {
5308/*MTKSOC1T*/ if(arfcn<=201)
5309/*MTKSOC1T*/ {
5310/*MTKSOC1T*/ if(arfcn<=169)
5311/*MTKSOC1T*/ {
5312/*MTKSOC1T*/ if(arfcn<=136)
5313/*MTKSOC1T*/ {/*arfcn:128~136*/
5314/*MTKSOC1T*/ Nfrac = (arfcn-128)*258111 + 6065609;
5315/*MTKSOC1T*/ *rfN = (133L<<10); /* N_INT[7:0]*/
5316/*MTKSOC1T*/ }
5317/*MTKSOC1T*/ else
5318/*MTKSOC1T*/ {/*arfcn:137~169*/
5319/*MTKSOC1T*/ Nfrac = (arfcn-137)*258111;
5320/*MTKSOC1T*/ *rfN = (134L<<10); /* N_INT[7:0]*/
5321/*MTKSOC1T*/
5322/*MTKSOC1T*/ }
5323/*MTKSOC1T*/ }
5324/*MTKSOC1T*/ else
5325/*MTKSOC1T*/ {/*arfcn:170~201*/
5326/*MTKSOC1T*/ Nfrac = (arfcn-170)*258111+129056;
5327/*MTKSOC1T*/ *rfN = (135L<<10); /* N_INT[7:0]*/
5328/*MTKSOC1T*/ }
5329/*MTKSOC1T*/ }
5330/*MTKSOC1T*/ else
5331/*MTKSOC1T*/ {
5332/*MTKSOC1T*/ if(arfcn<=234)
5333/*MTKSOC1T*/ {/*arfcn:202~234*/
5334/*MTKSOC1T*/ Nfrac = (arfcn-202)*258111;
5335/*MTKSOC1T*/ *rfN = (136L<<10); /* N_INT[7:0]*/
5336/*MTKSOC1T*/ }
5337/*MTKSOC1T*/ else
5338/*MTKSOC1T*/ {/*arfcn:235~251*/
5339/*MTKSOC1T*/ Nfrac = (arfcn-235)*258111+129056;
5340/*MTKSOC1T*/ *rfN = (137L<<10); /* N_INT[7:0]*/
5341/*MTKSOC1T*/ }
5342/*MTKSOC1T*/ }
5343/*MTKSOC1T*/ *ifN = (Nfrac>>10)|0x0202000; /* CW2, TRX:0, BAND:0, MODE:1, N_RFC[22:10]*/
5344/*MTKSOC1T*/ if(Nfrac==0) SDM_IFM = 0;
5345/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5346/*MTKSOC1T*/
5347/*MTKSOC1T*/ // Get GSM850 signal from GSM900 input pins if flag=1
5348/*MTKSOC1T*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN |=0x0010000L ;
5349/*MTKSOC1T*/ break;
5350/*MTKSOC1T*/ }
5351/*MTKSOC1T*/ case FrequencyBand900 :
5352/*MTKSOC1T*/ {
5353/*MTKSOC1T*/ if(arfcn<=102)
5354/*MTKSOC1T*/ {
5355/*MTKSOC1T*/ if(arfcn<=37)
5356/*MTKSOC1T*/ {
5357/*MTKSOC1T*/ if(arfcn<=4)
5358/*MTKSOC1T*/ {/*arfcn:0~4*/
5359/*MTKSOC1T*/ Nfrac = (arfcn)*258111+7098053;
5360/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5361/*MTKSOC1T*/ }
5362/*MTKSOC1T*/ else
5363/*MTKSOC1T*/ {/*arfcn:5~37*/
5364/*MTKSOC1T*/ Nfrac = (arfcn-5)*258111;
5365/*MTKSOC1T*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5366/*MTKSOC1T*/ }
5367/*MTKSOC1T*/ }
5368/*MTKSOC1T*/ else
5369/*MTKSOC1T*/ {
5370/*MTKSOC1T*/ if(arfcn<=69)
5371/*MTKSOC1T*/ {/*arfcn:38~69*/
5372/*MTKSOC1T*/ Nfrac = (arfcn-38)*258111+129056;
5373/*MTKSOC1T*/ *rfN = (145L<<10); /* N_INT[7:0]*/
5374/*MTKSOC1T*/ }
5375/*MTKSOC1T*/ else
5376/*MTKSOC1T*/ {/*arfcn:70~102*/
5377/*MTKSOC1T*/ Nfrac = (arfcn-70)*258111;
5378/*MTKSOC1T*/ *rfN = (146L<<10); /* N_INT[7:0]*/
5379/*MTKSOC1T*/ }
5380/*MTKSOC1T*/ }
5381/*MTKSOC1T*/ }
5382/*MTKSOC1T*/ else
5383/*MTKSOC1T*/ {
5384/*MTKSOC1T*/ if(arfcn<=996)
5385/*MTKSOC1T*/ {
5386/*MTKSOC1T*/ if(arfcn<=124)
5387/*MTKSOC1T*/ {/*arfcn:103~124*/
5388/*MTKSOC1T*/ Nfrac = (arfcn-103)*258111+129056;
5389/*MTKSOC1T*/ *rfN = (147L<<10); /* N_INT[7:0]*/
5390/*MTKSOC1T*/ }
5391/*MTKSOC1T*/ else
5392/*MTKSOC1T*/ {/*arfcn:975~996*/
5393/*MTKSOC1T*/ Nfrac = (arfcn-975)*258111+2839221;
5394/*MTKSOC1T*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5395/*MTKSOC1T*/ }
5396/*MTKSOC1T*/ }
5397/*MTKSOC1T*/ else
5398/*MTKSOC1T*/ {/*arfcn:997~1023*/
5399/*MTKSOC1T*/ Nfrac = (arfcn-997)*258111+129056;
5400/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5401/*MTKSOC1T*/ }
5402/*MTKSOC1T*/ }
5403/*MTKSOC1T*/
5404/*MTKSOC1T*/ *ifN = (Nfrac>>10)|0x0212000; /* CW2, TRX:0, BAND:1, MODE:1, N_RFC[22:10]*/
5405/*MTKSOC1T*/
5406/*MTKSOC1T*/ if(Nfrac==0) SDM_IFM = 0;
5407/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5408/*MTKSOC1T*/
5409/*MTKSOC1T*/ // Get GSM900 signal from GSM850 input pins if flag=1
5410/*MTKSOC1T*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN &= (~(0x0010000L));
5411/*MTKSOC1T*/ break;
5412/*MTKSOC1T*/ }
5413/*MTKSOC1T*/ case FrequencyBand1800 :
5414/*MTKSOC1T*/ {
5415/*MTKSOC1T*/ if(arfcn<=715)
5416/*MTKSOC1T*/ {
5417/*MTKSOC1T*/ if(arfcn<=585)
5418/*MTKSOC1T*/ {
5419/*MTKSOC1T*/ if(arfcn<=520)
5420/*MTKSOC1T*/ {/*arfcn:512~520*/
5421/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 456);
5422/*MTKSOC1T*/ *rfN = (138L<<10); /* N_INT[7:0]*/
5423/*MTKSOC1T*/ }
5424/*MTKSOC1T*/ else
5425/*MTKSOC1T*/ {/*arfcn:521~585*/
5426/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 521);
5427/*MTKSOC1T*/ *rfN = (139L<<10); /* N_INT[7:0]*/
5428/*MTKSOC1T*/ }
5429/*MTKSOC1T*/ }
5430/*MTKSOC1T*/ else
5431/*MTKSOC1T*/ {
5432/*MTKSOC1T*/ if(arfcn<=650)
5433/*MTKSOC1T*/ {/*arfcn:586~650*/
5434/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 586);
5435/*MTKSOC1T*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5436/*MTKSOC1T*/ }
5437/*MTKSOC1T*/ else
5438/*MTKSOC1T*/ {/*arfcn:651~715*/
5439/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 651);
5440/*MTKSOC1T*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5441/*MTKSOC1T*/ }
5442/*MTKSOC1T*/ }
5443/*MTKSOC1T*/ }
5444/*MTKSOC1T*/ else
5445/*MTKSOC1T*/ {
5446/*MTKSOC1T*/ if(arfcn<=845)
5447/*MTKSOC1T*/ {
5448/*MTKSOC1T*/ if(arfcn<=780)
5449/*MTKSOC1T*/ {/*arfcn:716~780*/
5450/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 716);
5451/*MTKSOC1T*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5452/*MTKSOC1T*/ }
5453/*MTKSOC1T*/ else
5454/*MTKSOC1T*/ {/*arfcn:781~845*/
5455/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 781);
5456/*MTKSOC1T*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5457/*MTKSOC1T*/ }
5458/*MTKSOC1T*/ }
5459/*MTKSOC1T*/ else
5460/*MTKSOC1T*/ {/*arfcn:846~885*/
5461/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 846);
5462/*MTKSOC1T*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5463/*MTKSOC1T*/ }
5464/*MTKSOC1T*/ }
5465/*MTKSOC1T*/
5466/*MTKSOC1T*/
5467/*MTKSOC1T*/ *ifN = (Nfrac>>10)|0x0222000; /* CW2, TRX:0, BAND:2, MODE:1, N_RFC[22:10]*/
5468/*MTKSOC1T*/
5469/*MTKSOC1T*/ if(Nfrac==0) SDM_IFM = 0;
5470/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5471/*MTKSOC1T*/
5472/*MTKSOC1T*/ // Get PCS1900 signal from DCS1800 input pins if flag=1
5473/*MTKSOC1T*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *ifN |=0x0010000L ;
5474/*MTKSOC1T*/ break;
5475/*MTKSOC1T*/ }
5476/*MTKSOC1T*/ case FrequencyBand1900 :
5477/*MTKSOC1T*/ {
5478/*MTKSOC1T*/ if(arfcn<=675)
5479/*MTKSOC1T*/ {
5480/*MTKSOC1T*/ if(arfcn<=610)
5481/*MTKSOC1T*/ {
5482/*MTKSOC1T*/ if(arfcn<=545)
5483/*MTKSOC1T*/ {/*arfcn:512~545*/
5484/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 481);
5485/*MTKSOC1T*/ *rfN = (148L<<10); /* N_INT[7:0]*/
5486/*MTKSOC1T*/ }
5487/*MTKSOC1T*/ else
5488/*MTKSOC1T*/ {/*arfcn:546~610*/
5489/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 546);
5490/*MTKSOC1T*/ *rfN = (149L<<10); /* N_INT[7:0]*/
5491/*MTKSOC1T*/ }
5492/*MTKSOC1T*/ }
5493/*MTKSOC1T*/ else
5494/*MTKSOC1T*/ {/*arfcn:611~675*/
5495/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 611);
5496/*MTKSOC1T*/ *rfN = (150L<<10); /* N_INT[7:0]*/
5497/*MTKSOC1T*/ }
5498/*MTKSOC1T*/ }
5499/*MTKSOC1T*/ else
5500/*MTKSOC1T*/ {
5501/*MTKSOC1T*/ if(arfcn<=805)
5502/*MTKSOC1T*/ {
5503/*MTKSOC1T*/ if(arfcn<=740)
5504/*MTKSOC1T*/ {/*arfcn:676~740*/
5505/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 676);
5506/*MTKSOC1T*/ *rfN = (151L<<10); /* N_INT[7:0]*/
5507/*MTKSOC1T*/ }
5508/*MTKSOC1T*/ else
5509/*MTKSOC1T*/ {/*arfcn:741~805*/
5510/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 741);
5511/*MTKSOC1T*/ *rfN = (152L<<10); /* N_INT[7:0]*/
5512/*MTKSOC1T*/ }
5513/*MTKSOC1T*/ }
5514/*MTKSOC1T*/ else
5515/*MTKSOC1T*/ {/*arfcn:806~810*/
5516/*MTKSOC1T*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 806);
5517/*MTKSOC1T*/ *rfN = (153L<<10); /* N_INT[7:0]*/
5518/*MTKSOC1T*/ }
5519/*MTKSOC1T*/ }
5520/*MTKSOC1T*/
5521/*MTKSOC1T*/ *ifN = (Nfrac>>10)|0x0232000; /* CW2, TRX:0, BAND:2, MODE:1, N_RFC[22:10]*/
5522/*MTKSOC1T*/
5523/*MTKSOC1T*/ if(Nfrac==0) SDM_IFM = 0;
5524/*MTKSOC1T*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5525/*MTKSOC1T*/ // Get DCS1800 signal from PCS1900 input pins if flag=1
5526/*MTKSOC1T*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *ifN &= (~(0x0010000L));
5527/*MTKSOC1T*/ break;
5528/*MTKSOC1T*/ }
5529/*MTKSOC1T*/ default :
5530/*MTKSOC1T*/ {
5531/*MTKSOC1T*/ break;
5532/*MTKSOC1T*/ }
5533/*MTKSOC1T*/ }
5534/*MTKSOC1T*/ L1D_RF_GetRX_SX_CAL_FBX_Setting(arfcn, rf_band, &cw27, MTKSOC1_SX_CAL_DMD_T);
5535/*MTKSOC1T*/ *ifN |= ( ( cw27 & 0x7F) << 25);
5536/*MTKSOC1T*/ *rfN |= ( ((cw27>>7) & 0x3F) << 25);
5537/*MTKSOC1T*/}
5538/*MTKSOC1T*//* =============================================================== */
5539/*MTKSOC1T*/
5540/*MTKSOC1T*/void L1D_RF_GetRxPLL_HB_FractionPart(int *Nfrac, int arfcn, int arfcn_base)
5541/*MTKSOC1T*/{
5542/*MTKSOC1T*/ int Diff_arfcn;
5543/*MTKSOC1T*/
5544/*MTKSOC1T*/ Diff_arfcn = arfcn - arfcn_base;
5545/*MTKSOC1T*/ *Nfrac = (Diff_arfcn >>1) * 258111;
5546/*MTKSOC1T*/ if(Diff_arfcn & 0x1) *Nfrac += 129056;
5547/*MTKSOC1T*/}
5548/*MTKSOC1T*/
5549/*MTKSOC1T*//*output: CW27 */
5550/*MTKSOC1T*/void L1D_RF_GetRX_SX_CAL_FBX_Setting(int arfcn, int rf_band, long *cw27, short sx_cal_dmd_t)
5551/*MTKSOC1T*/{
5552/*MTKSOC1T*/ int N_sx_cal_fbx = 0;
5553/*MTKSOC1T*/ if( !MTKSOC1_SX_CALSBA )
5554/*MTKSOC1T*/ {
5555/*MTKSOC1T*/ *cw27 = 0;
5556/*MTKSOC1T*/ return;
5557/*MTKSOC1T*/ }
5558/*MTKSOC1T*/ if(sx_cal_dmd_t)
5559/*MTKSOC1T*/ {
5560/*MTKSOC1T*/ switch(rf_band)
5561/*MTKSOC1T*/ {
5562/*MTKSOC1T*/ case FrequencyBand850 :
5563/*MTKSOC1T*/ {
5564/*MTKSOC1T*/ N_sx_cal_fbx = 468 + arfcn;
5565/*MTKSOC1T*/ break;
5566/*MTKSOC1T*/ }
5567/*MTKSOC1T*/ case FrequencyBand900 :
5568/*MTKSOC1T*/ {
5569/*MTKSOC1T*/ if(arfcn<=124)
5570/*MTKSOC1T*/ N_sx_cal_fbx = 925 + arfcn;
5571/*MTKSOC1T*/ else
5572/*MTKSOC1T*/ N_sx_cal_fbx = -99 + arfcn;
5573/*MTKSOC1T*/
5574/*MTKSOC1T*/ break;
5575/*MTKSOC1T*/ }
5576/*MTKSOC1T*/ case FrequencyBand1800 :
5577/*MTKSOC1T*/ {
5578/*MTKSOC1T*/ N_sx_cal_fbx = 251- ( (arfcn-512)>>1 )+ arfcn;
5579/*MTKSOC1T*/ break;
5580/*MTKSOC1T*/ }
5581/*MTKSOC1T*/ case FrequencyBand1900 :
5582/*MTKSOC1T*/ {
5583/*MTKSOC1T*/ N_sx_cal_fbx = 564- ( (arfcn-511)>>1 )+ arfcn;
5584/*MTKSOC1T*/ break;
5585/*MTKSOC1T*/ }
5586/*MTKSOC1T*/ default:
5587/*MTKSOC1T*/ break;
5588/*MTKSOC1T*/ }
5589/*MTKSOC1T*/
5590/*MTKSOC1T*/ }
5591/*MTKSOC1T*/ else
5592/*MTKSOC1T*/ {
5593/*MTKSOC1T*/ switch(rf_band)
5594/*MTKSOC1T*/ {
5595/*MTKSOC1T*/ case FrequencyBand850 :
5596/*MTKSOC1T*/ {
5597/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 348+ 1+ arfcn - (arfcn-130 +5)/5 ); /* 1- 5/5 =0 */
5598/*MTKSOC1T*/ break;
5599/*MTKSOC1T*/ }
5600/*MTKSOC1T*/ case FrequencyBand900 :
5601/*MTKSOC1T*/ {
5602/*MTKSOC1T*/ if(arfcn<=124)
5603/*MTKSOC1T*/ {
5604/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 739+ 1+ arfcn -(arfcn-3+5)/5 ); /* 1- 5/5 =0 */
5605/*MTKSOC1T*/ }
5606/*MTKSOC1T*/ else
5607/*MTKSOC1T*/ {
5608/*MTKSOC1T*/ N_sx_cal_fbx = (int)( -275+ 1+ arfcn -(arfcn-977+5)/5 ); /* 1- 5/5 =0 */
5609/*MTKSOC1T*/ }
5610/*MTKSOC1T*/ break;
5611/*MTKSOC1T*/ }
5612/*MTKSOC1T*/ case FrequencyBand1800 :
5613/*MTKSOC1T*/ {
5614/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 98+ arfcn- ( (arfcn-512)/5 )*3 - ( ( (arfcn-512)%5 )>>1 ) );
5615/*MTKSOC1T*/ break;
5616/*MTKSOC1T*/ }
5617/*MTKSOC1T*/ case FrequencyBand1900 :
5618/*MTKSOC1T*/ {
5619/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 348+ arfcn- ( (arfcn-512)/5 )*3 - ( ( (arfcn-512)%5 )>>1 ) );
5620/*MTKSOC1T*/ break;
5621/*MTKSOC1T*/ }
5622/*MTKSOC1T*/ default:
5623/*MTKSOC1T*/ break;
5624/*MTKSOC1T*/ }
5625/*MTKSOC1T*/
5626/*MTKSOC1T*/ }
5627/*MTKSOC1T*/ *cw27 = 0x1b00001L | (N_sx_cal_fbx<<2) | (sx_cal_dmd_t<<1); /*CW27 | sx_cal_fbx | sx_cal_dmd_t | sx_calsba*/
5628/*MTKSOC1T*/}
5629/*MTKSOC1T*/
5630/*MTKSOC1T*//*output: CW27 */
5631/*MTKSOC1T*/void L1D_RF_GetTX_SX_CAL_FBX_Setting(int arfcn, int rf_band, long *cw27, short sx_cal_dmd_t, short OPLL_DIV4O5_DIV4)
5632/*MTKSOC1T*/{
5633/*MTKSOC1T*/ int N_sx_cal_fbx = 0;
5634/*MTKSOC1T*/ if(!MTKSOC1_SX_CALSBA)
5635/*MTKSOC1T*/ {
5636/*MTKSOC1T*/ *cw27 = 0;
5637/*MTKSOC1T*/ return;
5638/*MTKSOC1T*/ }
5639/*MTKSOC1T*/ if(sx_cal_dmd_t)
5640/*MTKSOC1T*/ {
5641/*MTKSOC1T*/ switch(rf_band)
5642/*MTKSOC1T*/ {
5643/*MTKSOC1T*/ case FrequencyBand850 :
5644/*MTKSOC1T*/ {
5645/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 702 -1 +arfcn +(arfcn-134 +9)/9 ); /* 1- 9/9 =0 */
5646/*MTKSOC1T*/ break;
5647/*MTKSOC1T*/ }
5648/*MTKSOC1T*/ case FrequencyBand900 :
5649/*MTKSOC1T*/ {
5650/*MTKSOC1T*/ if(arfcn<=124)
5651/*MTKSOC1T*/ {
5652/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 1195 -1 +arfcn +(arfcn-1+9)/9 ); /* 1- 9/9 =0 */
5653/*MTKSOC1T*/ }
5654/*MTKSOC1T*/ else
5655/*MTKSOC1T*/ {
5656/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 166 -1 +arfcn +(arfcn-980+9)/9 ); /* 1- 9/9 =0 */
5657/*MTKSOC1T*/ }
5658/*MTKSOC1T*/
5659/*MTKSOC1T*/ break;
5660/*MTKSOC1T*/ }
5661/*MTKSOC1T*/ case FrequencyBand1800 :
5662/*MTKSOC1T*/ {
5663/*MTKSOC1T*/ if(OPLL_DIV4O5_DIV4)
5664/*MTKSOC1T*/ N_sx_cal_fbx = (int) ((arfcn-512+8551)*2*16-3000*15*5+30)/(15*4); //DIV16
5665/*MTKSOC1T*/ else
5666/*MTKSOC1T*/ N_sx_cal_fbx = (int) ((arfcn-512+8551)*2*20-3000*19*5+38)/(19*4); //DIV20
5667/*MTKSOC1T*/ break;
5668/*MTKSOC1T*/ }
5669/*MTKSOC1T*/ case FrequencyBand1900 :
5670/*MTKSOC1T*/ {
5671/*MTKSOC1T*/ if(OPLL_DIV4O5_DIV4)
5672/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ( (arfcn-512+9251)*2*16 -3000*5*17 +34) /(4*17)); /* DIV16 (((Arfcn-512+1850.2*5)*2*16-3000*5*17+34)/(5*17*0.8)).*/
5673/*MTKSOC1T*/ else
5674/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ( (arfcn-512+9251)*2*20 -3000*5*21 +42) /(4*21)); //DIV20 =INT(((A5-512+1850.2*5)*2*20-3000*5*21+42)/(5*21*0.8))
5675/*MTKSOC1T*/ break;
5676/*MTKSOC1T*/ }
5677/*MTKSOC1T*/ default:
5678/*MTKSOC1T*/ break;
5679/*MTKSOC1T*/ }
5680/*MTKSOC1T*/
5681/*MTKSOC1T*/ }
5682/*MTKSOC1T*/ else
5683/*MTKSOC1T*/ {
5684/*MTKSOC1T*/ switch(rf_band)
5685/*MTKSOC1T*/ {
5686/*MTKSOC1T*/ case FrequencyBand850 :
5687/*MTKSOC1T*/ {
5688/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 534+ 1+ arfcn - (arfcn-134 +9)/9 ); /* 1- 9/9 =0 */
5689/*MTKSOC1T*/ break;
5690/*MTKSOC1T*/ }
5691/*MTKSOC1T*/ case FrequencyBand900 :
5692/*MTKSOC1T*/ {
5693/*MTKSOC1T*/ if(arfcn<=124)
5694/*MTKSOC1T*/ {
5695/*MTKSOC1T*/ N_sx_cal_fbx = (int)( 955+ 1+ arfcn -(arfcn-1+9)/9 ); /* 1- 9/9 =0 */
5696/*MTKSOC1T*/ }
5697/*MTKSOC1T*/ else
5698/*MTKSOC1T*/ {
5699/*MTKSOC1T*/ N_sx_cal_fbx = (int)( -64+ 1+ arfcn -(arfcn-980+9)/9 ); /* 1- 9/9 =0 */
5700/*MTKSOC1T*/ }
5701/*MTKSOC1T*/ break;
5702/*MTKSOC1T*/ }
5703/*MTKSOC1T*/ case FrequencyBand1800 :
5704/*MTKSOC1T*/ {
5705/*MTKSOC1T*/ if(OPLL_DIV4O5_DIV4)
5706/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ((arfcn-512+8551)*2*16-3000*15*5+37) / (15*5) ); /* DIV16 ( (arfcn-512+1710.2*5)*2*16-3000*15*5+37) / (15*5) ) (arfcn-512+1710.2*5)*2 is RFVCO freq. 37 is for round. 16/15 is div16.*/
5707/*MTKSOC1T*/ else
5708/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ((arfcn-512+8551)*2*20-3000*19*5+47) / (19*5)); //DIV20
5709/*MTKSOC1T*/ break;
5710/*MTKSOC1T*/ }
5711/*MTKSOC1T*/ case FrequencyBand1900 :
5712/*MTKSOC1T*/ {
5713/*MTKSOC1T*/ if(OPLL_DIV4O5_DIV4)
5714/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ( (arfcn-512+9251)*2*16 -3000*5*17 + 42)/ (5*17)); /* DIV16 INT(((A5-512+1850.2*5)*2*16+42)/(5*17)-3000).*/
5715/*MTKSOC1T*/ else
5716/*MTKSOC1T*/ N_sx_cal_fbx = (int)( ( (arfcn-512+9251)*2*20 -3000*5*21 + 52)/ (5*21) ); //DIV20
5717/*MTKSOC1T*/ break;
5718/*MTKSOC1T*/ }
5719/*MTKSOC1T*/ default:
5720/*MTKSOC1T*/ break;
5721/*MTKSOC1T*/ }
5722/*MTKSOC1T*/
5723/*MTKSOC1T*/ }
5724/*MTKSOC1T*/ *cw27 = 0x1b00001L | (N_sx_cal_fbx<<2) | (sx_cal_dmd_t<<1); /*CW27 | sx_cal_fbx | sx_cal_dmd_t | sx_calsba*/
5725/*MTKSOC1T*/}
5726#endif
5727
5728#if IS_RF_MTKSOC1
5729/*MTKSOC1*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
5730/*MTKSOC1*/{
5731/*MTKSOC1*/ int Nfrac, SDM_IFM = 1, OPLL_DIV4O5_DIV4 = 0;
5732/*MTKSOC1*/ switch(rf_band)
5733/*MTKSOC1*/ {
5734/*MTKSOC1*/ case FrequencyBand850 :
5735/*MTKSOC1*/ {
5736/*MTKSOC1*/ if(arfcn<=189)
5737/*MTKSOC1*/ {
5738/*MTKSOC1*/ if(arfcn<=160)
5739/*MTKSOC1*/ {
5740/*MTKSOC1*/ if(arfcn<=131)
5741/*MTKSOC1*/ { /* ARFCN : 128~131 */
5742/*MTKSOC1*/ Nfrac = (arfcn-128)*286790 + 7456540;
5743/*MTKSOC1*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5744/*MTKSOC1*/ }
5745/*MTKSOC1*/ else
5746/*MTKSOC1*/ { /* ARFCN : 132~160 */
5747/*MTKSOC1*/ Nfrac = (arfcn-132)*286790 + 215093;
5748/*MTKSOC1*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5749/*MTKSOC1*/ }
5750/*MTKSOC1*/ }
5751/*MTKSOC1*/ else
5752/*MTKSOC1*/ { /* ARFCN : 161~189 */
5753/*MTKSOC1*/ Nfrac = (arfcn-161)*286790 + 143395;
5754/*MTKSOC1*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5755/*MTKSOC1*/ }
5756/*MTKSOC1*/ }
5757/*MTKSOC1*/ else
5758/*MTKSOC1*/ {
5759/*MTKSOC1*/ if(arfcn<=218)
5760/*MTKSOC1*/ { /* ARFCN : 190~218 */
5761/*MTKSOC1*/ Nfrac = (arfcn-190)*286790 + 71698;
5762/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5763/*MTKSOC1*/ }
5764/*MTKSOC1*/ else
5765/*MTKSOC1*/ {
5766/*MTKSOC1*/ if(arfcn<=248)
5767/*MTKSOC1*/ { /* ARFCN : 219~248 */
5768/*MTKSOC1*/ Nfrac = (arfcn-219)*286790;
5769/*MTKSOC1*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5770/*MTKSOC1*/
5771/*MTKSOC1*/ if(arfcn == 219)
5772/*MTKSOC1*/ SDM_IFM = 0;
5773/*MTKSOC1*/ }
5774/*MTKSOC1*/ else
5775/*MTKSOC1*/ { /* ARFCN : 249~251 */
5776/*MTKSOC1*/ Nfrac = (arfcn-249)*286790 + 215093;
5777/*MTKSOC1*/ *rfN = (145L<<10); /* N_INT[7:0]*/
5778/*MTKSOC1*/ }
5779/*MTKSOC1*/ }
5780/*MTKSOC1*/ }
5781/*MTKSOC1*/
5782/*MTKSOC1*/ *ifN = (Nfrac>>10) | 0x0242000L; /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
5783/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5784/*MTKSOC1*/
5785/*MTKSOC1*/ break;
5786/*MTKSOC1*/ }
5787/*MTKSOC1*/ case FrequencyBand900 :
5788/*MTKSOC1*/ {
5789/*MTKSOC1*/ if(arfcn<=112)
5790/*MTKSOC1*/ {
5791/*MTKSOC1*/ if(arfcn<=54)
5792/*MTKSOC1*/ {
5793/*MTKSOC1*/ if(arfcn<=25)
5794/*MTKSOC1*/ { /* ARFCN : 0~25 */
5795/*MTKSOC1*/ Nfrac = (arfcn)*286790 + 1147160;
5796/*MTKSOC1*/ *rfN = (152L<<10); /* N_INT[7:0]*/
5797/*MTKSOC1*/ }
5798/*MTKSOC1*/ else
5799/*MTKSOC1*/ { /* ARFCN : 26~54 */
5800/*MTKSOC1*/ Nfrac = (arfcn-26)*286790 + 215093;
5801/*MTKSOC1*/ *rfN = (153L<<10); /* N_INT[7:0]*/
5802/*MTKSOC1*/ }
5803/*MTKSOC1*/ }
5804/*MTKSOC1*/ else
5805/*MTKSOC1*/ {
5806/*MTKSOC1*/ if(arfcn<=83)
5807/*MTKSOC1*/ { /* ARFCN : 55~83 */
5808/*MTKSOC1*/ Nfrac = (arfcn-55)*286790 + 143395;
5809/*MTKSOC1*/ *rfN = (154L<<10); /* N_INT[7:0]*/
5810/*MTKSOC1*/ }
5811/*MTKSOC1*/ else
5812/*MTKSOC1*/ { /* ARFCN : 84~112 */
5813/*MTKSOC1*/ Nfrac = (arfcn-84)*286790 + 71698;
5814/*MTKSOC1*/ *rfN = (155L<<10); /* N_INT[7:0]*/
5815/*MTKSOC1*/ }
5816/*MTKSOC1*/ }
5817/*MTKSOC1*/ }
5818/*MTKSOC1*/ else
5819/*MTKSOC1*/ {
5820/*MTKSOC1*/ if(arfcn<=990)
5821/*MTKSOC1*/ {
5822/*MTKSOC1*/ if(arfcn<=124)
5823/*MTKSOC1*/ { /* ARFCN : 113~124 */
5824/*MTKSOC1*/ Nfrac = (arfcn-113)*286790;
5825/*MTKSOC1*/ *rfN = (156L<<10);
5826/*MTKSOC1*/
5827/*MTKSOC1*/ if(arfcn == 113)
5828/*MTKSOC1*/ SDM_IFM = 0;
5829/*MTKSOC1*/
5830/*MTKSOC1*/ }
5831/*MTKSOC1*/ else
5832/*MTKSOC1*/ { /* ARFCN : 975~990 */
5833/*MTKSOC1*/ Nfrac = (arfcn-975)*286790 + 3871665;
5834/*MTKSOC1*/ *rfN = (150L<<10); /* N_INT[7:0]*/
5835/*MTKSOC1*/ }
5836/*MTKSOC1*/ }
5837/*MTKSOC1*/ else
5838/*MTKSOC1*/ {
5839/*MTKSOC1*/ if(arfcn<=1019)
5840/*MTKSOC1*/ { /* ARFCN : 991~1019 */
5841/*MTKSOC1*/ Nfrac = (arfcn-991)*286790 + 71698;
5842/*MTKSOC1*/ *rfN = (151L<<10); /* N_INT[7:0]*/
5843/*MTKSOC1*/ }
5844/*MTKSOC1*/ else
5845/*MTKSOC1*/ { /* ARFCN : 1020~1023 */
5846/*MTKSOC1*/ Nfrac = (arfcn-1020)*286790;
5847/*MTKSOC1*/ *rfN = (152L<<10);
5848/*MTKSOC1*/
5849/*MTKSOC1*/ if(arfcn == 1020)
5850/*MTKSOC1*/ SDM_IFM = 0;
5851/*MTKSOC1*/ }
5852/*MTKSOC1*/ }
5853/*MTKSOC1*/ }
5854/*MTKSOC1*/ *ifN = (Nfrac>>10) | 0x0252000L; /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
5855/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
5856/*MTKSOC1*/
5857/*MTKSOC1*/ break;
5858/*MTKSOC1*/ }
5859/*MTKSOC1*/ case FrequencyBand1800 :
5860/*MTKSOC1*/ {
5861/*MTKSOC1*/ if(arfcn<=670)
5862/*MTKSOC1*/ {
5863/*MTKSOC1*/ if(arfcn<=603)
5864/*MTKSOC1*/ {
5865/*MTKSOC1*/ if(arfcn<=547)
5866/*MTKSOC1*/ {
5867/*MTKSOC1*/ if(arfcn<=541)
5868/*MTKSOC1*/ { /* ARFCN : 512~541 */
5869/*MTKSOC1*/ Nfrac = (arfcn-529)*135848 + 6316927;
5870/*MTKSOC1*/ *rfN = (138L<<10); /* N_INT[7:0]*/
5871/*MTKSOC1*/
5872/*MTKSOC1*/ /*error compensation*/
5873/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 0, 0, 519, 529, 540, 542);
5874/*MTKSOC1*/ /*End: error compensation*/
5875/*MTKSOC1*/
5876/*MTKSOC1*/ }
5877/*MTKSOC1*/ else
5878/*MTKSOC1*/ { /* ARFCN : 542~547 */
5879/*MTKSOC1*/ Nfrac = (arfcn-542)*137659 + 6848546;
5880/*MTKSOC1*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5881/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
5882/*MTKSOC1*/
5883/*MTKSOC1*/ /*error compensation*/
5884/*MTKSOC1*/ if(arfcn>=547)
5885/*MTKSOC1*/ Nfrac++;
5886/*MTKSOC1*/ /*End: error compensation*/
5887/*MTKSOC1*/
5888/*MTKSOC1*/ }
5889/*MTKSOC1*/
5890/*MTKSOC1*/ }
5891/*MTKSOC1*/ else
5892/*MTKSOC1*/ { /* ARFCN : 548~603 */
5893/*MTKSOC1*/ Nfrac = (arfcn-581)*135848 + 4992410;
5894/*MTKSOC1*/ *rfN = (139L<<10); /* N_INT[7:0]*/
5895/*MTKSOC1*/
5896/*MTKSOC1*/ /*error compensation*/
5897/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 550, 560, 570, 581, 591, 601);
5898/*MTKSOC1*/ /*End: error compensation*/
5899/*MTKSOC1*/
5900/*MTKSOC1*/ }
5901/*MTKSOC1*/ }
5902/*MTKSOC1*/ else
5903/*MTKSOC1*/ {
5904/*MTKSOC1*/ if(arfcn<=665)
5905/*MTKSOC1*/ {
5906/*MTKSOC1*/ if(arfcn<=608)
5907/*MTKSOC1*/ { /* ARFCN : 604~608 */
5908/*MTKSOC1*/ Nfrac = (arfcn-604)*137659 + 6994809;
5909/*MTKSOC1*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5910/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
5911/*MTKSOC1*/
5912/*MTKSOC1*/ /*error compensation*/
5913/*MTKSOC1*/ /*End: error compensation*/
5914/*MTKSOC1*/ }
5915/*MTKSOC1*/ else
5916/*MTKSOC1*/ { /* ARFCN : 609~665 */
5917/*MTKSOC1*/ Nfrac = (arfcn-643)*135848 + 5026372;
5918/*MTKSOC1*/ *rfN = (140L<<10); /* N_INT[7:0]*/
5919/*MTKSOC1*/
5920/*MTKSOC1*/ /*error compensation*/
5921/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 612, 622, 632, 643, 653, 663);
5922/*MTKSOC1*/ /*End: error compensation*/
5923/*MTKSOC1*/ }
5924/*MTKSOC1*/ }
5925/*MTKSOC1*/ else
5926/*MTKSOC1*/ { /* ARFCN : 666~670 */
5927/*MTKSOC1*/ Nfrac = (arfcn-666)*137659 + 7141071;
5928/*MTKSOC1*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5929/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
5930/*MTKSOC1*/
5931/*MTKSOC1*/ /*error compensation*/
5932/*MTKSOC1*/ if(arfcn>=667)
5933/*MTKSOC1*/ Nfrac++;
5934/*MTKSOC1*/ /*End: error compensation*/
5935/*MTKSOC1*/ }
5936/*MTKSOC1*/ }
5937/*MTKSOC1*/ }
5938/*MTKSOC1*/ else
5939/*MTKSOC1*/ {
5940/*MTKSOC1*/ if(arfcn<=788)
5941/*MTKSOC1*/ {
5942/*MTKSOC1*/ if(arfcn<=732)
5943/*MTKSOC1*/ {
5944/*MTKSOC1*/ if(arfcn<=726)
5945/*MTKSOC1*/ {/* ARFCN : 671~726 */
5946/*MTKSOC1*/ Nfrac = (arfcn-704)*135848 + 4924486;
5947/*MTKSOC1*/ *rfN = (141L<<10); /* N_INT[7:0]*/
5948/*MTKSOC1*/
5949/*MTKSOC1*/ /*error compensation*/
5950/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 673, 684, 694, 704, 715, 725);
5951/*MTKSOC1*/ /*End: error compensation*/
5952/*MTKSOC1*/ }
5953/*MTKSOC1*/ else
5954/*MTKSOC1*/ {/*ARFCN:727~732*/
5955/*MTKSOC1*/ Nfrac = (arfcn-727)*137659 + 7149675;
5956/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5957/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
5958/*MTKSOC1*/
5959/*MTKSOC1*/ /*error compensation*/
5960/*MTKSOC1*/ if(arfcn>=729)
5961/*MTKSOC1*/ Nfrac++;
5962/*MTKSOC1*/ /*End: error compensation*/
5963/*MTKSOC1*/
5964/*MTKSOC1*/ }
5965/*MTKSOC1*/ }
5966/*MTKSOC1*/ else
5967/*MTKSOC1*/ {/*ARFCN:733~788*/
5968/*MTKSOC1*/ Nfrac = (arfcn-766)*135848 + 4958448;
5969/*MTKSOC1*/ *rfN = (142L<<10); /* N_INT[7:0]*/
5970/*MTKSOC1*/
5971/*MTKSOC1*/ /*error compensation*/
5972/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 735, 745, 756, 766, 776, 786);
5973/*MTKSOC1*/ /*End: error compensation*/
5974/*MTKSOC1*/ }
5975/*MTKSOC1*/ }
5976/*MTKSOC1*/ else
5977/*MTKSOC1*/ {
5978/*MTKSOC1*/ if(arfcn<=850)
5979/*MTKSOC1*/ {
5980/*MTKSOC1*/ if(arfcn<=794)
5981/*MTKSOC1*/ {/*ARFCN:789~794*/
5982/*MTKSOC1*/ Nfrac = (arfcn-789)*137659 + 7295938;
5983/*MTKSOC1*/ *rfN = (144L<<10); /* N_INT[7:0]*/
5984/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
5985/*MTKSOC1*/
5986/*MTKSOC1*/ /*error compensation*/
5987/*MTKSOC1*/ if(arfcn>=792)
5988/*MTKSOC1*/ Nfrac++;
5989/*MTKSOC1*/ /*End: error compensation*/
5990/*MTKSOC1*/ }
5991/*MTKSOC1*/ else
5992/*MTKSOC1*/ {/*ARFCN:795~850*/
5993/*MTKSOC1*/ Nfrac = (arfcn-828)*135848 + 4992410;
5994/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
5995/*MTKSOC1*/ /*error compensation*/
5996/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 797, 806, 817, 828, 838, 848);
5997/*MTKSOC1*/ /*End:*error compensation*/
5998/*MTKSOC1*/ }
5999/*MTKSOC1*/ }
6000/*MTKSOC1*/ else
6001/*MTKSOC1*/ {
6002/*MTKSOC1*/ if(arfcn<=855)
6003/*MTKSOC1*/ {/*ARFCN:851~855*/
6004/*MTKSOC1*/ Nfrac = (arfcn-851)*137659 + 7442201;
6005/*MTKSOC1*/ *rfN = (145L<<10); /* N_INT[7:0]*/
6006/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
6007/*MTKSOC1*/
6008/*MTKSOC1*/ /*error compensation*/
6009/*MTKSOC1*/ if(arfcn>=854)
6010/*MTKSOC1*/ Nfrac++;
6011/*MTKSOC1*/ /*End: error compensation*/
6012/*MTKSOC1*/ }
6013/*MTKSOC1*/ else
6014/*MTKSOC1*/ {/*ARFCN:856~885*/
6015/*MTKSOC1*/ Nfrac = (arfcn-869)*135848 + 2173566;
6016/*MTKSOC1*/ *rfN = (144L<<10); /* N_INT[7:0]*/
6017/*MTKSOC1*/
6018/*MTKSOC1*/ /*error compensation*/
6019/*MTKSOC1*/ L1D_RF_Band1800_FrequecyFractionPartCompensation(arfcn, &Nfrac, 0, 0, 859, 869, 879, 885);
6020/*MTKSOC1*/ /*End: error compensation*/
6021/*MTKSOC1*/ }
6022/*MTKSOC1*/ }
6023/*MTKSOC1*/ }
6024/*MTKSOC1*/ }
6025/*MTKSOC1*/ *ifN = (Nfrac>>10) | 0x0262000L | (OPLL_DIV4O5_DIV4<<19); /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
6026/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x01C0000L); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6027/*MTKSOC1*/ break;
6028/*MTKSOC1*/ }
6029/*MTKSOC1*/ case FrequencyBand1900 :
6030/*MTKSOC1*/ {
6031/*MTKSOC1*/ if(arfcn<=676)
6032/*MTKSOC1*/ {
6033/*MTKSOC1*/ if(arfcn<=546)
6034/*MTKSOC1*/ {
6035/*MTKSOC1*/ if(arfcn<=540)
6036/*MTKSOC1*/ { /*ARFCN:512~540*/
6037/*MTKSOC1*/ Nfrac = (arfcn-512)*122910 + 4578398;
6038/*MTKSOC1*/ *rfN = (135L<<10); /* N_INT[7:0]*/
6039/*MTKSOC1*/ }
6040/*MTKSOC1*/ else
6041/*MTKSOC1*/ { /*ARFCN:541~546*/
6042/*MTKSOC1*/ Nfrac = (arfcn-541)*121464 + 3112515;
6043/*MTKSOC1*/ *rfN = (134L<<10); /* N_INT[7:0]*/
6044/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
6045/*MTKSOC1*/ }
6046/*MTKSOC1*/ }
6047/*MTKSOC1*/ else
6048/*MTKSOC1*/ {
6049/*MTKSOC1*/ if(arfcn<=614)
6050/*MTKSOC1*/ {
6051/*MTKSOC1*/ if(arfcn<=608)
6052/*MTKSOC1*/ { /*ARFCN:547~608*/
6053/*MTKSOC1*/ Nfrac = (arfcn-547)*122910 + 491640;
6054/*MTKSOC1*/ *rfN = (136L<<10); /* N_INT[7:0]*/
6055/*MTKSOC1*/ }
6056/*MTKSOC1*/ else
6057/*MTKSOC1*/ { /*ARFCN:609~614*/
6058/*MTKSOC1*/ Nfrac = (arfcn-609)*121464 + 2983460;
6059/*MTKSOC1*/ *rfN = (135L<<10); /* N_INT[7:0]*/
6060/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
6061/*MTKSOC1*/ }
6062/*MTKSOC1*/ }
6063/*MTKSOC1*/ else
6064/*MTKSOC1*/ { /*ARFCN:615~676*/
6065/*MTKSOC1*/ Nfrac = (arfcn-615)*122910 + 460913;
6066/*MTKSOC1*/ *rfN = (137L<<10); /* N_INT[7:0]*/
6067/*MTKSOC1*/ }
6068/*MTKSOC1*/ }
6069/*MTKSOC1*/ }
6070/*MTKSOC1*/ else
6071/*MTKSOC1*/ {
6072/*MTKSOC1*/ if(arfcn<=744)
6073/*MTKSOC1*/ {
6074/*MTKSOC1*/ if(arfcn<=682)
6075/*MTKSOC1*/ {/*ARFCN:677~682*/
6076/*MTKSOC1*/ Nfrac = (arfcn-677)*121464 + 2854404;
6077/*MTKSOC1*/ *rfN = (136L<<10); /* N_INT[7:0]*/
6078/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
6079/*MTKSOC1*/ }
6080/*MTKSOC1*/ else
6081/*MTKSOC1*/ { /*ARFCN:683~744*/
6082/*MTKSOC1*/ Nfrac = (arfcn-683)*122910 + 430185;
6083/*MTKSOC1*/ *rfN = (138L<<10); /* N_INT[7:0]*/
6084/*MTKSOC1*/ }
6085/*MTKSOC1*/ }
6086/*MTKSOC1*/ else
6087/*MTKSOC1*/ {
6088/*MTKSOC1*/ if(arfcn<=750)
6089/*MTKSOC1*/ {/*ARFCN:745~750*/
6090/*MTKSOC1*/ Nfrac = (arfcn-745)*121464 + 2725349;
6091/*MTKSOC1*/ *rfN = (137L<<10); /* N_INT[7:0]*/
6092/*MTKSOC1*/ OPLL_DIV4O5_DIV4 = 1;
6093/*MTKSOC1*/ }
6094/*MTKSOC1*/ else
6095/*MTKSOC1*/ { /*ARFCN:751~810*/
6096/*MTKSOC1*/ Nfrac = (arfcn-751)*122910 + 399458;
6097/*MTKSOC1*/ *rfN = (139L<<10); /* N_INT[7:0]*/
6098/*MTKSOC1*/ }
6099/*MTKSOC1*/ }
6100/*MTKSOC1*/ }
6101/*MTKSOC1*/
6102/*MTKSOC1*/ *ifN = (Nfrac>>10) | 0x0272000L | (OPLL_DIV4O5_DIV4<<19); /* N_FRAC[22:10] | (CW2|OPLL_DIV4O5_DIV4|TRX|BAND|MODE(warm_up mode))*/
6103/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0140000L); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6104/*MTKSOC1*/ break;
6105/*MTKSOC1*/ }
6106/*MTKSOC1*/ default :
6107/*MTKSOC1*/ {
6108/*MTKSOC1*/ break;
6109/*MTKSOC1*/ }
6110/*MTKSOC1*/ }
6111/*MTKSOC1*/}
6112/*MTKSOC1*//* =============================================================== */
6113/*MTKSOC1*/
6114/*MTKSOC1*/void L1D_RF_Band1800_FrequecyFractionPartCompensation(int arfcn, int *Nfrac, short arfcn1, short arfcn2, short arfcn3, short arfcn4, short arfcn5, short arfcn6)
6115/*MTKSOC1*/{
6116/*MTKSOC1*/ if(arfcn<arfcn4)
6117/*MTKSOC1*/ {
6118/*MTKSOC1*/ if(arfcn<arfcn2)
6119/*MTKSOC1*/ {
6120/*MTKSOC1*/ if(arfcn<arfcn1)
6121/*MTKSOC1*/ *Nfrac+=4;
6122/*MTKSOC1*/ else
6123/*MTKSOC1*/ *Nfrac+=3;
6124/*MTKSOC1*/ }
6125/*MTKSOC1*/ else
6126/*MTKSOC1*/ {
6127/*MTKSOC1*/ if(arfcn<arfcn3)
6128/*MTKSOC1*/ *Nfrac+=2;
6129/*MTKSOC1*/ else
6130/*MTKSOC1*/ *Nfrac+=1;
6131/*MTKSOC1*/ }
6132/*MTKSOC1*/ }
6133/*MTKSOC1*/ else if (arfcn>=arfcn5)
6134/*MTKSOC1*/ {
6135/*MTKSOC1*/ if(arfcn<arfcn6)
6136/*MTKSOC1*/ {
6137/*MTKSOC1*/ *Nfrac-=1;
6138/*MTKSOC1*/ }
6139/*MTKSOC1*/ else
6140/*MTKSOC1*/ {
6141/*MTKSOC1*/ *Nfrac-=2;
6142/*MTKSOC1*/ }
6143/*MTKSOC1*/ }
6144/*MTKSOC1*/}
6145/*MTKSOC1*/
6146/*MTKSOC1*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6147/*MTKSOC1*/{
6148/*MTKSOC1*/ int Nfrac, SDM_IFM = 1;
6149/*MTKSOC1*/ switch(rf_band)
6150/*MTKSOC1*/ {
6151/*MTKSOC1*/ case FrequencyBand850 :
6152/*MTKSOC1*/ {
6153/*MTKSOC1*/ if(arfcn<=201)
6154/*MTKSOC1*/ {
6155/*MTKSOC1*/ if(arfcn<=169)
6156/*MTKSOC1*/ {
6157/*MTKSOC1*/ if(arfcn<=136)
6158/*MTKSOC1*/ {/*arfcn:128~136*/
6159/*MTKSOC1*/ Nfrac = (arfcn-128)*258111 + 6065609;
6160/*MTKSOC1*/ *rfN = (133L<<10); /* N_INT[7:0]*/
6161/*MTKSOC1*/ }
6162/*MTKSOC1*/ else
6163/*MTKSOC1*/ {/*arfcn:137~169*/
6164/*MTKSOC1*/ Nfrac = (arfcn-137)*258111;
6165/*MTKSOC1*/ *rfN = (134L<<10); /* N_INT[7:0]*/
6166/*MTKSOC1*/
6167/*MTKSOC1*/ }
6168/*MTKSOC1*/ }
6169/*MTKSOC1*/ else
6170/*MTKSOC1*/ {/*arfcn:170~201*/
6171/*MTKSOC1*/ Nfrac = (arfcn-170)*258111+129056;
6172/*MTKSOC1*/ *rfN = (135L<<10); /* N_INT[7:0]*/
6173/*MTKSOC1*/ }
6174/*MTKSOC1*/ }
6175/*MTKSOC1*/ else
6176/*MTKSOC1*/ {
6177/*MTKSOC1*/ if(arfcn<=234)
6178/*MTKSOC1*/ {/*arfcn:202~234*/
6179/*MTKSOC1*/ Nfrac = (arfcn-202)*258111;
6180/*MTKSOC1*/ *rfN = (136L<<10); /* N_INT[7:0]*/
6181/*MTKSOC1*/ }
6182/*MTKSOC1*/ else
6183/*MTKSOC1*/ {/*arfcn:235~251*/
6184/*MTKSOC1*/ Nfrac = (arfcn-235)*258111+129056;
6185/*MTKSOC1*/ *rfN = (137L<<10); /* N_INT[7:0]*/
6186/*MTKSOC1*/ }
6187/*MTKSOC1*/ }
6188/*MTKSOC1*/ *ifN = (Nfrac>>10)|0x0202000; /* CW2, TRX:0, BAND:0, MODE:1, N_RFC[22:10]*/
6189/*MTKSOC1*/ if(Nfrac==0) SDM_IFM = 0;
6190/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6191/*MTKSOC1*/
6192/*MTKSOC1*/ // Get GSM850 signal from GSM900 input pins if flag=1
6193/*MTKSOC1*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN |=0x0010000L ;
6194/*MTKSOC1*/ break;
6195/*MTKSOC1*/ }
6196/*MTKSOC1*/ case FrequencyBand900 :
6197/*MTKSOC1*/ {
6198/*MTKSOC1*/ if(arfcn<=102)
6199/*MTKSOC1*/ {
6200/*MTKSOC1*/ if(arfcn<=37)
6201/*MTKSOC1*/ {
6202/*MTKSOC1*/ if(arfcn<=4)
6203/*MTKSOC1*/ {/*arfcn:0~4*/
6204/*MTKSOC1*/ Nfrac = (arfcn)*258111+7098053;
6205/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
6206/*MTKSOC1*/ }
6207/*MTKSOC1*/ else
6208/*MTKSOC1*/ {/*arfcn:5~37*/
6209/*MTKSOC1*/ Nfrac = (arfcn-5)*258111;
6210/*MTKSOC1*/ *rfN = (144L<<10); /* N_INT[7:0]*/
6211/*MTKSOC1*/ }
6212/*MTKSOC1*/ }
6213/*MTKSOC1*/ else
6214/*MTKSOC1*/ {
6215/*MTKSOC1*/ if(arfcn<=69)
6216/*MTKSOC1*/ {/*arfcn:38~69*/
6217/*MTKSOC1*/ Nfrac = (arfcn-38)*258111+129056;
6218/*MTKSOC1*/ *rfN = (145L<<10); /* N_INT[7:0]*/
6219/*MTKSOC1*/ }
6220/*MTKSOC1*/ else
6221/*MTKSOC1*/ {/*arfcn:70~102*/
6222/*MTKSOC1*/ Nfrac = (arfcn-70)*258111;
6223/*MTKSOC1*/ *rfN = (146L<<10); /* N_INT[7:0]*/
6224/*MTKSOC1*/ }
6225/*MTKSOC1*/ }
6226/*MTKSOC1*/ }
6227/*MTKSOC1*/ else
6228/*MTKSOC1*/ {
6229/*MTKSOC1*/ if(arfcn<=996)
6230/*MTKSOC1*/ {
6231/*MTKSOC1*/ if(arfcn<=124)
6232/*MTKSOC1*/ {/*arfcn:103~124*/
6233/*MTKSOC1*/ Nfrac = (arfcn-103)*258111+129056;
6234/*MTKSOC1*/ *rfN = (147L<<10); /* N_INT[7:0]*/
6235/*MTKSOC1*/ }
6236/*MTKSOC1*/ else
6237/*MTKSOC1*/ {/*arfcn:975~996*/
6238/*MTKSOC1*/ Nfrac = (arfcn-975)*258111+2839221;
6239/*MTKSOC1*/ *rfN = (142L<<10); /* N_INT[7:0]*/
6240/*MTKSOC1*/ }
6241/*MTKSOC1*/ }
6242/*MTKSOC1*/ else
6243/*MTKSOC1*/ {/*arfcn:997~1023*/
6244/*MTKSOC1*/ Nfrac = (arfcn-997)*258111+129056;
6245/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
6246/*MTKSOC1*/ }
6247/*MTKSOC1*/ }
6248/*MTKSOC1*/
6249/*MTKSOC1*/ *ifN = (Nfrac>>10)|0x0212000; /* CW2, TRX:0, BAND:1, MODE:1, N_RFC[22:10]*/
6250/*MTKSOC1*/
6251/*MTKSOC1*/ if(Nfrac==0) SDM_IFM = 0;
6252/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6253/*MTKSOC1*/
6254/*MTKSOC1*/ // Get GSM900 signal from GSM850 input pins if flag=1
6255/*MTKSOC1*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN &= (~(0x0010000L));
6256/*MTKSOC1*/ break;
6257/*MTKSOC1*/ }
6258/*MTKSOC1*/ case FrequencyBand1800 :
6259/*MTKSOC1*/ {
6260/*MTKSOC1*/ if(arfcn<=715)
6261/*MTKSOC1*/ {
6262/*MTKSOC1*/ if(arfcn<=585)
6263/*MTKSOC1*/ {
6264/*MTKSOC1*/ if(arfcn<=520)
6265/*MTKSOC1*/ {/*arfcn:512~520*/
6266/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 456);
6267/*MTKSOC1*/ *rfN = (138L<<10); /* N_INT[7:0]*/
6268/*MTKSOC1*/ }
6269/*MTKSOC1*/ else
6270/*MTKSOC1*/ {/*arfcn:521~585*/
6271/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 521);
6272/*MTKSOC1*/ *rfN = (139L<<10); /* N_INT[7:0]*/
6273/*MTKSOC1*/ }
6274/*MTKSOC1*/ }
6275/*MTKSOC1*/ else
6276/*MTKSOC1*/ {
6277/*MTKSOC1*/ if(arfcn<=650)
6278/*MTKSOC1*/ {/*arfcn:586~650*/
6279/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 586);
6280/*MTKSOC1*/ *rfN = (140L<<10); /* N_INT[7:0]*/
6281/*MTKSOC1*/ }
6282/*MTKSOC1*/ else
6283/*MTKSOC1*/ {/*arfcn:651~715*/
6284/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 651);
6285/*MTKSOC1*/ *rfN = (141L<<10); /* N_INT[7:0]*/
6286/*MTKSOC1*/ }
6287/*MTKSOC1*/ }
6288/*MTKSOC1*/ }
6289/*MTKSOC1*/ else
6290/*MTKSOC1*/ {
6291/*MTKSOC1*/ if(arfcn<=845)
6292/*MTKSOC1*/ {
6293/*MTKSOC1*/ if(arfcn<=780)
6294/*MTKSOC1*/ {/*arfcn:716~780*/
6295/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 716);
6296/*MTKSOC1*/ *rfN = (142L<<10); /* N_INT[7:0]*/
6297/*MTKSOC1*/ }
6298/*MTKSOC1*/ else
6299/*MTKSOC1*/ {/*arfcn:781~845*/
6300/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 781);
6301/*MTKSOC1*/ *rfN = (143L<<10); /* N_INT[7:0]*/
6302/*MTKSOC1*/ }
6303/*MTKSOC1*/ }
6304/*MTKSOC1*/ else
6305/*MTKSOC1*/ {/*arfcn:846~885*/
6306/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 846);
6307/*MTKSOC1*/ *rfN = (144L<<10); /* N_INT[7:0]*/
6308/*MTKSOC1*/ }
6309/*MTKSOC1*/ }
6310/*MTKSOC1*/
6311/*MTKSOC1*/
6312/*MTKSOC1*/ *ifN = (Nfrac>>10)|0x0222000; /* CW2, TRX:0, BAND:2, MODE:1, N_RFC[22:10]*/
6313/*MTKSOC1*/
6314/*MTKSOC1*/ if(Nfrac==0) SDM_IFM = 0;
6315/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6316/*MTKSOC1*/
6317/*MTKSOC1*/ // Get PCS1900 signal from DCS1800 input pins if flag=1
6318/*MTKSOC1*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *ifN |=0x0010000L ;
6319/*MTKSOC1*/ break;
6320/*MTKSOC1*/ }
6321/*MTKSOC1*/ case FrequencyBand1900 :
6322/*MTKSOC1*/ {
6323/*MTKSOC1*/ if(arfcn<=675)
6324/*MTKSOC1*/ {
6325/*MTKSOC1*/ if(arfcn<=610)
6326/*MTKSOC1*/ {
6327/*MTKSOC1*/ if(arfcn<=545)
6328/*MTKSOC1*/ {/*arfcn:512~545*/
6329/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 481);
6330/*MTKSOC1*/ *rfN = (148L<<10); /* N_INT[7:0]*/
6331/*MTKSOC1*/ }
6332/*MTKSOC1*/ else
6333/*MTKSOC1*/ {/*arfcn:546~610*/
6334/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 546);
6335/*MTKSOC1*/ *rfN = (149L<<10); /* N_INT[7:0]*/
6336/*MTKSOC1*/ }
6337/*MTKSOC1*/ }
6338/*MTKSOC1*/ else
6339/*MTKSOC1*/ {/*arfcn:611~675*/
6340/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 611);
6341/*MTKSOC1*/ *rfN = (150L<<10); /* N_INT[7:0]*/
6342/*MTKSOC1*/ }
6343/*MTKSOC1*/ }
6344/*MTKSOC1*/ else
6345/*MTKSOC1*/ {
6346/*MTKSOC1*/ if(arfcn<=805)
6347/*MTKSOC1*/ {
6348/*MTKSOC1*/ if(arfcn<=740)
6349/*MTKSOC1*/ {/*arfcn:676~740*/
6350/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 676);
6351/*MTKSOC1*/ *rfN = (151L<<10); /* N_INT[7:0]*/
6352/*MTKSOC1*/ }
6353/*MTKSOC1*/ else
6354/*MTKSOC1*/ {/*arfcn:741~805*/
6355/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 741);
6356/*MTKSOC1*/ *rfN = (152L<<10); /* N_INT[7:0]*/
6357/*MTKSOC1*/ }
6358/*MTKSOC1*/ }
6359/*MTKSOC1*/ else
6360/*MTKSOC1*/ {/*arfcn:806~810*/
6361/*MTKSOC1*/ L1D_RF_GetRxPLL_HB_FractionPart(&Nfrac, arfcn, 806);
6362/*MTKSOC1*/ *rfN = (153L<<10); /* N_INT[7:0]*/
6363/*MTKSOC1*/ }
6364/*MTKSOC1*/ }
6365/*MTKSOC1*/
6366/*MTKSOC1*/ *ifN = (Nfrac>>10)|0x0232000; /* CW2, TRX:0, BAND:2, MODE:1, N_RFC[22:10]*/
6367/*MTKSOC1*/
6368/*MTKSOC1*/ if(Nfrac==0) SDM_IFM = 0;
6369/*MTKSOC1*/ *rfN |= ((Nfrac&0x3FF) | 0x0180000L | (SDM_IFM<<18) ); /* N_INT[7:0] | N_FRAC[9:0] | (CW1|OPLL_HLSIDE)| SDM_IFM)*/
6370/*MTKSOC1*/ // Get DCS1800 signal from PCS1900 input pins if flag=1
6371/*MTKSOC1*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *ifN &= (~(0x0010000L));
6372/*MTKSOC1*/ break;
6373/*MTKSOC1*/ }
6374/*MTKSOC1*/ default :
6375/*MTKSOC1*/ {
6376/*MTKSOC1*/ break;
6377/*MTKSOC1*/ }
6378/*MTKSOC1*/ }
6379/*MTKSOC1*/}
6380/*MTKSOC1*//* =============================================================== */
6381/*MTKSOC1*/
6382/*MTKSOC1*/void L1D_RF_GetRxPLL_HB_FractionPart(int *Nfrac, int arfcn, int arfcn_base)
6383/*MTKSOC1*/{
6384/*MTKSOC1*/ int Diff_arfcn;
6385/*MTKSOC1*/
6386/*MTKSOC1*/ Diff_arfcn = arfcn - arfcn_base;
6387/*MTKSOC1*/ *Nfrac = (Diff_arfcn >>1) * 258111;
6388/*MTKSOC1*/ if(Diff_arfcn & 0x1) *Nfrac += 129056;
6389/*MTKSOC1*/}
6390/*MTKSOC1*//* =============================================================== */
6391#endif
6392
6393#if IS_RF_MT6252RF
6394/*MT6252RF*/
6395/*MT6252RF*/ static void L1D_RF_GetRxPLLifNrfN( int rf_band, short K, long *ifN, long *rfN )
6396/*MT6252RF*/ {
6397/*MT6252RF*/ int Nfrac = 64527*K + ( ( 3*K + 2 ) >> 2 );
6398/*MT6252RF*/
6399/*MT6252RF*/ /* CW2, TRX:0, BAND:0, MODE:010, N_RFC[22:10]*/
6400/*MT6252RF*/ *ifN = ( Nfrac >> 10) | 0x0204000L | ( ( rf_band - 1 ) << 16 );
6401/*MT6252RF*/
6402/*MT6252RF*/ *rfN |= ( ( Nfrac&0x3FF ) | 0x0100000L );
6403/*MT6252RF*/ }
6404/*MT6252RF*/ /* ============================================================================= */
6405/*MT6252RF*/
6406/*MT6252RF*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6407/*MT6252RF*/ {
6408/*MT6252RF*/ short D = 0, K = 0;
6409/*MT6252RF*/ int Nfrac, DFM_LGCP_IOSTPOL;
6410/*MT6252RF*/ switch(rf_band)
6411/*MT6252RF*/ {
6412/*MT6252RF*/ case FrequencyBand850 :
6413/*MT6252RF*/ {
6414/*MT6252RF*/ D = arfcn - 128;
6415/*MT6252RF*/ K = 104 + 4*D - 130*( ( 1653 + 63*D ) >> 11 );
6416/*MT6252RF*/
6417/*MT6252RF*/ // Nint = 126 + ( ( 1653 + 63*D ) >> 11 ); *rfN = Nint << 10;
6418/*MT6252RF*/ *rfN = ( 126 << 10 ) + (long)( ( ( 1653 + 63*D ) >> 1 ) & 0xFC00 );
6419/*MT6252RF*/ break;
6420/*MT6252RF*/ }
6421/*MT6252RF*/ case FrequencyBand900 :
6422/*MT6252RF*/ {
6423/*MT6252RF*/ D = ( arfcn > 974 ) ? ( arfcn - 1024 ) : arfcn;
6424/*MT6252RF*/ K = 250 + 4*D - 130*( ( 3953 + 63*D ) >> 11 );
6425/*MT6252RF*/
6426/*MT6252RF*/ // Nint = 135 + ( ( 3953 + 63 D ) >> 11 ); *rfN = Nint << 10;
6427/*MT6252RF*/ *rfN = ( 135 << 10 ) + (long)( ( ( 3953 + 63*D ) >> 1 ) & 0xFC00 );
6428/*MT6252RF*/ break;
6429/*MT6252RF*/ }
6430/*MT6252RF*/ case FrequencyBand1800 :
6431/*MT6252RF*/ {
6432/*MT6252RF*/ D = arfcn - 512;
6433/*MT6252RF*/ K = 72 + 2*D - 130*( ( 2300 + 63*D ) >> 12 );
6434/*MT6252RF*/
6435/*MT6252RF*/ // Nint = 131 + ( ( 2300 + 63*D ) >> 12 ); *rfN = Nint << 10;
6436/*MT6252RF*/ *rfN = ( 131 << 10 ) + (long)( ( ( 2300 + 63*D ) >> 2 ) & 0xFC00 );
6437/*MT6252RF*/ break;
6438/*MT6252RF*/ }
6439/*MT6252RF*/ case FrequencyBand1900 :
6440/*MT6252RF*/ {
6441/*MT6252RF*/ D = arfcn - 512;
6442/*MT6252RF*/ K = 42 + 2*D - 130*( ( 1355 + 63*D ) >> 12 );
6443/*MT6252RF*/
6444/*MT6252RF*/ // Nint = 142 + ( ( 1355 + 63*D ) >> 12 ); *rfN = Nint << 10;
6445/*MT6252RF*/ *rfN = ( 142 << 10 ) + (long)( ( ( 1355 + 63*D ) >> 2 ) & 0xFC00 );
6446/*MT6252RF*/ break;
6447/*MT6252RF*/ }
6448/*MT6252RF*/ default :
6449/*MT6252RF*/ {
6450/*MT6252RF*/ break;
6451/*MT6252RF*/ }
6452/*MT6252RF*/ }
6453/*MT6252RF*/ DFM_LGCP_IOSTPOL = (27 < K && K < 37) || (49 < K && K < 59) || (113 < K && K < 129) ? 1 : 0;
6454/*MT6252RF*/ Nfrac = 64527*K + ( ( 3*K + 2 ) >> 2 );
6455/*MT6252RF*/
6456/*MT6252RF*/ /* CW2: [27:20] | [19:18] | [17:16] | [15:13] | [12:0] */
6457/*MT6252RF*/ /* Address[7:0] | TRX[1:0] | BAND[1:0] | MODE[2:0](warm_up mode) | N_FRAC[22:10] */
6458/*MT6252RF*/ *ifN = ( Nfrac >> 10 ) | 0x0244000L | ( ( rf_band - 1 ) << 16 );
6459/*MT6252RF*/
6460/*MT6252RF*/ /* CW1: [27:20] | [19] | [18] | [17:10] | [9:0] */
6461/*MT6252RF*/ /* Address[7:0] | DFM_SDM_DI_EN | DFM_LGCP_IOSTPOL | N_INT[7:0] | N_FRAC[9:0] */
6462/*MT6252RF*/ *rfN |= ( ( Nfrac & 0x3FF ) | 0x0180000L | DFM_LGCP_IOSTPOL << 18 );
6463/*MT6252RF*/ }
6464/*MT6252RF*/ /* ============================================================================= */
6465/*MT6252RF*/
6466/*MT6252RF*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6467/*MT6252RF*/ {
6468/*MT6252RF*/ short D = 0, K = 0;
6469/*MT6252RF*/ switch(rf_band)
6470/*MT6252RF*/ {
6471/*MT6252RF*/ case FrequencyBand850 :
6472/*MT6252RF*/ {
6473/*MT6252RF*/ D = arfcn - 128;
6474/*MT6252RF*/ K = 94 + 4*D - 130*( ( 1496 + 63*D ) >> 11 );
6475/*MT6252RF*/
6476/*MT6252RF*/ // Nint = 133 + ( ( 1496 + 63*D ) >> 11); *rfN = Nint << 10;
6477/*MT6252RF*/ *rfN = ( 133 << 10 ) + (long)( ( ( 1496 + 63*D ) >> 1 ) & 0xFC00 );
6478/*MT6252RF*/ L1D_RF_GetRxPLLifNrfN( rf_band, K, ifN, rfN );
6479/*MT6252RF*/
6480/*MT6252RF*/ // Get GSM850 signal from GSM900 input pins if flag = 1
6481/*MT6252RF*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN |=0x0010000L ;
6482/*MT6252RF*/ break;
6483/*MT6252RF*/ }
6484/*MT6252RF*/ case FrequencyBand900 :
6485/*MT6252RF*/ {
6486/*MT6252RF*/ D = ( arfcn > 974 ) ? ( arfcn - 1024 ) : arfcn;
6487/*MT6252RF*/ K = 240 + 4*D - 130*( ( 3796 + 63*D ) >> 11 );
6488/*MT6252RF*/
6489/*MT6252RF*/ // Nint = 142 + ( ( 3796 + 63 D ) >> 11); *rfN = Nint << 10;
6490/*MT6252RF*/ *rfN = ( 142 << 10 ) + (long)( ( ( 3796 + 63*D ) >> 1 ) & 0xFC00 );
6491/*MT6252RF*/ L1D_RF_GetRxPLLifNrfN( rf_band, K, ifN, rfN );
6492/*MT6252RF*/
6493/*MT6252RF*/ // Get GSM900 signal from GSM850 input pins if flag = 1
6494/*MT6252RF*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap ) *ifN &= (~(0x0010000L));
6495/*MT6252RF*/ break;
6496/*MT6252RF*/ }
6497/*MT6252RF*/ case FrequencyBand1800 :
6498/*MT6252RF*/ {
6499/*MT6252RF*/ D = arfcn - 512;
6500/*MT6252RF*/ K = 112 + 2*D - 130*( ( 3560 + 63*D ) >> 12 );
6501/*MT6252RF*/
6502/*MT6252RF*/ // Nint = 138 + ( (3560 + 63 D) >> 12); *rfN = Nint << 10;
6503/*MT6252RF*/ *rfN = ( 138 << 10 ) + (long)( ( ( 3560 + 63*D ) >> 2 ) & 0xFC00 );
6504/*MT6252RF*/ L1D_RF_GetRxPLLifNrfN( rf_band, K, ifN, rfN );
6505/*MT6252RF*/
6506/*MT6252RF*/ // Get PCS1900 signal from DCS1800 input pins if flag = 1
6507/*MT6252RF*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap ) *ifN |=0x0010000L ;
6508/*MT6252RF*/ break;
6509/*MT6252RF*/ }
6510/*MT6252RF*/ case FrequencyBand1900 :
6511/*MT6252RF*/ {
6512/*MT6252RF*/ D = arfcn - 512;
6513/*MT6252RF*/ K = 62 + 2*D - 130*( ( 1985 + 63*D ) >> 12 );
6514/*MT6252RF*/
6515/*MT6252RF*/ // Nint = 148 + ( ( 1985 + 63*D ) >> 12); *rfN = Nint << 10;
6516/*MT6252RF*/ *rfN = ( 148 << 10 ) + (long)( ( ( 1985 + 63*D ) >> 2 ) & 0xFC00 );
6517/*MT6252RF*/ L1D_RF_GetRxPLLifNrfN( rf_band, K, ifN, rfN );
6518/*MT6252RF*/
6519/*MT6252RF*/ // Get DCS1800 signal from PCS1900 input pins if flag = 1
6520/*MT6252RF*/ if( BBTXParameters.bbrx_dcs1800_pcs1900_swap) *ifN &= (~(0x0010000L));
6521/*MT6252RF*/ break;
6522/*MT6252RF*/ }
6523/*MT6252RF*/ }
6524/*MT6252RF*/ }
6525/*MT6252RF*/ /* ============================================================================= */
6526#endif
6527
6528#if IS_RF_MT6256RF || IS_RF_MT6251RF || IS_RF_MT6255RF
6529 #if IS_MT6256_DCR_MODE || IS_MT6251_DCR_MODE
6530/*MT6256RF*/ //For DCR backup mode
6531/*MT6256RF*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6532/*MT6256RF*/ { long *if_sel = ifN+1;
6533/*MT6256RF*/ unsigned short Nint =0, CH_freq =0;
6534/*MT6256RF*/ unsigned long Nfrac=0, VCO_freq=0;
6535/*MT6256RF*/
6536/*MT6256RF*/ *if_sel = 2;
6537/*MT6256RF*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
6538/*MT6256RF*/
6539/*MT6256RF*/ if( rf_band < FrequencyBand1800 )
6540/*MT6256RF*/ { VCO_freq = 4*CH_freq; }
6541/*MT6256RF*/ else
6542/*MT6256RF*/ { VCO_freq = 2*CH_freq; }
6543/*MT6256RF*/
6544/*MT6256RF*/ Nint = VCO_freq/DCXO_FREQ;
6545/*MT6256RF*/ Nfrac = ( ( (VCO_freq - Nint*DCXO_FREQ)<<23 ) + DCXO_FREQ/2 )/DCXO_FREQ;
6546/*MT6256RF*/
6547/*MT6256RF*/ // CW2, TRX:0, BAND, MODE: standby, N_RFC[22:10]
6548/*MT6256RF*/ *ifN = BSI_CW( 0x02, 0x04000|(Nfrac>>10)|((rf_band-1)<<16) );
6549/*MT6256RF*/ // CW1, DFM_LG_COE, N_INT[7:0], N_FRAC[9:0]
6550/*MT6256RF*/ *rfN = BSI_CW( 0x01, 0xC0000|(Nfrac&0x3FF)|(Nint<<10) );
6551/*MT6256RF*/
6552/*MT6256RF*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap || BBTXParameters.bbrx_dcs1800_pcs1900_swap )
6553/*MT6256RF*/ {
6554/*MT6256RF*/ switch( rf_band )
6555/*MT6256RF*/ {
6556/*MT6256RF*/ case FrequencyBand850 :
6557/*MT6256RF*/ case FrequencyBand1800 :
6558/*MT6256RF*/ { *ifN |= 0x0010000L;
6559/*MT6256RF*/ break;
6560/*MT6256RF*/ }
6561/*MT6256RF*/ case FrequencyBand900 :
6562/*MT6256RF*/ case FrequencyBand1900 :
6563/*MT6256RF*/ { *ifN &= (~(0x0010000L));
6564/*MT6256RF*/ break;
6565/*MT6256RF*/ }
6566/*MT6256RF*/ default:
6567/*MT6256RF*/ { break;
6568/*MT6256RF*/ }
6569/*MT6256RF*/ }
6570/*MT6256RF*/ }
6571/*MT6256RF*/ }
6572/*MT6256RF*/ /* =========================================================================== */
6573 #else
6574/*MT6256RF*/ //For DLIF mode
6575/*MT6256RF*/ void L1D_RF_Cal_Synthesizer_Params( unsigned short* Nint, unsigned long* Nfrac, unsigned long VCO_freq )
6576/*MT6256RF*/ {
6577/*MT6256RF*/ *Nint = VCO_freq/(DCXO_FREQ*DLIF_SCALE);
6578/*MT6256RF*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
6579/*MT6256RF*/ *Nfrac = ( ( (VCO_freq - *Nint*DCXO_FREQ*DLIF_SCALE)<<15 ) + 195/2 )/195;
6580/*MT6256RF*/ }
6581/*MT6256RF*/ /* =========================================================================== */
6582/*MT6256RF*/
6583/*MT6256RF*/ char L1D_RF_Cal_IF_Synth_State( void )
6584/*MT6256RF*/ {
6585 #if IS_W_CANCELLATION_SUPPORT
6586/*MT6256RF*/ if( L1D_CheckIfMetaMode() )
6587/*MT6256RF*/ { return l1d_rf.if_state; }
6588/*MT6256RF*/ else
6589/*MT6256RF*/ { return 0; }
6590 #else
6591/*MT6256RF*/ return 0;
6592 #endif
6593/*MT6256RF*/ }
6594/*MT6256RF*/ /* =========================================================================== */
6595/*MT6256RF*/
6596/*MT6256RF*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6597/*MT6256RF*/ { long *if_sel = ifN+1;
6598/*MT6256RF*/ unsigned short Nint =0, CH_freq =0;
6599/*MT6256RF*/ unsigned long Nfrac=0, VCO_freq=0;
6600/*MT6256RF*/ unsigned long frac_spurs_thd0=0, frac_spurs_thd1=0;
6601/*MT6256RF*/ unsigned char IF_state=0; //IF_state=0:default, IF_state=1:+IF, IF_state=2:-IF
6602/*MT6256RF*/
6603/*MT6256RF*/ IF_state = L1D_RF_Cal_IF_Synth_State();
6604/*MT6256RF*/
6605/*MT6256RF*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
6606/*MT6256RF*/
6607/*MT6256RF*/ if( IF_state != 2 )
6608/*MT6256RF*/ {
6609/*MT6256RF*/ *if_sel = 0;
6610/*MT6256RF*/ if( rf_band < FrequencyBand1800 )
6611/*MT6256RF*/ {
6612/*MT6256RF*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
6613/*MT6256RF*/ frac_spurs_thd0 = 193584;
6614/*MT6256RF*/ frac_spurs_thd1 = 8195024;
6615/*MT6256RF*/ }
6616/*MT6256RF*/ else
6617/*MT6256RF*/ {
6618/*MT6256RF*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
6619/*MT6256RF*/ frac_spurs_thd0 = 96792;
6620/*MT6256RF*/ frac_spurs_thd1 = 8291816;
6621/*MT6256RF*/ }
6622/*MT6256RF*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
6623/*MT6256RF*/ }
6624/*MT6256RF*/
6625/*MT6256RF*/ if( IF_state != 1 )
6626/*MT6256RF*/ {
6627/*MT6256RF*/ // check fractional spurs criterion (for run-time) or IRR state (for IRR calibration)
6628/*MT6256RF*/ if( ( Nfrac < frac_spurs_thd0 ) || ( Nfrac > frac_spurs_thd1) || ( Nfrac < 4258832 && Nfrac > 4129776 ) || ( IF_state == 2 ) )
6629/*MT6256RF*/ {
6630/*MT6256RF*/ *if_sel = 1; //-170k
6631/*MT6256RF*/ if( rf_band < FrequencyBand1800 )
6632/*MT6256RF*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE + DLIF); } //Low-side mixing
6633/*MT6256RF*/ else
6634/*MT6256RF*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE + DLIF); } //Low-side mixing
6635/*MT6256RF*/
6636/*MT6256RF*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
6637/*MT6256RF*/ }
6638/*MT6256RF*/ }
6639/*MT6256RF*/
6640 #if IS_OBB_DETECTION_SUPPORT
6641/*MT6256RF*/ if( !L1D_CheckIfMetaMode() )
6642/*MT6256RF*/ {
6643/*MT6256RF*/ if( l1d_rf.if_change == -1 && arfcn == l1d_rf.obb_arfcn )
6644/*MT6256RF*/ {
6645/*MT6256RF*/ signed short if_sign = l1d_rf.if_change*(*if_sel*2-1);
6646/*MT6256RF*/
6647/*MT6256RF*/ *if_sel = if_sign > 0 ? 1 : 0;
6648/*MT6256RF*/ if( rf_band < FrequencyBand1800 )
6649/*MT6256RF*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
6650/*MT6256RF*/ else
6651/*MT6256RF*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
6652/*MT6256RF*/
6653/*MT6256RF*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
6654/*MT6256RF*/ }
6655/*MT6256RF*/ }
6656 #endif
6657/*MT6256RF*/ // CW2, TRX:0, BAND, MODE: standby, N_RFC[22:10]
6658/*MT6256RF*/ *ifN = BSI_CW( 0x02, 0x04000|(Nfrac>>10)|((rf_band-1)<<16) );
6659/*MT6256RF*/ // CW1, DFM_LG_COE, N_INT[7:0], N_FRAC[9:0]
6660/*MT6256RF*/ *rfN = BSI_CW( 0x01, 0xC0000|(Nfrac&0x3FF)|(Nint<<10) );
6661/*MT6256RF*/
6662/*MT6256RF*/ if( BBTXParameters.bbrx_gsm850_gsm900_swap || BBTXParameters.bbrx_dcs1800_pcs1900_swap )
6663/*MT6256RF*/ {
6664/*MT6256RF*/ switch( rf_band )
6665/*MT6256RF*/ {
6666/*MT6256RF*/ case FrequencyBand850 :
6667/*MT6256RF*/ case FrequencyBand1800 :
6668/*MT6256RF*/ { *ifN |= 0x0010000L;
6669/*MT6256RF*/ break;
6670/*MT6256RF*/ }
6671/*MT6256RF*/ case FrequencyBand900 :
6672/*MT6256RF*/ case FrequencyBand1900 :
6673/*MT6256RF*/ { *ifN &= (~(0x0010000L));
6674/*MT6256RF*/ break;
6675/*MT6256RF*/ }
6676/*MT6256RF*/ default:
6677/*MT6256RF*/ { break;
6678/*MT6256RF*/ }
6679/*MT6256RF*/ }
6680/*MT6256RF*/ }
6681/*MT6256RF*/ }
6682/*MT6256RF*/ /* =========================================================================== */
6683 #endif
6684/*MT6256RF*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6685/*MT6256RF*/ {
6686/*MT6256RF*/ unsigned short Nint =0, CH_freq =0;
6687/*MT6256RF*/ unsigned long Nfrac=0, VCO_freq=0;
6688/*MT6256RF*/
6689/*MT6256RF*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_GetSData_ST2()
6690/*MT6256RF*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
6691/*MT6256RF*/
6692/*MT6256RF*/ if( rf_band < FrequencyBand1800 )
6693/*MT6256RF*/ { VCO_freq = 4*CH_freq; }
6694/*MT6256RF*/ else
6695/*MT6256RF*/ { VCO_freq = 2*CH_freq; }
6696/*MT6256RF*/
6697/*MT6256RF*/ Nint = VCO_freq/DCXO_FREQ;
6698/*MT6256RF*/ Nfrac = ( ((VCO_freq-Nint*DCXO_FREQ)<<23) + DCXO_FREQ/2 )/DCXO_FREQ; //+DCXO_freq/2 is for rounding
6699/*MT6256RF*/
6700/*MT6256RF*/ // CW2, TRX:1, BAND, MODE: standby, N_RFC[22:10]
6701/*MT6256RF*/ *ifN = BSI_CW( 0x02, 0x44000|(Nfrac>>10)|((rf_band-1)<<16) );
6702/*MT6256RF*/ // CW1, DFM_LG_COE, N_INT[7:0], N_FRAC[9:0]
6703/*MT6256RF*/ *rfN = BSI_CW( 0x01, 0xC0000|(Nfrac&0x3FF)|(Nint<<10) );
6704 #if IS_CHIP_MT6256_S00 || IS_CHIP_MT6251_S00
6705 /* Do nothing */
6706 #elif IS_CHIP_MT6256 || IS_CHIP_MT6255
6707/*MT6256RF*/ if( ( Nfrac>=225847 && Nfrac<=419430 ) || ( Nfrac>=1000180 && Nfrac<=1193763 ) ||
6708/*MT6256RF*/ ( Nfrac>=1903568 && Nfrac<=2097152 ) || ( Nfrac>=3452234 && Nfrac<=3645818 ) ||
6709/*MT6256RF*/ ( Nfrac>=4484678 && Nfrac<=4678262 ) || ( Nfrac>=5000900 && Nfrac<=5065428 ) ||
6710/*MT6256RF*/ ( Nfrac>=5517122 && Nfrac<=5581650 ) || ( Nfrac>=7452955 && Nfrac<=7904649 )
6711/*MT6256RF*/ )
6712/*MT6256RF*/ { /*CW1, DFM_LG_COE = 0*/
6713/*MT6256RF*/ *rfN &= ~(1<<19);
6714/*MT6256RF*/ }
6715 #elif IS_CHIP_MT6251
6716/*MT6251RF*/ if( ( Nfrac>=1774513 && Nfrac<=2355264 ) || ( Nfrac>=2936012 && Nfrac<=3129597 ) ||
6717/*MT6251RF*/ ( Nfrac>=3452235 && Nfrac<=3516763 ) || ( Nfrac>=3968457 && Nfrac<=4162041 ) ||
6718/*MT6251RF*/ ( Nfrac>=6162401 && Nfrac<=6355983 ) || ( Nfrac>=6807678 && Nfrac<=7130316 ) ||
6719/*MT6251RF*/ ( Nfrac>=7711067 && Nfrac<=8033705 ) )
6720/*MT6251RF*/ { /*CW1, DFM_LG_COE = 0*/
6721/*MT6251RF*/ *rfN &= ~(1<<19);
6722/*MT6251RF*/ }
6723 #endif
6724/*MT6256RF*/ }
6725/*MT6256RF*/ /* =========================================================================== */
6726/*MT6256RF*/
6727/*MT6256RF*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
6728/*MT6256RF*/ {
6729/*MT6256RF*/ unsigned short freq=4450+225;
6730/*MT6256RF*/ switch( rf_band )
6731/*MT6256RF*/ {
6732/*MT6256RF*/ case FrequencyBand850 :
6733/*MT6256RF*/ {
6734/*MT6256RF*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
6735/*MT6256RF*/ break;
6736/*MT6256RF*/ }
6737/*MT6256RF*/ case FrequencyBand900 :
6738/*MT6256RF*/ {
6739/*MT6256RF*/ if( arfcn<=124 )
6740/*MT6256RF*/ { freq=4450+arfcn+225; }
6741/*MT6256RF*/ else
6742/*MT6256RF*/ { freq=4450+(arfcn-1024)+225; }
6743/*MT6256RF*/ break;
6744/*MT6256RF*/ }
6745/*MT6256RF*/ case FrequencyBand1800 :
6746/*MT6256RF*/ {
6747/*MT6256RF*/ freq=8551+(arfcn-512)+475;
6748/*MT6256RF*/ break;
6749/*MT6256RF*/ }
6750/*MT6256RF*/ case FrequencyBand1900 :
6751/*MT6256RF*/ {
6752/*MT6256RF*/ freq=9251+(arfcn-512)+400;
6753/*MT6256RF*/ break;
6754/*MT6256RF*/ }
6755/*MT6256RF*/ default :
6756/*MT6256RF*/ {
6757/*MT6256RF*/ break;
6758/*MT6256RF*/ }
6759/*MT6256RF*/ }
6760/*MT6256RF*/
6761/*MT6256RF*/ return freq;
6762/*MT6256RF*/ }
6763/*MT6256RF*/ /* =========================================================================== */
6764/*MT6256RF*/
6765/*MT6256RF*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
6766/*MT6256RF*/ {
6767/*MT6256RF*/ unsigned short freq=4450;
6768/*MT6256RF*/ switch( rf_band )
6769/*MT6256RF*/ {
6770/*MT6256RF*/ case FrequencyBand850 :
6771/*MT6256RF*/ {
6772/*MT6256RF*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
6773/*MT6256RF*/ break;
6774/*MT6256RF*/ }
6775/*MT6256RF*/ case FrequencyBand900 :
6776/*MT6256RF*/ {
6777/*MT6256RF*/ if( arfcn<=124 )
6778/*MT6256RF*/ { freq=4450+arfcn; }
6779/*MT6256RF*/ else
6780/*MT6256RF*/ { freq=4450+(arfcn-1024); }
6781/*MT6256RF*/ break;
6782/*MT6256RF*/ }
6783/*MT6256RF*/ case FrequencyBand1800 :
6784/*MT6256RF*/ {
6785/*MT6256RF*/ freq=8551+(arfcn-512);
6786/*MT6256RF*/ break;
6787/*MT6256RF*/ }
6788/*MT6256RF*/ case FrequencyBand1900 :
6789/*MT6256RF*/ {
6790/*MT6256RF*/ freq=9251+(arfcn-512);
6791/*MT6256RF*/ break;
6792/*MT6256RF*/ }
6793/*MT6256RF*/ default :
6794/*MT6256RF*/ {
6795/*MT6256RF*/ break;
6796/*MT6256RF*/ }
6797/*MT6256RF*/ }
6798/*MT6256RF*/
6799/*MT6256RF*/ return freq;
6800/*MT6256RF*/ }
6801/*MT6256RF*/ /* =========================================================================== */
6802#endif
6803
6804#if IS_RF_SKY74045
6805/*SKY74045*/
6806/*SKY74045*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6807/*SKY74045*/ { int Nfrac=0;
6808/*SKY74045*/
6809/*SKY74045*/ switch(rf_band)
6810/*SKY74045*/ {
6811/*SKY74045*/ case FrequencyBand850 :
6812/*SKY74045*/ {
6813/*SKY74045*/ if (arfcn <= 180)
6814/*SKY74045*/ { if (arfcn <= 136) /* ARFCN : 128~136 */
6815/*SKY74045*/ { Nfrac = 3323179 + 96792*(arfcn-128) - ((arfcn-128)>>2) ;
6816/*SKY74045*/ *rfN = 0x008538 | (96L<<16);
6817/*SKY74045*/ }
6818/*SKY74045*/ else /* ARFCN : 137~180 */
6819/*SKY74045*/ { Nfrac = 96791*(arfcn-137) + ((arfcn-137)>>2) +3 ;
6820/*SKY74045*/ *rfN = 0x008538 | (97L<<16);
6821/*SKY74045*/ }
6822/*SKY74045*/ }
6823/*SKY74045*/ else
6824/*SKY74045*/ { if (arfcn <= 223) /* ARFCN : 181~223 */
6825/*SKY74045*/ { Nfrac = 64528 + 96792*(arfcn-181) - ((arfcn-181)>>2) -3 ;
6826/*SKY74045*/ *rfN = 0x008538 | (98L<<16);
6827/*SKY74045*/ }
6828/*SKY74045*/ else /* ARFCN : 224~251 */
6829/*SKY74045*/ { Nfrac = 32264 + 96792*(arfcn-224) - ((arfcn-224)>>2) -2 ;
6830/*SKY74045*/ *rfN = 0x008538 | (99L<<16);
6831/*SKY74045*/ }
6832/*SKY74045*/ }
6833/*SKY74045*/ break;
6834/*SKY74045*/ }
6835/*SKY74045*/ case FrequencyBand900 :
6836/*SKY74045*/ {
6837/*SKY74045*/ if (arfcn <=113)
6838/*SKY74045*/ { if (arfcn<=26) /* ARFCN : 0~26 */
6839/*SKY74045*/ { Nfrac = 1613194 + 96792*arfcn - (arfcn>>2) - 2 ;
6840/*SKY74045*/ *rfN = 0x008538 | (104L<<16);
6841/*SKY74045*/ }
6842/*SKY74045*/ else if (arfcn<=69) /* ARFCN : 27~69 */
6843/*SKY74045*/ { Nfrac = 32264 + (96792*(arfcn-27)) - ((arfcn-27)>>2) - 3 ;
6844/*SKY74045*/ *rfN = 0x008538 | (105L<<16);
6845/*SKY74045*/ }
6846/*SKY74045*/ else /* ARFCN : 70~113 */
6847/*SKY74045*/ { Nfrac = (96791*(arfcn-70)) + ((arfcn-70)>>1) + 3 ;
6848/*SKY74045*/ *rfN = 0x008538 | (106L<<16);
6849/*SKY74045*/ }
6850/*SKY74045*/ }
6851/*SKY74045*/ else
6852/*SKY74045*/ { if (arfcn<=1007)
6853/*SKY74045*/ { if (arfcn<=124) /* ARFCN : 114~124 */
6854/*SKY74045*/ { Nfrac = 64528 + (96792*(arfcn-114)) - ((arfcn-114)>>2) ;
6855/*SKY74045*/ *rfN = 0x008538 | (107L<<16);
6856/*SKY74045*/ }
6857/*SKY74045*/ else /* ARFCN : 975~1007 */
6858/*SKY74045*/ { Nfrac = 1064708 + (96792*(arfcn-975)) - ((arfcn-975)>>2) - 2 ;
6859/*SKY74045*/ *rfN = 0x008538 | (103L<<16);
6860/*SKY74045*/ }
6861/*SKY74045*/ }
6862/*SKY74045*/ else /* ARFCN : 1008~1023 */
6863/*SKY74045*/ { Nfrac = 64528 + (96792*(arfcn-1008)) - ((arfcn-1008)>>2) - 2 ;
6864/*SKY74045*/ *rfN = 0x008538 | (104L<<16);
6865/*SKY74045*/ }
6866/*SKY74045*/ }
6867/*SKY74045*/ break;
6868/*SKY74045*/ }
6869/*SKY74045*/ case FrequencyBand1800 :
6870/*SKY74045*/ {
6871/*SKY74045*/ if (arfcn<=715)
6872/*SKY74045*/ { if(arfcn<=542) /* ARFCN : 512~542 */
6873/*SKY74045*/ { Nfrac = 2710166 + (48396*(arfcn-512)) - ((arfcn-512)>>2);
6874/*SKY74045*/ *rfN = 0x008568 | (100L<<16);
6875/*SKY74045*/ }
6876/*SKY74045*/ else if (arfcn<=629) /* ARFCN : 543~629 */
6877/*SKY74045*/ { Nfrac = 16132 + (48396*(arfcn-543)) - ((arfcn-543)>>2) +2 ;
6878/*SKY74045*/ *rfN = 0x008568 | (101L<<16);
6879/*SKY74045*/ }
6880/*SKY74045*/ else /* ARFCN : 630~715 */
6881/*SKY74045*/ { Nfrac = 32264 + (48396*(arfcn-630)) - ((arfcn-630)>>2) +2 ;
6882/*SKY74045*/ *rfN = 0x008568 | (102L<<16);
6883/*SKY74045*/ }
6884/*SKY74045*/ }
6885/*SKY74045*/ else
6886/*SKY74045*/ { if (arfcn<=802) /* ARFCN : 716~802 */
6887/*SKY74045*/ { Nfrac = (48396*(arfcn-716)) - ((arfcn-716)>>2) +2 ;
6888/*SKY74045*/ *rfN = 0x008568 | (103L<<16);
6889/*SKY74045*/ }
6890/*SKY74045*/ else /* ARFCN : 803~885 */
6891/*SKY74045*/ { Nfrac = 16132 + (48396*(arfcn-803)) - ((arfcn-803)>>2) +2 ;
6892/*SKY74045*/ *rfN = 0x008568 | (104L<<16);
6893/*SKY74045*/ }
6894/*SKY74045*/ }
6895/*SKY74045*/ break;
6896/*SKY74045*/ }
6897/*SKY74045*/ case FrequencyBand1900 :
6898/*SKY74045*/ {
6899/*SKY74045*/ if (arfcn<=697)
6900/*SKY74045*/ { if(arfcn<=524) /* ARFCN : 512~524 */
6901/*SKY74045*/ { Nfrac = 3597422 + (48396*(arfcn-512)) - ((arfcn-512)>>2) ;
6902/*SKY74045*/ *rfN = 0x008568 | (107L<<16);
6903/*SKY74045*/ }
6904/*SKY74045*/ else if (arfcn<=610) /* ARFCN : 525~610 */
6905/*SKY74045*/ { Nfrac = 32264 + (48396*(arfcn-525)) - ((arfcn-525)>>2) +2 ;
6906/*SKY74045*/ *rfN = 0x008568 | (108L<<16);
6907/*SKY74045*/ }
6908/*SKY74045*/ else /* ARFCN : 611~697 */
6909/*SKY74045*/ { Nfrac = (48396*(arfcn-611)) - ((arfcn-611)>>2) +2 ;
6910/*SKY74045*/ *rfN = 0x008568 | (109L<<16);
6911/*SKY74045*/ }
6912/*SKY74045*/ }
6913/*SKY74045*/ else
6914/*SKY74045*/ { if (arfcn<=784) /* ARFCN : 698~784 */
6915/*SKY74045*/ { Nfrac = 16132 + (48396*(arfcn-698)) - ((arfcn-698)>>2) +2 ;
6916/*SKY74045*/ *rfN = 0x008568 | (110L<<16);
6917/*SKY74045*/ }
6918/*SKY74045*/ else /* ARFCN : 785~810 */
6919/*SKY74045*/ { Nfrac = 32264 + (48396*(arfcn-785)) - ((arfcn-785)>>2) ;
6920/*SKY74045*/ *rfN = 0x008568 | (111L<<16);
6921/*SKY74045*/ }
6922/*SKY74045*/ }
6923/*SKY74045*/ break;
6924/*SKY74045*/ }
6925/*SKY74045*/ default :
6926/*SKY74045*/ {
6927/*SKY74045*/ break;
6928/*SKY74045*/ }
6929/*SKY74045*/ }
6930/*SKY74045*/ *ifN = 0x2 | (Nfrac<<2);
6931/*SKY74045*/ }
6932/*SKY74045*/ /* =========================================================================== */
6933/*SKY74045*/
6934/*SKY74045*/ char SKY_d_flag = 0;
6935/*SKY74045*/ char SKY_TXCP = 0; //tx charge pump current choice
6936/*SKY74045*/
6937/*SKY74045*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
6938/*SKY74045*/ { int Nfrac=0;
6939/*SKY74045*/
6940/*SKY74045*/ switch(rf_band)
6941/*SKY74045*/ {
6942/*SKY74045*/ case FrequencyBand850 :
6943/*SKY74045*/ {
6944/*SKY74045*/ if (arfcn <= 186)
6945/*SKY74045*/ { if (arfcn <= 147) /* ARFCN : 128~147 */
6946/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
6947/*SKY74045*/ Nfrac = 2044723 + 108891*(arfcn-128) - ((arfcn-128)>>2) -2 ;
6948/*SKY74045*/ *rfN = 0x008538 | (103L<<16);
6949/*SKY74045*/ }
6950/*SKY74045*/ else /* ARFCN : 148~186 */
6951/*SKY74045*/ { if ( (arfcn ==166) || (arfcn ==168) )
6952/*SKY74045*/ { SKY_d_flag = 0x2; //D = 10
6953/*SKY74045*/ Nfrac = 591504 + (arfcn - 166)*107546 ;
6954/*SKY74045*/ *rfN = 0x008538 | (103L<<16);
6955/*SKY74045*/ }
6956/*SKY74045*/ else
6957/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
6958/*SKY74045*/ Nfrac = 28231 + 108891*(arfcn-148) - ((arfcn-148)>>2) -4 ;
6959/*SKY74045*/ *rfN = 0x008538 | (104L<<16);
6960/*SKY74045*/ }
6961/*SKY74045*/ }
6962/*SKY74045*/ }
6963/*SKY74045*/ else
6964/*SKY74045*/ {
6965/*SKY74045*/ if (arfcn <= 224) /* ARFCN : 187~224 */
6966/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
6967/*SKY74045*/ Nfrac = 80660 + 108891*(arfcn-187) - ((arfcn-187)>>2) -4 ;
6968/*SKY74045*/ *rfN = 0x008538 | (105L<<16);
6969/*SKY74045*/ }
6970/*SKY74045*/ else /* ARFCN : 225~251 */
6971/*SKY74045*/ { if ( (arfcn == 243) || (arfcn == 244) )
6972/*SKY74045*/ { SKY_d_flag = 0x2; //D = 10
6973/*SKY74045*/ Nfrac = 483958 + (arfcn - 243)*107546 ;
6974/*SKY74045*/ *rfN = 0x008538 | (105L<<16);
6975/*SKY74045*/ }
6976/*SKY74045*/ else
6977/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
6978/*SKY74045*/ Nfrac = 24198 + 108891*(arfcn-225) - ((arfcn-225)>>2) -3 ;
6979/*SKY74045*/ *rfN = 0x008538 | (106L<<16);
6980/*SKY74045*/ }
6981/*SKY74045*/ }
6982/*SKY74045*/ }
6983/*SKY74045*/ break;
6984/*SKY74045*/ }
6985/*SKY74045*/ case FrequencyBand900 :
6986/*SKY74045*/ {
6987/*SKY74045*/ if(arfcn<=99)
6988/*SKY74045*/ { if(arfcn<=54)
6989/*SKY74045*/ { if(arfcn<=34) /* ARFCN : 0~34 */
6990/*SKY74045*/ { if (arfcn == 18)
6991/*SKY74045*/ { SKY_d_flag = 0x2; //D = 10
6992/*SKY74045*/ Nfrac = 268866;
6993/*SKY74045*/ *rfN = 0x008538 | (111L<<16);
6994/*SKY74045*/ }
6995/*SKY74045*/ else
6996/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
6997/*SKY74045*/ Nfrac = 120990 + (108891*arfcn) - (arfcn>>2) -4 ;
6998/*SKY74045*/ *rfN = 0x008538 | (112L<<16);
6999/*SKY74045*/ }
7000/*SKY74045*/ }
7001/*SKY74045*/ else /* ARFCN : 35~54 */
7002/*SKY74045*/ { SKY_d_flag = 0x2; //D = 10
7003/*SKY74045*/ Nfrac = 2097152 + (107546*(arfcn-35)) - ((arfcn-35)>>2) ;
7004/*SKY74045*/ *rfN = 0x008538 | (111L<<16);
7005/*SKY74045*/ }
7006/*SKY74045*/ }
7007/*SKY74045*/ else
7008/*SKY74045*/ { if(arfcn<=90) /* ARFCN : 55~90 */
7009/*SKY74045*/ { SKY_d_flag = 0x2; //D = 10
7010/*SKY74045*/ Nfrac = 53773 + (107546*(arfcn-55)) - ((arfcn-55)>>2) ;
7011/*SKY74045*/ *rfN = 0x008538 | (112L<<16);
7012/*SKY74045*/ }
7013/*SKY74045*/ else /* ARFCN : 91~99 */
7014/*SKY74045*/ { SKY_d_flag = 0x1; //D = 11
7015/*SKY74045*/ Nfrac = 3236067 + (106471*(arfcn-91)) - ((arfcn-91)>>2) ;
7016/*SKY74045*/ *rfN = 0x008538 | (111L<<16);
7017/*SKY74045*/ }
7018/*SKY74045*/ }
7019/*SKY74045*/ }
7020/*SKY74045*/ else
7021/*SKY74045*/ { if(arfcn<=984)
7022/*SKY74045*/ { if(arfcn<=124) /* ARFCN : 100~124 */
7023/*SKY74045*/ { SKY_d_flag = 0x1; //D = 11
7024/*SKY74045*/ Nfrac = (106471*(arfcn-100)) - ((arfcn-100)>>2) ;
7025/*SKY74045*/ *rfN = 0x008538 | (112L<<16);
7026/*SKY74045*/ }
7027/*SKY74045*/ else /* ARFCN : 975~984 */
7028/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
7029/*SKY74045*/ Nfrac = 3173959 + (108891*(arfcn-975)) - ((arfcn-975)>>2) -1 ;
7030/*SKY74045*/ *rfN = 0x008538 | (110L<<16);
7031/*SKY74045*/ }
7032/*SKY74045*/ }
7033/*SKY74045*/ else
7034/*SKY74045*/ { if (arfcn == 1023) /* ARFCN : 1023 */
7035/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
7036/*SKY74045*/ Nfrac = 12099;
7037/*SKY74045*/ *rfN = 0x008538 | (112L<<16);
7038/*SKY74045*/ }
7039/*SKY74045*/ else /* ARFCN : 985~1022 */
7040/*SKY74045*/ { SKY_d_flag = 0x0; //D = 9
7041/*SKY74045*/ Nfrac = 68561 + (108891*(arfcn-985)) - ((arfcn-985)>>2) -4 ;
7042/*SKY74045*/ *rfN = 0x008538 | (111L<<16);
7043/*SKY74045*/ }
7044/*SKY74045*/ }
7045/*SKY74045*/ }
7046/*SKY74045*/
7047/*SKY74045*/ /* choose tx cp current */
7048/*SKY74045*/ if (arfcn<100)
7049/*SKY74045*/ SKY_TXCP = 0;
7050/*SKY74045*/ else
7051/*SKY74045*/ SKY_TXCP = 1;
7052/*SKY74045*/
7053/*SKY74045*/ break;
7054/*SKY74045*/ }
7055/*SKY74045*/ case FrequencyBand1800 :
7056/*SKY74045*/ {
7057/*SKY74045*/ if (arfcn <= 740)
7058/*SKY74045*/ {
7059/*SKY74045*/ if(arfcn<=576) /* ARFCN : 512~576 */
7060/*SKY74045*/ {
7061/*SKY74045*/ if ( (arfcn == 534) || (arfcn == 538) )
7062/*SKY74045*/ {
7063/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7064/*SKY74045*/ Nfrac = 77312 + (arfcn-534)*51135 ;
7065/*SKY74045*/ *rfN = 0x008568 | (101L<<16);
7066/*SKY74045*/ }
7067/*SKY74045*/ else
7068/*SKY74045*/ {
7069/*SKY74045*/ SKY_d_flag = 0x0; //D = 13
7070/*SKY74045*/ Nfrac = 864540 + (51359*(arfcn-512)) - ((arfcn-512)>>2) +2 ;
7071/*SKY74045*/ *rfN = 0x008568 | (101L<<16);
7072/*SKY74045*/ }
7073/*SKY74045*/ }
7074/*SKY74045*/ else if (arfcn <= 658) /* ARFCN : 577~658 */
7075/*SKY74045*/ {
7076/*SKY74045*/ if ( (arfcn == 618) || (arfcn == 620) )
7077/*SKY74045*/ {
7078/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7079/*SKY74045*/ Nfrac = 178364 + (arfcn-618)*51135 ;
7080/*SKY74045*/ *rfN = 0x008568 | (102L<<16);
7081/*SKY74045*/ }
7082/*SKY74045*/ else
7083/*SKY74045*/ {
7084/*SKY74045*/ SKY_d_flag = 0x0; //D = 13
7085/*SKY74045*/ Nfrac = 8560 + (51359*(arfcn-577)) - ((arfcn-577)>>2) +3 ;
7086/*SKY74045*/ *rfN = 0x008568 | (102L<<16);
7087/*SKY74045*/ }
7088/*SKY74045*/ }
7089/*SKY74045*/ else /* ARFCN : 659~740 */
7090/*SKY74045*/ {
7091/*SKY74045*/ if ( (arfcn == 697) || (arfcn == 699) || (arfcn == 702) )
7092/*SKY74045*/ {
7093/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7094/*SKY74045*/ Nfrac = 23741 + (arfcn-697)*51135 ;
7095/*SKY74045*/ *rfN = 0x008568 | (103L<<16);
7096/*SKY74045*/ }
7097/*SKY74045*/ else
7098/*SKY74045*/ {
7099/*SKY74045*/ SKY_d_flag = 0x0; //D = 13
7100/*SKY74045*/ Nfrac = 25679 + (51359*(arfcn-659)) - ((arfcn-659)>>2) +3 ;
7101/*SKY74045*/ *rfN = 0x008568 | (103L<<16);
7102/*SKY74045*/ }
7103/*SKY74045*/ }
7104/*SKY74045*/ }
7105/*SKY74045*/ else
7106/*SKY74045*/ {
7107/*SKY74045*/ if (arfcn <= 821) /* ARFCN : 741~821 */
7108/*SKY74045*/ {
7109/*SKY74045*/ if ( (arfcn == 779) || (arfcn == 783) || (arfcn == 791) )
7110/*SKY74045*/ {
7111/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7112/*SKY74045*/ Nfrac = 22524 + (arfcn-779)*51135 ;
7113/*SKY74045*/ *rfN = 0x008568 | (104L<<16);
7114/*SKY74045*/ }
7115/*SKY74045*/ else
7116/*SKY74045*/ {
7117/*SKY74045*/ SKY_d_flag = 0x0; //D = 13
7118/*SKY74045*/ Nfrac = 42799 + (51359*(arfcn-741)) - ((arfcn-741)>>2) +3 ;
7119/*SKY74045*/ *rfN = 0x008568 | (104L<<16);
7120/*SKY74045*/ }
7121/*SKY74045*/ }
7122/*SKY74045*/ else /* ARFCN : 822~885 */
7123/*SKY74045*/ {
7124/*SKY74045*/ if (arfcn == 860)
7125/*SKY74045*/ {
7126/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7127/*SKY74045*/ Nfrac = 4164475;
7128/*SKY74045*/ *rfN = 0x008568 | (104L<<16);
7129/*SKY74045*/ }
7130/*SKY74045*/ else if ( (arfcn == 863) || (arfcn == 865) )
7131/*SKY74045*/ {
7132/*SKY74045*/ SKY_d_flag = 0x2; //D = 14
7133/*SKY74045*/ Nfrac = 123577 + (arfcn-863)*51135 ;
7134/*SKY74045*/ *rfN = 0x008568 | (105L<<16);
7135/*SKY74045*/ }
7136/*SKY74045*/ else
7137/*SKY74045*/ {
7138/*SKY74045*/ SKY_d_flag = 0x0; //D = 13
7139/*SKY74045*/ Nfrac = 8560 + (51359*(arfcn-822)) - ((arfcn-822)>>2) +1 ;
7140/*SKY74045*/ *rfN = 0x008568 | (105L<<16);
7141/*SKY74045*/ }
7142/*SKY74045*/ }
7143/*SKY74045*/ }
7144/*SKY74045*/ /* choose tx cp current */
7145/*SKY74045*/ if (arfcn<661)
7146/*SKY74045*/ SKY_TXCP = 0;
7147/*SKY74045*/ else
7148/*SKY74045*/ SKY_TXCP = 1;
7149/*SKY74045*/
7150/*SKY74045*/ break;
7151/*SKY74045*/ }
7152/*SKY74045*/ case FrequencyBand1900 :
7153/*SKY74045*/ {
7154/*SKY74045*/ if(arfcn<=652)
7155/*SKY74045*/ {
7156/*SKY74045*/ if(arfcn<=570) /* ARFCN : 512~570 */
7157/*SKY74045*/ {
7158/*SKY74045*/ if ( (arfcn == 530) || (arfcn == 532) )
7159/*SKY74045*/ { SKY_d_flag = 0x3; //D = 16
7160/*SKY74045*/ Nfrac = 2977268 + (arfcn-530)*50776 ;
7161/*SKY74045*/ *rfN = 0x008568 | (108L<<16);
7162/*SKY74045*/ }
7163/*SKY74045*/ else
7164/*SKY74045*/ { SKY_d_flag = 0x2; //D = 14
7165/*SKY74045*/ Nfrac = 1192546 + (51135*(arfcn-512)) - ((arfcn-512)>>2) -1 ;
7166/*SKY74045*/ *rfN = 0x008568 | (109L<<16);
7167/*SKY74045*/ }
7168/*SKY74045*/ }
7169/*SKY74045*/ else /* ARFCN : 571~652 */
7170/*SKY74045*/ {
7171/*SKY74045*/ if ( (arfcn == 609) || (arfcn == 610) || (arfcn == 612) || (arfcn == 614) | (arfcn == 628))
7172/*SKY74045*/ { SKY_d_flag = 0x3; //D = 16
7173/*SKY74045*/ Nfrac = 2794263 + (arfcn-609)*50776 ;
7174/*SKY74045*/ *rfN = 0x008568 | (109L<<16);
7175/*SKY74045*/ }
7176/*SKY74045*/ else
7177/*SKY74045*/ { SKY_d_flag = 0x2; //D = 14
7178/*SKY74045*/ Nfrac = 15219 + (51135*(arfcn-571)) - ((arfcn-571)>>2) -2 ;
7179/*SKY74045*/ *rfN = 0x008568 | (110L<<16);
7180/*SKY74045*/ }
7181/*SKY74045*/ }
7182/*SKY74045*/ }
7183/*SKY74045*/ else
7184/*SKY74045*/ {
7185/*SKY74045*/ if(arfcn<=734) /* ARFCN : 653~734 */
7186/*SKY74045*/ {
7187/*SKY74045*/ if ( (arfcn == 694) || (arfcn == 696) )
7188/*SKY74045*/ { SKY_d_flag = 0x3; //D = 16
7189/*SKY74045*/ Nfrac = 2915914 + (arfcn-694)*50776 ;
7190/*SKY74045*/ *rfN = 0x008568 | (110L<<16);
7191/*SKY74045*/ }
7192/*SKY74045*/ else
7193/*SKY74045*/ { SKY_d_flag = 0x2; //D = 14
7194/*SKY74045*/ Nfrac = 14001 + (51135*(arfcn-653)) - ((arfcn-653)>>2) -1 ;
7195/*SKY74045*/ *rfN = 0x008568 | (111L<<16);
7196/*SKY74045*/ }
7197/*SKY74045*/ }
7198/*SKY74045*/ else /* ARFCN : 735~810 */
7199/*SKY74045*/ {
7200/*SKY74045*/ if ( (arfcn == 773) || (arfcn == 774) || (arfcn == 776) || (arfcn == 778) )
7201/*SKY74045*/ { SKY_d_flag = 0x3; //D = 16
7202/*SKY74045*/ Nfrac = 2732909 + (arfcn-773)*50776 ;
7203/*SKY74045*/ *rfN = 0x008568 | (111L<<16);
7204/*SKY74045*/ }
7205/*SKY74045*/ else
7206/*SKY74045*/ { SKY_d_flag = 0x2; //D = 14
7207/*SKY74045*/ Nfrac = 12784 + (51135*(arfcn-735)) - ((arfcn-735)>>2) -2 ;
7208/*SKY74045*/ *rfN = 0x008568 | (112L<<16);
7209/*SKY74045*/ }
7210/*SKY74045*/ }
7211/*SKY74045*/ }
7212/*SKY74045*/
7213/*SKY74045*/ /* choose tx cp current */
7214/*SKY74045*/ if (arfcn<611)
7215/*SKY74045*/ SKY_TXCP = 0;
7216/*SKY74045*/ else
7217/*SKY74045*/ SKY_TXCP = 1;
7218/*SKY74045*/
7219/*SKY74045*/ break;
7220/*SKY74045*/ }
7221/*SKY74045*/ default :
7222/*SKY74045*/ {
7223/*SKY74045*/ break;
7224/*SKY74045*/ }
7225/*SKY74045*/ }
7226/*SKY74045*/ *ifN = 0x2 | (Nfrac<<2);
7227/*SKY74045*/ }
7228/*SKY74045*/ /* =========================================================================== */
7229#endif
7230
7231#if IS_RF_AERO2
7232/*AERO2*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7233/*AERO2*/ {
7234/*AERO2*/ int BandInd = (~rf_band )& 0x01; /* 1:GSM/PCS, 0:GSM850/DCS */
7235/*AERO2*/ *rfN = (BandInd<<16) | (arfcn<<6) | 0x00021L;
7236/*AERO2*/ *ifN = 0;
7237/*AERO2*/ }
7238/*AERO2*/ /* =========================================================================== */
7239/*AERO2*/
7240/*AERO2*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7241/*AERO2*/ {
7242/*AERO2*/ int BandInd = (~rf_band )& 0x01; /* 1:GSM/PCS, 0:GSM850/DCS */
7243/*AERO2*/ *rfN = (BandInd<<16) | (arfcn<<6) | 0x00021L;
7244/*AERO2*/ *ifN = 0;
7245/*AERO2*/ }
7246/*AERO2*/ /* =========================================================================== */
7247#endif
7248
7249#if IS_RF_SKY74137
7250/*SKY74137*/
7251/*SKY74137*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7252/*SKY74137*/ { int Nfrac=0;
7253/*SKY74137*/
7254/*SKY74137*/ switch(rf_band)
7255/*SKY74137*/ {
7256/*SKY74137*/ case FrequencyBand850 :
7257/*SKY74137*/ {
7258/*SKY74137*/ if (arfcn <= 201)
7259/*SKY74137*/ { if (arfcn <= 158) /* ARFCN : 128~158 */
7260/*SKY74137*/ { Nfrac = 1226027 + 96792*(arfcn-128) - ((arfcn-128)>>2) -2 ;
7261/*SKY74137*/ *rfN = 0xE20000 | (97L<<6);
7262/*SKY74137*/ }
7263/*SKY74137*/ else /* ARFCN : 159~201 */
7264/*SKY74137*/ { Nfrac = 32264 + 96791*(arfcn-159) + ((arfcn-159)>>1) +3 ;
7265/*SKY74137*/ *rfN = 0xE20000 | (98L<<6);
7266/*SKY74137*/ }
7267/*SKY74137*/ }
7268/*SKY74137*/ else
7269/*SKY74137*/ { if (arfcn <= 245) /* ARFCN : 202~245 */
7270/*SKY74137*/ { Nfrac = 96792*(arfcn-202) - ((arfcn-202)>>1) +2 ;
7271/*SKY74137*/ *rfN = 0xE20000 | (99L<<6);
7272/*SKY74137*/ }
7273/*SKY74137*/ else /* ARFCN : 246~251 */
7274/*SKY74137*/ { Nfrac = 64528 + 96792*(arfcn-246) - ((arfcn-246)>>2) ;
7275/*SKY74137*/ *rfN = 0xE20000 | (100L<<6);
7276/*SKY74137*/ }
7277/*SKY74137*/ }
7278/*SKY74137*/ break;
7279/*SKY74137*/ }
7280/*SKY74137*/ case FrequencyBand900 :
7281/*SKY74137*/ {
7282/*SKY74137*/ if (arfcn<=91)
7283/*SKY74137*/ { if (arfcn<=4) /* ARFCN : 0~4 */
7284/*SKY74137*/ { Nfrac = 3710346 + 96792*arfcn - (arfcn>>2) ;
7285/*SKY74137*/ *rfN = 0xE20000 | (104L<<6);
7286/*SKY74137*/ }
7287/*SKY74137*/ else if (arfcn<=48) /* ARFCN : 5~48 */
7288/*SKY74137*/ { Nfrac = 0 + (96792*(arfcn-5)) - ((arfcn-5)>>1) +2 ;
7289/*SKY74137*/ *rfN = 0xE20000 | (105L<<6);
7290/*SKY74137*/ }
7291/*SKY74137*/ else /* ARFCN : 49~91 */
7292/*SKY74137*/ { Nfrac = 64528 + (96792*(arfcn-49)) - ((arfcn-49)>>2) -3 ;
7293/*SKY74137*/ *rfN = 0xE20000 | (106L<<6);
7294/*SKY74137*/ }
7295/*SKY74137*/ }
7296/*SKY74137*/ else
7297/*SKY74137*/ { if (arfcn<=985)
7298/*SKY74137*/ { if (arfcn<=124) /* ARFCN : 92~124 */
7299/*SKY74137*/ { Nfrac = 32264 + (96791*(arfcn-92)) + ((arfcn-92)>>1) +2 ;
7300/*SKY74137*/ *rfN = 0xE20000 | (107L<<6);
7301/*SKY74137*/ }
7302/*SKY74137*/ else /* ARFCN : 975~985 */
7303/*SKY74137*/ { Nfrac = 3161860 + (96792*(arfcn-975)) - ((arfcn-975)>>2) - 1 ;
7304/*SKY74137*/ *rfN = 0xE20000 | (103L<<6);
7305/*SKY74137*/ }
7306/*SKY74137*/ }
7307/*SKY74137*/ else /* ARFCN : 986~1023 */
7308/*SKY74137*/ { Nfrac = 32264 + (96792*(arfcn-986)) - ((arfcn-986)>>2) - 2 ;
7309/*SKY74137*/ *rfN = 0xE20000 | (104L<<6);
7310/*SKY74137*/ }
7311/*SKY74137*/ }
7312/*SKY74137*/ break;
7313/*SKY74137*/ }
7314/*SKY74137*/ case FrequencyBand1800 :
7315/*SKY74137*/ {
7316/*SKY74137*/ if (arfcn<=759)
7317/*SKY74137*/ { if(arfcn<=585) /* ARFCN : 512~585 */
7318/*SKY74137*/ { Nfrac = 613014 + (48396*(arfcn-512)) - ((arfcn-512)>>2) +2 ;
7319/*SKY74137*/ *rfN = 0xE20000 | (101L<<6);
7320/*SKY74137*/ }
7321/*SKY74137*/ else if (arfcn<=672) /* ARFCN : 586~672 */
7322/*SKY74137*/ { Nfrac = (48396*(arfcn-586)) - ((arfcn-586)>>2) +2 ;
7323/*SKY74137*/ *rfN = 0xE20000 | (102L<<6);
7324/*SKY74137*/ }
7325/*SKY74137*/ else /* ARFCN : 673~759 */
7326/*SKY74137*/ { Nfrac = 16132 + (48396*(arfcn-673)) - ((arfcn-673)>>2) +2 ;
7327/*SKY74137*/ *rfN = 0xE20000 | (103L<<6);
7328/*SKY74137*/ }
7329/*SKY74137*/ }
7330/*SKY74137*/ else
7331/*SKY74137*/ { if (arfcn<=845) /* ARFCN : 760~845 */
7332/*SKY74137*/ { Nfrac = 32264 + (48396*(arfcn-760)) - ((arfcn-760)>>2) +2 ;
7333/*SKY74137*/ *rfN = 0xE20000 | (104L<<6);
7334/*SKY74137*/ }
7335/*SKY74137*/ else /* ARFCN : 846~885 */
7336/*SKY74137*/ { Nfrac = (48396*(arfcn-846)) - ((arfcn-846)>>2) +1 ;
7337/*SKY74137*/ *rfN = 0xE20000 | (105L<<6);
7338/*SKY74137*/ }
7339/*SKY74137*/ }
7340/*SKY74137*/ break;
7341/*SKY74137*/ }
7342/*SKY74137*/ case FrequencyBand1900 :
7343/*SKY74137*/ {
7344/*SKY74137*/ if (arfcn<=654)
7345/*SKY74137*/ { if(arfcn<=567) /* ARFCN : 512~567 */
7346/*SKY74137*/ { Nfrac = 1500270 + (48396*(arfcn-512)) - ((arfcn-512)>>2) +2 ;
7347/*SKY74137*/ *rfN = 0xE20000 | (108L<<6);
7348/*SKY74137*/ }
7349/*SKY74137*/ else /* ARFCN : 568~654 */
7350/*SKY74137*/ { Nfrac = 16132 + (48396*(arfcn-568)) - ((arfcn-568)>>2) +2 ;
7351/*SKY74137*/ *rfN = 0xE20000 | (109L<<6);
7352/*SKY74137*/ }
7353/*SKY74137*/ }
7354/*SKY74137*/ else
7355/*SKY74137*/ { if (arfcn<=740) /* ARFCN : 655~740 */
7356/*SKY74137*/ { Nfrac = 32264 + (48396*(arfcn-655)) - ((arfcn-655)>>2) +2 ;
7357/*SKY74137*/ *rfN = 0xE20000 | (110L<<6);
7358/*SKY74137*/ }
7359/*SKY74137*/ else /* ARFCN : 741~810 */
7360/*SKY74137*/ { Nfrac = (48396*(arfcn-741)) - ((arfcn-741)>>2) +2 ;
7361/*SKY74137*/ *rfN = 0xE20000 | (111L<<6);
7362/*SKY74137*/ }
7363/*SKY74137*/ }
7364/*SKY74137*/ break;
7365/*SKY74137*/ }
7366/*SKY74137*/ default :
7367/*SKY74137*/ {
7368/*SKY74137*/ break;
7369/*SKY74137*/ }
7370/*SKY74137*/ }
7371/*SKY74137*/ *ifN = 0x3 | (Nfrac<<2);
7372/*SKY74137*/ }
7373/*SKY74137*/ /* =========================================================================== */
7374/*SKY74137*/
7375/*SKY74137*/ char SKY_TXCP = 0; //tx charge pump current choice
7376/*SKY74137*/
7377/*SKY74137*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7378/*SKY74137*/ { int Nfrac=0;
7379/*SKY74137*/
7380/*SKY74137*/ switch(rf_band)
7381/*SKY74137*/ {
7382/*SKY74137*/ case FrequencyBand850 :
7383/*SKY74137*/ {
7384/*SKY74137*/ if (arfcn <= 185)
7385/*SKY74137*/ { if (arfcn <= 146) /* ARFCN : 128~146 */
7386/*SKY74137*/ {
7387/*SKY74137*/ Nfrac = 2147484 + 108407*(arfcn-128) - ((arfcn-128)>>2) -2 ;
7388/*SKY74137*/ *rfN = 0xE20000 | (103L<<6);
7389/*SKY74137*/ }
7390/*SKY74137*/ else /* ARFCN : 147~185 */
7391/*SKY74137*/ {
7392/*SKY74137*/ Nfrac = 12906 + 108407*(arfcn-147) - ((arfcn-147)>>2) -3 ;
7393/*SKY74137*/ *rfN = 0xE20000 | (104L<<6);
7394/*SKY74137*/ }
7395/*SKY74137*/ }
7396/*SKY74137*/ else
7397/*SKY74137*/ {
7398/*SKY74137*/ if (arfcn <= 224) /* ARFCN : 186~224 */
7399/*SKY74137*/ {
7400/*SKY74137*/ Nfrac = 46460 + 108407*(arfcn-186) - ((arfcn-186)>>2) -3 ;
7401/*SKY74137*/ *rfN = 0xE20000 | (105L<<6);
7402/*SKY74137*/ }
7403/*SKY74137*/ else /* ARFCN : 225~251 */
7404/*SKY74137*/ {
7405/*SKY74137*/ Nfrac = 80014 + 108407*(arfcn-225) - ((arfcn-225)>>2) -2 ;
7406/*SKY74137*/ *rfN = 0xE20000 | (106L<<6);
7407/*SKY74137*/ }
7408/*SKY74137*/ }
7409/*SKY74137*/
7410/*SKY74137*/ SKY_TXCP = 1;
7411/*SKY74137*/
7412/*SKY74137*/ break;
7413/*SKY74137*/ }
7414/*SKY74137*/ case FrequencyBand900 :
7415/*SKY74137*/ {
7416/*SKY74137*/ if(arfcn<=115)
7417/*SKY74137*/ { if(arfcn<=76)
7418/*SKY74137*/ { if(arfcn<=38) /* ARFCN : 0~38 */
7419/*SKY74137*/ {
7420/*SKY74137*/ Nfrac = 64528 + (108407*arfcn) - (arfcn>>2) -3 ;
7421/*SKY74137*/ *rfN = 0xE20000 | (112L<<6);
7422/*SKY74137*/ }
7423/*SKY74137*/ else /* ARFCN : 39~76 */
7424/*SKY74137*/ {
7425/*SKY74137*/ Nfrac = 98082 + (108407*(arfcn-39)) - ((arfcn-39)>>2) -2 ;
7426/*SKY74137*/ *rfN = 0xE20000 | (113L<<6);
7427/*SKY74137*/ }
7428/*SKY74137*/ }
7429/*SKY74137*/ else /* ARFCN : 77~115 */
7430/*SKY74137*/ {
7431/*SKY74137*/ Nfrac = 23230 + (108407*(arfcn-77)) - ((arfcn-77)>>2) -2 ;
7432/*SKY74137*/ *rfN = 0xE20000 | (114L<<6);
7433/*SKY74137*/ }
7434/*SKY74137*/ }
7435/*SKY74137*/ else
7436/*SKY74137*/ { if(arfcn<=984)
7437/*SKY74137*/ { if(arfcn<=124) /* ARFCN : 116~124 */
7438/*SKY74137*/ {
7439/*SKY74137*/ Nfrac = 56784 + (108407*(arfcn-116)) - ((arfcn-116)>>2) ;
7440/*SKY74137*/ *rfN = 0xE20000 | (115L<<6);
7441/*SKY74137*/ }
7442/*SKY74137*/ else /* ARFCN : 975~984 */
7443/*SKY74137*/ {
7444/*SKY74137*/ Nfrac = 3141211 + (108407*(arfcn-975)) - ((arfcn-975)>>2) -1 ;
7445/*SKY74137*/ *rfN = 0xE20000 | (110L<<6);
7446/*SKY74137*/ }
7447/*SKY74137*/ }
7448/*SKY74137*/ else /* ARFCN : 985~1023 */
7449/*SKY74137*/ {
7450/*SKY74137*/ Nfrac = 30973 + (108407*(arfcn-985)) - ((arfcn-985)>>2) -2 ;
7451/*SKY74137*/ *rfN = 0xE20000 | (111L<<6);
7452/*SKY74137*/ }
7453/*SKY74137*/ }
7454/*SKY74137*/
7455/*SKY74137*/ SKY_TXCP = 1;
7456/*SKY74137*/
7457/*SKY74137*/ break;
7458/*SKY74137*/ }
7459/*SKY74137*/ case FrequencyBand1800 :
7460/*SKY74137*/ {
7461/*SKY74137*/ if (arfcn <= 737)
7462/*SKY74137*/ {
7463/*SKY74137*/ if(arfcn<=655)
7464/*SKY74137*/ { if(arfcn <= 573) /* ARFCN : 512~573 */
7465/*SKY74137*/ {
7466/*SKY74137*/ Nfrac = 1049489 + (51135*(arfcn-512)) + ((arfcn-512)>>2) -2 ;
7467/*SKY74137*/ *rfN = 0xE20000 | (101L<<6);
7468/*SKY74137*/ }
7469/*SKY74137*/ else /* ARFCN : 574~655 */
7470/*SKY74137*/ {
7471/*SKY74137*/ Nfrac = 25568 + (51135*(arfcn-574)) + ((arfcn-574)>>2) -2 ;
7472/*SKY74137*/ *rfN = 0xE20000 | (102L<<6);
7473/*SKY74137*/ }
7474/*SKY74137*/ }
7475/*SKY74137*/ else /* ARFCN : 656~737 */
7476/*SKY74137*/ {
7477/*SKY74137*/ Nfrac = 24350 + (51135*(arfcn-656)) + ((arfcn-656)>>2) -2 ;
7478/*SKY74137*/ *rfN = 0xE20000 | (103L<<6);
7479/*SKY74137*/ }
7480/*SKY74137*/ }
7481/*SKY74137*/ else
7482/*SKY74137*/ {
7483/*SKY74137*/ if(arfcn <= 819) /* ARFCN : 738~819 */
7484/*SKY74137*/ {
7485/*SKY74137*/ Nfrac = 23133 + (51135*(arfcn-738)) + ((arfcn-738)>>2) -2 ;
7486/*SKY74137*/ *rfN = 0xE20000 | (104L<<6);
7487/*SKY74137*/ }
7488/*SKY74137*/ else /* ARFCN : 820~885 */
7489/*SKY74137*/ {
7490/*SKY74137*/ Nfrac = 21915 + (51135*(arfcn-820)) + ((arfcn-820)>>2) -2 ;
7491/*SKY74137*/ *rfN = 0xE20000 | (105L<<6);
7492/*SKY74137*/ }
7493/*SKY74137*/ }
7494/*SKY74137*/
7495/*SKY74137*/ SKY_TXCP = 3;
7496/*SKY74137*/
7497/*SKY74137*/ break;
7498/*SKY74137*/ }
7499/*SKY74137*/ case FrequencyBand1900 :
7500/*SKY74137*/ {
7501/*SKY74137*/ if (arfcn <= 693)
7502/*SKY74137*/ {
7503/*SKY74137*/ if(arfcn<=611)
7504/*SKY74137*/ { if(arfcn <= 529) /* ARFCN : 512~529 */
7505/*SKY74137*/ {
7506/*SKY74137*/ Nfrac = 3289698 + (51135*(arfcn-512)) + ((arfcn-512)>>2) ;
7507/*SKY74137*/ *rfN = 0xE20000 | (109L<<6);
7508/*SKY74137*/ }
7509/*SKY74137*/ else /* ARFCN : 530~611 */
7510/*SKY74137*/ {
7511/*SKY74137*/ Nfrac = 15828 + (51135*(arfcn-530)) + ((arfcn-530)>>2) -2 ;
7512/*SKY74137*/ *rfN = 0xE20000 | (110L<<6);
7513/*SKY74137*/ }
7514/*SKY74137*/ }
7515/*SKY74137*/ else /* ARFCN : 612~693 */
7516/*SKY74137*/ {
7517/*SKY74137*/ Nfrac = 14610 + (51135*(arfcn-612)) + ((arfcn-612)>>2) -2 ;
7518/*SKY74137*/ *rfN = 0xE20000 | (111L<<6);
7519/*SKY74137*/ }
7520/*SKY74137*/ }
7521/*SKY74137*/ else
7522/*SKY74137*/ {
7523/*SKY74137*/ if(arfcn <= 775) /* ARFCN : 694~775 */
7524/*SKY74137*/ {
7525/*SKY74137*/ Nfrac = 13393 + (51135*(arfcn-694)) + ((arfcn-694)>>2) -2 ;
7526/*SKY74137*/ *rfN = 0xE20000 | (112L<<6);
7527/*SKY74137*/ }
7528/*SKY74137*/ else /* ARFCN : 820~885 */
7529/*SKY74137*/ {
7530/*SKY74137*/ Nfrac = 12175 + (51135*(arfcn-776)) + ((arfcn-776)>>2) ;
7531/*SKY74137*/ *rfN = 0xE20000 | (113L<<6);
7532/*SKY74137*/ }
7533/*SKY74137*/ }
7534/*SKY74137*/
7535/*SKY74137*/ SKY_TXCP = 3;
7536/*SKY74137*/
7537/*SKY74137*/ break;
7538/*SKY74137*/ }
7539/*SKY74137*/ default :
7540/*SKY74137*/ {
7541/*SKY74137*/ break;
7542/*SKY74137*/ }
7543/*SKY74137*/ }
7544/*SKY74137*/ *ifN = 0x3 | (Nfrac<<2);
7545/*SKY74137*/ }
7546/*SKY74137*/ /* =========================================================================== */
7547#endif
7548
7549#if IS_RF_GRF6201
7550/*GRF6201*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7551/*GRF6201*/{
7552/*GRF6201*/ unsigned long PC;
7553/*GRF6201*/ unsigned long SC;
7554/*GRF6201*/ unsigned long MC;
7555/*GRF6201*/
7556/*GRF6201*/ switch(rf_band)
7557/*GRF6201*/ {
7558/*GRF6201*/ case FrequencyBand850:
7559/*GRF6201*/ {
7560/*GRF6201*/ if (arfcn<=201)
7561/*GRF6201*/ {
7562/*GRF6201*/ if (arfcn<=169)
7563/*GRF6201*/ {
7564/*GRF6201*/ if (arfcn<=136) /* ARFCN : 128~136 */
7565/*GRF6201*/ {
7566/*GRF6201*/ PC = 16;
7567/*GRF6201*/ SC = 5;
7568/*GRF6201*/ MC = (unsigned long)( 4065248 - (136-arfcn)*129055 - ((136-arfcn)>>1) );
7569/*GRF6201*/ }
7570/*GRF6201*/ else /* ARFCN : 137~169 */
7571/*GRF6201*/ {
7572/*GRF6201*/ PC = 16;
7573/*GRF6201*/ SC = 6;
7574/*GRF6201*/ MC = (unsigned long)( 4129776 - (169-arfcn)*129055 - ((169-arfcn)>>1) );
7575/*GRF6201*/ }
7576/*GRF6201*/ }
7577/*GRF6201*/ else /* ARFCN : 170~201 */
7578/*GRF6201*/ {
7579/*GRF6201*/ PC = 16;
7580/*GRF6201*/ SC = 7;
7581/*GRF6201*/ MC = (unsigned long)( 4065248 - (201-arfcn)*129055 - ((201-arfcn)>>1) );
7582/*GRF6201*/ }
7583/*GRF6201*/ }
7584/*GRF6201*/ else
7585/*GRF6201*/ {
7586/*GRF6201*/ if (arfcn<=234) /* ARFCN : 202~234 */
7587/*GRF6201*/ {
7588/*GRF6201*/ PC = 17;
7589/*GRF6201*/ SC = 0;
7590/*GRF6201*/ MC = (unsigned long)( 4129776 - (234-arfcn)*129055 - ((234-arfcn)>>1) );
7591/*GRF6201*/ }
7592/*GRF6201*/ else /* ARFCN : 235~251 */
7593/*GRF6201*/ {
7594/*GRF6201*/ PC = 17;
7595/*GRF6201*/ SC = 1;
7596/*GRF6201*/ MC = (unsigned long)( 2129416 - (251-arfcn)*129056 + ((251-arfcn)>>1) );
7597/*GRF6201*/ }
7598/*GRF6201*/ }
7599/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x00L<<8) | (0x02L<<6); /* MC/PC/SC/Band/Mode */
7600/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L; /* MC/Addr */
7601/*GRF6201*/
7602/*GRF6201*/ break;
7603/*GRF6201*/ }
7604/*GRF6201*/ case FrequencyBand900:
7605/*GRF6201*/ {
7606/*GRF6201*/ if (arfcn<=102)
7607/*GRF6201*/ {
7608/*GRF6201*/ if (arfcn<=37)
7609/*GRF6201*/ {
7610/*GRF6201*/ if (arfcn<=4) /* ARFCN : 0~4 */
7611/*GRF6201*/ {
7612/*GRF6201*/ PC = 17;
7613/*GRF6201*/ SC = 7;
7614/*GRF6201*/ MC = (unsigned long)( 4065248 - (4-arfcn)*129055 - ((4-arfcn)>>1) );
7615/*GRF6201*/ }
7616/*GRF6201*/ else /* ARFCN : 5~37 */
7617/*GRF6201*/ {
7618/*GRF6201*/ PC = 18;
7619/*GRF6201*/ SC = 0;
7620/*GRF6201*/ MC = (unsigned long)( 4129776 - (37-arfcn)*129055 - ((37-arfcn)>>1) );
7621/*GRF6201*/ }
7622/*GRF6201*/ }
7623/*GRF6201*/ else
7624/*GRF6201*/ {
7625/*GRF6201*/ if (arfcn<=69) /* ARFCN : 38~69 */
7626/*GRF6201*/ {
7627/*GRF6201*/ PC = 18;
7628/*GRF6201*/ SC = 1;
7629/*GRF6201*/ MC = (unsigned long)( 4065248 - (69-arfcn)*129055 - ((69-arfcn)>>1) );
7630/*GRF6201*/ }
7631/*GRF6201*/ else /* ARFCN : 70~102 */
7632/*GRF6201*/ {
7633/*GRF6201*/ PC = 18;
7634/*GRF6201*/ SC = 2;
7635/*GRF6201*/ MC = (unsigned long)( 4129776 - (102-arfcn)*129055 - ((102-arfcn)>>1) );
7636/*GRF6201*/ }
7637/*GRF6201*/ }
7638/*GRF6201*/ }
7639/*GRF6201*/ else
7640/*GRF6201*/ {
7641/*GRF6201*/ if (arfcn<=124) /* ARFCN : 103~124 */
7642/*GRF6201*/ {
7643/*GRF6201*/ PC = 18;
7644/*GRF6201*/ SC = 3;
7645/*GRF6201*/ MC = (unsigned long)( 2774693 - (124-arfcn)*129055 - ((124-arfcn)>>1) );
7646/*GRF6201*/ }
7647/*GRF6201*/ else
7648/*GRF6201*/ {
7649/*GRF6201*/ if (arfcn<=996) /* ARFCN : 975~996 */
7650/*GRF6201*/ {
7651/*GRF6201*/ PC = 17;
7652/*GRF6201*/ SC = 6;
7653/*GRF6201*/ MC = (unsigned long)( 4129776 - (996-arfcn)*129055 - ((996-arfcn)>>1) );
7654/*GRF6201*/ }
7655/*GRF6201*/ else /* ARFCN : 997~1023 */
7656/*GRF6201*/ {
7657/*GRF6201*/ PC = 17;
7658/*GRF6201*/ SC = 7;
7659/*GRF6201*/ MC = (unsigned long)( 3419971 - (1023-arfcn)*129056 + ((1023-arfcn)>>1) );
7660/*GRF6201*/ }
7661/*GRF6201*/ }
7662/*GRF6201*/ }
7663/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x01L<<8) | (0x02L<<6); /* MC/PC/SC/Band/Mode */
7664/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L; /* MC/Addr */
7665/*GRF6201*/
7666/*GRF6201*/ break;
7667/*GRF6201*/ }
7668/*GRF6201*/ case FrequencyBand1800:
7669/*GRF6201*/ {
7670/*GRF6201*/ if (arfcn<=715)
7671/*GRF6201*/ {
7672/*GRF6201*/ if (arfcn<=585)
7673/*GRF6201*/ {
7674/*GRF6201*/ if (arfcn<=520) /* ARFCN : 512~520 */
7675/*GRF6201*/ {
7676/*GRF6201*/ PC = 17;
7677/*GRF6201*/ SC = 2;
7678/*GRF6201*/ MC = (unsigned long)( 3807137 + (arfcn-515)*64528 - ((arfcn-515)>>2) );
7679/*GRF6201*/ }
7680/*GRF6201*/ else /* ARFCN : 521~585 */
7681/*GRF6201*/ {
7682/*GRF6201*/ PC = 17;
7683/*GRF6201*/ SC = 3;
7684/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-552)*64528 - ((arfcn-552)>>2) );
7685/*GRF6201*/ }
7686/*GRF6201*/ }
7687/*GRF6201*/ else
7688/*GRF6201*/ {
7689/*GRF6201*/ if (arfcn<=650) /* ARFCN : 586~650 */
7690/*GRF6201*/ {
7691/*GRF6201*/ PC = 17;
7692/*GRF6201*/ SC = 4;
7693/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-617)*64528 - ((arfcn-617)>>2) );
7694/*GRF6201*/ }
7695/*GRF6201*/ else /* ARFCN : 651~715 */
7696/*GRF6201*/ {
7697/*GRF6201*/ PC = 17;
7698/*GRF6201*/ SC = 5;
7699/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-682)*64528 - ((arfcn-682)>>2) );
7700/*GRF6201*/ }
7701/*GRF6201*/ }
7702/*GRF6201*/ }
7703/*GRF6201*/ else
7704/*GRF6201*/ {
7705/*GRF6201*/ if (arfcn<=845)
7706/*GRF6201*/ {
7707/*GRF6201*/ if (arfcn<=780) /* ARFCN : 716~780 */
7708/*GRF6201*/ {
7709/*GRF6201*/ PC = 17;
7710/*GRF6201*/ SC = 6;
7711/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-747)*64528 - ((arfcn-747)>>2) );
7712/*GRF6201*/ }
7713/*GRF6201*/ else /* ARFCN : 781~845 */
7714/*GRF6201*/ {
7715/*GRF6201*/ PC = 17;
7716/*GRF6201*/ SC = 7;
7717/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-812)*64528 - ((arfcn-812)>>2) );
7718/*GRF6201*/ }
7719/*GRF6201*/ }
7720/*GRF6201*/ else /* ARFCN : 846~885 */
7721/*GRF6201*/ {
7722/*GRF6201*/ PC = 18;
7723/*GRF6201*/ SC = 0;
7724/*GRF6201*/ MC = (unsigned long)( 1226027 + (arfcn-865)*64528 - ((arfcn-865)>>2) );
7725/*GRF6201*/ }
7726/*GRF6201*/ }
7727/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x02L<<8) | (0x02L<<6); /* MC/PC/SC/Band/Mode */
7728/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L; /* MC/Addr */
7729/*GRF6201*/
7730/*GRF6201*/ break;
7731/*GRF6201*/ }
7732/*GRF6201*/ case FrequencyBand1900:
7733/*GRF6201*/ {
7734/*GRF6201*/ if (arfcn<=675)
7735/*GRF6201*/ {
7736/*GRF6201*/ if (arfcn<=610)
7737/*GRF6201*/ {
7738/*GRF6201*/ if (arfcn<=545) /* ARFCN : 512~545 */
7739/*GRF6201*/ {
7740/*GRF6201*/ PC = 18;
7741/*GRF6201*/ SC = 4;
7742/*GRF6201*/ MC = (unsigned long)( 3032804 + (arfcn-528)*64528 - ((arfcn-528)>>2) );
7743/*GRF6201*/ }
7744/*GRF6201*/ else /* ARFCN : 546~610 */
7745/*GRF6201*/ {
7746/*GRF6201*/ PC = 18;
7747/*GRF6201*/ SC = 5;
7748/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-577)*64528 - ((arfcn-577)>>2) );
7749/*GRF6201*/ }
7750/*GRF6201*/ }
7751/*GRF6201*/ else /* ARFCN : 611~675 */
7752/*GRF6201*/ {
7753/*GRF6201*/ PC = 18;
7754/*GRF6201*/ SC = 6;
7755/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-642)*64528 - ((arfcn-642)>>2) );
7756/*GRF6201*/ }
7757/*GRF6201*/ }
7758/*GRF6201*/ else
7759/*GRF6201*/ {
7760/*GRF6201*/ if (arfcn<=805)
7761/*GRF6201*/ {
7762/*GRF6201*/ if (arfcn<=740) /* ARFCN : 676~740 */
7763/*GRF6201*/ {
7764/*GRF6201*/ PC = 18;
7765/*GRF6201*/ SC = 7;
7766/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-707)*64528 - ((arfcn-707)>>2) );
7767/*GRF6201*/ }
7768/*GRF6201*/ else /* ARFCN : 741~805 */
7769/*GRF6201*/ {
7770/*GRF6201*/ PC = 19;
7771/*GRF6201*/ SC = 0;
7772/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-772)*64528 - ((arfcn-772)>>2) );
7773/*GRF6201*/ }
7774/*GRF6201*/ }
7775/*GRF6201*/ else /* ARFCN : 806~810 */
7776/*GRF6201*/ {
7777/*GRF6201*/ PC = 19;
7778/*GRF6201*/ SC = 1;
7779/*GRF6201*/ MC = (unsigned long)( 129055 + (arfcn-808)*64528 - ((arfcn-808)>>2) );
7780/*GRF6201*/ }
7781/*GRF6201*/ }
7782/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x03L<<8) | (0x02L<<6); /* MC/PC/SC/Band/Mode */
7783/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L; /* MC/Addr */
7784/*GRF6201*/
7785/*GRF6201*/ break;
7786/*GRF6201*/ }
7787/*GRF6201*/ }
7788/*GRF6201*/}
7789/*GRF6201*//* =========================================================================== */
7790/*GRF6201*/
7791/*GRF6201*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
7792/*GRF6201*/{
7793/*GRF6201*/ unsigned long PC;
7794/*GRF6201*/ unsigned long SC;
7795/*GRF6201*/ unsigned long MC;
7796/*GRF6201*/ unsigned long special_ch;
7797/*GRF6201*/
7798/*GRF6201*/ special_ch = 0;
7799/*GRF6201*/ switch(rf_band)
7800/*GRF6201*/ {
7801/*GRF6201*/ case FrequencyBand850:
7802/*GRF6201*/ {
7803/*GRF6201*/ if (arfcn<=199)
7804/*GRF6201*/ {
7805/*GRF6201*/ if (arfcn<=166)
7806/*GRF6201*/ {
7807/*GRF6201*/ if (arfcn<=134) /* ARFCN : 128~134 */
7808/*GRF6201*/ {
7809/*GRF6201*/ PC = 15;
7810/*GRF6201*/ SC = 6;
7811/*GRF6201*/ MC = (unsigned long)( 4129776 - (134-arfcn)*129055 - ((134-arfcn)>>1) );
7812/*GRF6201*/ }
7813/*GRF6201*/ else /* ARFCN : 135~166 */
7814/*GRF6201*/ {
7815/*GRF6201*/ PC = 15;
7816/*GRF6201*/ SC = 7;
7817/*GRF6201*/ MC = (unsigned long)( 4065248 - (166-arfcn)*129055 - ((166-arfcn)>>1) );
7818/*GRF6201*/ }
7819/*GRF6201*/ }
7820/*GRF6201*/ else /* ARFCN : 167~199 */
7821/*GRF6201*/ {
7822/*GRF6201*/ PC = 16;
7823/*GRF6201*/ SC = 0;
7824/*GRF6201*/ MC = (unsigned long)( 4129776 - (199-arfcn)*129055 - ((199-arfcn)>>1) );
7825/*GRF6201*/ }
7826/*GRF6201*/ }
7827/*GRF6201*/ else
7828/*GRF6201*/ {
7829/*GRF6201*/ if (arfcn<=231) /* ARFCN : 200~231 */
7830/*GRF6201*/ {
7831/*GRF6201*/ PC = 16;
7832/*GRF6201*/ SC = 1;
7833/*GRF6201*/ MC = (unsigned long)( 4065248 - (231-arfcn)*129055 - ((231-arfcn)>>1) );
7834/*GRF6201*/ }
7835/*GRF6201*/ else /* ARFCN : 232~251 */
7836/*GRF6201*/ {
7837/*GRF6201*/ PC = 16;
7838/*GRF6201*/ SC = 2;
7839/*GRF6201*/ MC = (unsigned long)( 2452055 - (251-arfcn)*129056 + ((251-arfcn)>>1) );
7840/*GRF6201*/ }
7841/*GRF6201*/ }
7842/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x00L<<8) | (0x03L<<6); /* MC/PC/SC/Band/Mode */
7843/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L | (0x00L<<24); /* MC/Addr/TxCurMag */
7844/*GRF6201*/
7845/*GRF6201*/ break;
7846/*GRF6201*/ }
7847/*GRF6201*/ case FrequencyBand900:
7848/*GRF6201*/ {
7849/*GRF6201*/ if (arfcn<=99)
7850/*GRF6201*/ {
7851/*GRF6201*/ if (arfcn<=34)
7852/*GRF6201*/ {
7853/*GRF6201*/ if (arfcn<=2) /* ARFCN : 0~2 */
7854/*GRF6201*/ {
7855/*GRF6201*/ PC = 17;
7856/*GRF6201*/ SC = 0;
7857/*GRF6201*/ MC = (unsigned long)( 4129776 - (2-arfcn)*129055 - ((2-arfcn)>>1) );
7858/*GRF6201*/ }
7859/*GRF6201*/ else /* ARFCN : 3~34 */
7860/*GRF6201*/ {
7861/*GRF6201*/ PC = 17;
7862/*GRF6201*/ SC = 1;
7863/*GRF6201*/ MC = (unsigned long)( 4065248 - (34-arfcn)*129055 - ((34-arfcn)>>1) );
7864/*GRF6201*/ }
7865/*GRF6201*/ }
7866/*GRF6201*/ else
7867/*GRF6201*/ {
7868/*GRF6201*/ if (arfcn<=67) /* ARFCN : 35~67 */
7869/*GRF6201*/ {
7870/*GRF6201*/ PC = 17;
7871/*GRF6201*/ SC = 2;
7872/*GRF6201*/ MC = (unsigned long)( 4129776 - (67-arfcn)*129055 - ((67-arfcn)>>1) );
7873/*GRF6201*/ }
7874/*GRF6201*/ else /* ARFCN : 68~99 */
7875/*GRF6201*/ {
7876/*GRF6201*/ PC = 17;
7877/*GRF6201*/ SC = 3;
7878/*GRF6201*/ MC = (unsigned long)( 4065248 - (99-arfcn)*129055 - ((99-arfcn)>>1) );
7879/*GRF6201*/ }
7880/*GRF6201*/ }
7881/*GRF6201*/ }
7882/*GRF6201*/ else
7883/*GRF6201*/ {
7884/*GRF6201*/ if (arfcn<=124) /* ARFCN : 100~124 */
7885/*GRF6201*/ {
7886/*GRF6201*/ PC = 17;
7887/*GRF6201*/ SC = 4;
7888/*GRF6201*/ MC = (unsigned long)( 3097332 - (124-arfcn)*129055 - ((124-arfcn)>>1) );
7889/*GRF6201*/ }
7890/*GRF6201*/ else
7891/*GRF6201*/ {
7892/*GRF6201*/ if (arfcn<=993) /* ARFCN : 975~993 */
7893/*GRF6201*/ {
7894/*GRF6201*/ PC = 16;
7895/*GRF6201*/ SC = 7;
7896/*GRF6201*/ MC = (unsigned long)( 4065248 - (993-arfcn)*129055 - ((993-arfcn)>>1) );
7897/*GRF6201*/ }
7898/*GRF6201*/ else /* ARFCN : 994~1023 */
7899/*GRF6201*/ {
7900/*GRF6201*/ PC = 17;
7901/*GRF6201*/ SC = 0;
7902/*GRF6201*/ MC = (unsigned long)( 3742610 - (1023-arfcn)*129056 + ((1023-arfcn)>>1) );
7903/*GRF6201*/ }
7904/*GRF6201*/ }
7905/*GRF6201*/ }
7906/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x01L<<8) | (0x03L<<6); /* MC/PC/SC/Band/Mode */
7907/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | 0x01L | (0x00L<<24); /* MC/Addr/TxCurMag */
7908/*GRF6201*/
7909/*GRF6201*/ break;
7910/*GRF6201*/ }
7911/*GRF6201*/ case FrequencyBand1800:
7912/*GRF6201*/ {
7913/*GRF6201*/ if (arfcn<=735)
7914/*GRF6201*/ {
7915/*GRF6201*/ if (arfcn<=605)
7916/*GRF6201*/ {
7917/*GRF6201*/ if (arfcn<=540) /* ARFCN : 512~540 */
7918/*GRF6201*/ {
7919/*GRF6201*/ PC = 16;
7920/*GRF6201*/ SC = 3;
7921/*GRF6201*/ MC = (unsigned long)( 3290915 + (arfcn-527)*64528 - ((arfcn-527)>>2) );
7922/*GRF6201*/ }
7923/*GRF6201*/ else /* ARFCN : 541~605 */
7924/*GRF6201*/ {
7925/*GRF6201*/ PC = 16;
7926/*GRF6201*/ SC = 4;
7927/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-572)*64528 - ((arfcn-572)>>2) );
7928/*GRF6201*/ }
7929/*GRF6201*/ }
7930/*GRF6201*/ else
7931/*GRF6201*/ {
7932/*GRF6201*/ if (arfcn<=670) /* ARFCN : 606~670 */
7933/*GRF6201*/ {
7934/*GRF6201*/ PC = 16;
7935/*GRF6201*/ SC = 5;
7936/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-637)*64528 - ((arfcn-637)>>2) );
7937/*GRF6201*/ }
7938/*GRF6201*/ else /* ARFCN : 671~735 */
7939/*GRF6201*/ {
7940/*GRF6201*/ PC = 16;
7941/*GRF6201*/ SC = 6;
7942/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-702)*64528 - ((arfcn-702)>>2) );
7943/*GRF6201*/ }
7944/*GRF6201*/ }
7945/*GRF6201*/ }
7946/*GRF6201*/ else
7947/*GRF6201*/ {
7948/*GRF6201*/ if (arfcn<=865)
7949/*GRF6201*/ {
7950/*GRF6201*/ if (arfcn<=800) /* ARFCN : 736~800 */
7951/*GRF6201*/ {
7952/*GRF6201*/ PC = 16;
7953/*GRF6201*/ SC = 7;
7954/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-767)*64528 - ((arfcn-767)>>2) );
7955/*GRF6201*/ }
7956/*GRF6201*/ else /* ARFCN : 801~865 */
7957/*GRF6201*/ {
7958/*GRF6201*/ PC = 17;
7959/*GRF6201*/ SC = 0;
7960/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-832)*64528 - ((arfcn-832)>>2) );
7961/*GRF6201*/ }
7962/*GRF6201*/ }
7963/*GRF6201*/ else /* ARFCN : 866~885 */
7964/*GRF6201*/ {
7965/*GRF6201*/ PC = 17;
7966/*GRF6201*/ SC = 1;
7967/*GRF6201*/ MC = (unsigned long)( 451694 + (arfcn-873)*64528 - ((arfcn-873)>>2) );
7968/*GRF6201*/ }
7969/*GRF6201*/ }
7970/*GRF6201*/
7971/*GRF6201*/ /* Special channel */
7972/*GRF6201*/ if ( ((arfcn>=553) && (arfcn<=562)) ||
7973/*GRF6201*/ ((arfcn>=615) && (arfcn<=624)) ||
7974/*GRF6201*/ ((arfcn>=677) && (arfcn<=686)) ||
7975/*GRF6201*/ ((arfcn>=740) && (arfcn<=748)) ||
7976/*GRF6201*/ ((arfcn>=802) && (arfcn<=811)) ||
7977/*GRF6201*/ ((arfcn>=864) && (arfcn<=885)) )
7978/*GRF6201*/ {
7979/*GRF6201*/ special_ch = 0x01L;
7980/*GRF6201*/ }
7981/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x02L<<8) | (0x03L<<6); /* MC/PC/SC/Band/Mode */
7982/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | (special_ch<<6) | 0x01L | (0x01L<<24) | (special_ch<<26); /* MC/REV0/Addr/TxCurMag/REV1 */
7983/*GRF6201*/
7984/*GRF6201*/ break;
7985/*GRF6201*/ }
7986/*GRF6201*/ case FrequencyBand1900:
7987/*GRF6201*/ {
7988/*GRF6201*/ if (arfcn<=685)
7989/*GRF6201*/ {
7990/*GRF6201*/ if (arfcn<=620)
7991/*GRF6201*/ {
7992/*GRF6201*/ if (arfcn<=555) /* ARFCN : 512~555 */
7993/*GRF6201*/ {
7994/*GRF6201*/ PC = 17;
7995/*GRF6201*/ SC = 6;
7996/*GRF6201*/ MC = (unsigned long)( 2774693 + (arfcn-534)*64528 - ((arfcn-534)>>2) );
7997/*GRF6201*/ }
7998/*GRF6201*/ else /* ARFCN : 556~620 */
7999/*GRF6201*/ {
8000/*GRF6201*/ PC = 17;
8001/*GRF6201*/ SC = 7;
8002/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-587)*64528 - ((arfcn-587)>>2) );
8003/*GRF6201*/ }
8004/*GRF6201*/ }
8005/*GRF6201*/ else /* ARFCN : 621~685 */
8006/*GRF6201*/ {
8007/*GRF6201*/ PC = 18;
8008/*GRF6201*/ SC = 0;
8009/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-652)*64528 - ((arfcn-652)>>2) );
8010/*GRF6201*/ }
8011/*GRF6201*/ }
8012/*GRF6201*/ else
8013/*GRF6201*/ {
8014/*GRF6201*/ if (arfcn<=750) /* ARFCN : 686~750 */
8015/*GRF6201*/ {
8016/*GRF6201*/ PC = 18;
8017/*GRF6201*/ SC = 1;
8018/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-717)*64528 - ((arfcn-717)>>2) );
8019/*GRF6201*/ }
8020/*GRF6201*/ else /* ARFCN : 751~810 */
8021/*GRF6201*/ {
8022/*GRF6201*/ PC = 18;
8023/*GRF6201*/ SC = 2;
8024/*GRF6201*/ MC = (unsigned long)( 2000360 + (arfcn-782)*64528 - ((arfcn-782)>>2) );
8025/*GRF6201*/ }
8026/*GRF6201*/ }
8027/*GRF6201*/
8028/*GRF6201*/ /* Special channel */
8029/*GRF6201*/ if ( ((arfcn>=538) && (arfcn<=547)) ||
8030/*GRF6201*/ ((arfcn>=600) && (arfcn<=609)) ||
8031/*GRF6201*/ ((arfcn>=663) && (arfcn<=671)) ||
8032/*GRF6201*/ ((arfcn>=725) && (arfcn<=737)) ||
8033/*GRF6201*/ ((arfcn>=787) && (arfcn<=796)) )
8034/*GRF6201*/ {
8035/*GRF6201*/ special_ch = 0x01L;
8036/*GRF6201*/ }
8037/*GRF6201*/ *rfN = ((MC&0x3E0000L)<<1) | (PC<<13) | (SC<<10) | (0x03L<<8) | (0x03L<<6); /* MC/PC/SC/Band/Mode */
8038/*GRF6201*/ *ifN = ((MC&0x1FFFFL)<<7 ) | (special_ch<<6) | 0x01L | (0x01L<<24) | (special_ch<<26); /* MC/REV0/Addr/TxCurMag/REV1 */
8039/*GRF6201*/
8040/*GRF6201*/ break;
8041/*GRF6201*/ }
8042/*GRF6201*/ }
8043/*GRF6201*/}
8044/*GRF6201*//* =========================================================================== */
8045#endif
8046
8047#if IS_RF_IRFS3001
8048/*IRFS3001*/#define IRFS3001_MOD10( _in ) (( (_in*51)+76 ) >> 9);
8049/*IRFS3001*/
8050/*IRFS3001*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8051/*IRFS3001*/{
8052/*IRFS3001*/ unsigned short x1, x2;
8053/*IRFS3001*/
8054/*IRFS3001*/ switch(rf_band)
8055/*IRFS3001*/ {
8056/*IRFS3001*/ case FrequencyBand850 :
8057/*IRFS3001*/ {
8058/*IRFS3001*/ x1 = (arfcn - 127) << 1; // x1 = (ARFCN-127)*2
8059/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8060/*IRFS3001*/ *rfN = ( (x2+869) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8061/*IRFS3001*/ break;
8062/*IRFS3001*/ }
8063/*IRFS3001*/ case FrequencyBand900 :
8064/*IRFS3001*/ {
8065/*IRFS3001*/ if( arfcn<125 )// ARFCN = 0~124
8066/*IRFS3001*/ {
8067/*IRFS3001*/ x1 = arfcn << 1; // x1 = ARFCN * 2
8068/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8069/*IRFS3001*/ *rfN = ( (x2+935) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8070/*IRFS3001*/ }
8071/*IRFS3001*/ else // ARFCN = 975~1023
8072/*IRFS3001*/ {
8073/*IRFS3001*/ x1 = (arfcn-974) << 1; // x1 = (ARFCN-974) * 2
8074/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8075/*IRFS3001*/ *rfN = ( (x2+925) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8076/*IRFS3001*/ }
8077/*IRFS3001*/ break;
8078/*IRFS3001*/ }
8079/*IRFS3001*/ case FrequencyBand1800 :
8080/*IRFS3001*/ {
8081/*IRFS3001*/ if( arfcn<701 )// ARFCN = 512~700
8082/*IRFS3001*/ {
8083/*IRFS3001*/ x1 = (arfcn-511) << 1; // x1 = (ARFCN-511) * 2
8084/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8085/*IRFS3001*/ *rfN = ( (x2+1805) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8086/*IRFS3001*/ }
8087/*IRFS3001*/ else // ARFCN = 701~885
8088/*IRFS3001*/ {
8089/*IRFS3001*/ x1 = (arfcn-701) << 1; // x1 = (ARFCN-701) * 2
8090/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8091/*IRFS3001*/ *rfN = ( (x2+1843) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8092/*IRFS3001*/ }
8093/*IRFS3001*/ break;
8094/*IRFS3001*/ }
8095/*IRFS3001*/ case FrequencyBand1900 :
8096/*IRFS3001*/ {
8097/*IRFS3001*/ if( arfcn<661 )// ARFCN = 512~660
8098/*IRFS3001*/ {
8099/*IRFS3001*/ x1 = (arfcn-511) << 1; // x1 = (ARFCN-511) * 2
8100/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8101/*IRFS3001*/ *rfN = ( (x2+1930) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8102/*IRFS3001*/ }
8103/*IRFS3001*/ else // ARFCN = 661~810
8104/*IRFS3001*/ {
8105/*IRFS3001*/ x1 = (arfcn-661) << 1; // x1 = (ARFCN-701) * 2
8106/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8107/*IRFS3001*/ *rfN = ( (x2+1960) << 10 ) | ( (x1-x2*10) << 6 ) | 0x04;
8108/*IRFS3001*/ }
8109/*IRFS3001*/ break;
8110/*IRFS3001*/ }
8111/*IRFS3001*/ default :
8112/*IRFS3001*/ {
8113/*IRFS3001*/ break;
8114/*IRFS3001*/ }
8115/*IRFS3001*/ }
8116/*IRFS3001*/
8117/*IRFS3001*/ *ifN = 0;
8118/*IRFS3001*/}
8119/*IRFS3001*//* =========================================================================== */
8120/*IRFS3001*/
8121/*IRFS3001*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8122/*IRFS3001*/{
8123/*IRFS3001*/ unsigned short x1, x2;
8124/*IRFS3001*/
8125/*IRFS3001*/ switch(rf_band)
8126/*IRFS3001*/ {
8127/*IRFS3001*/ case FrequencyBand850 :
8128/*IRFS3001*/ {
8129/*IRFS3001*/ x1 = (arfcn - 127) << 1; // x1 = (ARFCN-127)*2
8130/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8131/*IRFS3001*/ *rfN = ( (x2+824) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8132/*IRFS3001*/ break;
8133/*IRFS3001*/ }
8134/*IRFS3001*/ case FrequencyBand900 :
8135/*IRFS3001*/ {
8136/*IRFS3001*/ if( arfcn<125 )// ARFCN = 0~124
8137/*IRFS3001*/ {
8138/*IRFS3001*/ x1 = arfcn << 1; // x1 = ARFCN * 2
8139/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8140/*IRFS3001*/ *rfN = ( (x2+890) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8141/*IRFS3001*/ }
8142/*IRFS3001*/ else // ARFCN = 975~1023
8143/*IRFS3001*/ {
8144/*IRFS3001*/ x1 = (arfcn-974) << 1; // x1 = (ARFCN-974) * 2
8145/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8146/*IRFS3001*/ *rfN = ( (x2+880) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8147/*IRFS3001*/ }
8148/*IRFS3001*/ break;
8149/*IRFS3001*/ }
8150/*IRFS3001*/ case FrequencyBand1800 :
8151/*IRFS3001*/ {
8152/*IRFS3001*/ if( arfcn<701 )// ARFCN = 512~700
8153/*IRFS3001*/ {
8154/*IRFS3001*/ x1 = (arfcn-511) << 1; // x1 = (ARFCN-511) * 2
8155/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8156/*IRFS3001*/ *rfN = ( (x2+1710) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8157/*IRFS3001*/ }
8158/*IRFS3001*/ else // ARFCN = 701~885
8159/*IRFS3001*/ {
8160/*IRFS3001*/ x1 = (arfcn-701) << 1; // x1 = (ARFCN-701) * 2
8161/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8162/*IRFS3001*/ *rfN = ( (x2+1748) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8163/*IRFS3001*/ }
8164/*IRFS3001*/ break;
8165/*IRFS3001*/ }
8166/*IRFS3001*/ case FrequencyBand1900 :
8167/*IRFS3001*/ {
8168/*IRFS3001*/ if( arfcn<661 )// ARFCN = 512~660
8169/*IRFS3001*/ {
8170/*IRFS3001*/ x1 = (arfcn-511) << 1; // x1 = (ARFCN-511) * 2
8171/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8172/*IRFS3001*/ *rfN = ( (x2+1850) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8173/*IRFS3001*/ }
8174/*IRFS3001*/ else // ARFCN = 661~810
8175/*IRFS3001*/ {
8176/*IRFS3001*/ x1 = (arfcn-661) << 1; // x1 = (ARFCN-701) * 2
8177/*IRFS3001*/ x2 = IRFS3001_MOD10( x1 ); // x2 = x1 mod 10
8178/*IRFS3001*/ *rfN = ( (x2+1880) << 10 ) | ( (x1-x2*10) << 6 ) | 0x05;
8179/*IRFS3001*/ }
8180/*IRFS3001*/ break;
8181/*IRFS3001*/ }
8182/*IRFS3001*/ default :
8183/*IRFS3001*/ {
8184/*IRFS3001*/ break;
8185/*IRFS3001*/ }
8186/*IRFS3001*/ }
8187/*IRFS3001*/
8188/*IRFS3001*/ *ifN = 0;
8189/*IRFS3001*/}
8190/*IRFS3001*//* =========================================================================== */
8191#endif
8192
8193#if IS_RF_AD6548
8194/*AD6548*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8195/*AD6548*/{
8196/*AD6548*/ switch(rf_band)
8197/*AD6548*/ {
8198/*AD6548*/ case FrequencyBand850 :
8199/*AD6548*/ {
8200/*AD6548*/ if(arfcn<=201)
8201/*AD6548*/ { if(arfcn<=158)
8202/*AD6548*/ { /* ARFCN : 128~158 */
8203/*AD6548*/ *rfN = (((arfcn-128)*24 + 304)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8204/*AD6548*/ }
8205/*AD6548*/ else
8206/*AD6548*/ { /* ARFCN : 159~201 */
8207/*AD6548*/ *rfN = (((arfcn-159)*24 + 8)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8208/*AD6548*/ }
8209/*AD6548*/ }
8210/*AD6548*/ else
8211/*AD6548*/ { if(arfcn<=245)
8212/*AD6548*/ { /* ARFCN : 202~245 */
8213/*AD6548*/ *rfN = (((arfcn-202)*24 )<<13) | 0x1306L /*(38L<<7|0x06L)*/;
8214/*AD6548*/ }
8215/*AD6548*/ else
8216/*AD6548*/ { /* ARFCN : 246~251 */
8217/*AD6548*/ *rfN = (((arfcn-246)*24+16)<<13) | 0x1386L /*(39L<<7|0x06L)*/;
8218/*AD6548*/ }
8219/*AD6548*/ }
8220/*AD6548*/ break;
8221/*AD6548*/ }
8222/*AD6548*/ case FrequencyBand900 :
8223/*AD6548*/ {
8224/*AD6548*/ if(arfcn<=48)
8225/*AD6548*/ { if(arfcn<=4)
8226/*AD6548*/ { /* ARFCN : 0~4 */
8227/*AD6548*/ *rfN = (((arfcn)*24+920 )<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8228/*AD6548*/ }
8229/*AD6548*/ else
8230/*AD6548*/ { /* ARFCN : 5~48 */
8231/*AD6548*/ *rfN = (((arfcn-5)*24 )<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8232/*AD6548*/ }
8233/*AD6548*/ }
8234/*AD6548*/ else
8235/*AD6548*/ { if(arfcn<=124)
8236/*AD6548*/ { if(arfcn<=91)
8237/*AD6548*/ { /* ARFCN : 49~91 */
8238/*AD6548*/ *rfN = (((arfcn-49)*24+16)<<13) | 0x1686L /*(45L<<7|0x06L)*/;
8239/*AD6548*/ }
8240/*AD6548*/ else
8241/*AD6548*/ { /* ARFCN : 92~124 */
8242/*AD6548*/ *rfN = (((arfcn-92)*24+8 )<<13) | 0x1706L /*(46L<<7|0x06L)*/;
8243/*AD6548*/ }
8244/*AD6548*/ }
8245/*AD6548*/ else
8246/*AD6548*/ { if(arfcn<=985)
8247/*AD6548*/ { /* ARFCN : 975~985 */
8248/*AD6548*/ *rfN = (((arfcn-975)*24+784)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8249/*AD6548*/ }
8250/*AD6548*/ else
8251/*AD6548*/ { /* ARFCN : 986~1023 */
8252/*AD6548*/ *rfN = (((arfcn-986)*24+8 )<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8253/*AD6548*/ }
8254/*AD6548*/ }
8255/*AD6548*/ }
8256/*AD6548*/ break;
8257/*AD6548*/ }
8258/*AD6548*/ case FrequencyBand1800 :
8259/*AD6548*/ {
8260/*AD6548*/ if(arfcn<=672)
8261/*AD6548*/ { if(arfcn<=585)
8262/*AD6548*/ { /* ARFCN : 512~585 */
8263/*AD6548*/ *rfN = (((arfcn-512)*12+152)<<13) | 0x1406L /*(40L<<7|0x06L)*/;
8264/*AD6548*/ }
8265/*AD6548*/ else
8266/*AD6548*/ { /* ARFCN : 586~672 */
8267/*AD6548*/ *rfN = (((arfcn-586)*12)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8268/*AD6548*/ }
8269/*AD6548*/ }
8270/*AD6548*/ else
8271/*AD6548*/ { if(arfcn<=759)
8272/*AD6548*/ { /* ARFCN : 673~759 */
8273/*AD6548*/ *rfN = (((arfcn-673)*12+4)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8274/*AD6548*/ }
8275/*AD6548*/ else
8276/*AD6548*/ { if(arfcn<=845)
8277/*AD6548*/ { /* ARFCN : 760~845 */
8278/*AD6548*/ *rfN = (((arfcn-760)*12+8)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8279/*AD6548*/ }
8280/*AD6548*/ else
8281/*AD6548*/ { /* ARFCN : 846~885 */
8282/*AD6548*/ *rfN = (((arfcn-846)*12)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8283/*AD6548*/ }
8284/*AD6548*/ }
8285/*AD6548*/ }
8286/*AD6548*/ break;
8287/*AD6548*/ }
8288/*AD6548*/ case FrequencyBand1900 :
8289/*AD6548*/ {
8290/*AD6548*/ if(arfcn<=654)
8291/*AD6548*/ { if(arfcn<=567)
8292/*AD6548*/ { /* ARFCN : 512~567 */
8293/*AD6548*/ *rfN = (((arfcn-512)*12+372)<<13) | 0x1786L /*(47L<<7|0x06L)*/;
8294/*AD6548*/ }
8295/*AD6548*/ else
8296/*AD6548*/ { /* ARFCN : 568~654 */
8297/*AD6548*/ *rfN = (((arfcn-568)*12+4)<<13) | 0x1806L /*(48L<<7|0x06L)*/;
8298/*AD6548*/ }
8299/*AD6548*/ }
8300/*AD6548*/ else
8301/*AD6548*/ { if(arfcn<=740)
8302/*AD6548*/ { /* ARFCN : 655~740 */
8303/*AD6548*/ *rfN = (((arfcn-655)*12+8)<<13) | 0x1886L /*(49L<<7|0x06L)*/;
8304/*AD6548*/ }
8305/*AD6548*/ else
8306/*AD6548*/ { /* ARFCN : 741~810 */
8307/*AD6548*/ *rfN = (((arfcn-741)*12)<<13) | 0x1906L /*(50L<<7|0x06L)*/;
8308/*AD6548*/ }
8309/*AD6548*/ }
8310/*AD6548*/ break;
8311/*AD6548*/ }
8312/*AD6548*/ default :
8313/*AD6548*/ {
8314/*AD6548*/ break;
8315/*AD6548*/ }
8316/*AD6548*/ }
8317/*AD6548*/ *ifN = 0;
8318/*AD6548*/}
8319/*AD6548*//* ========================================================================== */
8320/*AD6548*/
8321/*AD6548*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8322/*AD6548*/{
8323/*AD6548*/ switch(rf_band)
8324/*AD6548*/ {
8325/*AD6548*/ case FrequencyBand850 :
8326/*AD6548*/ {
8327/*AD6548*/ if(arfcn<=185)
8328/*AD6548*/ { if(arfcn<=143)
8329/*AD6548*/ { /* ARFCN : 128~143 */
8330/*AD6548*/ *rfN = (((arfcn-128)*28+728)<<13) | 0x1106L /*(34L<<7|0x06L)*/;
8331/*AD6548*/ }
8332/*AD6548*/ else
8333/*AD6548*/ { /* ARFCN : 144~185 */
8334/*AD6548*/ *rfN = (((arfcn-144)*28+6)<<13) | 0x1186L /*(35L<<7|0x06L)*/;
8335/*AD6548*/ }
8336/*AD6548*/ }
8337/*AD6548*/ else
8338/*AD6548*/ { if(arfcn<=227)
8339/*AD6548*/ { /* ARFCN : 186~227 */
8340/*AD6548*/ *rfN = (((arfcn-186)*28+12)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8341/*AD6548*/ }
8342/*AD6548*/ else
8343/*AD6548*/ { /* ARFCN : 228~251 */
8344/*AD6548*/ *rfN = (((arfcn-228)*28+18)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8345/*AD6548*/ }
8346/*AD6548*/ }
8347/*AD6548*/ break;
8348/*AD6548*/ }
8349/*AD6548*/ case FrequencyBand900 :
8350/*AD6548*/ {
8351/*AD6548*/ if(arfcn<=62)
8352/*AD6548*/ { if(arfcn<=21)
8353/*AD6548*/ { /* ARFCN : 0~21 */
8354/*AD6548*/ *rfN = (((arfcn)*28+580)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8355/*AD6548*/ }
8356/*AD6548*/ else
8357/*AD6548*/ { /* ARFCN : 22~62 */
8358/*AD6548*/ *rfN = (((arfcn-22)*28+26)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8359/*AD6548*/ }
8360/*AD6548*/ }
8361/*AD6548*/ else
8362/*AD6548*/ { if(arfcn<=124)
8363/*AD6548*/ { if(arfcn<=104)
8364/*AD6548*/ { /* ARFCN : 63~104 */
8365/*AD6548*/ *rfN = (((arfcn-63)*28+4)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8366/*AD6548*/ }
8367/*AD6548*/ else
8368/*AD6548*/ { /* ARFCN : 105~124 */
8369/*AD6548*/ *rfN = (((arfcn-105)*28+10)<<13) | 0x1686L /*(45L<<7|0x06L)*/;
8370/*AD6548*/ }
8371/*AD6548*/ }
8372/*AD6548*/ else
8373/*AD6548*/ { if(arfcn<=1003)
8374/*AD6548*/ { /* ARFCN : 975~1003 */
8375/*AD6548*/ *rfN = (((arfcn-975)*28+378)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8376/*AD6548*/ }
8377/*AD6548*/ else
8378/*AD6548*/ { /* ARFCN : 1004~1023 */
8379/*AD6548*/ *rfN = (((arfcn-1004)*28+20)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8380/*AD6548*/ }
8381/*AD6548*/ }
8382/*AD6548*/ }
8383/*AD6548*/ break;
8384/*AD6548*/ }
8385/*AD6548*/ case FrequencyBand1800 :
8386/*AD6548*/ {
8387/*AD6548*/ if(arfcn<=694)
8388/*AD6548*/ { if(arfcn<=605)
8389/*AD6548*/ { if(arfcn<=517)
8390/*AD6548*/ { /* ARFCN : 512~517 */
8391/*AD6548*/ *rfN = (((arfcn-512)*14+1154)<<13) | 0x1006L /*(32L<<7|0x06L)*/;
8392/*AD6548*/ }
8393/*AD6548*/ else
8394/*AD6548*/ { /* ARFCN : 518~605 */
8395/*AD6548*/ *rfN = (((arfcn-518)*14+3)<<13) | 0x1086L /*(33L<<7|0x06L)*/;
8396/*AD6548*/ }
8397/*AD6548*/ }
8398/*AD6548*/ else
8399/*AD6548*/ { /* ARFCN : 606~694 */
8400/*AD6548*/ *rfN = (((arfcn-606)*14)<<13) | 0x1106L /*(34L<<7|0x06L)*/;
8401/*AD6548*/ }
8402/*AD6548*/ }
8403/*AD6548*/ else
8404/*AD6548*/ { if(arfcn<=782)
8405/*AD6548*/ { /* ARFCN : 695~782 */
8406/*AD6548*/ *rfN = (((arfcn-695)*14+11)<<13) | 0x1186L /*(35L<<7|0x06L)*/;
8407/*AD6548*/ }
8408/*AD6548*/ else
8409/*AD6548*/ { if(arfcn<=870)
8410/*AD6548*/ { /* ARFCN : 783~870 */
8411/*AD6548*/ *rfN = (((arfcn-783)*14+8)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8412/*AD6548*/ }
8413/*AD6548*/ else
8414/*AD6548*/ { /* ARFCN : 871~885 */
8415/*AD6548*/ *rfN = (((arfcn-871)*14+5)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8416/*AD6548*/ }
8417/*AD6548*/ }
8418/*AD6548*/ }
8419/*AD6548*/ break;
8420/*AD6548*/ }
8421/*AD6548*/ case FrequencyBand1900 :
8422/*AD6548*/ {
8423/*AD6548*/ if(arfcn<=699)
8424/*AD6548*/ { if(arfcn<=611)
8425/*AD6548*/ { if(arfcn<=523)
8426/*AD6548*/ { /* ARFCN : 512~523 */
8427/*AD6548*/ *rfN = (((arfcn-512)*14+1074)<<13) | 0x1406L /*(40L<<7|0x06L)*/;
8428/*AD6548*/ }
8429/*AD6548*/ else
8430/*AD6548*/ { /* ARFCN : 524~611 */
8431/*AD6548*/ *rfN = (((arfcn-524)*14+7)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8432/*AD6548*/ }
8433/*AD6548*/ }
8434/*AD6548*/ else
8435/*AD6548*/ { /* ARFCN : 612~699 */
8436/*AD6548*/ *rfN = (((arfcn-612)*14+4)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8437/*AD6548*/ }
8438/*AD6548*/ }
8439/*AD6548*/ else
8440/*AD6548*/ { if(arfcn<=788)
8441/*AD6548*/ { /* ARFCN : 700~788 */
8442/*AD6548*/ *rfN = (((arfcn-700)*14+1)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8443/*AD6548*/ }
8444/*AD6548*/ else
8445/*AD6548*/ { /* ARFCN : 789~810 */
8446/*AD6548*/ *rfN = (((arfcn-789)*14+12)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8447/*AD6548*/ }
8448/*AD6548*/ }
8449/*AD6548*/ break;
8450/*AD6548*/ }
8451/*AD6548*/ default :
8452/*AD6548*/ {
8453/*AD6548*/ break;
8454/*AD6548*/ }
8455/*AD6548*/ }
8456/*AD6548*/ *ifN = 0;
8457/*AD6548*/}
8458/*AD6548*//* ========================================================================== */
8459#endif
8460
8461#if IS_RF_AD6546
8462/*AD6546*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8463/*AD6546*/{
8464/*AD6546*/ switch(rf_band)
8465/*AD6546*/ {
8466/*AD6546*/ case FrequencyBand850 :
8467/*AD6546*/ {
8468/*AD6546*/ if(arfcn<=201)
8469/*AD6546*/ { if(arfcn<=158)
8470/*AD6546*/ { /* ARFCN : 128~158 */
8471/*AD6546*/ *rfN = (((arfcn-128)*24 + 304)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8472/*AD6546*/ }
8473/*AD6546*/ else
8474/*AD6546*/ { /* ARFCN : 159~201 */
8475/*AD6546*/ *rfN = (((arfcn-159)*24 + 8)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8476/*AD6546*/ }
8477/*AD6546*/ }
8478/*AD6546*/ else
8479/*AD6546*/ { if(arfcn<=245)
8480/*AD6546*/ { /* ARFCN : 202~245 */
8481/*AD6546*/ *rfN = (((arfcn-202)*24 )<<13) | 0x1306L /*(38L<<7|0x06L)*/;
8482/*AD6546*/ }
8483/*AD6546*/ else
8484/*AD6546*/ { /* ARFCN : 246~251 */
8485/*AD6546*/ *rfN = (((arfcn-246)*24+16)<<13) | 0x1386L /*(39L<<7|0x06L)*/;
8486/*AD6546*/ }
8487/*AD6546*/ }
8488/*AD6546*/ break;
8489/*AD6546*/ }
8490/*AD6546*/ case FrequencyBand900 :
8491/*AD6546*/ {
8492/*AD6546*/ if(arfcn<=48)
8493/*AD6546*/ { if(arfcn<=4)
8494/*AD6546*/ { /* ARFCN : 0~4 */
8495/*AD6546*/ *rfN = (((arfcn)*24+920 )<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8496/*AD6546*/ }
8497/*AD6546*/ else
8498/*AD6546*/ { /* ARFCN : 5~48 */
8499/*AD6546*/ *rfN = (((arfcn-5)*24 )<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8500/*AD6546*/ }
8501/*AD6546*/ }
8502/*AD6546*/ else
8503/*AD6546*/ { if(arfcn<=124)
8504/*AD6546*/ { if(arfcn<=91)
8505/*AD6546*/ { /* ARFCN : 49~91 */
8506/*AD6546*/ *rfN = (((arfcn-49)*24+16)<<13) | 0x1686L /*(45L<<7|0x06L)*/;
8507/*AD6546*/ }
8508/*AD6546*/ else
8509/*AD6546*/ { /* ARFCN : 92~124 */
8510/*AD6546*/ *rfN = (((arfcn-92)*24+8 )<<13) | 0x1706L /*(46L<<7|0x06L)*/;
8511/*AD6546*/ }
8512/*AD6546*/ }
8513/*AD6546*/ else
8514/*AD6546*/ { if(arfcn<=985)
8515/*AD6546*/ { /* ARFCN : 975~985 */
8516/*AD6546*/ *rfN = (((arfcn-975)*24+784)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8517/*AD6546*/ }
8518/*AD6546*/ else
8519/*AD6546*/ { /* ARFCN : 986~1023 */
8520/*AD6546*/ *rfN = (((arfcn-986)*24+8 )<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8521/*AD6546*/ }
8522/*AD6546*/ }
8523/*AD6546*/ }
8524/*AD6546*/ break;
8525/*AD6546*/ }
8526/*AD6546*/ case FrequencyBand1800 :
8527/*AD6546*/ {
8528/*AD6546*/ if(arfcn<=672)
8529/*AD6546*/ { if(arfcn<=585)
8530/*AD6546*/ { /* ARFCN : 512~585 */
8531/*AD6546*/ *rfN = (((arfcn-512)*12+152)<<13) | 0x1406L /*(40L<<7|0x06L)*/;
8532/*AD6546*/ }
8533/*AD6546*/ else
8534/*AD6546*/ { /* ARFCN : 586~672 */
8535/*AD6546*/ *rfN = (((arfcn-586)*12)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8536/*AD6546*/ }
8537/*AD6546*/ }
8538/*AD6546*/ else
8539/*AD6546*/ { if(arfcn<=759)
8540/*AD6546*/ { /* ARFCN : 673~759 */
8541/*AD6546*/ *rfN = (((arfcn-673)*12+4)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8542/*AD6546*/ }
8543/*AD6546*/ else
8544/*AD6546*/ { if(arfcn<=845)
8545/*AD6546*/ { /* ARFCN : 760~845 */
8546/*AD6546*/ *rfN = (((arfcn-760)*12+8)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8547/*AD6546*/ }
8548/*AD6546*/ else
8549/*AD6546*/ { /* ARFCN : 846~885 */
8550/*AD6546*/ *rfN = (((arfcn-846)*12)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8551/*AD6546*/ }
8552/*AD6546*/ }
8553/*AD6546*/ }
8554/*AD6546*/ break;
8555/*AD6546*/ }
8556/*AD6546*/ case FrequencyBand1900 :
8557/*AD6546*/ {
8558/*AD6546*/ if(arfcn<=654)
8559/*AD6546*/ { if(arfcn<=567)
8560/*AD6546*/ { /* ARFCN : 512~567 */
8561/*AD6546*/ *rfN = (((arfcn-512)*12+372)<<13) | 0x1786L /*(47L<<7|0x06L)*/;
8562/*AD6546*/ }
8563/*AD6546*/ else
8564/*AD6546*/ { /* ARFCN : 568~654 */
8565/*AD6546*/ *rfN = (((arfcn-568)*12+4)<<13) | 0x1806L /*(48L<<7|0x06L)*/;
8566/*AD6546*/ }
8567/*AD6546*/ }
8568/*AD6546*/ else
8569/*AD6546*/ { if(arfcn<=740)
8570/*AD6546*/ { /* ARFCN : 655~740 */
8571/*AD6546*/ *rfN = (((arfcn-655)*12+8)<<13) | 0x1886L /*(49L<<7|0x06L)*/;
8572/*AD6546*/ }
8573/*AD6546*/ else
8574/*AD6546*/ { /* ARFCN : 741~810 */
8575/*AD6546*/ *rfN = (((arfcn-741)*12)<<13) | 0x1906L /*(50L<<7|0x06L)*/;
8576/*AD6546*/ }
8577/*AD6546*/ }
8578/*AD6546*/ break;
8579/*AD6546*/ }
8580/*AD6546*/ default :
8581/*AD6546*/ {
8582/*AD6546*/ break;
8583/*AD6546*/ }
8584/*AD6546*/ }
8585/*AD6546*/ *ifN = 0;
8586/*AD6546*/}
8587/*AD6546*//* ========================================================================== */
8588/*AD6546*/
8589/*AD6546*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8590/*AD6546*/{
8591/*AD6546*/ switch(rf_band)
8592/*AD6546*/ {
8593/*AD6546*/ case FrequencyBand850 :
8594/*AD6546*/ {
8595/*AD6546*/ if(arfcn<=185)
8596/*AD6546*/ { if(arfcn<=143)
8597/*AD6546*/ { /* ARFCN : 128~143 */
8598/*AD6546*/ *rfN = (((arfcn-128)*28+728)<<13) | 0x1106L /*(34L<<7|0x06L)*/;
8599/*AD6546*/ }
8600/*AD6546*/ else
8601/*AD6546*/ { /* ARFCN : 144~185 */
8602/*AD6546*/ *rfN = (((arfcn-144)*28+6)<<13) | 0x1186L /*(35L<<7|0x06L)*/;
8603/*AD6546*/ }
8604/*AD6546*/ }
8605/*AD6546*/ else
8606/*AD6546*/ { if(arfcn<=227)
8607/*AD6546*/ { /* ARFCN : 186~227 */
8608/*AD6546*/ *rfN = (((arfcn-186)*28+12)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8609/*AD6546*/ }
8610/*AD6546*/ else
8611/*AD6546*/ { /* ARFCN : 228~251 */
8612/*AD6546*/ *rfN = (((arfcn-228)*28+18)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8613/*AD6546*/ }
8614/*AD6546*/ }
8615/*AD6546*/ break;
8616/*AD6546*/ }
8617/*AD6546*/ case FrequencyBand900 :
8618/*AD6546*/ {
8619/*AD6546*/ if(arfcn<=62)
8620/*AD6546*/ { if(arfcn<=21)
8621/*AD6546*/ { /* ARFCN : 0~21 */
8622/*AD6546*/ *rfN = (((arfcn)*28+580)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8623/*AD6546*/ }
8624/*AD6546*/ else
8625/*AD6546*/ { /* ARFCN : 22~62 */
8626/*AD6546*/ *rfN = (((arfcn-22)*28+26)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8627/*AD6546*/ }
8628/*AD6546*/ }
8629/*AD6546*/ else
8630/*AD6546*/ { if(arfcn<=124)
8631/*AD6546*/ { if(arfcn<=104)
8632/*AD6546*/ { /* ARFCN : 63~104 */
8633/*AD6546*/ *rfN = (((arfcn-63)*28+4)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8634/*AD6546*/ }
8635/*AD6546*/ else
8636/*AD6546*/ { /* ARFCN : 105~124 */
8637/*AD6546*/ *rfN = (((arfcn-105)*28+10)<<13) | 0x1686L /*(45L<<7|0x06L)*/;
8638/*AD6546*/ }
8639/*AD6546*/ }
8640/*AD6546*/ else
8641/*AD6546*/ { if(arfcn<=1003)
8642/*AD6546*/ { /* ARFCN : 975~1003 */
8643/*AD6546*/ *rfN = (((arfcn-975)*28+378)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8644/*AD6546*/ }
8645/*AD6546*/ else
8646/*AD6546*/ { /* ARFCN : 1004~1023 */
8647/*AD6546*/ *rfN = (((arfcn-1004)*28+20)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8648/*AD6546*/ }
8649/*AD6546*/ }
8650/*AD6546*/ }
8651/*AD6546*/ break;
8652/*AD6546*/ }
8653/*AD6546*/ case FrequencyBand1800 :
8654/*AD6546*/ {
8655/*AD6546*/ if(arfcn<=694)
8656/*AD6546*/ { if(arfcn<=605)
8657/*AD6546*/ { if(arfcn<=517)
8658/*AD6546*/ { /* ARFCN : 512~517 */
8659/*AD6546*/ *rfN = (((arfcn-512)*14+1154)<<13) | 0x1006L /*(32L<<7|0x06L)*/;
8660/*AD6546*/ }
8661/*AD6546*/ else
8662/*AD6546*/ { /* ARFCN : 518~605 */
8663/*AD6546*/ *rfN = (((arfcn-518)*14+3)<<13) | 0x1086L /*(33L<<7|0x06L)*/;
8664/*AD6546*/ }
8665/*AD6546*/ }
8666/*AD6546*/ else
8667/*AD6546*/ { /* ARFCN : 606~694 */
8668/*AD6546*/ *rfN = (((arfcn-606)*14)<<13) | 0x1106L /*(34L<<7|0x06L)*/;
8669/*AD6546*/ }
8670/*AD6546*/ }
8671/*AD6546*/ else
8672/*AD6546*/ { if(arfcn<=782)
8673/*AD6546*/ { /* ARFCN : 695~782 */
8674/*AD6546*/ *rfN = (((arfcn-695)*14+11)<<13) | 0x1186L /*(35L<<7|0x06L)*/;
8675/*AD6546*/ }
8676/*AD6546*/ else
8677/*AD6546*/ { if(arfcn<=870)
8678/*AD6546*/ { /* ARFCN : 783~870 */
8679/*AD6546*/ *rfN = (((arfcn-783)*14+8)<<13) | 0x1206L /*(36L<<7|0x06L)*/;
8680/*AD6546*/ }
8681/*AD6546*/ else
8682/*AD6546*/ { /* ARFCN : 871~885 */
8683/*AD6546*/ *rfN = (((arfcn-871)*14+5)<<13) | 0x1286L /*(37L<<7|0x06L)*/;
8684/*AD6546*/ }
8685/*AD6546*/ }
8686/*AD6546*/ }
8687/*AD6546*/ break;
8688/*AD6546*/ }
8689/*AD6546*/ case FrequencyBand1900 :
8690/*AD6546*/ {
8691/*AD6546*/ if(arfcn<=699)
8692/*AD6546*/ { if(arfcn<=611)
8693/*AD6546*/ { if(arfcn<=523)
8694/*AD6546*/ { /* ARFCN : 512~523 */
8695/*AD6546*/ *rfN = (((arfcn-512)*14+1074)<<13) | 0x1406L /*(40L<<7|0x06L)*/;
8696/*AD6546*/ }
8697/*AD6546*/ else
8698/*AD6546*/ { /* ARFCN : 524~611 */
8699/*AD6546*/ *rfN = (((arfcn-524)*14+7)<<13) | 0x1486L /*(41L<<7|0x06L)*/;
8700/*AD6546*/ }
8701/*AD6546*/ }
8702/*AD6546*/ else
8703/*AD6546*/ { /* ARFCN : 612~699 */
8704/*AD6546*/ *rfN = (((arfcn-612)*14+4)<<13) | 0x1506L /*(42L<<7|0x06L)*/;
8705/*AD6546*/ }
8706/*AD6546*/ }
8707/*AD6546*/ else
8708/*AD6546*/ { if(arfcn<=788)
8709/*AD6546*/ { /* ARFCN : 700~788 */
8710/*AD6546*/ *rfN = (((arfcn-700)*14+1)<<13) | 0x1586L /*(43L<<7|0x06L)*/;
8711/*AD6546*/ }
8712/*AD6546*/ else
8713/*AD6546*/ { /* ARFCN : 789~810 */
8714/*AD6546*/ *rfN = (((arfcn-789)*14+12)<<13) | 0x1606L /*(44L<<7|0x06L)*/;
8715/*AD6546*/ }
8716/*AD6546*/ }
8717/*AD6546*/ break;
8718/*AD6546*/ }
8719/*AD6546*/ default :
8720/*AD6546*/ {
8721/*AD6546*/ break;
8722/*AD6546*/ }
8723/*AD6546*/ }
8724/*AD6546*/ *ifN = 0;
8725/*AD6546*/}
8726/*AD6546*//* ========================================================================== */
8727#endif
8728
8729#if IS_RF_MT6162
8730/*MT6162*/unsigned long TX_N_FRAC_THRESHOLD_LB = 7356163; /* 7356163/2^23 = 0.876922965 */
8731/*MT6162*/unsigned long TX_N_FRAC_THRESHOLD_HB = 7485219; /* 7485219/2^23 = 0.892307639 */
8732/*MT6162*/ short AFC_TRx_Offset_Threshold_LB = 30; /* the offset range in LB is -30Hz ~ +30Hz*/
8733/*MT6162*/ short AFC_TRx_Offset_Threshold_HB = 60; /* the offset range in HB is -60Hz ~ +60Hz*/
8734/*MT6162*/extern short AFC_TRx_Offset[5];
8735/*MT6162*/
8736/*MT6162*//* rfN : 0x61, SRX_FREQ=>SRX_B[5:0],SRX_A[0] and SRX_FRAC[11:0] */
8737/*MT6162*/void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8738/*MT6162*/{
8739/*MT6162*/ int channelFrequency = 0;
8740/*MT6162*/ int synthesizerFrequency = 0;
8741/*MT6162*/ int N_INT;
8742/*MT6162*/ int N_FRAC;
8743/*MT6162*/
8744/*MT6162*/ switch(rf_band)
8745/*MT6162*/ {
8746/*MT6162*/ case FrequencyBand850 :
8747/*MT6162*/ { channelFrequency = 8242+2*(arfcn-128)+450; /* 824.2+0.2*(arfcn-128)+45 */
8748/*MT6162*/ synthesizerFrequency = 4*channelFrequency;
8749/*MT6162*/
8750/*MT6162*/ if(arfcn<=201)
8751/*MT6162*/ { if(arfcn<=136)
8752/*MT6162*/ { /* ARFCN : 128~136 */
8753/*MT6162*/ *rfN = ((arfcn-128)*32+1792) | (66<<12);
8754/*MT6162*/ }
8755/*MT6162*/ else
8756/*MT6162*/ { /* ARFCN : 137~201 */
8757/*MT6162*/ *rfN = ((arfcn-137)*32) | (67<<12);
8758/*MT6162*/ }
8759/*MT6162*/ }
8760/*MT6162*/ else
8761/*MT6162*/ { /* ARFCN : 202~251 */
8762/*MT6162*/ *rfN = ((arfcn-202)*32) | (68<<12);
8763/*MT6162*/ }
8764/*MT6162*/ break;
8765/*MT6162*/ }
8766/*MT6162*/ case FrequencyBand900 :
8767/*MT6162*/ {
8768/*MT6162*/ if(arfcn<=124)
8769/*MT6162*/ { channelFrequency = 8900+2*(arfcn)+450; /* 890+0.2*(arfcn)+45 */
8770/*MT6162*/ }
8771/*MT6162*/ else
8772/*MT6162*/ { channelFrequency = 8900+2*(arfcn-1024)+450; /* 890+0.2*(arfcn-1024)+45 */
8773/*MT6162*/ }
8774/*MT6162*/ synthesizerFrequency = 4*channelFrequency;
8775/*MT6162*/
8776/*MT6162*/ if(arfcn<=124)
8777/*MT6162*/ { if(arfcn<=69)
8778/*MT6162*/ { if(arfcn<=4)
8779/*MT6162*/ { /* ARFCN : 0~4 */
8780/*MT6162*/ *rfN = ((arfcn)*32+1920) | (71<<12);
8781/*MT6162*/ }
8782/*MT6162*/ else
8783/*MT6162*/ { /* ARFCN : 5~69 */
8784/*MT6162*/ *rfN = ((arfcn-5)*32) | (72<<12);
8785/*MT6162*/ }
8786/*MT6162*/ }
8787/*MT6162*/ else
8788/*MT6162*/ { /* ARFCN : 70~124 */
8789/*MT6162*/ *rfN = ((arfcn-70)*32) | (73<<12);
8790/*MT6162*/ }
8791/*MT6162*/ }
8792/*MT6162*/ else
8793/*MT6162*/ { /* ARFCN : 975~1023 */
8794/*MT6162*/ *rfN = ((arfcn-975)*32+352) | (71<<12);
8795/*MT6162*/ }
8796/*MT6162*/ break;
8797/*MT6162*/ }
8798/*MT6162*/ case FrequencyBand1800 :
8799/*MT6162*/ {
8800/*MT6162*/ channelFrequency = 17102+2*(arfcn-512)+950; /* 1710.2+0.2*(arfcn-512)+95 */
8801/*MT6162*/ synthesizerFrequency = 2*channelFrequency;
8802/*MT6162*/
8803/*MT6162*/ if(arfcn<=715)
8804/*MT6162*/ { if(arfcn<=585)
8805/*MT6162*/ { /* ARFCN : 512~585 */
8806/*MT6162*/ *rfN = ((arfcn-512)*16+896) | (69<<12);
8807/*MT6162*/ }
8808/*MT6162*/ else
8809/*MT6162*/ { /* ARFCN : 586~715 */
8810/*MT6162*/ *rfN = ((arfcn-586)*16) | (70<<12);
8811/*MT6162*/ }
8812/*MT6162*/ }
8813/*MT6162*/ else
8814/*MT6162*/ { if(arfcn<=845)
8815/*MT6162*/ { /* ARFCN : 716~845 */
8816/*MT6162*/ *rfN = ((arfcn-716)*16) | (71<<12);
8817/*MT6162*/ }
8818/*MT6162*/ else
8819/*MT6162*/ { /* ARFCN : 846~885 */
8820/*MT6162*/ *rfN = ((arfcn-846)*16) | (72<<12);
8821/*MT6162*/ }
8822/*MT6162*/ }
8823/*MT6162*/ break;
8824/*MT6162*/ }
8825/*MT6162*/ case FrequencyBand1900 :
8826/*MT6162*/ {
8827/*MT6162*/ channelFrequency = 18502+2*(arfcn-512)+800; /* 1850.2+0.2*(arfcn-512)+80 */
8828/*MT6162*/ synthesizerFrequency = 2*channelFrequency;
8829/*MT6162*/
8830/*MT6162*/ if(arfcn<=740)
8831/*MT6162*/ { if(arfcn<=610)
8832/*MT6162*/ { /* ARFCN : 512~610 */
8833/*MT6162*/ *rfN = ((arfcn-512)*16+496) | (74<<12);
8834/*MT6162*/ }
8835/*MT6162*/ else
8836/*MT6162*/ { /* ARFCN : 611~740 */
8837/*MT6162*/ *rfN = ((arfcn-611)*16) | (75<<12);
8838/*MT6162*/ }
8839/*MT6162*/ }
8840/*MT6162*/ else
8841/*MT6162*/ { /* ARFCN : 741~810 */
8842/*MT6162*/ *rfN = ((arfcn-741)*16) | (76<<12);
8843/*MT6162*/ }
8844/*MT6162*/ break;
8845/*MT6162*/ }
8846/*MT6162*/ }
8847/*MT6162*/ N_INT = synthesizerFrequency/520;
8848/*MT6162*/ N_FRAC = ((synthesizerFrequency-520*N_INT)*2080) / 520;
8849/*MT6162*/ *rfN = (N_FRAC&0xFFF) | ((N_INT&0x7F)<<12);
8850/*MT6162*/}
8851/*MT6162*//* ========================================================================== */
8852/*MT6162*/
8853/*MT6162*//* rfN : 0x01, CW1=>N_INT[7:0] and N_FRAC[ 9: 0] */
8854/*MT6162*//* irN : 0x02, CW2=> N_FRAC[22:10] */
8855/*MT6162*/void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
8856/*MT6162*/{
8857/*MT6162*/ int channelFrequency = 0;
8858/*MT6162*/ int synthesizerFrequency = 0;
8859/*MT6162*/ int N_INT;
8860/*MT6162*/ int N_FRAC;
8861/*MT6162*/ int TRx_Offset_value;
8862/*MT6162*/
8863/*MT6162*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_SetTxGainWrite()
8864/*MT6162*/
8865/*MT6162*/ switch(rf_band)
8866/*MT6162*/ {
8867/*MT6162*/ case FrequencyBand850 :
8868/*MT6162*/ {
8869/*MT6162*/ channelFrequency = 8242+2*(arfcn-128); /* 824.2+0.2*(arfcn-128) */
8870/*MT6162*/ synthesizerFrequency = 4*channelFrequency;
8871/*MT6162*/
8872/*MT6162*/ if(arfcn<=199)
8873/*MT6162*/ { if(arfcn<=166)
8874/*MT6162*/ { if(arfcn<=134)
8875/*MT6162*/ { /* ARFCN : 128~134 */
8876/*MT6162*/ *rfN = (((arfcn-128)*258111+6710886)&0x3FF) | (126<<10);
8877/*MT6162*/ *ifN = (((arfcn-128)*258111+6710886)>>10)&0x1FFF;
8878/*MT6162*/ }
8879/*MT6162*/ else
8880/*MT6162*/ { /* ARFCN : 135~166 */
8881/*MT6162*/ *rfN = (((arfcn-135)*258111+129055)&0x3FF) | (127<<10);
8882/*MT6162*/ *ifN = (((arfcn-135)*258111+129055)>>10)&0x1FFF;
8883/*MT6162*/ }
8884/*MT6162*/ }
8885/*MT6162*/ else
8886/*MT6162*/ { /* ARFCN : 167~199 */
8887/*MT6162*/ *rfN = (((arfcn-167)*258111)&0x3FF) | (128<<10);
8888/*MT6162*/ *ifN = (((arfcn-167)*258111)>>10)&0x1FFF;
8889/*MT6162*/ }
8890/*MT6162*/ }
8891/*MT6162*/ else
8892/*MT6162*/ { if(arfcn<=231)
8893/*MT6162*/ { /* ARFCN : 200~231 */
8894/*MT6162*/ *rfN = (((arfcn-200)*258111+129055)&0x3FF) | (129<<10);
8895/*MT6162*/ *ifN = (((arfcn-200)*258111+129055)>>10)&0x1FFF;
8896/*MT6162*/ }
8897/*MT6162*/ else
8898/*MT6162*/ { /* ARFCN : 232~251 */
8899/*MT6162*/ *rfN = (((arfcn-232)*258111)&0x3FF) | (130<<10);
8900/*MT6162*/ *ifN = (((arfcn-232)*258111)>>10)&0x1FFF;
8901/*MT6162*/ }
8902/*MT6162*/ }
8903/*MT6162*/ break;
8904/*MT6162*/ }
8905/*MT6162*/ case FrequencyBand900 :
8906/*MT6162*/ { if(arfcn<=124)
8907/*MT6162*/ { channelFrequency = 8900+2*(arfcn); /* 890+0.2*(arfcn) */
8908/*MT6162*/ }
8909/*MT6162*/ else
8910/*MT6162*/ { channelFrequency = 8900+2*(arfcn-1024); /* 890+0.2*(arfcn-1024) */
8911/*MT6162*/ }
8912/*MT6162*/ synthesizerFrequency = 4*channelFrequency;
8913/*MT6162*/
8914/*MT6162*/ if(arfcn<=124)
8915/*MT6162*/ { if(arfcn<=67)
8916/*MT6162*/ { if(arfcn<=34)
8917/*MT6162*/ { if(arfcn<=2)
8918/*MT6162*/ { /* ARFCN : 0~2 */
8919/*MT6162*/ *rfN = (((arfcn-0)*258111+7743330)&0x3FF) | (136<<10);
8920/*MT6162*/ *ifN = (((arfcn-0)*258111+7743330)>>10)&0x1FFF;
8921/*MT6162*/ }
8922/*MT6162*/ else
8923/*MT6162*/ { /* ARFCN : 3~34 */
8924/*MT6162*/ *rfN = (((arfcn-3)*258111+129055)&0x3FF) | (137<<10);
8925/*MT6162*/ *ifN = (((arfcn-3)*258111+129055)>>10)&0x1FFF;
8926/*MT6162*/ }
8927/*MT6162*/ }
8928/*MT6162*/ else
8929/*MT6162*/ { /* ARFCN : 35~67 */
8930/*MT6162*/ *rfN = (((arfcn-35)*258111)&0x3FF) | (138<<10);
8931/*MT6162*/ *ifN = (((arfcn-35)*258111)>>10)&0x1FFF;
8932/*MT6162*/ }
8933/*MT6162*/ }
8934/*MT6162*/ else
8935/*MT6162*/ { if(arfcn<=99)
8936/*MT6162*/ { /* ARFCN : 68~99 */
8937/*MT6162*/ *rfN = (((arfcn-68)*258111+129055)&0x3FF) | (139<<10);
8938/*MT6162*/ *ifN = (((arfcn-68)*258111+129055)>>10)&0x1FFF;
8939/*MT6162*/ }
8940/*MT6162*/ else
8941/*MT6162*/ { /* ARFCN : 100~124 */
8942/*MT6162*/ *rfN = (((arfcn-100)*258111)&0x3FF) | (140<<10);
8943/*MT6162*/ *ifN = (((arfcn-100)*258111)>>10)&0x1FFF;
8944/*MT6162*/ }
8945/*MT6162*/ }
8946/*MT6162*/ }
8947/*MT6162*/ else
8948/*MT6162*/ { if(arfcn<=993)
8949/*MT6162*/ { /* ARFCN : 975~993 */
8950/*MT6162*/ *rfN = (((arfcn-975)*258111+3484498)&0x3FF) | (135<<10);
8951/*MT6162*/ *ifN = (((arfcn-975)*258111+3484498)>>10)&0x1FFF;
8952/*MT6162*/ }
8953/*MT6162*/ else
8954/*MT6162*/ { /* ARFCN : 994~1023 */
8955/*MT6162*/ *rfN = (((arfcn-994)*258111)&0x3FF) | (136<<10);
8956/*MT6162*/ *ifN = (((arfcn-994)*258111)>>10)&0x1FFF;
8957/*MT6162*/ }
8958/*MT6162*/ }
8959/*MT6162*/ break;
8960/*MT6162*/ }
8961/*MT6162*/ case FrequencyBand1800 :
8962/*MT6162*/ {
8963/*MT6162*/ channelFrequency = 17102+2*(arfcn-512); /* 1710.2+0.2*(arfcn-512) */
8964/*MT6162*/ synthesizerFrequency = 2*channelFrequency;
8965/*MT6162*/
8966/*MT6162*/ if(arfcn<=735)
8967/*MT6162*/ { if(arfcn<=670)
8968/*MT6162*/ { if(arfcn<=605)
8969/*MT6162*/ { if(arfcn<=540)
8970/*MT6162*/ { /* ARFCN : 512~540 */
8971/*MT6162*/ *rfN = (((arfcn-512)*129055+4645998+(arfcn-512)/2)&0x3FF) | (131<<10);
8972/*MT6162*/ *ifN = (((arfcn-512)*129055+4645998+(arfcn-512)/2)>>10)&0x1FFF;
8973/*MT6162*/ }
8974/*MT6162*/ else
8975/*MT6162*/ { /* ARFCN : 541~605 */
8976/*MT6162*/ *rfN = (((arfcn-541)*129055+(arfcn-541)/2)&0x3FF) | (132<<10);
8977/*MT6162*/ *ifN = (((arfcn-541)*129055+(arfcn-541)/2)>>10)&0x1FFF;
8978/*MT6162*/ }
8979/*MT6162*/ }
8980/*MT6162*/ else
8981/*MT6162*/ { /* ARFCN : 606~670 */
8982/*MT6162*/ *rfN = (((arfcn-606)*129055+(arfcn-606)/2)&0x3FF) | (133<<10);
8983/*MT6162*/ *ifN = (((arfcn-606)*129055+(arfcn-606)/2)>>10)&0x1FFF;
8984/*MT6162*/ }
8985/*MT6162*/ }
8986/*MT6162*/ else
8987/*MT6162*/ { /* ARFCN : 671~735 */
8988/*MT6162*/ *rfN = (((arfcn-671)*129055+(arfcn-671)/2)&0x3FF) | (134<<10);
8989/*MT6162*/ *ifN = (((arfcn-671)*129055+(arfcn-671)/2)>>10)&0x1FFF;
8990/*MT6162*/ }
8991/*MT6162*/ }
8992/*MT6162*/ else
8993/*MT6162*/ { if(arfcn<=865)
8994/*MT6162*/ { if(arfcn<=800)
8995/*MT6162*/ { /* ARFCN : 736~800 */
8996/*MT6162*/ *rfN = (((arfcn-736)*129055+(arfcn-736)/2)&0x3FF) | (135<<10);
8997/*MT6162*/ *ifN = (((arfcn-736)*129055+(arfcn-736)/2)>>10)&0x1FFF;
8998/*MT6162*/ }
8999/*MT6162*/ else
9000/*MT6162*/ { /* ARFCN : 801~865 */
9001/*MT6162*/ *rfN = (((arfcn-801)*129055+(arfcn-801)/2)&0x3FF) | (136<<10);
9002/*MT6162*/ *ifN = (((arfcn-801)*129055+(arfcn-801)/2)>>10)&0x1FFF;
9003/*MT6162*/ }
9004/*MT6162*/ }
9005/*MT6162*/ else
9006/*MT6162*/ { /* ARFCN : 866~885 */
9007/*MT6162*/ *rfN = (((arfcn-866)*129055+(arfcn-866)/2)&0x3FF) | (137<<10);
9008/*MT6162*/ *ifN = (((arfcn-866)*129055+(arfcn-866)/2)>>10)&0x1FFF;
9009/*MT6162*/ }
9010/*MT6162*/ }
9011/*MT6162*/ break;
9012/*MT6162*/ }
9013/*MT6162*/ case FrequencyBand1900 :
9014/*MT6162*/ {
9015/*MT6162*/ channelFrequency = 18502+2*(arfcn-512); /* 1850.2+0.2*(arfcn-512) */
9016/*MT6162*/ synthesizerFrequency = 2*channelFrequency;
9017/*MT6162*/
9018/*MT6162*/ if(arfcn<=685)
9019/*MT6162*/ { if(arfcn<=620)
9020/*MT6162*/ { if(arfcn<=555)
9021/*MT6162*/ { /* ARFCN : 512~555 */
9022/*MT6162*/ *rfN = (((arfcn-512)*129056+2710165-(arfcn-512)/2)&0x3FF) | (142<<10);
9023/*MT6162*/ *ifN = (((arfcn-512)*129056+2710165-(arfcn-512)/2)>>10)&0x1FFF;
9024/*MT6162*/ }
9025/*MT6162*/ else
9026/*MT6162*/ { /* ARFCN : 556~620 */
9027/*MT6162*/ *rfN = (((arfcn-556)*129055+(arfcn-556)/2)&0x3FF) | (143<<10);
9028/*MT6162*/ *ifN = (((arfcn-556)*129055+(arfcn-556)/2)>>10)&0x1FFF;
9029/*MT6162*/ }
9030/*MT6162*/ }
9031/*MT6162*/ else
9032/*MT6162*/ { /* ARFCN : 621~685 */
9033/*MT6162*/ *rfN = (((arfcn-621)*129055+(arfcn-621)/2)&0x3FF) | (144<<10);
9034/*MT6162*/ *ifN = (((arfcn-621)*129055+(arfcn-621)/2)>>10)&0x1FFF;
9035/*MT6162*/ }
9036/*MT6162*/ }
9037/*MT6162*/ else
9038/*MT6162*/ { if(arfcn<=750)
9039/*MT6162*/ { /* ARFCN : 686~750 */
9040/*MT6162*/ *rfN = (((arfcn-686)*129055+(arfcn-686)/2)&0x3FF) | (145<<10);
9041/*MT6162*/ *ifN = (((arfcn-686)*129055+(arfcn-686)/2)>>10)&0x1FFF;
9042/*MT6162*/ }
9043/*MT6162*/ else
9044/*MT6162*/ { /* ARFCN : 751~810 */
9045/*MT6162*/ *rfN = (((arfcn-751)*129055+(arfcn-751)/2)&0x3FF) | (146<<10);
9046/*MT6162*/ *ifN = (((arfcn-751)*129055+(arfcn-751)/2)>>10)&0x1FFF;
9047/*MT6162*/ }
9048/*MT6162*/ }
9049/*MT6162*/ break;
9050/*MT6162*/ }
9051/*MT6162*/ }
9052/*MT6162*/ N_INT = synthesizerFrequency/260;
9053/*MT6162*/ N_FRAC = ((synthesizerFrequency-260*N_INT)<<21) / 65; /* ((synthesizerFrequency-260*N_INT)<<23) / 260 */
9054/*MT6162*/
9055/*MT6162*/ if( L1D_RF_Get6162Version() == 1 )
9056/*MT6162*/ { /* for OH E1, do nothing */ }
9057/*MT6162*/ else
9058/*MT6162*/ { /* for OH E2 */
9059/*MT6162*/ l1d_rf2.is_integer = (N_FRAC == 0) ? 1 : 0;
9060/*MT6162*/ if( rf_band <= FrequencyBand900 )
9061/*MT6162*/ { l1d_rf2.is_isotpol = (N_FRAC > TX_N_FRAC_THRESHOLD_LB) ? 1 : 0; }
9062/*MT6162*/ else
9063/*MT6162*/ { l1d_rf2.is_isotpol = (N_FRAC > TX_N_FRAC_THRESHOLD_HB) ? 1 : 0; }
9064/*MT6162*/ }
9065/*MT6162*/
9066/*MT6162*/ if( rf_band <= FrequencyBand900 )
9067/*MT6162*/ {
9068/*MT6162*/ if( AFC_TRx_Offset[rf_band] > AFC_TRx_Offset_Threshold_LB )
9069/*MT6162*/ { TRx_Offset_value = (int)((AFC_TRx_Offset_Threshold_LB*258111)/200000); }
9070/*MT6162*/ else if( AFC_TRx_Offset[rf_band] < (-AFC_TRx_Offset_Threshold_LB) )
9071/*MT6162*/ { TRx_Offset_value = (int)(((-AFC_TRx_Offset_Threshold_LB)*258111)/200000); }
9072/*MT6162*/ else
9073/*MT6162*/ { TRx_Offset_value = (int)((AFC_TRx_Offset[rf_band]*258111)/200000); }
9074/*MT6162*/ }
9075/*MT6162*/ else
9076/*MT6162*/ {
9077/*MT6162*/ if( AFC_TRx_Offset[rf_band] > AFC_TRx_Offset_Threshold_HB )
9078/*MT6162*/ { TRx_Offset_value = (int)((AFC_TRx_Offset_Threshold_HB*129055)/200000); }
9079/*MT6162*/ else if( AFC_TRx_Offset[rf_band] < (-AFC_TRx_Offset_Threshold_HB) )
9080/*MT6162*/ { TRx_Offset_value = (int)(((-AFC_TRx_Offset_Threshold_HB)*129055)/200000); }
9081/*MT6162*/ else
9082/*MT6162*/ { TRx_Offset_value = (int)((AFC_TRx_Offset[rf_band]*129055)/200000); }
9083/*MT6162*/ }
9084/*MT6162*/
9085/*MT6162*/ if( N_FRAC == 0 )
9086/*MT6162*/ {
9087/*MT6162*/ if( TRx_Offset_value >= 0 )
9088/*MT6162*/ { N_FRAC += TRx_Offset_value; }
9089/*MT6162*/ else
9090/*MT6162*/ {
9091/*MT6162*/ N_INT -= 1;
9092/*MT6162*/ N_FRAC = 8388608+TRx_Offset_value; /* 2^23 = 8388608 */
9093/*MT6162*/ }
9094/*MT6162*/ }
9095/*MT6162*/ else
9096/*MT6162*/ { N_FRAC += TRx_Offset_value; }
9097/*MT6162*/
9098/*MT6162*/ *rfN = (N_FRAC&0x3FF) | ((N_INT&0xFF)<<10);
9099/*MT6162*/ *ifN = (N_FRAC>>10)&0x1FFF;
9100/*MT6162*/}
9101/*MT6162*//* ========================================================================== */
9102#endif
9103
9104#if IS_RF_MT6163
9105/*MT6163*/ /* rfN : 0x01, CW1=>N_INT[7:0] and N_FRAC[ 9: 0] */
9106/*MT6163*/ /* irN : 0x02, CW2=> N_FRAC[22:10] */
9107/*MT6163*/
9108/*MT6163*/ #define TX_NEAR_INT_N_FRAC_MIN 167772
9109/*MT6163*/ #define TX_NEAR_INT_N_FRAC_MAX 754974
9110/*MT6163*/ #define N_FRAC_DIFF_200KHZ_LB 258111 /* LB N_FRAC difference of neighboring ARFCN (200KHz) */
9111/*MT6163*/ #define N_FRAC_DIFF_200KHZ_HB 129055 /* HB N_FRAC difference of neighboring ARFCN (200KHz) */
9112/*MT6163*/ #define N_FRAC_MIN 0
9113/*MT6163*/ #define N_FRAC_MAX 8388608 /* 2^23 */
9114/*MT6163*/ #define AFC_TRX_OFFSET_BOUND_LB 30 /* offset range in LB is -30Hz ~ +30Hz */
9115/*MT6163*/ #define AFC_TRX_OFFSET_BOUND_HB 60 /* offset range in HB is -60Hz ~ +60Hz */
9116/*MT6163*/ #define CW2_DFM_SDM_IFM_ON_SET (0x1<<13)
9117/*MT6163*/
9118/*MT6163*/ extern short AFC_TRx_Offset[FrequencyBandCount];
9119/*MT6163*/
9120/*MT6163*/ static void L1D_RF_ComputeTxPLLFreq( char is_Rx, int rf_band, int arfcn, long *rfN, long *ifN )
9121/*MT6163*/ {
9122/*MT6163*/ int channelFrequency = 0;
9123/*MT6163*/ int synthesizerFrequency = 0;
9124/*MT6163*/ int N_INT, N_FRAC, frac_diff;
9125/*MT6163*/ short trx_offset_bound;
9126/*MT6163*/ char int_mask = 0x1<<is_Rx; /* bit1: RX, bit0: TX */
9127/*MT6163*/ unsigned long sdm = 0;
9128/*MT6163*/
9129/*MT6163*/ if( is_Rx )
9130/*MT6163*/ { /* Add freq offset of RX/TX at the same ARFCN */
9131/*MT6163*/ switch( rf_band )
9132/*MT6163*/ {
9133/*MT6163*/ case FrequencyBand850:
9134/*MT6163*/ case FrequencyBand900:
9135/*MT6163*/ {
9136/*MT6163*/ channelFrequency = 450; /* 45 MHz */
9137/*MT6163*/ break;
9138/*MT6163*/ }
9139/*MT6163*/ case FrequencyBand1800:
9140/*MT6163*/ {
9141/*MT6163*/ channelFrequency = 950; /* 95 MHz */
9142/*MT6163*/ break;
9143/*MT6163*/ }
9144/*MT6163*/ case FrequencyBand1900:
9145/*MT6163*/ {
9146/*MT6163*/ channelFrequency = 800; /* 80 MHz */
9147/*MT6163*/ break;
9148/*MT6163*/ }
9149/*MT6163*/ }
9150/*MT6163*/ }
9151/*MT6163*/
9152/*MT6163*/ switch( rf_band )
9153/*MT6163*/ {
9154/*MT6163*/ case FrequencyBand850:
9155/*MT6163*/ {
9156/*MT6163*/ channelFrequency += (8242 + 2*(arfcn-128)); /* 824.2 + 0.2*(arfcn-128) */
9157/*MT6163*/ synthesizerFrequency = 4*channelFrequency;
9158/*MT6163*/ break;
9159/*MT6163*/ }
9160/*MT6163*/ case FrequencyBand900:
9161/*MT6163*/ {
9162/*MT6163*/ if(arfcn<=124)
9163/*MT6163*/ { channelFrequency += (8900 + 2*(arfcn)); } /* 890.0 + 0.2*(arfcn) */
9164/*MT6163*/ else
9165/*MT6163*/ { channelFrequency += (8900 + 2*(arfcn-1024)); } /* 890.0 + 0.2*(arfcn-1024) */
9166/*MT6163*/ synthesizerFrequency = 4*channelFrequency;
9167/*MT6163*/ break;
9168/*MT6163*/ }
9169/*MT6163*/ case FrequencyBand1800:
9170/*MT6163*/ {
9171/*MT6163*/ channelFrequency += (17102 + 2*(arfcn-512)); /* 1710.2 + 0.2*(arfcn-512) */
9172/*MT6163*/ synthesizerFrequency = 2*channelFrequency;
9173/*MT6163*/ break;
9174/*MT6163*/ }
9175/*MT6163*/ case FrequencyBand1900:
9176/*MT6163*/ {
9177/*MT6163*/ channelFrequency += (18502 + 2*(arfcn-512)); /* 1850.2 + 0.2*(arfcn-512) */
9178/*MT6163*/ synthesizerFrequency = 2*channelFrequency;
9179/*MT6163*/ break;
9180/*MT6163*/ }
9181/*MT6163*/ }
9182/*MT6163*/
9183/*MT6163*/ N_INT = synthesizerFrequency/260;
9184/*MT6163*/ N_FRAC = ((synthesizerFrequency - 260*N_INT)<<21) / 65; /* ((synthesizerFrequency-260*N_INT)<<23) / 260 */
9185/*MT6163*/
9186/*MT6163*/ /* add TRX offset */
9187/*MT6163*/ if( is_Rx )
9188/*MT6163*/ { /* do nothing for RX */ }
9189/*MT6163*/ else
9190/*MT6163*/ {
9191/*MT6163*/ if( rf_band <= FrequencyBand900 )
9192/*MT6163*/ {
9193/*MT6163*/ trx_offset_bound = AFC_TRX_OFFSET_BOUND_LB;
9194/*MT6163*/ frac_diff = N_FRAC_DIFF_200KHZ_LB;
9195/*MT6163*/ }
9196/*MT6163*/ else
9197/*MT6163*/ {
9198/*MT6163*/ trx_offset_bound = AFC_TRX_OFFSET_BOUND_HB;
9199/*MT6163*/ frac_diff = N_FRAC_DIFF_200KHZ_HB;
9200/*MT6163*/ }
9201/*MT6163*/
9202/*MT6163*/ if( AFC_TRx_Offset[rf_band] > trx_offset_bound )
9203/*MT6163*/ { AFC_TRx_Offset[rf_band] = trx_offset_bound; }
9204/*MT6163*/ else if( AFC_TRx_Offset[rf_band] < (-1)*trx_offset_bound )
9205/*MT6163*/ { AFC_TRx_Offset[rf_band] = (-1)*trx_offset_bound; }
9206/*MT6163*/
9207/*MT6163*/ N_FRAC += (int)(AFC_TRx_Offset[rf_band]*frac_diff/200000);
9208/*MT6163*/
9209/*MT6163*/ if( N_FRAC >= N_FRAC_MAX )
9210/*MT6163*/ {
9211/*MT6163*/ N_FRAC -= N_FRAC_MAX;
9212/*MT6163*/ N_INT++;
9213/*MT6163*/ }
9214/*MT6163*/ else if( N_FRAC < N_FRAC_MIN )
9215/*MT6163*/ {
9216/*MT6163*/ N_FRAC += N_FRAC_MAX;
9217/*MT6163*/ N_INT--;
9218/*MT6163*/ }
9219/*MT6163*/ }
9220/*MT6163*/
9221/*MT6163*/ /* integer channel check */
9222/*MT6163*/ if( N_FRAC == 0 )
9223/*MT6163*/ { l1d_rf2.is_integer |= int_mask; } /* integer */
9224/*MT6163*/ else
9225/*MT6163*/ { l1d_rf2.is_integer &= ~int_mask; } /* not integer */
9226/*MT6163*/
9227/*MT6163*/ /* near-integer channel check */
9228/*MT6163*/ if( is_Rx )
9229/*MT6163*/ { sdm = (l1d_rf2.is_integer&0x2) ? 0 : CW2_DFM_SDM_IFM_ON_SET; } /* turn off for integer channels */
9230/*MT6163*/ else
9231/*MT6163*/ { l1d_rf2.is_isotpol = (N_FRAC>TX_NEAR_INT_N_FRAC_MIN && N_FRAC<TX_NEAR_INT_N_FRAC_MAX) ? 1 : 0; }
9232/*MT6163*/
9233/*MT6163*/ *rfN = (N_FRAC&0x3FF) | ((N_INT&0xFF)<<10);
9234/*MT6163*/ *ifN = (sdm)|((N_FRAC>>10)&0x1FFF);
9235/*MT6163*/ }
9236/*MT6163*/ /* ========================================================================== */
9237/*MT6163*/
9238/*MT6163*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9239/*MT6163*/ {
9240/*MT6163*/ L1D_RF_ComputeTxPLLFreq( 1/*RX*/, rf_band, arfcn, rfN, ifN );
9241/*MT6163*/ }
9242/*MT6163*/ /* ========================================================================== */
9243/*MT6163*/
9244/*MT6163*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9245/*MT6163*/ {
9246/*MT6163*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_SetTxGainWrite()
9247/*MT6163*/ L1D_RF_ComputeTxPLLFreq( 0/*TX*/, rf_band, arfcn, rfN, ifN );
9248/*MT6163*/ }
9249/*MT6163*/ /* ========================================================================== */
9250#endif
9251
9252#if IS_RF_MT6280RF
9253/*MT6280RF*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9254/*MT6280RF*/ { long *if_sel = ifN+1;
9255/*MT6280RF*/ unsigned short Nint =0, CH_freq =0;
9256/*MT6280RF*/ unsigned long Nfrac=0, VCO_freq=0;
9257/*MT6280RF*/
9258/*MT6280RF*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
9259/*MT6280RF*/
9260/*MT6280RF*/ *if_sel = 0;
9261/*MT6280RF*/ if( rf_band < FrequencyBand1800 )
9262/*MT6280RF*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF);
9263/*MT6280RF*/ else
9264/*MT6280RF*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF);
9265/*MT6280RF*/
9266/*MT6280RF*/ Nint = VCO_freq/(RX_DCXO_FREQ*DLIF_SCALE);
9267/*MT6280RF*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
9268/*MT6280RF*/ Nfrac = ( (((VCO_freq-Nint*RX_DCXO_FREQ*DLIF_SCALE)*2080)<<3) + (195)/2 )/195;
9269/*MT6280RF*/
9270/*MT6280RF*/ /* CW99, N_INT[6:0], N_RFC[23:11] */
9271/*MT6280RF*/ *rfN = BSI_CW( 0x63, ((Nint &0x7F)<<13) | (Nfrac>>11) );
9272/*MT6280RF*/ /* CW100, N_FRAC[10:0], DITHER_MASK[4:0] */
9273/*MT6280RF*/ *ifN = BSI_CW( 0x64, ((Nfrac&0x7FF)<<9) | 0x10 );
9274/*MT6280RF*/
9275/*MT6280RF*/ }
9276/*MT6280RF*/ /* =========================================================================== */
9277/*MT6280RF*/
9278/*MT6280RF*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9279/*MT6280RF*/ {
9280/*MT6280RF*/ unsigned short Nint =0, CH_freq =0;
9281/*MT6280RF*/ unsigned long Nfrac=0, VCO_freq=0;
9282/*MT6280RF*/ unsigned short DAoffset=0;
9283/*MT6280RF*/
9284/*MT6280RF*/
9285/*MT6280RF*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
9286/*MT6280RF*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
9287/*MT6280RF*/
9288/*MT6280RF*/ if( rf_band < FrequencyBand1800 )
9289/*MT6280RF*/ VCO_freq = 4*CH_freq;
9290/*MT6280RF*/ else
9291/*MT6280RF*/ VCO_freq = 2*CH_freq;
9292/*MT6280RF*/
9293/*MT6280RF*/ Nint = VCO_freq/TX_DCXO_FREQ;
9294/*MT6280RF*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
9295/*MT6280RF*/
9296/*MT6280RF*/ DAoffset = L1D_RF_GetTxDAoffsetSetting( Nint );
9297/*MT6280RF*/
9298/*MT6280RF*/ /* CW95, N_INT[7:0], N_RFC[22:11] */
9299/*MT6280RF*/ *rfN = BSI_CW( 0x5F, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9300/*MT6280RF*/ /* CW96, N_FRAC[10:0], DA_OFFSET[7:0], DI_EN */
9301/*MT6280RF*/ *ifN = BSI_CW( 0x60, ((Nfrac&0x7FF)<<9) | ((DAoffset&0xFF)<<1) | 0x1);
9302/*MT6280RF*/
9303/*MT6280RF*/ }
9304/*MT6280RF*/ /* =========================================================================== */
9305/*MT6280RF*/
9306/*MT6280RF*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
9307/*MT6280RF*/ {
9308/*MT6280RF*/ unsigned short freq=4450+225;
9309/*MT6280RF*/ switch( rf_band )
9310/*MT6280RF*/ {
9311/*MT6280RF*/ case FrequencyBand850 :
9312/*MT6280RF*/ {
9313/*MT6280RF*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
9314/*MT6280RF*/ break;
9315/*MT6280RF*/ }
9316/*MT6280RF*/ case FrequencyBand900 :
9317/*MT6280RF*/ {
9318/*MT6280RF*/ if( arfcn<=124 )
9319/*MT6280RF*/ { freq=4450+arfcn+225; }
9320/*MT6280RF*/ else
9321/*MT6280RF*/ { freq=4450+(arfcn-1024)+225; }
9322/*MT6280RF*/ break;
9323/*MT6280RF*/ }
9324/*MT6280RF*/ case FrequencyBand1800 :
9325/*MT6280RF*/ {
9326/*MT6280RF*/ freq=8551+(arfcn-512)+475;
9327/*MT6280RF*/ break;
9328/*MT6280RF*/ }
9329/*MT6280RF*/ case FrequencyBand1900 :
9330/*MT6280RF*/ {
9331/*MT6280RF*/ freq=9251+(arfcn-512)+400;
9332/*MT6280RF*/ break;
9333/*MT6280RF*/ }
9334/*MT6280RF*/ default :
9335/*MT6280RF*/ {
9336/*MT6280RF*/ break;
9337/*MT6280RF*/ }
9338/*MT6280RF*/ }
9339/*MT6280RF*/
9340/*MT6280RF*/ return freq;
9341/*MT6280RF*/ }
9342/*MT6280RF*/ /* =========================================================================== */
9343/*MT6280RF*/
9344/*MT6280RF*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
9345/*MT6280RF*/ {
9346/*MT6280RF*/ unsigned short freq=4450;
9347/*MT6280RF*/ switch( rf_band )
9348/*MT6280RF*/ {
9349/*MT6280RF*/ case FrequencyBand850 :
9350/*MT6280RF*/ {
9351/*MT6280RF*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
9352/*MT6280RF*/ break;
9353/*MT6280RF*/ }
9354/*MT6280RF*/ case FrequencyBand900 :
9355/*MT6280RF*/ {
9356/*MT6280RF*/ if( arfcn<=124 )
9357/*MT6280RF*/ { freq=4450+arfcn; }
9358/*MT6280RF*/ else
9359/*MT6280RF*/ { freq=4450+(arfcn-1024); }
9360/*MT6280RF*/ break;
9361/*MT6280RF*/ }
9362/*MT6280RF*/ case FrequencyBand1800 :
9363/*MT6280RF*/ {
9364/*MT6280RF*/ freq=8551+(arfcn-512);
9365/*MT6280RF*/ break;
9366/*MT6280RF*/ }
9367/*MT6280RF*/ case FrequencyBand1900 :
9368/*MT6280RF*/ {
9369/*MT6280RF*/ freq=9251+(arfcn-512);
9370/*MT6280RF*/ break;
9371/*MT6280RF*/ }
9372/*MT6280RF*/ default :
9373/*MT6280RF*/ {
9374/*MT6280RF*/ break;
9375/*MT6280RF*/ }
9376/*MT6280RF*/ }
9377/*MT6280RF*/
9378/*MT6280RF*/ return freq;
9379/*MT6280RF*/ }
9380/*MT6280RF*/ /* =========================================================================== */
9381/*MT6280RF*/
9382/*MT6280RF*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
9383/*MT6280RF*/ {
9384/*MT6280RF*/ char segment_tx=3, LUT_num_tx=8, offset_tx=13; // LUT method related parameters
9385/*MT6280RF*/ unsigned short TXDCO_LUT[8]={1865, 1424, 1067, 774, 534, 331, 160, 13}; // TXDCO LUT
9386/*MT6280RF*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
9387/*MT6280RF*/
9388/*MT6280RF*/ /* STX DCO SCA Typical Code LUT */
9389/*MT6280RF*/ idx = (Nint>>segment_tx)-((short)offset_tx);
9390/*MT6280RF*/ if(idx<0)
9391/*MT6280RF*/ idx = 0;
9392/*MT6280RF*/ else if(idx>(LUT_num_tx-2))
9393/*MT6280RF*/ idx = LUT_num_tx-2;
9394/*MT6280RF*/
9395/*MT6280RF*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
9396/*MT6280RF*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
9397/*MT6280RF*/ code_type <<= 1;
9398/*MT6280RF*/
9399/*MT6280RF*/ return code_type;
9400/*MT6280RF*/ }
9401/*MT6280RF*/ /* =========================================================================== */
9402/*MT6280RF*/
9403/*MT6280RF*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
9404/*MT6280RF*/ {
9405/*MT6280RF*/ unsigned short DEM_Chunk_L1;
9406/*MT6280RF*/ unsigned short OUT_G, OUT_E;
9407/*MT6280RF*/ char segment_dem=4, LUT_num_dem=4, offset_dem=7; // LUT method related parameters
9408/*MT6280RF*/ unsigned short DEM_chunk_G_LUT[4]={15, 10, 7, 5}; // DEM chunk GMSK LUT
9409/*MT6280RF*/ unsigned short DEM_chunk_E_LUT[4]={69, 46, 33, 24}; // DEM chunk EPSK LUT
9410/*MT6280RF*/ short idx;
9411/*MT6280RF*/
9412/*MT6280RF*/ /* STX DEM CHUNK LUT */
9413/*MT6280RF*/ idx = (Nint>>segment_dem)-((short)offset_dem);
9414/*MT6280RF*/ if(idx<0)
9415/*MT6280RF*/ idx = 0;
9416/*MT6280RF*/ else if(idx>(LUT_num_dem-2))
9417/*MT6280RF*/ idx = LUT_num_dem-2;
9418/*MT6280RF*/
9419/*MT6280RF*/ OUT_G = DEM_chunk_G_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_G_LUT[idx+1]-DEM_chunk_G_LUT[idx]))>>(segment_dem));
9420/*MT6280RF*/ OUT_E = DEM_chunk_E_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_E_LUT[idx+1]-DEM_chunk_E_LUT[idx]))>>(segment_dem));
9421/*MT6280RF*/
9422/*MT6280RF*/ if( ( (l1d_rf.tx_mod_type2)^(l1d_rf.tx_mod_type2<<1) ) & 0xE ) // IS_MIXED_MULTISLOT
9423/*MT6280RF*/ {
9424/*MT6280RF*/ if( rf_band < FrequencyBand1800 )
9425/*MT6280RF*/ DEM_Chunk_L1 = ((OUT_E+OUT_G+5)>40) ? (OUT_E+OUT_G+5) : 40;
9426/*MT6280RF*/ else
9427/*MT6280RF*/ DEM_Chunk_L1 = 40;
9428/*MT6280RF*/ }
9429/*MT6280RF*/ else
9430/*MT6280RF*/ {
9431/*MT6280RF*/ if( (l1d_rf.tx_mod_type2 != 0) && (rf_band < FrequencyBand1800) )
9432/*MT6280RF*/ DEM_Chunk_L1 = ((2*OUT_E+6)>40) ? (2*OUT_E+6) : 40;
9433/*MT6280RF*/ else
9434/*MT6280RF*/ DEM_Chunk_L1 = 40;
9435/*MT6280RF*/ }
9436/*MT6280RF*/ return DEM_Chunk_L1;
9437/*MT6280RF*/ }
9438/*MT6280RF*/ /* =========================================================================== */
9439/*MT6280RF*/
9440/*MT6280RF*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
9441/*MT6280RF*/ {
9442/*MT6280RF*/ unsigned short Nint =0, CH_freq =0;
9443/*MT6280RF*/ unsigned long Nfrac=0, DCO4G_freq=0;
9444/*MT6280RF*/
9445/*MT6280RF*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
9446/*MT6280RF*/
9447/*MT6280RF*/ if( rf_band < FrequencyBand1800 )
9448/*MT6280RF*/ DCO4G_freq = 4*CH_freq;
9449/*MT6280RF*/ else
9450/*MT6280RF*/ DCO4G_freq = 2*CH_freq;
9451/*MT6280RF*/
9452/*MT6280RF*/ Nint = ( (DCO4G_freq<<15) - 64*DCO4G_freq + 64*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
9453/*MT6280RF*/ Nfrac = ( ( ( (DCO4G_freq<<15) - 64*DCO4G_freq + 64*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
9454/*MT6280RF*/
9455/*MT6280RF*/ /* CW97, N_INT1[7:0], N_RFC1[22:11] */
9456/*MT6280RF*/ *rfN = BSI_CW( 0x61, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9457/*MT6280RF*/ /* CW98, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[2:0], STX_MMD_SDM_DI_LS[1:0] */
9458/*MT6280RF*/ *ifN = BSI_CW( 0x62, ((Nfrac&0x7FF)<<9) | 0x00);
9459/*MT6280RF*/
9460/*MT6280RF*/ }
9461/*MT6280RF*/ /* =========================================================================== */
9462/*MT6280RF*/
9463/*MT6280RF*/ unsigned short L1D_RF_GetTxDAoffsetSetting(unsigned short Nint)
9464/*MT6280RF*/ {
9465/*MT6280RF*/ return (Nint - 10);
9466/*MT6280RF*/ }
9467#endif
9468
9469#if IS_RF_MT6169
9470/*MT6169*/ //For DLIF mode
9471/*MT6169*/ char L1D_RF_Cal_IF_Synth_State( void )
9472/*MT6169*/ {
9473 #if IS_W_CANCELLATION_SUPPORT
9474/*MT6169*/ if( L1D_CheckIfMetaMode() )
9475/*MT6169*/ { return l1d_rf.if_state; }
9476/*MT6169*/ else
9477/*MT6169*/ { return 0; }
9478 #else
9479/*MT6169*/ return 0;
9480 #endif
9481/*MT6169*/ }
9482/*MT6169*/ /* =========================================================================== */
9483/*MT6169*/
9484/*MT6169*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9485/*MT6169*/ { long *if_sel = ifN+1;
9486/*MT6169*/ unsigned short Nint =0, CH_freq =0;
9487/*MT6169*/ unsigned long Nfrac=0, VCO_freq=0;
9488/*MT6169*/ unsigned short Nint_spur =0;
9489/*MT6169*/ unsigned long Nfrac_spur=0;
9490/*MT6169*/ unsigned long frac_spurs_thd0=0, frac_spurs_thd1=0;
9491/*MT6169*/ unsigned long frac_spurs_mid_thd0=4129776, frac_spurs_mid_thd1=4258832;
9492/*MT6169*/ long freqOffset=0;
9493/*MT6169*/
9494/*MT6169*/ unsigned short RG_RXREP_EN = 1;
9495/*MT6169*/ unsigned short RG_SRX_REF_SEL = (SDATA_CW117[rf_band]&0x3);
9496/*MT6169*/ unsigned short RG_SRX_KVCO_SEL[5] = { 0, 2, 2, 2, 2};
9497/*MT6169*/ unsigned short RG_SRX_LF_R2[5] = { 0, 24, 20, 21, 18};
9498/*MT6169*/ unsigned short FREF_SRX[3] = {26, 13, 52};
9499/*MT6169*/ unsigned short multiplier[3] = {15, 16, 14};
9500/*MT6169*/ unsigned char IF_state=0; //IF_state=0:default, IF_state=1:+IF, IF_state=2:-IF
9501/*MT6169*/
9502/*MT6169*/ IF_state = L1D_RF_Cal_IF_Synth_State();
9503/*MT6169*/
9504/*MT6169*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
9505/*MT6169*/
9506/*MT6169*/ if( IF_state != 2 )
9507/*MT6169*/ {
9508/*MT6169*/ *if_sel = 0;
9509/*MT6169*/ if( rf_band < FrequencyBand1800 )
9510/*MT6169*/ {
9511/*MT6169*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
9512/*MT6169*/ frac_spurs_thd0 = 193584;
9513/*MT6169*/ frac_spurs_thd1 = 8195024;
9514/*MT6169*/ }
9515/*MT6169*/ else
9516/*MT6169*/ {
9517/*MT6169*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
9518/*MT6169*/ frac_spurs_thd0 = 96792;
9519/*MT6169*/ frac_spurs_thd1 = 8291816;
9520/*MT6169*/ }
9521/*MT6169*/ }
9522/*MT6169*/
9523/*MT6169*/ Nint = VCO_freq/(FREF_SRX[RG_SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
9524/*MT6169*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
9525/*MT6169*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[RG_SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[RG_SRX_REF_SEL]) + (195)/2 )/195;
9526/*MT6169*/
9527/*MT6169*/ Nint_spur = VCO_freq/(FREF_SRX[0]*SYNTH_SCALE*DLIF_SCALE);
9528/*MT6169*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
9529/*MT6169*/ Nfrac_spur = ( ((VCO_freq-Nint_spur*FREF_SRX[0]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[0]) + (195)/2 )/195;
9530/*MT6169*/
9531/*MT6169*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
9532/*MT6169*/ extern long L1D_DualLoopAFC_CalculateFreqOffset();
9533/*MT6169*/ freqOffset = (long)L1D_DualLoopAFC_CalculateFreqOffset(); // Check current freqOffset from activer rat
9534/*MT6169*/ if( (l1d_rf.is_lock_dcxo) && (freqOffset > SRX_SPUR_SEL_CRITERION) )
9535/*MT6169*/ { /* 26MHz is faster, Spur freq will move to lower frequency */
9536/*MT6169*/ frac_spurs_thd0 += ( (rf_band<FrequencyBand1800) ? SRX_SPUR_LB_OFFSET : SRX_SPUR_HB_OFFSET );
9537/*MT6169*/ frac_spurs_thd1 += ( (rf_band<FrequencyBand1800) ? SRX_SPUR_LB_OFFSET : SRX_SPUR_HB_OFFSET );
9538/*MT6169*/ frac_spurs_mid_thd0 += ( (rf_band<FrequencyBand1800) ? SRX_MID_SPUR_LB_OFFSET : SRX_MID_SPUR_HB_OFFSET-2 ); // Adjust srx spur range at HB to guratee spur channel far from spur when 26MHz drift
9539/*MT6169*/ frac_spurs_mid_thd1 += ( (rf_band<FrequencyBand1800) ? SRX_MID_SPUR_LB_OFFSET : SRX_MID_SPUR_HB_OFFSET );
9540/*MT6169*/ }
9541/*MT6169*/ else if( (l1d_rf.is_lock_dcxo) && (freqOffset < -SRX_SPUR_SEL_CRITERION) )
9542/*MT6169*/ { /* 26MHz is slower, Spur freq will move to higher frequency */
9543/*MT6169*/ frac_spurs_thd0 -= ( (rf_band<FrequencyBand1800) ? SRX_SPUR_LB_OFFSET : SRX_SPUR_HB_OFFSET );
9544/*MT6169*/ frac_spurs_thd1 -= ( (rf_band<FrequencyBand1800) ? SRX_SPUR_LB_OFFSET : SRX_SPUR_HB_OFFSET );
9545/*MT6169*/ frac_spurs_mid_thd0 -= ( (rf_band<FrequencyBand1800) ? SRX_MID_SPUR_LB_OFFSET : SRX_MID_SPUR_HB_OFFSET );
9546/*MT6169*/ frac_spurs_mid_thd1 -= ( (rf_band<FrequencyBand1800) ? SRX_MID_SPUR_LB_OFFSET : SRX_MID_SPUR_HB_OFFSET );
9547/*MT6169*/ }
9548/*MT6169*/ #endif
9549/*MT6169*/
9550/*MT6169*/ if( IF_state != 1 )
9551/*MT6169*/ {
9552/*MT6169*/ // check fractional spurs criterion (for run-time) or IRR state (for IRR calibration)
9553/*MT6169*/ if( ( Nfrac_spur < frac_spurs_thd0 ) || ( Nfrac_spur > frac_spurs_thd1 ) || ( Nfrac_spur < frac_spurs_mid_thd1 && Nfrac_spur > frac_spurs_mid_thd0 ) || ( IF_state == 2 ) )
9554/*MT6169*/ {
9555/*MT6169*/ *if_sel = 1; //-170k
9556/*MT6169*/ if( rf_band < FrequencyBand1800 )
9557/*MT6169*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE + DLIF); } //Low-side mixing
9558/*MT6169*/ else
9559/*MT6169*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE + DLIF); } //Low-side mixing
9560/*MT6169*/
9561/*MT6169*/ Nint = VCO_freq/(FREF_SRX[RG_SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
9562/*MT6169*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
9563/*MT6169*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[RG_SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[RG_SRX_REF_SEL]) + (195)/2 )/195;
9564/*MT6169*/ }
9565/*MT6169*/ }
9566/*MT6169*/
9567/*MT6169*/ /* CW115, N_INT[8:0], N_RFC[22:20], RG_RXREP_EN, RG_SRX_KVCO_SEL[1:0], RG_SRX_LF_R2[4:0] */
9568/*MT6169*/ *rfN = BSI_CW( 0x73, ((Nint &0x1FF)<<11) | (((Nfrac>>20)&0x7)<<8) | ((RG_RXREP_EN&0x1)<<7) | ((RG_SRX_KVCO_SEL[rf_band]&0x3)<<5) | (RG_SRX_LF_R2[rf_band]&0x1F) );
9569/*MT6169*/ /* CW116, N_FRAC[19:0] */
9570/*MT6169*/ *ifN = BSI_CW( 0x74, (Nfrac&0xFFFFF) );
9571/*MT6169*/ }
9572/*MT6169*/ /* =========================================================================== */
9573/*MT6169*/
9574/*MT6169*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
9575/*MT6169*/ {
9576/*MT6169*/ *Nint = (rfN&(0x1FF<<11))>>11;
9577/*MT6169*/ *Nfrac = ( ((rfN>>8)&0x7)<<20 ) | (ifN&0xFFFFF);
9578/*MT6169*/ }
9579/*MT6169*/ /* =========================================================================== */
9580/*MT6169*/
9581/*MT6169*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
9582/*MT6169*/ {
9583/*MT6169*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
9584/*MT6169*/
9585/*MT6169*/ /* CW223, SRX_NINT[8:0], SRX_NRFC[22:12] */
9586/*MT6169*/ *rfN = BSI_CW( 0x73, ((Nint &0x1FF)<<11) | (((Nfrac>>20)&0x7)<<8) | ((*rfN)&0xFF) );
9587/*MT6169*/ /* CW224, SRX_NFRAC[11:0],SRX_REF_DOUBLER_EN,SRX_CAL_DISABLE,SRX_VCO_CFG[2:0],TALL_TRG_M,SRX_SDM_FRAC_MODE,SRX_RELOCK */
9588/*MT6169*/ *ifN = BSI_CW( 0x74, (Nfrac&0xFFFFF));
9589/*MT6169*/ }
9590/*MT6169*/ /* =========================================================================== */
9591/*MT6169*/
9592/*MT6169*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9593/*MT6169*/ {
9594/*MT6169*/ unsigned short Nint =0, CH_freq =0;
9595/*MT6169*/ unsigned long Nfrac=0, VCO_freq=0;
9596/*MT6169*/
9597/*MT6169*/ unsigned short DA_OFFSET_26M = 10;
9598/*MT6169*/ unsigned short MMD_SDM_DI_EN = 0; //keep POR = 0
9599/*MT6169*/
9600/*MT6169*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
9601/*MT6169*/ #if IS_MIPI_SUPPORT
9602/*MT6169*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
9603/*MT6169*/ #endif
9604/*MT6169*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
9605/*MT6169*/
9606/*MT6169*/ if( rf_band < FrequencyBand1800 )
9607/*MT6169*/ VCO_freq = 4*CH_freq;
9608/*MT6169*/ else
9609/*MT6169*/ VCO_freq = 2*CH_freq;
9610/*MT6169*/
9611/*MT6169*/ Nint = VCO_freq/TX_DCXO_FREQ;
9612/*MT6169*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
9613/*MT6169*/
9614/*MT6169*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
9615/*MT6169*/ if( l1d_rf.is_lock_dcxo )
9616/*MT6169*/ { /* SW dithering after L1D_RF_AdjustTxPLLSetting() */ }
9617/*MT6169*/ else
9618/*MT6169*/ #endif
9619/*MT6169*/ { /* Apply SW dithering no matter it is integer channel or not */
9620/*MT6169*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
9621/*MT6169*/ }
9622/*MT6169*/
9623/*MT6169*/ /* CW169, N_INT[7:0], N_RFC[22:11] */
9624/*MT6169*/ *rfN = BSI_CW( 0xA9, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9625/*MT6169*/ /* CW170, N_FRAC[10:0], DA_OFFSET[7:0], DI_EN */
9626/*MT6169*/ *ifN = BSI_CW( 0xAA, ((Nfrac&0x7FF)<<9) | ((DA_OFFSET_26M&0xFF)<<1) | (MMD_SDM_DI_EN&0x1) );
9627/*MT6169*/
9628/*MT6169*/ }
9629/*MT6169*/ /* =========================================================================== */
9630/*MT6169*/
9631/*MT6169*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
9632/*MT6169*/ {
9633/*MT6169*/ *Nint = (rfN&(0xFF<<12))>>12;
9634/*MT6169*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
9635/*MT6169*/ }
9636/*MT6169*/ /* =========================================================================== */
9637/*MT6169*/
9638/*MT6169*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
9639/*MT6169*/ {
9640/*MT6169*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
9641/*MT6169*/
9642/*MT6169*/ /* Apply SW dithering no matter it is integer channel or not */
9643/*MT6169*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
9644/*MT6169*/
9645/*MT6169*/ /* CW169, N_INT[7:0], N_RFC[22:11] */
9646/*MT6169*/ *rfN = BSI_CW( 0xA9, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9647/*MT6169*/ /* CW170, N_FRAC[10:0], DA_OFFSET[7:0], DI_EN */
9648/*MT6169*/ *ifN = BSI_CW( 0xAA, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
9649/*MT6169*/ }
9650/*MT6169*/ /* =========================================================================== */
9651/*MT6169*/
9652/*MT6169*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
9653/*MT6169*/ {
9654/*MT6169*/ signed long Max_Nfrac=0;
9655/*MT6169*/ if( is_TX )
9656/*MT6169*/ { Max_Nfrac = STX_MAX_NFRAC; }
9657/*MT6169*/ else
9658/*MT6169*/ { Max_Nfrac = SRX_MAX_NFRAC; }
9659/*MT6169*/
9660/*MT6169*/ //Calculate new Nfrac and Nint
9661/*MT6169*/ *Nfrac += (NfracOffset + Max_Nfrac);
9662/*MT6169*/ if( *Nfrac < Max_Nfrac )
9663/*MT6169*/ { (*Nint)--;
9664/*MT6169*/ }
9665/*MT6169*/ else if( *Nfrac >= (Max_Nfrac<<1) )
9666/*MT6169*/ { (*Nint)++;
9667/*MT6169*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
9668/*MT6169*/ }
9669/*MT6169*/ else
9670/*MT6169*/ { *Nfrac-= Max_Nfrac;
9671/*MT6169*/ }
9672/*MT6169*/ }
9673/*MT6169*/ /* =========================================================================== */
9674/*MT6169*/
9675/*MT6169*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
9676/*MT6169*/ {
9677/*MT6169*/ unsigned short freq=4450+225;
9678/*MT6169*/ switch( rf_band )
9679/*MT6169*/ {
9680/*MT6169*/ case FrequencyBand850 :
9681/*MT6169*/ {
9682/*MT6169*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
9683/*MT6169*/ break;
9684/*MT6169*/ }
9685/*MT6169*/ case FrequencyBand900 :
9686/*MT6169*/ {
9687/*MT6169*/ if( arfcn<=124 )
9688/*MT6169*/ { freq=4450+arfcn+225; }
9689/*MT6169*/ else
9690/*MT6169*/ { freq=4450+(arfcn-1024)+225; }
9691/*MT6169*/ break;
9692/*MT6169*/ }
9693/*MT6169*/ case FrequencyBand1800 :
9694/*MT6169*/ {
9695/*MT6169*/ freq=8551+(arfcn-512)+475;
9696/*MT6169*/ break;
9697/*MT6169*/ }
9698/*MT6169*/ case FrequencyBand1900 :
9699/*MT6169*/ {
9700/*MT6169*/ freq=9251+(arfcn-512)+400;
9701/*MT6169*/ break;
9702/*MT6169*/ }
9703/*MT6169*/ default :
9704/*MT6169*/ {
9705/*MT6169*/ break;
9706/*MT6169*/ }
9707/*MT6169*/ }
9708/*MT6169*/
9709/*MT6169*/ return freq;
9710/*MT6169*/ }
9711/*MT6169*/ /* =========================================================================== */
9712/*MT6169*/
9713/*MT6169*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
9714/*MT6169*/ {
9715/*MT6169*/ unsigned short freq=4450;
9716/*MT6169*/ switch( rf_band )
9717/*MT6169*/ {
9718/*MT6169*/ case FrequencyBand850 :
9719/*MT6169*/ {
9720/*MT6169*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
9721/*MT6169*/ break;
9722/*MT6169*/ }
9723/*MT6169*/ case FrequencyBand900 :
9724/*MT6169*/ {
9725/*MT6169*/ if( arfcn<=124 )
9726/*MT6169*/ { freq=4450+arfcn; }
9727/*MT6169*/ else
9728/*MT6169*/ { freq=4450+(arfcn-1024); }
9729/*MT6169*/ break;
9730/*MT6169*/ }
9731/*MT6169*/ case FrequencyBand1800 :
9732/*MT6169*/ {
9733/*MT6169*/ freq=8551+(arfcn-512);
9734/*MT6169*/ break;
9735/*MT6169*/ }
9736/*MT6169*/ case FrequencyBand1900 :
9737/*MT6169*/ {
9738/*MT6169*/ freq=9251+(arfcn-512);
9739/*MT6169*/ break;
9740/*MT6169*/ }
9741/*MT6169*/ default :
9742/*MT6169*/ {
9743/*MT6169*/ break;
9744/*MT6169*/ }
9745/*MT6169*/ }
9746/*MT6169*/
9747/*MT6169*/ return freq;
9748/*MT6169*/ }
9749/*MT6169*/ /* =========================================================================== */
9750/*MT6169*/
9751/*MT6169*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
9752/*MT6169*/ {
9753/*MT6169*/ char segment_tx=3, LUT_num_tx=6, offset_tx=15; // LUT method related parameters
9754/*MT6169*/ signed short TXDCO_LUT[6]={2786, 1986, 1337, 792, 316, -68}; // TXDCO LUT
9755/*MT6169*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
9756/*MT6169*/
9757/*MT6169*/ /* STX DCO SCA Typical Code LUT */
9758/*MT6169*/ idx = (Nint>>segment_tx)-((short)offset_tx);
9759/*MT6169*/ if(idx<0)
9760/*MT6169*/ idx = 0;
9761/*MT6169*/ else if(idx>(LUT_num_tx-2))
9762/*MT6169*/ idx = LUT_num_tx-2;
9763/*MT6169*/
9764/*MT6169*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
9765/*MT6169*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
9766/*MT6169*/
9767/*MT6169*/ return code_type;
9768/*MT6169*/ }
9769/*MT6169*/ /* =========================================================================== */
9770/*MT6169*/
9771/*MT6169*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
9772/*MT6169*/ {
9773/*MT6169*/ unsigned short DEM_Chunk_L1;
9774/*MT6169*/ unsigned short OUT_G, OUT_E;
9775/*MT6169*/ char segment_dem=4, LUT_num_dem=4, offset_dem=7; // LUT method related parameters
9776/*MT6169*/ unsigned short DEM_chunk_G_LUT[4]={15, 10, 7, 5}; // DEM chunk GMSK LUT
9777/*MT6169*/ unsigned short DEM_chunk_E_LUT[4]={69, 46, 33, 24}; // DEM chunk EPSK LUT
9778/*MT6169*/ short idx;
9779/*MT6169*/
9780/*MT6169*/ /* STX DEM CHUNK LUT */
9781/*MT6169*/ idx = (Nint>>segment_dem)-((short)offset_dem);
9782/*MT6169*/ if(idx<0)
9783/*MT6169*/ idx = 0;
9784/*MT6169*/ else if(idx>(LUT_num_dem-2))
9785/*MT6169*/ idx = LUT_num_dem-2;
9786/*MT6169*/
9787/*MT6169*/ OUT_G = DEM_chunk_G_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_G_LUT[idx+1]-DEM_chunk_G_LUT[idx]))>>(segment_dem));
9788/*MT6169*/ OUT_E = DEM_chunk_E_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_E_LUT[idx+1]-DEM_chunk_E_LUT[idx]))>>(segment_dem));
9789/*MT6169*/
9790/*MT6169*/ if( ( (l1d_rf.tx_mod_type2)^(l1d_rf.tx_mod_type2<<1) ) & 0xE ) // IS_MIXED_MULTISLOT
9791/*MT6169*/ {
9792/*MT6169*/ if( rf_band < FrequencyBand1800 )
9793/*MT6169*/ DEM_Chunk_L1 = ((OUT_E+OUT_G+5)>40) ? (OUT_E+OUT_G+5) : 40;
9794/*MT6169*/ else
9795/*MT6169*/ DEM_Chunk_L1 = 40;
9796/*MT6169*/ }
9797/*MT6169*/ else
9798/*MT6169*/ {
9799/*MT6169*/ if( (l1d_rf.tx_mod_type2 != 0) && (rf_band < FrequencyBand1800) )
9800/*MT6169*/ DEM_Chunk_L1 = ((2*OUT_E+6)>40) ? (2*OUT_E+6) : 40;
9801/*MT6169*/ else
9802/*MT6169*/ DEM_Chunk_L1 = 40;
9803/*MT6169*/ }
9804/*MT6169*/ return DEM_Chunk_L1;
9805/*MT6169*/ }
9806/*MT6169*/ /* =========================================================================== */
9807/*MT6169*/
9808/*MT6169*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
9809/*MT6169*/ {
9810/*MT6169*/ unsigned short Nint =0, CH_freq =0;
9811/*MT6169*/ unsigned long Nfrac=0, DCO4G_freq=0;
9812/*MT6169*/ unsigned short KDCO_NCAL = (POR_CW176&(0x3<<6))>>6;
9813/*MT6169*/ unsigned short NCAL[4] = {64, 96, 16, 32};
9814/*MT6169*/
9815/*MT6169*/ unsigned short DCO_SCAK_NOFFSET = 0; //keep POR = 0
9816/*MT6169*/ unsigned short MMD_SDM_DI_LS = 0; //keep POR = 0
9817/*MT6169*/ signed long Nfrac1Offset = 0;
9818/*MT6169*/
9819/*MT6169*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
9820/*MT6169*/
9821/*MT6169*/ if( rf_band < FrequencyBand1800 )
9822/*MT6169*/ DCO4G_freq = 4*CH_freq;
9823/*MT6169*/ else
9824/*MT6169*/ DCO4G_freq = 2*CH_freq;
9825/*MT6169*/
9826/*MT6169*/ Nint = ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
9827/*MT6169*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) )/TX_DCXO_FREQ; //floor
9828/*MT6169*/
9829/*MT6169*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
9830/*MT6169*/ if( l1d_rf.is_lock_dcxo )
9831/*MT6169*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCAL[KDCO_NCAL])*l1d_rf.tx_nfracoffset)>>15);
9832/*MT6169*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
9833/*MT6169*/ }
9834/*MT6169*/ #endif
9835/*MT6169*/
9836/*MT6169*/ /* CW171, N_INT1[7:0], N_RFC1[22:11] */
9837/*MT6169*/ *rfN = BSI_CW( 0x61, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9838/*MT6169*/ /* CW172, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[2:0], STX_MMD_SDM_DI_LS[1:0] */
9839/*MT6169*/ *ifN = BSI_CW( 0x62, ((Nfrac&0x7FF)<<9) | ((DCO_SCAK_NOFFSET&0xF)<<2) |(MMD_SDM_DI_LS&0x3) );
9840/*MT6169*/
9841/*MT6169*/ }
9842/*MT6169*/ /* =========================================================================== */
9843#endif
9844
9845#if IS_RF_MT6166
9846/*MT6166*/ //For DLIF mode
9847/*MT6166*/ void L1D_RF_Cal_Synthesizer_Params( unsigned short* Nint, unsigned long* Nfrac, unsigned long VCO_freq )
9848/*MT6166*/ {
9849/*MT6166*/ *Nint = VCO_freq/(RX_DCXO_FREQ*DLIF_SCALE);
9850/*MT6166*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
9851/*MT6166*/ *Nfrac = ( ((VCO_freq-*Nint*RX_DCXO_FREQ*DLIF_SCALE)<<15) + (195)/2 )/195;
9852/*MT6166*/ }
9853/*MT6166*/ /* =========================================================================== */
9854/*MT6166*/
9855/*MT6166*/ char L1D_RF_Cal_IF_Synth_State( void )
9856/*MT6166*/ {
9857/*MT6166*/ #if IS_W_CANCELLATION_SUPPORT
9858/*MT6166*/ if( L1D_CheckIfMetaMode() )
9859/*MT6166*/ { return l1d_rf.if_state; }
9860/*MT6166*/ else
9861/*MT6166*/ { return 0; }
9862/*MT6166*/ #else
9863/*MT6166*/ return 0;
9864/*MT6166*/ #endif
9865/*MT6166*/ }
9866/*MT6166*/ /* =========================================================================== */
9867/*MT6166*/
9868/*MT6166*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9869/*MT6166*/ { long *if_sel = ifN+1;
9870/*MT6166*/ unsigned short Nint =0, CH_freq =0;
9871/*MT6166*/ unsigned long Nfrac=0, VCO_freq=0;
9872/*MT6166*/ unsigned long frac_spurs_thd0=0, frac_spurs_thd1=0;
9873/*MT6166*/ unsigned char IF_state=0; //IF_state=0:default, IF_state=1:+IF, IF_state=2:-IF
9874/*MT6166*/
9875/*MT6166*/ IF_state = L1D_RF_Cal_IF_Synth_State();
9876/*MT6166*/
9877/*MT6166*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
9878/*MT6166*/
9879/*MT6166*/ if( IF_state != 2 )
9880/*MT6166*/ {
9881/*MT6166*/ *if_sel = 0;
9882/*MT6166*/ l1d_rf.if_sel_Nif_wc = 0;
9883/*MT6166*/ if( rf_band < FrequencyBand1800 )
9884/*MT6166*/ {
9885/*MT6166*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
9886/*MT6166*/ frac_spurs_thd0 = 193584;
9887/*MT6166*/ frac_spurs_thd1 = 8195024;
9888/*MT6166*/ }
9889/*MT6166*/ else
9890/*MT6166*/ {
9891/*MT6166*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
9892/*MT6166*/ frac_spurs_thd0 = 96792;
9893/*MT6166*/ frac_spurs_thd1 = 8291816;
9894/*MT6166*/ }
9895/*MT6166*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
9896/*MT6166*/ }
9897/*MT6166*/
9898/*MT6166*/ if( IF_state != 1 )
9899/*MT6166*/ {
9900/*MT6166*/ // use +IF channel instead of -IF for IRR calibration
9901/*MT6166*/ if( ( Nfrac < frac_spurs_thd0 ) || ( Nfrac > frac_spurs_thd1) || ( Nfrac < 4258832 && Nfrac > 4129776 ) || ( IF_state == 2 ) )
9902/*MT6166*/ {
9903/*MT6166*/ *if_sel = 0;
9904/*MT6166*/ l1d_rf.if_sel_Nif_wc = 1;
9905/*MT6166*/ if( rf_band < FrequencyBand1800 )
9906/*MT6166*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); } //Low-side mixing
9907/*MT6166*/ else
9908/*MT6166*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); } //Low-side mixing
9909/*MT6166*/
9910/*MT6166*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
9911/*MT6166*/ }
9912/*MT6166*/
9913/*MT6166*/ }
9914/*MT6166*/
9915/*MT6166*/ #if IS_OBB_DETECTION_SUPPORT
9916/*MT6166*/ if( !L1D_CheckIfMetaMode() )
9917/*MT6166*/ {
9918/*MT6166*/ if( l1d_rf.if_change == -1 && arfcn == l1d_rf.obb_arfcn )
9919/*MT6166*/ {
9920/*MT6166*/ signed short if_sign = l1d_rf.if_change*(*if_sel*2-1);
9921/*MT6166*/
9922/*MT6166*/ *if_sel = if_sign > 0 ? 1 : 0;
9923/*MT6166*/ if( rf_band < FrequencyBand1800 )
9924/*MT6166*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
9925/*MT6166*/ else
9926/*MT6166*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
9927/*MT6166*/
9928/*MT6166*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
9929/*MT6166*/ }
9930/*MT6166*/ }
9931/*MT6166*/ #endif
9932/*MT6166*/
9933/*MT6166*/ /* CW223, SRX_NINT[8:0], SRX_NRFC[22:12] */
9934/*MT6166*/ *rfN = BSI_CW( 0xDF, ((Nint &0x1FF)<<11) | ((Nfrac>>12)&0x7FF) );
9935/*MT6166*/ /* CW224, SRX_NFRAC[11:0],SRX_REF_DOUBLER_EN,SRX_CAL_DISABLE,SRX_VCO_CFG[2:0],TALL_TRG_M,SRX_SDM_FRAC_MODE,SRX_RELOCK */
9936/*MT6166*/ *ifN = BSI_CW( 0xE0, ((Nfrac&0xFFF)<<8) | SRX_REF_DOUBLER_EN | SRX_VCO_CFG | (POR_CW224&0x47) );
9937/*MT6166*/
9938/*MT6166*/ }
9939/*MT6166*/ /* =========================================================================== */
9940/*MT6166*/
9941/*MT6166*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
9942/*MT6166*/ {
9943/*MT6166*/ *Nint = (rfN&(0x1FF<<11))>>11;
9944/*MT6166*/ *Nfrac = ( (rfN&0x7FF)<<12 ) | ( (ifN&(0xFFF<<8))>>8 );
9945/*MT6166*/ }
9946/*MT6166*/ /* =========================================================================== */
9947/*MT6166*/
9948/*MT6166*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
9949/*MT6166*/ {
9950/*MT6166*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
9951/*MT6166*/
9952/*MT6166*/ /* CW223, SRX_NINT[8:0], SRX_NRFC[22:12] */
9953/*MT6166*/ *rfN = BSI_CW( 0xDF, ((Nint &0x1FF)<<11) | ((Nfrac>>12)&0x7FF) );
9954/*MT6166*/ /* CW224, SRX_NFRAC[11:0],SRX_REF_DOUBLER_EN,SRX_CAL_DISABLE,SRX_VCO_CFG[2:0],TALL_TRG_M,SRX_SDM_FRAC_MODE,SRX_RELOCK */
9955/*MT6166*/ *ifN = BSI_CW( 0xE0, ((Nfrac&0xFFF)<<8) | ((*ifN)&0xFF));
9956/*MT6166*/ }
9957/*MT6166*/ /* =========================================================================== */
9958/*MT6166*/
9959/*MT6166*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
9960/*MT6166*/ {
9961/*MT6166*/ unsigned short Nint =0, CH_freq =0;
9962/*MT6166*/ unsigned long Nfrac=0, VCO_freq=0;
9963/*MT6166*/ unsigned short DAoffset=0;
9964/*MT6166*/
9965/*MT6166*/
9966/*MT6166*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
9967/*MT6166*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
9968/*MT6166*/
9969/*MT6166*/ if( rf_band < FrequencyBand1800 )
9970/*MT6166*/ VCO_freq = 4*CH_freq;
9971/*MT6166*/ else
9972/*MT6166*/ VCO_freq = 2*CH_freq;
9973/*MT6166*/
9974/*MT6166*/ Nint = VCO_freq/TX_DCXO_FREQ;
9975/*MT6166*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
9976/*MT6166*/
9977/*MT6166*/ DAoffset = 10;//L1D_RF_GetTxDAoffsetSetting( Nint );
9978/*MT6166*/
9979/*MT6166*/ /* CW96, N_INT[7:0], N_RFC[22:11] */
9980/*MT6166*/ *rfN = BSI_CW( 0x60, ((Nint &0xFF)<<12) | (Nfrac>>11) );
9981/*MT6166*/ /* CW97, N_FRAC[10:0], DA_OFFSET[4:0], DI_EN */
9982/*MT6166*/ *ifN = BSI_CW( 0x61, ((Nfrac&0x7FF)<<9) | ((DAoffset&0x1F)<<4) | 0x1);
9983/*MT6166*/
9984/*MT6166*/ }
9985/*MT6166*/ /* =========================================================================== */
9986/*MT6166*/
9987/*MT6166*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
9988/*MT6166*/ {
9989/*MT6166*/ *Nint = (rfN&(0xFF<<12))>>12;
9990/*MT6166*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
9991/*MT6166*/ }
9992/*MT6166*/ /* =========================================================================== */
9993/*MT6166*/
9994/*MT6166*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
9995/*MT6166*/ {
9996/*MT6166*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
9997/*MT6166*/
9998/*MT6166*/ /* CW96, N_INT[7:0], N_RFC[22:11] */
9999/*MT6166*/ *rfN = BSI_CW( 0x60, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10000/*MT6166*/ /* CW97, N_FRAC[10:0], DA_OFFSET[4:0], DI_EN */
10001/*MT6166*/ *ifN = BSI_CW( 0x61, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
10002/*MT6166*/ }
10003/*MT6166*/ /* =========================================================================== */
10004/*MT6166*/
10005/*MT6166*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
10006/*MT6166*/ {
10007/*MT6166*/ signed long Max_Nfrac=0;
10008/*MT6166*/ if( is_TX )
10009/*MT6166*/ { Max_Nfrac = STX_MAX_NFRAC; }
10010/*MT6166*/ else
10011/*MT6166*/ { Max_Nfrac = SRX_MAX_NFRAC; }
10012/*MT6166*/
10013/*MT6166*/ //Calculate new Nfrac and Nint
10014/*MT6166*/ *Nfrac += (NfracOffset + Max_Nfrac);
10015/*MT6166*/ if( *Nfrac < Max_Nfrac )
10016/*MT6166*/ { (*Nint)--;
10017/*MT6166*/ }
10018/*MT6166*/ else if( *Nfrac >= (Max_Nfrac<<1) )
10019/*MT6166*/ { (*Nint)++;
10020/*MT6166*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
10021/*MT6166*/ }
10022/*MT6166*/ else
10023/*MT6166*/ { *Nfrac-= Max_Nfrac;
10024/*MT6166*/ }
10025/*MT6166*/ }
10026/*MT6166*/ /* =========================================================================== */
10027/*MT6166*/
10028/*MT6166*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
10029/*MT6166*/ {
10030/*MT6166*/ unsigned short freq=4450+225;
10031/*MT6166*/ switch( rf_band )
10032/*MT6166*/ {
10033/*MT6166*/ case FrequencyBand850 :
10034/*MT6166*/ {
10035/*MT6166*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
10036/*MT6166*/ break;
10037/*MT6166*/ }
10038/*MT6166*/ case FrequencyBand900 :
10039/*MT6166*/ {
10040/*MT6166*/ if( arfcn<=124 )
10041/*MT6166*/ { freq=4450+arfcn+225; }
10042/*MT6166*/ else
10043/*MT6166*/ { freq=4450+(arfcn-1024)+225; }
10044/*MT6166*/ break;
10045/*MT6166*/ }
10046/*MT6166*/ case FrequencyBand1800 :
10047/*MT6166*/ {
10048/*MT6166*/ freq=8551+(arfcn-512)+475;
10049/*MT6166*/ break;
10050/*MT6166*/ }
10051/*MT6166*/ case FrequencyBand1900 :
10052/*MT6166*/ {
10053/*MT6166*/ freq=9251+(arfcn-512)+400;
10054/*MT6166*/ break;
10055/*MT6166*/ }
10056/*MT6166*/ default :
10057/*MT6166*/ {
10058/*MT6166*/ break;
10059/*MT6166*/ }
10060/*MT6166*/ }
10061/*MT6166*/
10062/*MT6166*/ return freq;
10063/*MT6166*/ }
10064/*MT6166*/ /* =========================================================================== */
10065/*MT6166*/
10066/*MT6166*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
10067/*MT6166*/ {
10068/*MT6166*/ unsigned short freq=4450;
10069/*MT6166*/ switch( rf_band )
10070/*MT6166*/ {
10071/*MT6166*/ case FrequencyBand850 :
10072/*MT6166*/ {
10073/*MT6166*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
10074/*MT6166*/ break;
10075/*MT6166*/ }
10076/*MT6166*/ case FrequencyBand900 :
10077/*MT6166*/ {
10078/*MT6166*/ if( arfcn<=124 )
10079/*MT6166*/ { freq=4450+arfcn; }
10080/*MT6166*/ else
10081/*MT6166*/ { freq=4450+(arfcn-1024); }
10082/*MT6166*/ break;
10083/*MT6166*/ }
10084/*MT6166*/ case FrequencyBand1800 :
10085/*MT6166*/ {
10086/*MT6166*/ freq=8551+(arfcn-512);
10087/*MT6166*/ break;
10088/*MT6166*/ }
10089/*MT6166*/ case FrequencyBand1900 :
10090/*MT6166*/ {
10091/*MT6166*/ freq=9251+(arfcn-512);
10092/*MT6166*/ break;
10093/*MT6166*/ }
10094/*MT6166*/ default :
10095/*MT6166*/ {
10096/*MT6166*/ break;
10097/*MT6166*/ }
10098/*MT6166*/ }
10099/*MT6166*/
10100/*MT6166*/ return freq;
10101/*MT6166*/ }
10102/*MT6166*/ /* =========================================================================== */
10103/*MT6166*/
10104/*MT6166*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
10105/*MT6166*/ {
10106/*MT6166*/ char segment_tx=3, LUT_num_tx=6, offset_tx=15; // LUT method related parameters
10107/*MT6166*/ signed short TXDCO_LUT[6]={1566, 1169, 840, 565, 331, -40}; // TXDCO LUT
10108/*MT6166*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
10109/*MT6166*/
10110/*MT6166*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10111/*MT6166*/ if( l1d_rf.is_lock_dcxo )
10112/*MT6166*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
10113/*MT6166*/ #endif
10114/*MT6166*/
10115/*MT6166*/ /* STX DCO SCA Typical Code LUT */
10116/*MT6166*/ idx = (Nint>>segment_tx)-((short)offset_tx);
10117/*MT6166*/ if(idx<0)
10118/*MT6166*/ idx = 0;
10119/*MT6166*/ else if(idx>(LUT_num_tx-2))
10120/*MT6166*/ idx = LUT_num_tx-2;
10121/*MT6166*/
10122/*MT6166*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
10123/*MT6166*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
10124/*MT6166*/ code_type <<= 1;
10125/*MT6166*/
10126/*MT6166*/ return code_type;
10127/*MT6166*/ }
10128/*MT6166*/ /* =========================================================================== */
10129/*MT6166*/
10130/*MT6166*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
10131/*MT6166*/ {
10132/*MT6166*/ unsigned short DEM_Chunk_L1;
10133/*MT6166*/ unsigned short OUT_G, OUT_E;
10134/*MT6166*/ char segment_dem=4, LUT_num_dem=4, offset_dem=7; // LUT method related parameters
10135/*MT6166*/ signed short DEM_chunk_G_LUT[4]={15, 10, 7, 5}; // DEM chunk GMSK LUT
10136/*MT6166*/ signed short DEM_chunk_E_LUT[4]={69, 46, 33, 24}; // DEM chunk EPSK LUT
10137/*MT6166*/ short idx;
10138/*MT6166*/
10139/*MT6166*/ /* STX DEM CHUNK LUT */
10140/*MT6166*/ idx = (Nint>>segment_dem)-((short)offset_dem);
10141/*MT6166*/ if(idx<0)
10142/*MT6166*/ idx = 0;
10143/*MT6166*/ else if(idx>(LUT_num_dem-2))
10144/*MT6166*/ idx = LUT_num_dem-2;
10145/*MT6166*/
10146/*MT6166*/ OUT_G = DEM_chunk_G_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_G_LUT[idx+1]-DEM_chunk_G_LUT[idx]))>>(segment_dem));
10147/*MT6166*/ OUT_E = DEM_chunk_E_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_E_LUT[idx+1]-DEM_chunk_E_LUT[idx]))>>(segment_dem));
10148/*MT6166*/
10149/*MT6166*/ if( ( (l1d_rf.tx_mod_type2)^(l1d_rf.tx_mod_type2<<1) ) & 0xE ) // IS_MIXED_MULTISLOT
10150/*MT6166*/ {
10151/*MT6166*/ if( rf_band < FrequencyBand1800 )
10152/*MT6166*/ DEM_Chunk_L1 = ((OUT_E+OUT_G+5)>40) ? (OUT_E+OUT_G+5) : 40;
10153/*MT6166*/ else
10154/*MT6166*/ DEM_Chunk_L1 = 40;
10155/*MT6166*/ }
10156/*MT6166*/ else
10157/*MT6166*/ {
10158/*MT6166*/ if( (l1d_rf.tx_mod_type2 != 0) && (rf_band < FrequencyBand1800) )
10159/*MT6166*/ DEM_Chunk_L1 = ((2*OUT_E+6)>40) ? (2*OUT_E+6) : 40;
10160/*MT6166*/ else
10161/*MT6166*/ DEM_Chunk_L1 = 40;
10162/*MT6166*/ }
10163/*MT6166*/ return DEM_Chunk_L1;
10164/*MT6166*/ }
10165/*MT6166*/ /* =========================================================================== */
10166/*MT6166*/
10167/*MT6166*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
10168/*MT6166*/ {
10169/*MT6166*/ unsigned short Nint =0, CH_freq =0;
10170/*MT6166*/ unsigned long Nfrac=0, DCO4G_freq=0;
10171/*MT6166*/
10172/*MT6166*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10173/*MT6166*/
10174/*MT6166*/ if( rf_band < FrequencyBand1800 )
10175/*MT6166*/ DCO4G_freq = 4*CH_freq;
10176/*MT6166*/ else
10177/*MT6166*/ DCO4G_freq = 2*CH_freq;
10178/*MT6166*/
10179/*MT6166*/ Nint = ( (DCO4G_freq<<15) - 64*DCO4G_freq + 64*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
10180/*MT6166*/ Nfrac = ( ( ( (DCO4G_freq<<15) - 64*DCO4G_freq + 64*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
10181/*MT6166*/
10182/*MT6166*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10183/*MT6166*/ if( l1d_rf.is_lock_dcxo )
10184/*MT6166*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, l1d_rf.tx_nfracoffset, 1 ); }
10185/*MT6166*/ #endif
10186/*MT6166*/
10187/*MT6166*/ /* CW98, N_INT1[7:0], N_RFC1[22:11] */
10188/*MT6166*/ *rfN = BSI_CW( 0x62, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10189/*MT6166*/ /* CW99, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[2:0], STX_MMD_SDM_DI_LS[1:0] */
10190/*MT6166*/ *ifN = BSI_CW( 0x63, ((Nfrac&0x7FF)<<9) | (POR_CW99&0x1FF) );
10191/*MT6166*/
10192/*MT6166*/ }
10193/*MT6166*/ /* =========================================================================== */
10194/*MT6166*/
10195#endif
10196
10197#if IS_RF_MT6165
10198/*MT6165*/ //For DLIF mode
10199/*MT6165*/ void L1D_RF_Cal_Synthesizer_Params( unsigned short* Nint, unsigned long* Nfrac, unsigned long VCO_freq )
10200/*MT6165*/ {
10201/*MT6165*/ *Nint = VCO_freq/(RX_DCXO_FREQ*DLIF_SCALE);
10202/*MT6165*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
10203/*MT6165*/ *Nfrac = ( ((VCO_freq-*Nint*RX_DCXO_FREQ*DLIF_SCALE)<<15) + (195)/2 )/195;
10204/*MT6165*/ }
10205/*MT6165*/ /* =========================================================================== */
10206/*MT6165*/
10207/*MT6165*/ char L1D_RF_Cal_IF_Synth_State( void )
10208/*MT6165*/ {
10209/*MT6165*/ #if IS_W_CANCELLATION_SUPPORT
10210/*MT6165*/ if( L1D_CheckIfMetaMode() )
10211/*MT6165*/ { return l1d_rf.if_state; }
10212/*MT6165*/ else
10213/*MT6165*/ { return 0; }
10214/*MT6165*/ #else
10215/*MT6165*/ return 0;
10216/*MT6165*/ #endif
10217/*MT6165*/ }
10218/*MT6165*/ /* =========================================================================== */
10219/*MT6165*/
10220/*MT6165*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10221/*MT6165*/ { long *if_sel = ifN+1;
10222/*MT6165*/ unsigned short Nint =0, CH_freq =0;
10223/*MT6165*/ unsigned long Nfrac=0, VCO_freq=0;
10224/*MT6165*/ unsigned long frac_spurs_thd0=0, frac_spurs_thd1=0;
10225/*MT6165*/ unsigned char IF_state=0; //IF_state=0:default, IF_state=1:+IF, IF_state=2:-IF
10226/*MT6165*/
10227/*MT6165*/ IF_state = L1D_RF_Cal_IF_Synth_State();
10228/*MT6165*/
10229/*MT6165*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
10230/*MT6165*/
10231/*MT6165*/ if( IF_state != 2 )
10232/*MT6165*/ {
10233/*MT6165*/ *if_sel = 0;
10234/*MT6165*/ #if IS_W_CANCELLATION_SUPPORT
10235/*MT6165*/ l1d_rf.if_sel_Nif_wc = 0;
10236/*MT6165*/ #endif
10237/*MT6165*/ if( rf_band < FrequencyBand1800 )
10238/*MT6165*/ {
10239/*MT6165*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10240/*MT6165*/ frac_spurs_thd0 = 193584;
10241/*MT6165*/ frac_spurs_thd1 = 8195024;
10242/*MT6165*/ }
10243/*MT6165*/ else
10244/*MT6165*/ {
10245/*MT6165*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10246/*MT6165*/ frac_spurs_thd0 = 96792;
10247/*MT6165*/ frac_spurs_thd1 = 8291816;
10248/*MT6165*/ }
10249/*MT6165*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
10250/*MT6165*/ }
10251/*MT6165*/
10252/*MT6165*/ if( IF_state != 1 )
10253/*MT6165*/ {
10254/*MT6165*/ // use +IF channel instead of -IF for IRR calibration
10255/*MT6165*/ if( ( Nfrac < frac_spurs_thd0 ) || ( Nfrac > frac_spurs_thd1) || ( Nfrac < 4258832 && Nfrac > 4129776 ) || ( IF_state == 2 ) )
10256/*MT6165*/ {
10257/*MT6165*/ *if_sel = 0;
10258/*MT6165*/ #if IS_W_CANCELLATION_SUPPORT
10259/*MT6165*/ l1d_rf.if_sel_Nif_wc = 1;
10260/*MT6165*/ #endif
10261/*MT6165*/ if( rf_band < FrequencyBand1800 )
10262/*MT6165*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); } //use High-side mixing instead of Low-side for MT6165
10263/*MT6165*/ else
10264/*MT6165*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); } //use High-side mixing instead of Low-side for MT6165
10265/*MT6165*/
10266/*MT6165*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
10267/*MT6165*/ }
10268/*MT6165*/
10269/*MT6165*/ }
10270/*MT6165*/
10271/*MT6165*/ #if IS_OBB_DETECTION_SUPPORT
10272/*MT6165*/ if( !L1D_CheckIfMetaMode() )
10273/*MT6165*/ {
10274/*MT6165*/ if( l1d_rf.if_change == -1 && arfcn == l1d_rf.obb_arfcn )
10275/*MT6165*/ {
10276/*MT6165*/ signed short if_sign = l1d_rf.if_change*(*if_sel*2-1);
10277/*MT6165*/
10278/*MT6165*/ *if_sel = if_sign > 0 ? 1 : 0;
10279/*MT6165*/ if( rf_band < FrequencyBand1800 )
10280/*MT6165*/ { VCO_freq = 4*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
10281/*MT6165*/ else
10282/*MT6165*/ { VCO_freq = 2*(CH_freq*DLIF_SCALE + if_sign*DLIF); }
10283/*MT6165*/
10284/*MT6165*/ L1D_RF_Cal_Synthesizer_Params( &Nint, &Nfrac, VCO_freq );
10285/*MT6165*/ }
10286/*MT6165*/ }
10287/*MT6165*/ #endif
10288/*MT6165*/
10289/*MT6165*/ /* CW181, SRX_NINT[7:0], SRX_NRFC[22:11] */
10290/*MT6165*/ *rfN = BSI_CW( 0xB5, ((Nint &0xFF)<<12) | ((Nfrac>>11)&0xFFF) );
10291/*MT6165*/ /* CW182, SRX_NFRAC[10:0], DA_OFFSET[7:0], DI_EN */
10292/*MT6165*/ *ifN = BSI_CW( 0xB6, ((Nfrac&0x7FF)<<9) | (POR_CW182&0x1) ); // Keep DA_OFFSET=0x0 and setup at L1D_RF_SetSData_SR1()
10293/*MT6165*/
10294/*MT6165*/ }
10295/*MT6165*/ /* =========================================================================== */
10296/*MT6165*/
10297/*MT6165*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10298/*MT6165*/ {
10299/*MT6165*/ *Nint = (rfN&(0xFF<<12))>>12;
10300/*MT6165*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
10301/*MT6165*/ }
10302/*MT6165*/ /* =========================================================================== */
10303/*MT6165*/
10304/*MT6165*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10305/*MT6165*/ {
10306/*MT6165*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
10307/*MT6165*/
10308/*MT6165*/ /* CW181, SRX_NINT[7:0], SRX_NRFC[22:11] */
10309/*MT6165*/ *rfN = BSI_CW( 0xB5, ((Nint &0xFF)<<12) | ((Nfrac>>11)&0xFFF) );
10310/*MT6165*/ /* CW182, SRX_NFRAC[10:0], DA_OFFSET[7:0], DI_EN */
10311/*MT6165*/ *ifN = BSI_CW( 0xB6, ((Nfrac&0x7FF)<<9) | ((*ifN)&0x1FF) );
10312/*MT6165*/ }
10313/*MT6165*/ /* =========================================================================== */
10314/*MT6165*/
10315/*MT6165*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10316/*MT6165*/ {
10317/*MT6165*/ unsigned short Nint =0, CH_freq =0;
10318/*MT6165*/ unsigned long Nfrac=0, VCO_freq=0;
10319/*MT6165*/
10320/*MT6165*/
10321/*MT6165*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
10322/*MT6165*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10323/*MT6165*/
10324/*MT6165*/ if( rf_band < FrequencyBand1800 )
10325/*MT6165*/ VCO_freq = 4*CH_freq;
10326/*MT6165*/ else
10327/*MT6165*/ VCO_freq = 2*CH_freq;
10328/*MT6165*/
10329/*MT6165*/ Nint = VCO_freq/TX_DCXO_FREQ;
10330/*MT6165*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
10331/*MT6165*/
10332/*MT6165*/ /* CW181, SRX_NINT[7:0], SRX_NRFC[22:11] */
10333/*MT6165*/ *rfN = BSI_CW( 0xB5, ((Nint &0xFF)<<12) | ((Nfrac>>11)&0xFFF) );
10334/*MT6165*/ /* CW182, SRX_NFRAC[10:0], DA_OFFSET[7:0], DI_EN */
10335/*MT6165*/ *ifN = BSI_CW( 0xB6, ((Nfrac&0x7FF)<<9) | (POR_CW182&0x1) ); // Keep DA_OFFSET=0x0 and setup at L1D_RF_SetSData_ST1()
10336/*MT6165*/
10337/*MT6165*/ }
10338/*MT6165*/ /* =========================================================================== */
10339/*MT6165*/
10340/*MT6165*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10341/*MT6165*/ {
10342/*MT6165*/ *Nint = (rfN&(0xFF<<12))>>12;
10343/*MT6165*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
10344/*MT6165*/ }
10345/*MT6165*/ /* =========================================================================== */
10346/*MT6165*/
10347/*MT6165*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10348/*MT6165*/ {
10349/*MT6165*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
10350/*MT6165*/
10351/*MT6165*/ /* CW181, SRX_NINT[7:0], SRX_NRFC[22:11] */
10352/*MT6165*/ *rfN = BSI_CW( 0xB5, ((Nint &0xFF)<<12) | ((Nfrac>>11)&0xFFF) );
10353/*MT6165*/ /* CW182, SRX_NFRAC[10:0], DA_OFFSET[7:0], DI_EN */
10354/*MT6165*/ *ifN = BSI_CW( 0xB6, ((Nfrac&0x7FF)<<9) | ((*ifN)&0x1FF) );
10355/*MT6165*/ }
10356/*MT6165*/ /* =========================================================================== */
10357/*MT6165*/
10358/*MT6165*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
10359/*MT6165*/ {
10360/*MT6165*/ signed long Max_Nfrac=0;
10361/*MT6165*/ if( is_TX )
10362/*MT6165*/ { Max_Nfrac = STX_MAX_NFRAC; }
10363/*MT6165*/ else
10364/*MT6165*/ { Max_Nfrac = SRX_MAX_NFRAC; }
10365/*MT6165*/
10366/*MT6165*/ //Calculate new Nfrac and Nint
10367/*MT6165*/ *Nfrac += (NfracOffset + Max_Nfrac);
10368/*MT6165*/ if( *Nfrac < Max_Nfrac )
10369/*MT6165*/ { (*Nint)--;
10370/*MT6165*/ }
10371/*MT6165*/ else if( *Nfrac >= (Max_Nfrac<<1) )
10372/*MT6165*/ { (*Nint)++;
10373/*MT6165*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
10374/*MT6165*/ }
10375/*MT6165*/ else
10376/*MT6165*/ { *Nfrac-= Max_Nfrac;
10377/*MT6165*/ }
10378/*MT6165*/ }
10379/*MT6165*/ /* =========================================================================== */
10380/*MT6165*/
10381/*MT6165*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
10382/*MT6165*/ {
10383/*MT6165*/ unsigned short freq=4450+225;
10384/*MT6165*/ switch( rf_band )
10385/*MT6165*/ {
10386/*MT6165*/ case FrequencyBand850 :
10387/*MT6165*/ {
10388/*MT6165*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
10389/*MT6165*/ break;
10390/*MT6165*/ }
10391/*MT6165*/ case FrequencyBand900 :
10392/*MT6165*/ {
10393/*MT6165*/ if( arfcn<=124 )
10394/*MT6165*/ { freq=4450+arfcn+225; }
10395/*MT6165*/ else
10396/*MT6165*/ { freq=4450+(arfcn-1024)+225; }
10397/*MT6165*/ break;
10398/*MT6165*/ }
10399/*MT6165*/ case FrequencyBand1800 :
10400/*MT6165*/ {
10401/*MT6165*/ freq=8551+(arfcn-512)+475;
10402/*MT6165*/ break;
10403/*MT6165*/ }
10404/*MT6165*/ case FrequencyBand1900 :
10405/*MT6165*/ {
10406/*MT6165*/ freq=9251+(arfcn-512)+400;
10407/*MT6165*/ break;
10408/*MT6165*/ }
10409/*MT6165*/ default :
10410/*MT6165*/ {
10411/*MT6165*/ break;
10412/*MT6165*/ }
10413/*MT6165*/ }
10414/*MT6165*/
10415/*MT6165*/ return freq;
10416/*MT6165*/ }
10417/*MT6165*/ /* =========================================================================== */
10418/*MT6165*/
10419/*MT6165*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
10420/*MT6165*/ {
10421/*MT6165*/ unsigned short freq=4450;
10422/*MT6165*/ switch( rf_band )
10423/*MT6165*/ {
10424/*MT6165*/ case FrequencyBand850 :
10425/*MT6165*/ {
10426/*MT6165*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
10427/*MT6165*/ break;
10428/*MT6165*/ }
10429/*MT6165*/ case FrequencyBand900 :
10430/*MT6165*/ {
10431/*MT6165*/ if( arfcn<=124 )
10432/*MT6165*/ { freq=4450+arfcn; }
10433/*MT6165*/ else
10434/*MT6165*/ { freq=4450+(arfcn-1024); }
10435/*MT6165*/ break;
10436/*MT6165*/ }
10437/*MT6165*/ case FrequencyBand1800 :
10438/*MT6165*/ {
10439/*MT6165*/ freq=8551+(arfcn-512);
10440/*MT6165*/ break;
10441/*MT6165*/ }
10442/*MT6165*/ case FrequencyBand1900 :
10443/*MT6165*/ {
10444/*MT6165*/ freq=9251+(arfcn-512);
10445/*MT6165*/ break;
10446/*MT6165*/ }
10447/*MT6165*/ default :
10448/*MT6165*/ {
10449/*MT6165*/ break;
10450/*MT6165*/ }
10451/*MT6165*/ }
10452/*MT6165*/
10453/*MT6165*/ return freq;
10454/*MT6165*/ }
10455/*MT6165*/ /* =========================================================================== */
10456/*MT6165*/
10457/*MT6165*/ unsigned short L1D_RF_GetSxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
10458/*MT6165*/ {
10459/*MT6165*/ char segment=3, LUT_num=11, offset=15; // LUT method related parameters
10460/*MT6165*/ signed short TXDCO_LUT[11]={1625, 1307, 1040, 818, 628, 467, 328, 208, 102, 11, -30}; // SXDCO LUT
10461/*MT6165*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
10462/*MT6165*/
10463/*MT6165*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10464/*MT6165*/ if( l1d_rf.is_lock_dcxo )
10465/*MT6165*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
10466/*MT6165*/ #endif
10467/*MT6165*/
10468/*MT6165*/ /* STX DCO SCA Typical Code LUT */
10469/*MT6165*/ idx = (Nint>>segment)-((short)offset);
10470/*MT6165*/ if(idx<0)
10471/*MT6165*/ idx = 0;
10472/*MT6165*/ else if(idx>(LUT_num-2))
10473/*MT6165*/ idx = LUT_num-2;
10474/*MT6165*/
10475/*MT6165*/ x_axis = ((Nint-((Nint>>segment)<<segment))<<3)+((short)(Nfrac>>20));
10476/*MT6165*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment+3));
10477/*MT6165*/ code_type <<= 1;
10478/*MT6165*/
10479/*MT6165*/ return code_type;
10480/*MT6165*/ }
10481/*MT6165*/ /* =========================================================================== */
10482/*MT6165*/
10483/*MT6165*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
10484/*MT6165*/ {
10485/*MT6165*/ unsigned short DEM_Chunk_L1;
10486/*MT6165*/ unsigned short OUT_G, OUT_E;
10487/*MT6165*/ char segment_dem=4, LUT_num_dem=4, offset_dem=7; // LUT method related parameters
10488/*MT6165*/ signed short DEM_chunk_G_LUT[4]={15, 10, 7, 5}; // DEM chunk GMSK LUT
10489/*MT6165*/ signed short DEM_chunk_E_LUT[4]={69, 46, 33, 24}; // DEM chunk EPSK LUT
10490/*MT6165*/ short idx;
10491/*MT6165*/
10492/*MT6165*/ /* STX DEM CHUNK LUT */
10493/*MT6165*/ idx = (Nint>>segment_dem)-((short)offset_dem);
10494/*MT6165*/ if(idx<0)
10495/*MT6165*/ idx = 0;
10496/*MT6165*/ else if(idx>(LUT_num_dem-2))
10497/*MT6165*/ idx = LUT_num_dem-2;
10498/*MT6165*/
10499/*MT6165*/ OUT_G = DEM_chunk_G_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_G_LUT[idx+1]-DEM_chunk_G_LUT[idx]))>>(segment_dem));
10500/*MT6165*/ OUT_E = DEM_chunk_E_LUT[idx]+(((Nint-((Nint>>segment_dem)<<segment_dem))*(DEM_chunk_E_LUT[idx+1]-DEM_chunk_E_LUT[idx]))>>(segment_dem));
10501/*MT6165*/
10502/*MT6165*/ if( ( (l1d_rf.tx_mod_type2)^(l1d_rf.tx_mod_type2<<1) ) & 0xE ) // IS_MIXED_MULTISLOT
10503/*MT6165*/ {
10504/*MT6165*/ if( rf_band < FrequencyBand1800 )
10505/*MT6165*/ DEM_Chunk_L1 = ((OUT_E+OUT_G+5)>40) ? (OUT_E+OUT_G+5) : 40;
10506/*MT6165*/ else
10507/*MT6165*/ DEM_Chunk_L1 = 40;
10508/*MT6165*/ }
10509/*MT6165*/ else
10510/*MT6165*/ {
10511/*MT6165*/ if( (l1d_rf.tx_mod_type2 != 0) && (rf_band < FrequencyBand1800) )
10512/*MT6165*/ DEM_Chunk_L1 = ((2*OUT_E+6)>40) ? (2*OUT_E+6) : 40;
10513/*MT6165*/ else
10514/*MT6165*/ DEM_Chunk_L1 = 40;
10515/*MT6165*/ }
10516/*MT6165*/ return DEM_Chunk_L1;
10517/*MT6165*/ }
10518/*MT6165*/ /* =========================================================================== */
10519/*MT6165*/
10520/*MT6165*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
10521/*MT6165*/ {
10522/*MT6165*/ unsigned short Nint =0, CH_freq =0;
10523/*MT6165*/ unsigned long Nfrac=0, DCO4G_freq=0, NCal=64;
10524/*MT6165*/ signed long Nfrac1Offset=0;
10525/*MT6165*/ unsigned short KDCO_NCAL_LUT[4]={64, 96, 16, 32};
10526/*MT6165*/
10527/*MT6165*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10528/*MT6165*/ NCal = KDCO_NCAL_LUT[((POR_CW188>>6)&0x3)];
10529/*MT6165*/
10530/*MT6165*/ if( rf_band < FrequencyBand1800 )
10531/*MT6165*/ DCO4G_freq = 4*CH_freq;
10532/*MT6165*/ else
10533/*MT6165*/ DCO4G_freq = 2*CH_freq;
10534/*MT6165*/
10535/*MT6165*/ Nint = ( (DCO4G_freq<<15) - NCal*DCO4G_freq + NCal*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
10536/*MT6165*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCal*DCO4G_freq + NCal*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
10537/*MT6165*/
10538/*MT6165*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10539/*MT6165*/ if( l1d_rf.is_lock_dcxo )
10540/*MT6165*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCal)*l1d_rf.tx_nfracoffset)>>15);
10541/*MT6165*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
10542/*MT6165*/ }
10543/*MT6165*/ #endif
10544/*MT6165*/
10545/*MT6165*/ /* CW183, N_INT1[7:0], N_FRFC1[22:11] */
10546/*MT6165*/ *rfN = BSI_CW( 0xB7, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10547/*MT6165*/ /* CW184, N_FRAC1[10:0], NOFFSET_REV[2:0], STX_DCO_SCAK_NOFFSET[3:0], STX_MMD_SDM_DI_LS[1:0] */
10548/*MT6165*/ *ifN = BSI_CW( 0xB8, ((Nfrac&0x7FF)<<9) | (POR_CW184&0x1FF) );
10549/*MT6165*/ (void) Nfrac1Offset;
10550/*MT6165*/
10551/*MT6165*/ }
10552/*MT6165*/ /* =========================================================================== */
10553/*MT6165*/
10554/*MT6165*/ unsigned short L1D_RF_GetSxDAoffsetSetting(unsigned long rfn)
10555/*MT6165*/ {
10556/*MT6165*/ unsigned short Nint = ((rfn>>12)&0xFF);
10557/*MT6165*/ unsigned long Nfrac_round = ((rfn>>11)&0x1); // Check if (Nfrac*2^23)>0.5 by Nfrac[22]
10558/*MT6165*/ return (Nint+Nfrac_round-10);
10559/*MT6165*/ }
10560/*MT6165*/ /* =========================================================================== */
10561/*MT6165*/
10562/*MT6165*/ unsigned short L1D_RF_GetSCAKNoffsetSetting(unsigned short Nint)
10563/*MT6165*/ {
10564/*MT6165*/ unsigned short SCAK_NOFFSET;
10565/*MT6165*/ if( Nint<100 )
10566/*MT6165*/ { SCAK_NOFFSET = 0; }
10567/*MT6165*/ else if( Nint>227)
10568/*MT6165*/ { SCAK_NOFFSET = 127; }
10569/*MT6165*/ else
10570/*MT6165*/ { SCAK_NOFFSET = Nint-100; }
10571/*MT6165*/
10572/*MT6165*/ return (SCAK_NOFFSET>>3);
10573/*MT6165*/ }
10574/*MT6165*/ /* =========================================================================== */
10575/*MT6165*/
10576#endif
10577
10578#if IS_RF_MT6176
10579/*MT6176*/ //For DLIF mode
10580/*MT6176*/ char L1D_RF_Cal_IF_Synth_State( void )
10581/*MT6176*/ {
10582 #if IS_W_CANCELLATION_SUPPORT
10583/*MT6176*/ if( L1D_CheckIfMetaMode() )
10584/*MT6176*/ { return l1d_rf.if_state; }
10585/*MT6176*/ else
10586/*MT6176*/ { return 0; }
10587 #else
10588/*MT6176*/ return 0;
10589 #endif
10590/*MT6176*/ }
10591/*MT6176*/ /* =========================================================================== */
10592/*MT6176*/
10593/*MT6176*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10594/*MT6176*/ { long *if_sel = ifN+1;
10595/*MT6176*/ unsigned short Nint =0, CH_freq =0;
10596/*MT6176*/ unsigned long Nfrac=0, VCO_freq=0;
10597/*MT6176*/ unsigned char SRX_REF_SEL=1, SRX_CAL_EN=1, SRX_CAL_IMM=0, SRX_VCO1_SEL=1, SRX_VCO_CFG=5;
10598/*MT6176*/ unsigned short FREF_SRX[2] = {26, 52};
10599/*MT6176*/ unsigned short multiplier[2] = {15, 14};
10600/*MT6176*/
10601/*MT6176*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
10602/*MT6176*/
10603/*MT6176*/ {
10604/*MT6176*/ *if_sel = 0;
10605/*MT6176*/ if( rf_band < FrequencyBand1800 )
10606/*MT6176*/ {
10607/*MT6176*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10608/*MT6176*/ }
10609/*MT6176*/ else
10610/*MT6176*/ {
10611/*MT6176*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10612/*MT6176*/ }
10613/*MT6176*/ }
10614/*MT6176*/
10615/*MT6176*/ Nint = VCO_freq/(FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
10616/*MT6176*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
10617/*MT6176*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[SRX_REF_SEL]) + (195)/2 )/195;
10618/*MT6176*/
10619/*MT6176*/
10620/*MT6176*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
10621/*MT6176*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
10622/*MT6176*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
10623/*MT6176*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|((SRX_REF_SEL&0x1)<<7)|((SRX_CAL_EN&0x1)<<5)|((SRX_CAL_IMM&0x1)<<4)|((SRX_VCO1_SEL&0x1)<<3)|(SRX_VCO_CFG&0x7));
10624/*MT6176*/ }
10625/*MT6176*/ /* =========================================================================== */
10626/*MT6176*/
10627/*MT6176*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10628/*MT6176*/ {
10629/*MT6176*/ *Nint = ((rfN>>11)&0x1FF);
10630/*MT6176*/ *Nfrac = ((rfN&0x7FF)<<12)|((ifN>>8)&0xFFF);
10631/*MT6176*/ }
10632/*MT6176*/ /* =========================================================================== */
10633/*MT6176*/
10634/*MT6176*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10635/*MT6176*/ {
10636/*MT6176*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
10637/*MT6176*/
10638/*MT6176*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
10639/*MT6176*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
10640/*MT6176*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
10641/*MT6176*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|(*ifN&0xFF));
10642/*MT6176*/ }
10643/*MT6176*/ /* =========================================================================== */
10644/*MT6176*/
10645/*MT6176*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10646/*MT6176*/ {
10647/*MT6176*/ unsigned short Nint =0, CH_freq =0;
10648/*MT6176*/ unsigned long Nfrac=0, VCO_freq=0;
10649/*MT6176*/ unsigned short MMD_SDM_DI_EN = 0; //keep POR = 0
10650/*MT6176*/
10651/*MT6176*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
10652/*MT6176*/ #if IS_MIPI_SUPPORT
10653/*MT6176*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
10654/*MT6176*/ #endif
10655/*MT6176*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10656/*MT6176*/
10657/*MT6176*/ if( rf_band < FrequencyBand1800 )
10658/*MT6176*/ VCO_freq = 4*CH_freq;
10659/*MT6176*/ else
10660/*MT6176*/ VCO_freq = 2*CH_freq;
10661/*MT6176*/
10662/*MT6176*/ Nint = VCO_freq/TX_DCXO_FREQ;
10663/*MT6176*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
10664/*MT6176*/
10665/*MT6176*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10666/*MT6176*/ if( l1d_rf.is_lock_dcxo )
10667/*MT6176*/ { /* SW dithering after L1D_RF_AdjustTxPLLSetting() */ }
10668/*MT6176*/ else
10669/*MT6176*/ #endif
10670/*MT6176*/ { /* Apply SW dithering no matter it is integer channel or not */
10671/*MT6176*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
10672/*MT6176*/ }
10673/*MT6176*/
10674/*MT6176*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
10675/*MT6176*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10676/*MT6176*/ /* CW550, N_FRAC[10:0], DI_EN */
10677/*MT6176*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) | (MMD_SDM_DI_EN&0x1) );
10678/*MT6176*/
10679/*MT6176*/ }
10680/*MT6176*/ /* =========================================================================== */
10681/*MT6176*/
10682/*MT6176*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10683/*MT6176*/ {
10684/*MT6176*/ *Nint = (rfN&(0xFF<<12))>>12;
10685/*MT6176*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
10686/*MT6176*/ }
10687/*MT6176*/ /* =========================================================================== */
10688/*MT6176*/
10689/*MT6176*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10690/*MT6176*/ {
10691/*MT6176*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
10692/*MT6176*/
10693/*MT6176*/ /* Apply SW dithering no matter it is integer channel or not */
10694/*MT6176*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
10695/*MT6176*/
10696/*MT6176*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
10697/*MT6176*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10698/*MT6176*/ /* CW550, N_FRAC[10:0], DI_EN */
10699/*MT6176*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
10700/*MT6176*/ }
10701/*MT6176*/ /* =========================================================================== */
10702/*MT6176*/
10703/*MT6176*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
10704/*MT6176*/ {
10705/*MT6176*/ signed long Max_Nfrac=0;
10706/*MT6176*/ if( is_TX )
10707/*MT6176*/ { Max_Nfrac = STX_MAX_NFRAC; }
10708/*MT6176*/ else
10709/*MT6176*/ { Max_Nfrac = SRX_MAX_NFRAC; }
10710/*MT6176*/
10711/*MT6176*/ //Calculate new Nfrac and Nint
10712/*MT6176*/ *Nfrac += (NfracOffset + Max_Nfrac);
10713/*MT6176*/ if( *Nfrac < Max_Nfrac )
10714/*MT6176*/ { (*Nint)--;
10715/*MT6176*/ }
10716/*MT6176*/ else if( *Nfrac >= (Max_Nfrac<<1) )
10717/*MT6176*/ { (*Nint)++;
10718/*MT6176*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
10719/*MT6176*/ }
10720/*MT6176*/ else
10721/*MT6176*/ { *Nfrac-= Max_Nfrac;
10722/*MT6176*/ }
10723/*MT6176*/ }
10724/*MT6176*/ /* =========================================================================== */
10725/*MT6176*/
10726/*MT6176*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
10727/*MT6176*/ {
10728/*MT6176*/ unsigned short freq=4450+225;
10729/*MT6176*/ switch( rf_band )
10730/*MT6176*/ {
10731/*MT6176*/ case FrequencyBand850 :
10732/*MT6176*/ {
10733/*MT6176*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
10734/*MT6176*/ break;
10735/*MT6176*/ }
10736/*MT6176*/ case FrequencyBand900 :
10737/*MT6176*/ {
10738/*MT6176*/ if( arfcn<=124 )
10739/*MT6176*/ { freq=4450+arfcn+225; }
10740/*MT6176*/ else
10741/*MT6176*/ { freq=4450+(arfcn-1024)+225; }
10742/*MT6176*/ break;
10743/*MT6176*/ }
10744/*MT6176*/ case FrequencyBand1800 :
10745/*MT6176*/ {
10746/*MT6176*/ freq=8551+(arfcn-512)+475;
10747/*MT6176*/ break;
10748/*MT6176*/ }
10749/*MT6176*/ case FrequencyBand1900 :
10750/*MT6176*/ {
10751/*MT6176*/ freq=9251+(arfcn-512)+400;
10752/*MT6176*/ break;
10753/*MT6176*/ }
10754/*MT6176*/ default :
10755/*MT6176*/ {
10756/*MT6176*/ break;
10757/*MT6176*/ }
10758/*MT6176*/ }
10759/*MT6176*/
10760/*MT6176*/ return freq;
10761/*MT6176*/ }
10762/*MT6176*/ /* =========================================================================== */
10763/*MT6176*/
10764/*MT6176*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
10765/*MT6176*/ {
10766/*MT6176*/ unsigned short freq=4450;
10767/*MT6176*/ switch( rf_band )
10768/*MT6176*/ {
10769/*MT6176*/ case FrequencyBand850 :
10770/*MT6176*/ {
10771/*MT6176*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
10772/*MT6176*/ break;
10773/*MT6176*/ }
10774/*MT6176*/ case FrequencyBand900 :
10775/*MT6176*/ {
10776/*MT6176*/ if( arfcn<=124 )
10777/*MT6176*/ { freq=4450+arfcn; }
10778/*MT6176*/ else
10779/*MT6176*/ { freq=4450+(arfcn-1024); }
10780/*MT6176*/ break;
10781/*MT6176*/ }
10782/*MT6176*/ case FrequencyBand1800 :
10783/*MT6176*/ {
10784/*MT6176*/ freq=8551+(arfcn-512);
10785/*MT6176*/ break;
10786/*MT6176*/ }
10787/*MT6176*/ case FrequencyBand1900 :
10788/*MT6176*/ {
10789/*MT6176*/ freq=9251+(arfcn-512);
10790/*MT6176*/ break;
10791/*MT6176*/ }
10792/*MT6176*/ default :
10793/*MT6176*/ {
10794/*MT6176*/ break;
10795/*MT6176*/ }
10796/*MT6176*/ }
10797/*MT6176*/
10798/*MT6176*/ return freq;
10799/*MT6176*/ }
10800/*MT6176*/ /* =========================================================================== */
10801/*MT6176*/
10802/*MT6176*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
10803/*MT6176*/ {
10804/*MT6176*/ char segment_tx=3, LUT_num_tx=8, offset_tx=14; // LUT method related parameters
10805/*MT6176*/ signed short TXDCO_LUT[8]={4830, 3611, 2617, 1796, 1110, 530, 37, -386}; // TXDCO LUT
10806/*MT6176*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
10807/*MT6176*/
10808/*MT6176*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10809/*MT6176*/ if( l1d_rf.is_lock_dcxo )
10810/*MT6176*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
10811/*MT6176*/ #endif
10812/*MT6176*/
10813/*MT6176*/ /* STX DCO SCA Typical Code LUT */
10814/*MT6176*/ idx = (Nint>>segment_tx)-((short)offset_tx);
10815/*MT6176*/ if(idx<0)
10816/*MT6176*/ { idx = 0; }
10817/*MT6176*/ else if(idx>(LUT_num_tx-2))
10818/*MT6176*/ { idx = LUT_num_tx-2; }
10819/*MT6176*/
10820/*MT6176*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
10821/*MT6176*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
10822/*MT6176*/
10823/*MT6176*/ return code_type;
10824/*MT6176*/ }
10825/*MT6176*/ /* =========================================================================== */
10826/*MT6176*/
10827/*MT6176*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
10828/*MT6176*/ {
10829/*MT6176*/ unsigned short Nint =0, CH_freq =0;
10830/*MT6176*/ unsigned long Nfrac=0, DCO4G_freq=0;
10831/*MT6176*/ unsigned short KDCO_NCAL = 0x1;//(POR_CW559&(0x3<<9))>>9;
10832/*MT6176*/ unsigned short NCAL[4] = {12, 24, 16, 32};
10833/*MT6176*/
10834/*MT6176*/ unsigned short DCO_SCAK_NOFFSET = 0; //keep POR = 0
10835/*MT6176*/ unsigned short MMD_SDM_DI_LS = 0; //keep POR = 0
10836/*MT6176*/ signed long Nfrac1Offset = 0;
10837/*MT6176*/
10838/*MT6176*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10839/*MT6176*/
10840/*MT6176*/ if( rf_band < FrequencyBand1800 )
10841/*MT6176*/ DCO4G_freq = 4*CH_freq;
10842/*MT6176*/ else
10843/*MT6176*/ DCO4G_freq = 2*CH_freq;
10844/*MT6176*/
10845/*MT6176*/ Nint = ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
10846/*MT6176*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) )/TX_DCXO_FREQ; //floor
10847/*MT6176*/
10848/*MT6176*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10849/*MT6176*/ if( l1d_rf.is_lock_dcxo )
10850/*MT6176*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCAL[KDCO_NCAL])*l1d_rf.tx_nfracoffset)>>15);
10851/*MT6176*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
10852/*MT6176*/ }
10853/*MT6176*/ #endif
10854/*MT6176*/
10855/*MT6176*/ /* CW551, N_INT1[7:0], N_RFC1[22:11] */
10856/*MT6176*/ *rfN = BSI_CW( 0x227, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10857/*MT6176*/ /* CW552, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[2:0], STX_MMD_SDM_DI_LS[1:0] */
10858/*MT6176*/ *ifN = BSI_CW( 0x228, ((Nfrac&0x7FF)<<9) | ((DCO_SCAK_NOFFSET&0xF)<<2) |(MMD_SDM_DI_LS&0x3) );
10859/*MT6176*/
10860/*MT6176*/ }
10861/*MT6176*/
10862/*MT6176*/ /* =========================================================================== */
10863/*MT6176*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
10864/*MT6176*/ {
10865/*MT6176*/ return 0;
10866/*MT6176*/ }
10867/*MT6176*/ /* =========================================================================== */
10868/*MT6176*/
10869#endif
10870
10871#if IS_RF_MT6179
10872/*MT6179*/ //For DLIF mode
10873/*MT6179*/ char L1D_RF_Cal_IF_Synth_State( void )
10874/*MT6179*/ {
10875 #if IS_W_CANCELLATION_SUPPORT
10876/*MT6179*/ if( L1D_CheckIfMetaMode() )
10877/*MT6179*/ { return l1d_rf.if_state; }
10878/*MT6179*/ else
10879/*MT6179*/ { return 0; }
10880 #else
10881/*MT6179*/ return 0;
10882 #endif
10883/*MT6179*/ }
10884/*MT6179*/ /* =========================================================================== */
10885/*MT6179*/
10886/*MT6179*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10887/*MT6179*/ { long *if_sel = ifN+1;
10888/*MT6179*/ unsigned short Nint =0, CH_freq =0;
10889/*MT6179*/ unsigned long Nfrac=0, VCO_freq=0;
10890/*MT6179*/ unsigned char SRX_REF_SEL=1, SRX_VCO_INDSW_ON = 0, SRX_CAL_EN=1, SRX_CAL_IMM=0, SRX_VCO1_SEL=1, SRX_VCO_CFG=3;
10891/*MT6179*/ unsigned short FREF_SRX[2] = {26, 52};
10892/*MT6179*/ unsigned short multiplier[2] = {15, 14};
10893/*MT6179*/
10894/*MT6179*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
10895/*MT6179*/
10896/*MT6179*/ {
10897/*MT6179*/ *if_sel = 0;
10898/*MT6179*/ if( rf_band < FrequencyBand1800 )
10899/*MT6179*/ {
10900/*MT6179*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10901/*MT6179*/ }
10902/*MT6179*/ else
10903/*MT6179*/ {
10904/*MT6179*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
10905/*MT6179*/ }
10906/*MT6179*/ }
10907/*MT6179*/
10908/*MT6179*/ Nint = VCO_freq/(FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
10909/*MT6179*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
10910/*MT6179*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[SRX_REF_SEL]) + (195)/2 )/195;
10911/*MT6179*/
10912/*MT6179*/
10913/*MT6179*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
10914/*MT6179*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
10915/*MT6179*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
10916/*MT6179*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|((SRX_REF_SEL&0x1)<<7)|((SRX_VCO_INDSW_ON&0x1)<<6)| ((SRX_CAL_EN&0x1)<<5)|((SRX_CAL_IMM&0x1)<<4)|((SRX_VCO1_SEL&0x1)<<3)|(SRX_VCO_CFG&0x7));
10917/*MT6179*/ }
10918/*MT6179*/ /* =========================================================================== */
10919/*MT6179*/
10920/*MT6179*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10921/*MT6179*/ {
10922/*MT6179*/ *Nint = ((rfN>>11)&0x1FF);
10923/*MT6179*/ *Nfrac = ((rfN&0x7FF)<<12)|((ifN>>8)&0xFFF);
10924/*MT6179*/ }
10925/*MT6179*/ /* =========================================================================== */
10926/*MT6179*/
10927/*MT6179*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10928/*MT6179*/ {
10929/*MT6179*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
10930/*MT6179*/
10931/*MT6179*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
10932/*MT6179*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
10933/*MT6179*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
10934/*MT6179*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|(*ifN&0xFF));
10935/*MT6179*/ }
10936/*MT6179*/ /* =========================================================================== */
10937/*MT6179*/
10938/*MT6179*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
10939/*MT6179*/ {
10940/*MT6179*/ unsigned short Nint =0, CH_freq =0;
10941/*MT6179*/ unsigned long Nfrac=0, VCO_freq=0;
10942/*MT6179*/ unsigned short MMD_SDM_DI_EN = 0; //keep POR = 0
10943/*MT6179*/
10944/*MT6179*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
10945/*MT6179*/ #if IS_MIPI_SUPPORT
10946/*MT6179*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
10947/*MT6179*/ #endif
10948/*MT6179*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
10949/*MT6179*/
10950/*MT6179*/ if( rf_band < FrequencyBand1800 )
10951/*MT6179*/ VCO_freq = 4*CH_freq;
10952/*MT6179*/ else
10953/*MT6179*/ VCO_freq = 2*CH_freq;
10954/*MT6179*/
10955/*MT6179*/ Nint = VCO_freq/TX_DCXO_FREQ;
10956/*MT6179*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
10957/*MT6179*/
10958/*MT6179*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
10959/*MT6179*/ if( l1d_rf.is_lock_dcxo )
10960/*MT6179*/ { /* SW dithering after L1D_RF_AdjustTxPLLSetting() */ }
10961/*MT6179*/ else
10962/*MT6179*/ #endif
10963/*MT6179*/ { /* Apply SW dithering no matter it is integer channel or not */
10964/*MT6179*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
10965/*MT6179*/ }
10966/*MT6179*/
10967/*MT6179*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
10968/*MT6179*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10969/*MT6179*/ /* CW550, N_FRAC[10:0], DI_EN */
10970/*MT6179*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) | (MMD_SDM_DI_EN&0x1) );
10971/*MT6179*/
10972/*MT6179*/ }
10973/*MT6179*/ /* =========================================================================== */
10974/*MT6179*/
10975/*MT6179*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
10976/*MT6179*/ {
10977/*MT6179*/ *Nint = (rfN&(0xFF<<12))>>12;
10978/*MT6179*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
10979/*MT6179*/ }
10980/*MT6179*/ /* =========================================================================== */
10981/*MT6179*/
10982/*MT6179*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
10983/*MT6179*/ {
10984/*MT6179*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
10985/*MT6179*/
10986/*MT6179*/ /* Apply SW dithering no matter it is integer channel or not */
10987/*MT6179*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
10988/*MT6179*/
10989/*MT6179*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
10990/*MT6179*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
10991/*MT6179*/ /* CW550, N_FRAC[10:0], DI_EN */
10992/*MT6179*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
10993/*MT6179*/ }
10994/*MT6179*/ /* =========================================================================== */
10995/*MT6179*/
10996/*MT6179*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
10997/*MT6179*/ {
10998/*MT6179*/ signed long Max_Nfrac=0;
10999/*MT6179*/ if( is_TX )
11000/*MT6179*/ { Max_Nfrac = STX_MAX_NFRAC; }
11001/*MT6179*/ else
11002/*MT6179*/ { Max_Nfrac = SRX_MAX_NFRAC; }
11003/*MT6179*/
11004/*MT6179*/ //Calculate new Nfrac and Nint
11005/*MT6179*/ *Nfrac += (NfracOffset + Max_Nfrac);
11006/*MT6179*/ if( *Nfrac < Max_Nfrac )
11007/*MT6179*/ { (*Nint)--;
11008/*MT6179*/ }
11009/*MT6179*/ else if( *Nfrac >= (Max_Nfrac<<1) )
11010/*MT6179*/ { (*Nint)++;
11011/*MT6179*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
11012/*MT6179*/ }
11013/*MT6179*/ else
11014/*MT6179*/ { *Nfrac-= Max_Nfrac;
11015/*MT6179*/ }
11016/*MT6179*/ }
11017/*MT6179*/ /* =========================================================================== */
11018/*MT6179*/
11019/*MT6179*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
11020/*MT6179*/ {
11021/*MT6179*/ unsigned short freq=4450+225;
11022/*MT6179*/ switch( rf_band )
11023/*MT6179*/ {
11024/*MT6179*/ case FrequencyBand850 :
11025/*MT6179*/ {
11026/*MT6179*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
11027/*MT6179*/ break;
11028/*MT6179*/ }
11029/*MT6179*/ case FrequencyBand900 :
11030/*MT6179*/ {
11031/*MT6179*/ if( arfcn<=124 )
11032/*MT6179*/ { freq=4450+arfcn+225; }
11033/*MT6179*/ else
11034/*MT6179*/ { freq=4450+(arfcn-1024)+225; }
11035/*MT6179*/ break;
11036/*MT6179*/ }
11037/*MT6179*/ case FrequencyBand1800 :
11038/*MT6179*/ {
11039/*MT6179*/ freq=8551+(arfcn-512)+475;
11040/*MT6179*/ break;
11041/*MT6179*/ }
11042/*MT6179*/ case FrequencyBand1900 :
11043/*MT6179*/ {
11044/*MT6179*/ freq=9251+(arfcn-512)+400;
11045/*MT6179*/ break;
11046/*MT6179*/ }
11047/*MT6179*/ default :
11048/*MT6179*/ {
11049/*MT6179*/ break;
11050/*MT6179*/ }
11051/*MT6179*/ }
11052/*MT6179*/
11053/*MT6179*/ return freq;
11054/*MT6179*/ }
11055/*MT6179*/ /* =========================================================================== */
11056/*MT6179*/
11057/*MT6179*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
11058/*MT6179*/ {
11059/*MT6179*/ unsigned short freq=4450;
11060/*MT6179*/ switch( rf_band )
11061/*MT6179*/ {
11062/*MT6179*/ case FrequencyBand850 :
11063/*MT6179*/ {
11064/*MT6179*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
11065/*MT6179*/ break;
11066/*MT6179*/ }
11067/*MT6179*/ case FrequencyBand900 :
11068/*MT6179*/ {
11069/*MT6179*/ if( arfcn<=124 )
11070/*MT6179*/ { freq=4450+arfcn; }
11071/*MT6179*/ else
11072/*MT6179*/ { freq=4450+(arfcn-1024); }
11073/*MT6179*/ break;
11074/*MT6179*/ }
11075/*MT6179*/ case FrequencyBand1800 :
11076/*MT6179*/ {
11077/*MT6179*/ freq=8551+(arfcn-512);
11078/*MT6179*/ break;
11079/*MT6179*/ }
11080/*MT6179*/ case FrequencyBand1900 :
11081/*MT6179*/ {
11082/*MT6179*/ freq=9251+(arfcn-512);
11083/*MT6179*/ break;
11084/*MT6179*/ }
11085/*MT6179*/ default :
11086/*MT6179*/ {
11087/*MT6179*/ break;
11088/*MT6179*/ }
11089/*MT6179*/ }
11090/*MT6179*/
11091/*MT6179*/ return freq;
11092/*MT6179*/ }
11093/*MT6179*/ /* =========================================================================== */
11094/*MT6179*/
11095/*MT6179*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
11096/*MT6179*/ {
11097/*MT6179*/ char segment_tx=3, LUT_num_tx=8, offset_tx=14; // LUT method related parameters
11098/*MT6179*/ signed short TXDCO_LUT[8]={4948, 3695, 2671, 1823, 1114, 514, 2, -438}; // TXDCO LUT
11099/*MT6179*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
11100/*MT6179*/
11101/*MT6179*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11102/*MT6179*/ if( l1d_rf.is_lock_dcxo )
11103/*MT6179*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
11104/*MT6179*/ #endif
11105/*MT6179*/
11106/*MT6179*/ /* STX DCO SCA Typical Code LUT */
11107/*MT6179*/ idx = (Nint>>segment_tx)-((short)offset_tx);
11108/*MT6179*/ if(idx<0)
11109/*MT6179*/ { idx = 0; }
11110/*MT6179*/ else if(idx>(LUT_num_tx-2))
11111/*MT6179*/ { idx = LUT_num_tx-2; }
11112/*MT6179*/
11113/*MT6179*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
11114/*MT6179*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
11115/*MT6179*/
11116/*MT6179*/ return code_type;
11117/*MT6179*/ }
11118/*MT6179*/ /* =========================================================================== */
11119/*MT6179*/
11120/*MT6179*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
11121/*MT6179*/ {
11122/*MT6179*/ unsigned short Nint =0, CH_freq =0;
11123/*MT6179*/ unsigned long Nfrac=0, DCO4G_freq=0;
11124/*MT6179*/ unsigned short KDCO_NCAL = 0x1;//(POR_CW559&(0x3<<9))>>9;
11125/*MT6179*/ unsigned short NCAL[4] = {12, 24, 16, 32};
11126/*MT6179*/
11127/*MT6179*/ unsigned short DCO_SCAK_NOFFSET = 0; //keep POR = 0
11128/*MT6179*/ unsigned short MMD_SDM_DI_LS = 0; //keep POR = 0
11129/*MT6179*/ signed long Nfrac1Offset = 0;
11130/*MT6179*/
11131/*MT6179*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11132/*MT6179*/
11133/*MT6179*/ if( rf_band < FrequencyBand1800 )
11134/*MT6179*/ DCO4G_freq = 4*CH_freq;
11135/*MT6179*/ else
11136/*MT6179*/ DCO4G_freq = 2*CH_freq;
11137/*MT6179*/
11138/*MT6179*/ Nint = ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
11139/*MT6179*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) )/TX_DCXO_FREQ; //floor
11140/*MT6179*/
11141/*MT6179*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11142/*MT6179*/ if( l1d_rf.is_lock_dcxo )
11143/*MT6179*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCAL[KDCO_NCAL])*l1d_rf.tx_nfracoffset)>>15);
11144/*MT6179*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
11145/*MT6179*/ }
11146/*MT6179*/ #endif
11147/*MT6179*/
11148/*MT6179*/ /* CW551, N_INT1[7:0], N_RFC1[22:11] */
11149/*MT6179*/ *rfN = BSI_CW( 0x227, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11150/*MT6179*/ /* CW552, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[3:0], STX_MMD_SDM_DI_LS[1:0] */
11151/*MT6179*/ *ifN = BSI_CW( 0x228, ((Nfrac&0x7FF)<<9) | ((DCO_SCAK_NOFFSET&0xF)<<2) |(MMD_SDM_DI_LS&0x3) );
11152/*MT6179*/
11153/*MT6179*/ }
11154/*MT6179*/
11155/*MT6179*/ /* =========================================================================== */
11156/*MT6179*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
11157/*MT6179*/ {
11158/*MT6179*/ return 0;
11159/*MT6179*/ }
11160/*MT6179*/ /* =========================================================================== */
11161/*MT6179*/
11162#endif
11163
11164#if IS_RF_MT6177L
11165/*MT6177L*/ //For DLIF mode
11166/*MT6177L*/ char L1D_RF_Cal_IF_Synth_State( void )
11167/*MT6177L*/ {
11168 #if IS_W_CANCELLATION_SUPPORT
11169/*MT6177L*/ if( L1D_CheckIfMetaMode() )
11170/*MT6177L*/ { return l1d_rf.if_state; }
11171/*MT6177L*/ else
11172/*MT6177L*/ { return 0; }
11173 #else
11174/*MT6177L*/ return 0;
11175 #endif
11176/*MT6177L*/ }
11177/*MT6177L*/ /* =========================================================================== */
11178/*MT6177L*/
11179/*MT6177L*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
11180/*MT6177L*/ { long *if_sel = ifN+1;
11181/*MT6177L*/ unsigned short Nint =0, CH_freq =0;
11182/*MT6177L*/ unsigned long Nfrac=0, VCO_freq=0;
11183/*MT6177L*/ unsigned char SRX_REF_SEL=1, SRX_VCO_INDSW_ON = 0, SRX_CAL_EN=1, SRX_CAL_IMM=0, SRX_VCO1_SEL=1, SRX_VCO_CFG=3;
11184/*MT6177L*/ unsigned short FREF_SRX[2] = {26, 52};
11185/*MT6177L*/ unsigned short multiplier[2] = {15, 14};
11186/*MT6177L*/
11187/*MT6177L*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
11188/*MT6177L*/
11189/*MT6177L*/ {
11190/*MT6177L*/ *if_sel = 0;
11191/*MT6177L*/ if( rf_band < FrequencyBand1800 )
11192/*MT6177L*/ {
11193/*MT6177L*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
11194/*MT6177L*/ }
11195/*MT6177L*/ else
11196/*MT6177L*/ {
11197/*MT6177L*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
11198/*MT6177L*/ }
11199/*MT6177L*/ }
11200/*MT6177L*/
11201/*MT6177L*/ Nint = VCO_freq/(FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
11202/*MT6177L*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
11203/*MT6177L*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[SRX_REF_SEL]) + (195)/2 )/195;
11204/*MT6177L*/
11205/*MT6177L*/
11206/*MT6177L*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
11207/*MT6177L*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
11208/*MT6177L*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
11209/*MT6177L*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|((SRX_REF_SEL&0x1)<<7)|((SRX_VCO_INDSW_ON&0x1)<<6)| ((SRX_CAL_EN&0x1)<<5)|((SRX_CAL_IMM&0x1)<<4)|((SRX_VCO1_SEL&0x1)<<3)|(SRX_VCO_CFG&0x7));
11210/*MT6177L*/ }
11211/*MT6177L*/ /* =========================================================================== */
11212/*MT6177L*/
11213/*MT6177L*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
11214/*MT6177L*/ {
11215/*MT6177L*/ *Nint = ((rfN>>11)&0x1FF);
11216/*MT6177L*/ *Nfrac = ((rfN&0x7FF)<<12)|((ifN>>8)&0xFFF);
11217/*MT6177L*/ }
11218/*MT6177L*/ /* =========================================================================== */
11219/*MT6177L*/
11220/*MT6177L*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
11221/*MT6177L*/ {
11222/*MT6177L*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
11223/*MT6177L*/
11224/*MT6177L*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
11225/*MT6177L*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
11226/*MT6177L*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
11227/*MT6177L*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|(*ifN&0xFF));
11228/*MT6177L*/ }
11229/*MT6177L*/ /* =========================================================================== */
11230/*MT6177L*/
11231/*MT6177L*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
11232/*MT6177L*/ {
11233/*MT6177L*/ unsigned short Nint =0, CH_freq =0;
11234/*MT6177L*/ unsigned long Nfrac=0, VCO_freq=0;
11235/*MT6177L*/ unsigned short MMD_SDM_DI_EN = 0; //keep POR = 0
11236/*MT6177L*/
11237/*MT6177L*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
11238/*MT6177L*/ #if IS_MIPI_SUPPORT
11239/*MT6177L*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
11240/*MT6177L*/ #endif
11241/*MT6177L*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11242/*MT6177L*/
11243/*MT6177L*/ if( rf_band < FrequencyBand1800 )
11244/*MT6177L*/ VCO_freq = 4*CH_freq;
11245/*MT6177L*/ else
11246/*MT6177L*/ VCO_freq = 2*CH_freq;
11247/*MT6177L*/
11248/*MT6177L*/ Nint = VCO_freq/TX_DCXO_FREQ;
11249/*MT6177L*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
11250/*MT6177L*/
11251/*MT6177L*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11252/*MT6177L*/ if( l1d_rf.is_lock_dcxo )
11253/*MT6177L*/ { /* SW dithering after L1D_RF_AdjustTxPLLSetting() */ }
11254/*MT6177L*/ else
11255/*MT6177L*/ #endif
11256/*MT6177L*/ { /* Apply SW dithering no matter it is integer channel or not */
11257/*MT6177L*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
11258/*MT6177L*/ }
11259/*MT6177L*/
11260/*MT6177L*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
11261/*MT6177L*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11262/*MT6177L*/ /* CW550, N_FRAC[10:0], DI_EN */
11263/*MT6177L*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) | (MMD_SDM_DI_EN&0x1) );
11264/*MT6177L*/
11265/*MT6177L*/ }
11266/*MT6177L*/ /* =========================================================================== */
11267/*MT6177L*/
11268/*MT6177L*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
11269/*MT6177L*/ {
11270/*MT6177L*/ *Nint = (rfN&(0xFF<<12))>>12;
11271/*MT6177L*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
11272/*MT6177L*/ }
11273/*MT6177L*/ /* =========================================================================== */
11274/*MT6177L*/
11275/*MT6177L*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
11276/*MT6177L*/ {
11277/*MT6177L*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
11278/*MT6177L*/
11279/*MT6177L*/ /* Apply SW dithering no matter it is integer channel or not */
11280/*MT6177L*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
11281/*MT6177L*/
11282/*MT6177L*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
11283/*MT6177L*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11284/*MT6177L*/ /* CW550, N_FRAC[10:0], DI_EN */
11285/*MT6177L*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
11286/*MT6177L*/ }
11287/*MT6177L*/ /* =========================================================================== */
11288/*MT6177L*/
11289/*MT6177L*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
11290/*MT6177L*/ {
11291/*MT6177L*/ signed long Max_Nfrac=0;
11292/*MT6177L*/ if( is_TX )
11293/*MT6177L*/ { Max_Nfrac = STX_MAX_NFRAC; }
11294/*MT6177L*/ else
11295/*MT6177L*/ { Max_Nfrac = SRX_MAX_NFRAC; }
11296/*MT6177L*/
11297/*MT6177L*/ //Calculate new Nfrac and Nint
11298/*MT6177L*/ *Nfrac += (NfracOffset + Max_Nfrac);
11299/*MT6177L*/ if( *Nfrac < Max_Nfrac )
11300/*MT6177L*/ { (*Nint)--;
11301/*MT6177L*/ }
11302/*MT6177L*/ else if( *Nfrac >= (Max_Nfrac<<1) )
11303/*MT6177L*/ { (*Nint)++;
11304/*MT6177L*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
11305/*MT6177L*/ }
11306/*MT6177L*/ else
11307/*MT6177L*/ { *Nfrac-= Max_Nfrac;
11308/*MT6177L*/ }
11309/*MT6177L*/ }
11310/*MT6177L*/ /* =========================================================================== */
11311/*MT6177L*/
11312/*MT6177L*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
11313/*MT6177L*/ {
11314/*MT6177L*/ unsigned short freq=4450+225;
11315/*MT6177L*/ switch( rf_band )
11316/*MT6177L*/ {
11317/*MT6177L*/ case FrequencyBand850 :
11318/*MT6177L*/ {
11319/*MT6177L*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
11320/*MT6177L*/ break;
11321/*MT6177L*/ }
11322/*MT6177L*/ case FrequencyBand900 :
11323/*MT6177L*/ {
11324/*MT6177L*/ if( arfcn<=124 )
11325/*MT6177L*/ { freq=4450+arfcn+225; }
11326/*MT6177L*/ else
11327/*MT6177L*/ { freq=4450+(arfcn-1024)+225; }
11328/*MT6177L*/ break;
11329/*MT6177L*/ }
11330/*MT6177L*/ case FrequencyBand1800 :
11331/*MT6177L*/ {
11332/*MT6177L*/ freq=8551+(arfcn-512)+475;
11333/*MT6177L*/ break;
11334/*MT6177L*/ }
11335/*MT6177L*/ case FrequencyBand1900 :
11336/*MT6177L*/ {
11337/*MT6177L*/ freq=9251+(arfcn-512)+400;
11338/*MT6177L*/ break;
11339/*MT6177L*/ }
11340/*MT6177L*/ default :
11341/*MT6177L*/ {
11342/*MT6177L*/ break;
11343/*MT6177L*/ }
11344/*MT6177L*/ }
11345/*MT6177L*/
11346/*MT6177L*/ return freq;
11347/*MT6177L*/ }
11348/*MT6177L*/ /* =========================================================================== */
11349/*MT6177L*/
11350/*MT6177L*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
11351/*MT6177L*/ {
11352/*MT6177L*/ unsigned short freq=4450;
11353/*MT6177L*/ switch( rf_band )
11354/*MT6177L*/ {
11355/*MT6177L*/ case FrequencyBand850 :
11356/*MT6177L*/ {
11357/*MT6177L*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
11358/*MT6177L*/ break;
11359/*MT6177L*/ }
11360/*MT6177L*/ case FrequencyBand900 :
11361/*MT6177L*/ {
11362/*MT6177L*/ if( arfcn<=124 )
11363/*MT6177L*/ { freq=4450+arfcn; }
11364/*MT6177L*/ else
11365/*MT6177L*/ { freq=4450+(arfcn-1024); }
11366/*MT6177L*/ break;
11367/*MT6177L*/ }
11368/*MT6177L*/ case FrequencyBand1800 :
11369/*MT6177L*/ {
11370/*MT6177L*/ freq=8551+(arfcn-512);
11371/*MT6177L*/ break;
11372/*MT6177L*/ }
11373/*MT6177L*/ case FrequencyBand1900 :
11374/*MT6177L*/ {
11375/*MT6177L*/ freq=9251+(arfcn-512);
11376/*MT6177L*/ break;
11377/*MT6177L*/ }
11378/*MT6177L*/ default :
11379/*MT6177L*/ {
11380/*MT6177L*/ break;
11381/*MT6177L*/ }
11382/*MT6177L*/ }
11383/*MT6177L*/
11384/*MT6177L*/ return freq;
11385/*MT6177L*/ }
11386/*MT6177L*/ /* =========================================================================== */
11387/*MT6177L*/
11388/*MT6177L*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
11389/*MT6177L*/ {
11390/*MT6177L*/ char segment_tx=3, LUT_num_tx=8, offset_tx=14; // LUT method related parameters
11391/*MT6177L*/ signed short TXDCO_LUT[8]={4948, 3695, 2671, 1823, 1114, 514, 2, -438}; // TXDCO LUT
11392/*MT6177L*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
11393/*MT6177L*/
11394/*MT6177L*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11395/*MT6177L*/ if( l1d_rf.is_lock_dcxo )
11396/*MT6177L*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
11397/*MT6177L*/ #endif
11398/*MT6177L*/
11399/*MT6177L*/ /* STX DCO SCA Typical Code LUT */
11400/*MT6177L*/ idx = (Nint>>segment_tx)-((short)offset_tx);
11401/*MT6177L*/ if(idx<0)
11402/*MT6177L*/ { idx = 0; }
11403/*MT6177L*/ else if(idx>(LUT_num_tx-2))
11404/*MT6177L*/ { idx = LUT_num_tx-2; }
11405/*MT6177L*/
11406/*MT6177L*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
11407/*MT6177L*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
11408/*MT6177L*/
11409/*MT6177L*/ return code_type;
11410/*MT6177L*/ }
11411/*MT6177L*/ /* =========================================================================== */
11412/*MT6177L*/
11413/*MT6177L*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
11414/*MT6177L*/ {
11415/*MT6177L*/ unsigned short Nint =0, CH_freq =0;
11416/*MT6177L*/ unsigned long Nfrac=0, DCO4G_freq=0;
11417/*MT6177L*/ unsigned short KDCO_NCAL = 0x1;//(POR_CW559&(0x3<<9))>>9;
11418/*MT6177L*/ unsigned short NCAL[4] = {12, 24, 16, 32};
11419/*MT6177L*/
11420/*MT6177L*/ unsigned short DCO_SCAK_NOFFSET = 0; //keep POR = 0
11421/*MT6177L*/ unsigned short MMD_SDM_DI_LS = 0; //keep POR = 0
11422/*MT6177L*/ signed long Nfrac1Offset = 0;
11423/*MT6177L*/
11424/*MT6177L*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11425/*MT6177L*/
11426/*MT6177L*/ if( rf_band < FrequencyBand1800 )
11427/*MT6177L*/ DCO4G_freq = 4*CH_freq;
11428/*MT6177L*/ else
11429/*MT6177L*/ DCO4G_freq = 2*CH_freq;
11430/*MT6177L*/
11431/*MT6177L*/ Nint = ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
11432/*MT6177L*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) )/TX_DCXO_FREQ; //floor
11433/*MT6177L*/
11434/*MT6177L*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11435/*MT6177L*/ if( l1d_rf.is_lock_dcxo )
11436/*MT6177L*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCAL[KDCO_NCAL])*l1d_rf.tx_nfracoffset)>>15);
11437/*MT6177L*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
11438/*MT6177L*/ }
11439/*MT6177L*/ #endif
11440/*MT6177L*/
11441/*MT6177L*/ /* CW551, N_INT1[7:0], N_RFC1[22:11] */
11442/*MT6177L*/ *rfN = BSI_CW( 0x227, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11443/*MT6177L*/ /* CW552, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[3:0], STX_MMD_SDM_DI_LS[1:0] */
11444/*MT6177L*/ *ifN = BSI_CW( 0x228, ((Nfrac&0x7FF)<<9) | ((DCO_SCAK_NOFFSET&0xF)<<2) |(MMD_SDM_DI_LS&0x3) );
11445/*MT6177L*/
11446/*MT6177L*/ }
11447/*MT6177L*/
11448/*MT6177L*/ /* =========================================================================== */
11449/*MT6177L*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
11450/*MT6177L*/ {
11451/*MT6177L*/ return 0;
11452/*MT6177L*/ }
11453/*MT6177L*/ /* =========================================================================== */
11454/*MT6177L*/
11455#endif
11456
11457#if IS_RF_MT6177M
11458/*MT6173*/ //For DLIF mode
11459/*MT6173*/ char L1D_RF_Cal_IF_Synth_State( void )
11460/*MT6173*/ {
11461 #if IS_W_CANCELLATION_SUPPORT
11462/*MT6173*/ if( L1D_CheckIfMetaMode() )
11463/*MT6173*/ { return l1d_rf.if_state; }
11464/*MT6173*/ else
11465/*MT6173*/ { return 0; }
11466 #else
11467/*MT6173*/ return 0;
11468 #endif
11469/*MT6173*/ }
11470/*MT6173*/ /* =========================================================================== */
11471/*MT6173*/
11472/*MT6173*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
11473/*MT6173*/ { long *if_sel = ifN+1;
11474/*MT6173*/ unsigned short Nint =0, CH_freq =0;
11475/*MT6173*/ unsigned long Nfrac=0, VCO_freq=0;
11476/*MT6173*/ unsigned char SRX_REF_SEL=1, SRX_VCO_INDSW_ON = 0, SRX_CAL_EN=1, SRX_CAL_IMM=0, SRX_VCO1_SEL=1, SRX_VCO_CFG=5;
11477/*MT6173*/ unsigned short FREF_SRX[2] = {26, 52};
11478/*MT6173*/ unsigned short multiplier[2] = {15, 14};
11479/*MT6173*/
11480/*MT6173*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
11481/*MT6173*/
11482/*MT6173*/ {
11483/*MT6173*/ *if_sel = 0;
11484/*MT6173*/ if( rf_band < FrequencyBand1800 )
11485/*MT6173*/ {
11486/*MT6173*/ VCO_freq = 4*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
11487/*MT6173*/ }
11488/*MT6173*/ else
11489/*MT6173*/ {
11490/*MT6173*/ VCO_freq = 2*(CH_freq*DLIF_SCALE - DLIF); //High-side mixing
11491/*MT6173*/ }
11492/*MT6173*/ }
11493/*MT6173*/
11494/*MT6173*/ Nint = VCO_freq/(FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE);
11495/*MT6173*/ //+195/2 is for rounding, 195=13*3*5, 5 is SYNTH_SCALE, 13 and 3 are related to DLIF
11496/*MT6173*/ Nfrac = ( ((VCO_freq-Nint*FREF_SRX[SRX_REF_SEL]*SYNTH_SCALE*DLIF_SCALE)<<multiplier[SRX_REF_SEL]) + (195)/2 )/195;
11497/*MT6173*/
11498/*MT6173*/
11499/*MT6173*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
11500/*MT6173*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
11501/*MT6173*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
11502/*MT6173*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|((SRX_REF_SEL&0x1)<<7)|((SRX_VCO_INDSW_ON&0x1)<<6)| ((SRX_CAL_EN&0x1)<<5)|((SRX_CAL_IMM&0x1)<<4)|((SRX_VCO1_SEL&0x1)<<3)|(SRX_VCO_CFG&0x7));
11503/*MT6173*/ }
11504/*MT6173*/ /* =========================================================================== */
11505/*MT6173*/
11506/*MT6173*/ void L1D_RF_SplitRxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
11507/*MT6173*/ {
11508/*MT6173*/ *Nint = ((rfN>>11)&0x1FF);
11509/*MT6173*/ *Nfrac = ((rfN&0x7FF)<<12)|((ifN>>8)&0xFFF);
11510/*MT6173*/ }
11511/*MT6173*/ /* =========================================================================== */
11512/*MT6173*/
11513/*MT6173*/ void L1D_RF_AdjustRxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
11514/*MT6173*/ {
11515/*MT6173*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 0 );
11516/*MT6173*/
11517/*MT6173*/ /* CW130, N_INT[8:0], N_FRFC[22:12] */
11518/*MT6173*/ *rfN = BSI_CW( 0x082, (((Nint&0x1FF)<<11)|((Nfrac>>12)&0x7FF)) );
11519/*MT6173*/ /* CW131, N_FRAC[11:0], REF_DOUBLER_EN, SRX_CAL_EN, SRX_CAL_IMM, SRX_VCO_SEL, SRX_VCO_CFG */
11520/*MT6173*/ *ifN = BSI_CW( 0x083, ((Nfrac&0xFFF)<<8)|(*ifN&0xFF));
11521/*MT6173*/ }
11522/*MT6173*/ /* =========================================================================== */
11523/*MT6173*/
11524/*MT6173*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, long *rfN, long *ifN )
11525/*MT6173*/ {
11526/*MT6173*/ unsigned short Nint =0, CH_freq =0;
11527/*MT6173*/ unsigned long Nfrac=0, VCO_freq=0;
11528/*MT6173*/ unsigned short MMD_SDM_DI_EN = 0; //keep POR = 0
11529/*MT6173*/
11530/*MT6173*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
11531/*MT6173*/ #if IS_MIPI_SUPPORT
11532/*MT6173*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
11533/*MT6173*/ #endif
11534/*MT6173*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11535/*MT6173*/
11536/*MT6173*/ if( rf_band < FrequencyBand1800 )
11537/*MT6173*/ VCO_freq = 4*CH_freq;
11538/*MT6173*/ else
11539/*MT6173*/ VCO_freq = 2*CH_freq;
11540/*MT6173*/
11541/*MT6173*/ Nint = VCO_freq/TX_DCXO_FREQ;
11542/*MT6173*/ Nfrac = ( ((VCO_freq-Nint*TX_DCXO_FREQ)<<23) + TX_DCXO_FREQ/2 )/TX_DCXO_FREQ; //+TX_DCXO_FREQ/2 is for rounding
11543/*MT6173*/
11544/*MT6173*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11545/*MT6173*/ if( l1d_rf.is_lock_dcxo )
11546/*MT6173*/ { /* SW dithering after L1D_RF_AdjustTxPLLSetting() */ }
11547/*MT6173*/ else
11548/*MT6173*/ #endif
11549/*MT6173*/ { /* Apply SW dithering no matter it is integer channel or not */
11550/*MT6173*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
11551/*MT6173*/ }
11552/*MT6173*/
11553/*MT6173*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
11554/*MT6173*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11555/*MT6173*/ /* CW550, N_FRAC[10:0], DI_EN */
11556/*MT6173*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) | (MMD_SDM_DI_EN&0x1) );
11557/*MT6173*/
11558/*MT6173*/ }
11559/*MT6173*/ /* =========================================================================== */
11560/*MT6173*/
11561/*MT6173*/ void L1D_RF_SplitTxPLLSetting(unsigned long rfN, unsigned long ifN, unsigned short *Nint, unsigned long *Nfrac)
11562/*MT6173*/ {
11563/*MT6173*/ *Nint = (rfN&(0xFF<<12))>>12;
11564/*MT6173*/ *Nfrac = ( (rfN&0xFFF)<<11 ) | ( (ifN&(0x7FF<<9))>>9 );
11565/*MT6173*/ }
11566/*MT6173*/ /* =========================================================================== */
11567/*MT6173*/
11568/*MT6173*/ void L1D_RF_AdjustTxPLLSetting(unsigned short Nint, unsigned long Nfrac, signed long NfracOffset, unsigned long *rfN, unsigned long *ifN )
11569/*MT6173*/ {
11570/*MT6173*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, NfracOffset, 1 );
11571/*MT6173*/
11572/*MT6173*/ /* Apply SW dithering no matter it is integer channel or not */
11573/*MT6173*/ Nfrac = ( (Nfrac&0x1) == 0 ) ? Nfrac+1 : Nfrac; //always let LSB[0]=1
11574/*MT6173*/
11575/*MT6173*/ /* CW549, N_INT[7:0], N_RFC[22:11] */
11576/*MT6173*/ *rfN = BSI_CW( 0x225, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11577/*MT6173*/ /* CW550, N_FRAC[10:0], DI_EN */
11578/*MT6173*/ *ifN = BSI_CW( 0x226, ((Nfrac&0x7FF)<<9) |((*ifN)&0x1FF));
11579/*MT6173*/ }
11580/*MT6173*/ /* =========================================================================== */
11581/*MT6173*/
11582/*MT6173*/ void L1D_RF_CompensateSXSetting( unsigned short *Nint, unsigned long *Nfrac, signed long NfracOffset, unsigned char is_TX)
11583/*MT6173*/ {
11584/*MT6173*/ signed long Max_Nfrac=0;
11585/*MT6173*/ if( is_TX )
11586/*MT6173*/ { Max_Nfrac = STX_MAX_NFRAC; }
11587/*MT6173*/ else
11588/*MT6173*/ { Max_Nfrac = SRX_MAX_NFRAC; }
11589/*MT6173*/
11590/*MT6173*/ //Calculate new Nfrac and Nint
11591/*MT6173*/ *Nfrac += (NfracOffset + Max_Nfrac);
11592/*MT6173*/ if( *Nfrac < Max_Nfrac )
11593/*MT6173*/ { (*Nint)--;
11594/*MT6173*/ }
11595/*MT6173*/ else if( *Nfrac >= (Max_Nfrac<<1) )
11596/*MT6173*/ { (*Nint)++;
11597/*MT6173*/ *Nfrac = *Nfrac - (Max_Nfrac<<1);
11598/*MT6173*/ }
11599/*MT6173*/ else
11600/*MT6173*/ { *Nfrac-= Max_Nfrac;
11601/*MT6173*/ }
11602/*MT6173*/ }
11603/*MT6173*/ /* =========================================================================== */
11604/*MT6173*/
11605/*MT6173*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
11606/*MT6173*/ {
11607/*MT6173*/ unsigned short freq=4450+225;
11608/*MT6173*/ switch( rf_band )
11609/*MT6173*/ {
11610/*MT6173*/ case FrequencyBand850 :
11611/*MT6173*/ {
11612/*MT6173*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
11613/*MT6173*/ break;
11614/*MT6173*/ }
11615/*MT6173*/ case FrequencyBand900 :
11616/*MT6173*/ {
11617/*MT6173*/ if( arfcn<=124 )
11618/*MT6173*/ { freq=4450+arfcn+225; }
11619/*MT6173*/ else
11620/*MT6173*/ { freq=4450+(arfcn-1024)+225; }
11621/*MT6173*/ break;
11622/*MT6173*/ }
11623/*MT6173*/ case FrequencyBand1800 :
11624/*MT6173*/ {
11625/*MT6173*/ freq=8551+(arfcn-512)+475;
11626/*MT6173*/ break;
11627/*MT6173*/ }
11628/*MT6173*/ case FrequencyBand1900 :
11629/*MT6173*/ {
11630/*MT6173*/ freq=9251+(arfcn-512)+400;
11631/*MT6173*/ break;
11632/*MT6173*/ }
11633/*MT6173*/ default :
11634/*MT6173*/ {
11635/*MT6173*/ break;
11636/*MT6173*/ }
11637/*MT6173*/ }
11638/*MT6173*/
11639/*MT6173*/ return freq;
11640/*MT6173*/ }
11641/*MT6173*/ /* =========================================================================== */
11642/*MT6173*/
11643/*MT6173*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
11644/*MT6173*/ {
11645/*MT6173*/ unsigned short freq=4450;
11646/*MT6173*/ switch( rf_band )
11647/*MT6173*/ {
11648/*MT6173*/ case FrequencyBand850 :
11649/*MT6173*/ {
11650/*MT6173*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
11651/*MT6173*/ break;
11652/*MT6173*/ }
11653/*MT6173*/ case FrequencyBand900 :
11654/*MT6173*/ {
11655/*MT6173*/ if( arfcn<=124 )
11656/*MT6173*/ { freq=4450+arfcn; }
11657/*MT6173*/ else
11658/*MT6173*/ { freq=4450+(arfcn-1024); }
11659/*MT6173*/ break;
11660/*MT6173*/ }
11661/*MT6173*/ case FrequencyBand1800 :
11662/*MT6173*/ {
11663/*MT6173*/ freq=8551+(arfcn-512);
11664/*MT6173*/ break;
11665/*MT6173*/ }
11666/*MT6173*/ case FrequencyBand1900 :
11667/*MT6173*/ {
11668/*MT6173*/ freq=9251+(arfcn-512);
11669/*MT6173*/ break;
11670/*MT6173*/ }
11671/*MT6173*/ default :
11672/*MT6173*/ {
11673/*MT6173*/ break;
11674/*MT6173*/ }
11675/*MT6173*/ }
11676/*MT6173*/
11677/*MT6173*/ return freq;
11678/*MT6173*/ }
11679/*MT6173*/ /* =========================================================================== */
11680/*MT6173*/
11681/*MT6173*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
11682/*MT6173*/ {
11683/*MT6173*/ char segment_tx=3, LUT_num_tx=7, offset_tx=14; // LUT method related parameters
11684/*MT6173*/ signed short TXDCO_LUT[7]={5058, 3703, 2596, 1679, 911, 263, -290}; // TXDCO LUT
11685/*MT6173*/ short idx, x_axis, code_type; // code_type value for SCA calibration (code_type > 0)
11686/*MT6173*/
11687/*MT6173*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11688/*MT6173*/ if( l1d_rf.is_lock_dcxo )
11689/*MT6173*/ { L1D_RF_CompensateSXSetting( &Nint, &Nfrac, -l1d_rf.tx_nfracoffset, 1 ); }
11690/*MT6173*/ #endif
11691/*MT6173*/
11692/*MT6173*/ /* STX DCO SCA Typical Code LUT */
11693/*MT6173*/ idx = (Nint>>segment_tx)-((short)offset_tx);
11694/*MT6173*/ if(idx<0)
11695/*MT6173*/ { idx = 0; }
11696/*MT6173*/ else if(idx>(LUT_num_tx-2))
11697/*MT6173*/ { idx = LUT_num_tx-2; }
11698/*MT6173*/
11699/*MT6173*/ x_axis = ((Nint-((Nint>>segment_tx)<<segment_tx))<<3)+((short)(Nfrac>>20));
11700/*MT6173*/ code_type = TXDCO_LUT[idx]+ ((x_axis*(TXDCO_LUT[idx+1]-TXDCO_LUT[idx]))>>(segment_tx+3));
11701/*MT6173*/
11702/*MT6173*/ return code_type;
11703/*MT6173*/ }
11704/*MT6173*/ /* =========================================================================== */
11705/*MT6173*/
11706/*MT6173*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
11707/*MT6173*/ {
11708/*MT6173*/ unsigned short Nint =0, CH_freq =0;
11709/*MT6173*/ unsigned long Nfrac=0, DCO4G_freq=0;
11710/*MT6173*/ unsigned short KDCO_NCAL = 0x1;//(POR_CW559&(0x3<<9))>>9;
11711/*MT6173*/ unsigned short NCAL[4] = {12, 24, 16, 32};
11712/*MT6173*/
11713/*MT6173*/ unsigned short DCO_SCAK_NOFFSET = 0; //keep POR = 0
11714/*MT6173*/ unsigned short MMD_SDM_DI_LS = 0; //keep POR = 0
11715/*MT6173*/ signed long Nfrac1Offset = 0;
11716/*MT6173*/
11717/*MT6173*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11718/*MT6173*/
11719/*MT6173*/ if( rf_band < FrequencyBand1800 )
11720/*MT6173*/ DCO4G_freq = 4*CH_freq;
11721/*MT6173*/ else
11722/*MT6173*/ DCO4G_freq = 2*CH_freq;
11723/*MT6173*/
11724/*MT6173*/ Nint = ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 ) / (TX_DCXO_FREQ<<15);
11725/*MT6173*/ Nfrac = ( ( ( (DCO4G_freq<<15) - NCAL[KDCO_NCAL]*DCO4G_freq + NCAL[KDCO_NCAL]*TX_DCXO_FREQ*92 - ((Nint*TX_DCXO_FREQ)<<15) )<<8 ) )/TX_DCXO_FREQ; //floor
11726/*MT6173*/
11727/*MT6173*/ #if IS_DUAL_LOOP_AFC_CONTROL_SUPPORT
11728/*MT6173*/ if( l1d_rf.is_lock_dcxo )
11729/*MT6173*/ { Nfrac1Offset = l1d_rf.tx_nfracoffset - ((((signed long)NCAL[KDCO_NCAL])*l1d_rf.tx_nfracoffset)>>15);
11730/*MT6173*/ L1D_RF_CompensateSXSetting( &Nint, &Nfrac, Nfrac1Offset, 1 );
11731/*MT6173*/ }
11732/*MT6173*/ #endif
11733/*MT6173*/
11734/*MT6173*/ /* CW551, N_INT1[7:0], N_RFC1[22:11] */
11735/*MT6173*/ *rfN = BSI_CW( 0x227, ((Nint &0xFF)<<12) | (Nfrac>>11) );
11736/*MT6173*/ /* CW552, N_FRAC1[10:0], NOFFSET_REV[3:0], STX_DCO_SCAK_NOFFSET[3:0], STX_MMD_SDM_DI_LS[1:0] */
11737/*MT6173*/ *ifN = BSI_CW( 0x228, ((Nfrac&0x7FF)<<9) | ((DCO_SCAK_NOFFSET&0xF)<<2) |(MMD_SDM_DI_LS&0x3) );
11738/*MT6173*/
11739/*MT6173*/ }
11740/*MT6173*/
11741/*MT6173*/ /* =========================================================================== */
11742/*MT6173*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
11743/*MT6173*/ {
11744/*MT6173*/ return 0;
11745/*MT6173*/ }
11746/*MT6173*/ /* =========================================================================== */
11747/*MT6173*/
11748#endif
11749
11750#if IS_RF_TRINITYE1
11751/*TRINITYE1*/ //For DLIF mode
11752/*TRINITYE1*/ char L1D_RF_Cal_IF_Synth_State( void )
11753/*TRINITYE1*/ {
11754 #if IS_W_CANCELLATION_SUPPORT
11755/*TRINITYE1*/ if( L1D_CheckIfMetaMode() )
11756/*TRINITYE1*/ { return l1d_rf.if_state; }
11757/*TRINITYE1*/ else
11758/*TRINITYE1*/ { return 0; }
11759 #else
11760/*TRINITYE1*/ return 0;
11761 #endif
11762/*TRINITYE1*/ }
11763/*TRINITYE1*/ /* =========================================================================== */
11764/*TRINITYE1*/
11765/*TRINITYE1*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
11766/*TRINITYE1*/ { unsigned long *if_sel = freq_lsb+1; //This will point to global if_sel
11767/*TRINITYE1*/ unsigned short CH_freq =0;
11768/*TRINITYE1*/ int64 FLO_scale_freq=0;
11769/*TRINITYE1*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
11770/*TRINITYE1*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
11771/*TRINITYE1*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
11772/*TRINITYE1*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
11773/*TRINITYE1*/
11774/*TRINITYE1*/ /* Switch +- DLIF */
11775/*TRINITYE1*/ *if_sel = 0;
11776/*TRINITYE1*/ l1d_rf.obb_if_sign = -1;
11777/*TRINITYE1*/ #if IS_OBB_DETECTION_SUPPORT
11778/*TRINITYE1*/ if( !L1D_CheckIfMetaMode() )
11779/*TRINITYE1*/ {
11780/*TRINITYE1*/ if( l1d_rf.if_change == -1 && arfcn == l1d_rf.obb_arfcn )
11781/*TRINITYE1*/ {
11782/*TRINITYE1*/ signed short if_sign = l1d_rf.if_change*(*if_sel*2-1);
11783/*TRINITYE1*/ *if_sel = if_sign > 0 ? 1 : 0;
11784/*TRINITYE1*/ l1d_rf.obb_if_sign = if_sign > 0 ? 1 : -1;
11785/*TRINITYE1*/ }
11786/*TRINITYE1*/ }
11787/*TRINITYE1*/ #endif
11788/*TRINITYE1*/ }
11789/*TRINITYE1*/ /* =========================================================================== */
11790/*TRINITYE1*/
11791/*TRINITYE1*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
11792/*TRINITYE1*/ {
11793/*TRINITYE1*/ unsigned short CH_freq =0;
11794/*TRINITYE1*/ int64 FLO_scale_freq=0;
11795/*TRINITYE1*/
11796/*TRINITYE1*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
11797/*TRINITYE1*/ #if IS_MIPI_SUPPORT
11798/*TRINITYE1*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
11799/*TRINITYE1*/ #endif
11800/*TRINITYE1*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11801/*TRINITYE1*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
11802/*TRINITYE1*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
11803/*TRINITYE1*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
11804/*TRINITYE1*/ }
11805/*TRINITYE1*/ /* =========================================================================== */
11806/*TRINITYE1*/
11807/*TRINITYE1*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
11808/*TRINITYE1*/ {
11809/*TRINITYE1*/ unsigned short freq=4450+225;
11810/*TRINITYE1*/ switch( rf_band )
11811/*TRINITYE1*/ {
11812/*TRINITYE1*/ case FrequencyBand850 :
11813/*TRINITYE1*/ {
11814/*TRINITYE1*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
11815/*TRINITYE1*/ break;
11816/*TRINITYE1*/ }
11817/*TRINITYE1*/ case FrequencyBand900 :
11818/*TRINITYE1*/ {
11819/*TRINITYE1*/ if( arfcn<=124 )
11820/*TRINITYE1*/ { freq=4450+arfcn+225; }
11821/*TRINITYE1*/ else
11822/*TRINITYE1*/ { freq=4450+(arfcn-1024)+225; }
11823/*TRINITYE1*/ break;
11824/*TRINITYE1*/ }
11825/*TRINITYE1*/ case FrequencyBand1800 :
11826/*TRINITYE1*/ {
11827/*TRINITYE1*/ freq=8551+(arfcn-512)+475;
11828/*TRINITYE1*/ break;
11829/*TRINITYE1*/ }
11830/*TRINITYE1*/ case FrequencyBand1900 :
11831/*TRINITYE1*/ {
11832/*TRINITYE1*/ freq=9251+(arfcn-512)+400;
11833/*TRINITYE1*/ break;
11834/*TRINITYE1*/ }
11835/*TRINITYE1*/ default :
11836/*TRINITYE1*/ {
11837/*TRINITYE1*/ break;
11838/*TRINITYE1*/ }
11839/*TRINITYE1*/ }
11840/*TRINITYE1*/
11841/*TRINITYE1*/ return freq;
11842/*TRINITYE1*/ }
11843/*TRINITYE1*/ /* =========================================================================== */
11844/*TRINITYE1*/
11845/*TRINITYE1*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
11846/*TRINITYE1*/ {
11847/*TRINITYE1*/ unsigned short freq=4450;
11848/*TRINITYE1*/ switch( rf_band )
11849/*TRINITYE1*/ {
11850/*TRINITYE1*/ case FrequencyBand850 :
11851/*TRINITYE1*/ {
11852/*TRINITYE1*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
11853/*TRINITYE1*/ break;
11854/*TRINITYE1*/ }
11855/*TRINITYE1*/ case FrequencyBand900 :
11856/*TRINITYE1*/ {
11857/*TRINITYE1*/ if( arfcn<=124 )
11858/*TRINITYE1*/ { freq=4450+arfcn; }
11859/*TRINITYE1*/ else
11860/*TRINITYE1*/ { freq=4450+(arfcn-1024); }
11861/*TRINITYE1*/ break;
11862/*TRINITYE1*/ }
11863/*TRINITYE1*/ case FrequencyBand1800 :
11864/*TRINITYE1*/ {
11865/*TRINITYE1*/ freq=8551+(arfcn-512);
11866/*TRINITYE1*/ break;
11867/*TRINITYE1*/ }
11868/*TRINITYE1*/ case FrequencyBand1900 :
11869/*TRINITYE1*/ {
11870/*TRINITYE1*/ freq=9251+(arfcn-512);
11871/*TRINITYE1*/ break;
11872/*TRINITYE1*/ }
11873/*TRINITYE1*/ default :
11874/*TRINITYE1*/ {
11875/*TRINITYE1*/ break;
11876/*TRINITYE1*/ }
11877/*TRINITYE1*/ }
11878/*TRINITYE1*/
11879/*TRINITYE1*/ return freq;
11880/*TRINITYE1*/ }
11881/*TRINITYE1*/ /* =========================================================================== */
11882/*TRINITYE1*/
11883/*TRINITYE1*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
11884/*TRINITYE1*/ {
11885/*TRINITYE1*/ return 0;
11886/*TRINITYE1*/ }
11887/*TRINITYE1*/ /* =========================================================================== */
11888/*TRINITYE1*/
11889/*TRINITYE1*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
11890/*TRINITYE1*/ {
11891/*TRINITYE1*/
11892/*TRINITYE1*/ *rfN = 0;
11893/*TRINITYE1*/ *ifN = 0;
11894/*TRINITYE1*/ }
11895/*TRINITYE1*/
11896/*TRINITYE1*/ /* =========================================================================== */
11897/*TRINITYE1*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
11898/*TRINITYE1*/ {
11899/*TRINITYE1*/ return 0;
11900/*TRINITYE1*/ }
11901/*TRINITYE1*/ /* =========================================================================== */
11902/*TRINITYE1*/
11903#endif
11904
11905#if IS_RF_TRINITYL
11906/*TRINITYL*/ //For DLIF mode
11907/*TRINITYL*/ char L1D_RF_Cal_IF_Synth_State( void )
11908/*TRINITYL*/ {
11909 #if IS_W_CANCELLATION_SUPPORT
11910/*TRINITYL*/ if( L1D_CheckIfMetaMode() )
11911/*TRINITYL*/ { return l1d_rf.if_state; }
11912/*TRINITYL*/ else
11913/*TRINITYL*/ { return 0; }
11914 #else
11915/*TRINITYL*/ return 0;
11916 #endif
11917/*TRINITYL*/ }
11918/*TRINITYL*/ /* =========================================================================== */
11919/*TRINITYL*/
11920/*TRINITYL*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
11921/*TRINITYL*/ {
11922/*TRINITYL*/ unsigned short CH_freq =0;
11923/*TRINITYL*/ int64 FLO_scale_freq=0;
11924/*TRINITYL*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
11925/*TRINITYL*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
11926/*TRINITYL*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
11927/*TRINITYL*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
11928/*TRINITYL*/
11929/*TRINITYL*/ /* Switch +- DLIF */
11930/*TRINITYL*/ l1d_rf.obb_if_sign = -1;
11931/*TRINITYL*/ }
11932/*TRINITYL*/ /* =========================================================================== */
11933/*TRINITYL*/
11934/*TRINITYL*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
11935/*TRINITYL*/ {
11936/*TRINITYL*/ unsigned short CH_freq =0;
11937/*TRINITYL*/ int64 FLO_scale_freq=0;
11938/*TRINITYL*/
11939/*TRINITYL*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
11940/*TRINITYL*/ #if IS_MIPI_SUPPORT
11941/*TRINITYL*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
11942/*TRINITYL*/ #endif
11943/*TRINITYL*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
11944/*TRINITYL*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
11945/*TRINITYL*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
11946/*TRINITYL*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
11947/*TRINITYL*/ }
11948/*TRINITYL*/ /* =========================================================================== */
11949/*TRINITYL*/
11950/*TRINITYL*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
11951/*TRINITYL*/ {
11952/*TRINITYL*/ unsigned short freq=4450+225;
11953/*TRINITYL*/ switch( rf_band )
11954/*TRINITYL*/ {
11955/*TRINITYL*/ case FrequencyBand850 :
11956/*TRINITYL*/ {
11957/*TRINITYL*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
11958/*TRINITYL*/ break;
11959/*TRINITYL*/ }
11960/*TRINITYL*/ case FrequencyBand900 :
11961/*TRINITYL*/ {
11962/*TRINITYL*/ if( arfcn<=124 )
11963/*TRINITYL*/ { freq=4450+arfcn+225; }
11964/*TRINITYL*/ else
11965/*TRINITYL*/ { freq=4450+(arfcn-1024)+225; }
11966/*TRINITYL*/ break;
11967/*TRINITYL*/ }
11968/*TRINITYL*/ case FrequencyBand1800 :
11969/*TRINITYL*/ {
11970/*TRINITYL*/ freq=8551+(arfcn-512)+475;
11971/*TRINITYL*/ break;
11972/*TRINITYL*/ }
11973/*TRINITYL*/ case FrequencyBand1900 :
11974/*TRINITYL*/ {
11975/*TRINITYL*/ freq=9251+(arfcn-512)+400;
11976/*TRINITYL*/ break;
11977/*TRINITYL*/ }
11978/*TRINITYL*/ default :
11979/*TRINITYL*/ {
11980/*TRINITYL*/ break;
11981/*TRINITYL*/ }
11982/*TRINITYL*/ }
11983/*TRINITYL*/
11984/*TRINITYL*/ return freq;
11985/*TRINITYL*/ }
11986/*TRINITYL*/ /* =========================================================================== */
11987/*TRINITYL*/
11988/*TRINITYL*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
11989/*TRINITYL*/ {
11990/*TRINITYL*/ unsigned short freq=4450;
11991/*TRINITYL*/ switch( rf_band )
11992/*TRINITYL*/ {
11993/*TRINITYL*/ case FrequencyBand850 :
11994/*TRINITYL*/ {
11995/*TRINITYL*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
11996/*TRINITYL*/ break;
11997/*TRINITYL*/ }
11998/*TRINITYL*/ case FrequencyBand900 :
11999/*TRINITYL*/ {
12000/*TRINITYL*/ if( arfcn<=124 )
12001/*TRINITYL*/ { freq=4450+arfcn; }
12002/*TRINITYL*/ else
12003/*TRINITYL*/ { freq=4450+(arfcn-1024); }
12004/*TRINITYL*/ break;
12005/*TRINITYL*/ }
12006/*TRINITYL*/ case FrequencyBand1800 :
12007/*TRINITYL*/ {
12008/*TRINITYL*/ freq=8551+(arfcn-512);
12009/*TRINITYL*/ break;
12010/*TRINITYL*/ }
12011/*TRINITYL*/ case FrequencyBand1900 :
12012/*TRINITYL*/ {
12013/*TRINITYL*/ freq=9251+(arfcn-512);
12014/*TRINITYL*/ break;
12015/*TRINITYL*/ }
12016/*TRINITYL*/ default :
12017/*TRINITYL*/ {
12018/*TRINITYL*/ break;
12019/*TRINITYL*/ }
12020/*TRINITYL*/ }
12021/*TRINITYL*/
12022/*TRINITYL*/ return freq;
12023/*TRINITYL*/ }
12024/*TRINITYL*/ /* =========================================================================== */
12025/*TRINITYL*/
12026/*TRINITYL*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
12027/*TRINITYL*/ {
12028/*TRINITYL*/ return 0;
12029/*TRINITYL*/ }
12030/*TRINITYL*/ /* =========================================================================== */
12031/*TRINITYL*/
12032/*TRINITYL*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
12033/*TRINITYL*/ {
12034/*TRINITYL*/
12035/*TRINITYL*/ *rfN = 0;
12036/*TRINITYL*/ *ifN = 0;
12037/*TRINITYL*/ }
12038/*TRINITYL*/
12039/*TRINITYL*/ /* =========================================================================== */
12040/*TRINITYL*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
12041/*TRINITYL*/ {
12042/*TRINITYL*/ return 0;
12043/*TRINITYL*/ }
12044/*TRINITYL*/ /* =========================================================================== */
12045/*TRINITYL*/
12046#endif
12047
12048#if IS_RF_MT6186
12049/*MT6186*/ //For DLIF mode
12050/*MT6186*/ char L1D_RF_Cal_IF_Synth_State( void )
12051/*MT6186*/ {
12052 #if IS_W_CANCELLATION_SUPPORT
12053/*MT6186*/ if( L1D_CheckIfMetaMode() )
12054/*MT6186*/ { return l1d_rf.if_state; }
12055/*MT6186*/ else
12056/*MT6186*/ { return 0; }
12057 #else
12058/*MT6186*/ return 0;
12059 #endif
12060/*MT6186*/ }
12061/*MT6186*/ /* =========================================================================== */
12062/*MT6186*/
12063/*MT6186*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12064/*MT6186*/ {
12065/*MT6186*/ unsigned short CH_freq =0;
12066/*MT6186*/ int64 FLO_scale_freq=0;
12067/*MT6186*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
12068/*MT6186*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12069/*MT6186*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12070/*MT6186*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12071/*MT6186*/
12072/*MT6186*/ /* Switch +- DLIF */
12073/*MT6186*/ l1d_rf.obb_if_sign = -1;
12074/*MT6186*/ }
12075/*MT6186*/ /* =========================================================================== */
12076/*MT6186*/
12077/*MT6186*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12078/*MT6186*/ {
12079/*MT6186*/ unsigned short CH_freq =0;
12080/*MT6186*/ int64 FLO_scale_freq=0;
12081/*MT6186*/
12082/*MT6186*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
12083/*MT6186*/ #if IS_MIPI_SUPPORT
12084/*MT6186*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
12085/*MT6186*/ #endif
12086/*MT6186*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
12087/*MT6186*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12088/*MT6186*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12089/*MT6186*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12090/*MT6186*/ }
12091/*MT6186*/ /* =========================================================================== */
12092/*MT6186*/
12093/*MT6186*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
12094/*MT6186*/ {
12095/*MT6186*/ unsigned short freq=4450+225;
12096/*MT6186*/ switch( rf_band )
12097/*MT6186*/ {
12098/*MT6186*/ case FrequencyBand850 :
12099/*MT6186*/ {
12100/*MT6186*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
12101/*MT6186*/ break;
12102/*MT6186*/ }
12103/*MT6186*/ case FrequencyBand900 :
12104/*MT6186*/ {
12105/*MT6186*/ if( arfcn<=124 )
12106/*MT6186*/ { freq=4450+arfcn+225; }
12107/*MT6186*/ else
12108/*MT6186*/ { freq=4450+(arfcn-1024)+225; }
12109/*MT6186*/ break;
12110/*MT6186*/ }
12111/*MT6186*/ case FrequencyBand1800 :
12112/*MT6186*/ {
12113/*MT6186*/ freq=8551+(arfcn-512)+475;
12114/*MT6186*/ break;
12115/*MT6186*/ }
12116/*MT6186*/ case FrequencyBand1900 :
12117/*MT6186*/ {
12118/*MT6186*/ freq=9251+(arfcn-512)+400;
12119/*MT6186*/ break;
12120/*MT6186*/ }
12121/*MT6186*/ default :
12122/*MT6186*/ {
12123/*MT6186*/ break;
12124/*MT6186*/ }
12125/*MT6186*/ }
12126/*MT6186*/
12127/*MT6186*/ return freq;
12128/*MT6186*/ }
12129/*MT6186*/ /* =========================================================================== */
12130/*MT6186*/
12131/*MT6186*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
12132/*MT6186*/ {
12133/*MT6186*/ unsigned short freq=4450;
12134/*MT6186*/ switch( rf_band )
12135/*MT6186*/ {
12136/*MT6186*/ case FrequencyBand850 :
12137/*MT6186*/ {
12138/*MT6186*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
12139/*MT6186*/ break;
12140/*MT6186*/ }
12141/*MT6186*/ case FrequencyBand900 :
12142/*MT6186*/ {
12143/*MT6186*/ if( arfcn<=124 )
12144/*MT6186*/ { freq=4450+arfcn; }
12145/*MT6186*/ else
12146/*MT6186*/ { freq=4450+(arfcn-1024); }
12147/*MT6186*/ break;
12148/*MT6186*/ }
12149/*MT6186*/ case FrequencyBand1800 :
12150/*MT6186*/ {
12151/*MT6186*/ freq=8551+(arfcn-512);
12152/*MT6186*/ break;
12153/*MT6186*/ }
12154/*MT6186*/ case FrequencyBand1900 :
12155/*MT6186*/ {
12156/*MT6186*/ freq=9251+(arfcn-512);
12157/*MT6186*/ break;
12158/*MT6186*/ }
12159/*MT6186*/ default :
12160/*MT6186*/ {
12161/*MT6186*/ break;
12162/*MT6186*/ }
12163/*MT6186*/ }
12164/*MT6186*/
12165/*MT6186*/ return freq;
12166/*MT6186*/ }
12167/*MT6186*/ /* =========================================================================== */
12168/*MT6186*/
12169/*MT6186*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
12170/*MT6186*/ {
12171/*MT6186*/ return 0;
12172/*MT6186*/ }
12173/*MT6186*/ /* =========================================================================== */
12174/*MT6186*/
12175/*MT6186*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
12176/*MT6186*/ {
12177/*MT6186*/
12178/*MT6186*/ *rfN = 0;
12179/*MT6186*/ *ifN = 0;
12180/*MT6186*/ }
12181/*MT6186*/
12182/*MT6186*/ /* =========================================================================== */
12183/*MT6186*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
12184/*MT6186*/ {
12185/*MT6186*/ return 0;
12186/*MT6186*/ }
12187/*MT6186*/ /* =========================================================================== */
12188/*MT6186*/
12189#endif
12190
12191#if IS_RF_MT6186M
12192/*MT6186M*/ //For DLIF mode
12193/*MT6186M*/ char L1D_RF_Cal_IF_Synth_State( void )
12194/*MT6186M*/ {
12195 #if IS_W_CANCELLATION_SUPPORT
12196/*MT6186M*/ if( L1D_CheckIfMetaMode() )
12197/*MT6186M*/ { return l1d_rf.if_state; }
12198/*MT6186M*/ else
12199/*MT6186M*/ { return 0; }
12200 #else
12201/*MT6186M*/ return 0;
12202 #endif
12203/*MT6186M*/ }
12204/*MT6186M*/ /* =========================================================================== */
12205/*MT6186M*/
12206/*MT6186M*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12207/*MT6186M*/ {
12208/*MT6186M*/ unsigned short CH_freq =0;
12209/*MT6186M*/ int64 FLO_scale_freq=0;
12210/*MT6186M*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
12211/*MT6186M*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12212/*MT6186M*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12213/*MT6186M*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12214/*MT6186M*/
12215/*MT6186M*/ /* Switch +- DLIF */
12216/*MT6186M*/ l1d_rf.obb_if_sign = -1;
12217/*MT6186M*/ }
12218/*MT6186M*/ /* =========================================================================== */
12219/*MT6186M*/
12220/*MT6186M*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12221/*MT6186M*/ {
12222/*MT6186M*/ unsigned short CH_freq =0;
12223/*MT6186M*/ int64 FLO_scale_freq=0;
12224/*MT6186M*/
12225/*MT6186M*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
12226/*MT6186M*/ #if IS_MIPI_SUPPORT
12227/*MT6186M*/ l1d_mipi.tx_arfcn = arfcn; //for L1D_RF_TxGainSetting
12228/*MT6186M*/ #endif
12229/*MT6186M*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
12230/*MT6186M*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12231/*MT6186M*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12232/*MT6186M*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12233/*MT6186M*/ }
12234/*MT6186M*/ /* =========================================================================== */
12235/*MT6186M*/
12236/*MT6186M*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
12237/*MT6186M*/ {
12238/*MT6186M*/ unsigned short freq=4450+225;
12239/*MT6186M*/ switch( rf_band )
12240/*MT6186M*/ {
12241/*MT6186M*/ case FrequencyBand850 :
12242/*MT6186M*/ {
12243/*MT6186M*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
12244/*MT6186M*/ break;
12245/*MT6186M*/ }
12246/*MT6186M*/ case FrequencyBand900 :
12247/*MT6186M*/ {
12248/*MT6186M*/ if( arfcn<=124 )
12249/*MT6186M*/ { freq=4450+arfcn+225; }
12250/*MT6186M*/ else
12251/*MT6186M*/ { freq=4450+(arfcn-1024)+225; }
12252/*MT6186M*/ break;
12253/*MT6186M*/ }
12254/*MT6186M*/ case FrequencyBand1800 :
12255/*MT6186M*/ {
12256/*MT6186M*/ freq=8551+(arfcn-512)+475;
12257/*MT6186M*/ break;
12258/*MT6186M*/ }
12259/*MT6186M*/ case FrequencyBand1900 :
12260/*MT6186M*/ {
12261/*MT6186M*/ freq=9251+(arfcn-512)+400;
12262/*MT6186M*/ break;
12263/*MT6186M*/ }
12264/*MT6186M*/ default :
12265/*MT6186M*/ {
12266/*MT6186M*/ break;
12267/*MT6186M*/ }
12268/*MT6186M*/ }
12269/*MT6186M*/
12270/*MT6186M*/ return freq;
12271/*MT6186M*/ }
12272/*MT6186M*/ /* =========================================================================== */
12273/*MT6186M*/
12274/*MT6186M*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
12275/*MT6186M*/ {
12276/*MT6186M*/ unsigned short freq=4450;
12277/*MT6186M*/ switch( rf_band )
12278/*MT6186M*/ {
12279/*MT6186M*/ case FrequencyBand850 :
12280/*MT6186M*/ {
12281/*MT6186M*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
12282/*MT6186M*/ break;
12283/*MT6186M*/ }
12284/*MT6186M*/ case FrequencyBand900 :
12285/*MT6186M*/ {
12286/*MT6186M*/ if( arfcn<=124 )
12287/*MT6186M*/ { freq=4450+arfcn; }
12288/*MT6186M*/ else
12289/*MT6186M*/ { freq=4450+(arfcn-1024); }
12290/*MT6186M*/ break;
12291/*MT6186M*/ }
12292/*MT6186M*/ case FrequencyBand1800 :
12293/*MT6186M*/ {
12294/*MT6186M*/ freq=8551+(arfcn-512);
12295/*MT6186M*/ break;
12296/*MT6186M*/ }
12297/*MT6186M*/ case FrequencyBand1900 :
12298/*MT6186M*/ {
12299/*MT6186M*/ freq=9251+(arfcn-512);
12300/*MT6186M*/ break;
12301/*MT6186M*/ }
12302/*MT6186M*/ default :
12303/*MT6186M*/ {
12304/*MT6186M*/ break;
12305/*MT6186M*/ }
12306/*MT6186M*/ }
12307/*MT6186M*/
12308/*MT6186M*/ return freq;
12309/*MT6186M*/ }
12310/*MT6186M*/ /* =========================================================================== */
12311/*MT6186M*/
12312/*MT6186M*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
12313/*MT6186M*/ {
12314/*MT6186M*/ return 0;
12315/*MT6186M*/ }
12316/*MT6186M*/ /* =========================================================================== */
12317/*MT6186M*/
12318/*MT6186M*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
12319/*MT6186M*/ {
12320/*MT6186M*/
12321/*MT6186M*/ *rfN = 0;
12322/*MT6186M*/ *ifN = 0;
12323/*MT6186M*/ }
12324/*MT6186M*/
12325/*MT6186M*/ /* =========================================================================== */
12326/*MT6186M*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
12327/*MT6186M*/ {
12328/*MT6186M*/ return 0;
12329/*MT6186M*/ }
12330/*MT6186M*/ /* =========================================================================== */
12331/*MT6186M*/
12332#endif
12333
12334#if IS_RF_MT6190T
12335/*MT6190T*/ //For DLIF mode
12336/*MT6190T*/ char L1D_RF_Cal_IF_Synth_State( void )
12337/*MT6190T*/ {
12338/*MT6190T*/ #if IS_W_CANCELLATION_SUPPORT
12339/*MT6190T*/ if( L1D_CheckIfMetaMode() )
12340/*MT6190T*/ { return l1d_rf.if_state; }
12341/*MT6190T*/ else
12342/*MT6190T*/ { return 0; }
12343/*MT6190T*/ #else
12344/*MT6190T*/ return 0;
12345/*MT6190T*/ #endif
12346/*MT6190T*/ }
12347/*MT6190T*/ /* =========================================================================== */
12348/*MT6190T*/
12349/*MT6190T*/ void L1D_RF_GetRxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12350/*MT6190T*/ {
12351/*MT6190T*/ unsigned short CH_freq =0;
12352/*MT6190T*/ int64 FLO_scale_freq=0;
12353/*MT6190T*/ CH_freq = L1D_RF_ARFCN_CH_to_RxFreq( rf_band, arfcn );
12354/*MT6190T*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12355/*MT6190T*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12356/*MT6190T*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12357/*MT6190T*/
12358/*MT6190T*/ /* Switch +- DLIF */
12359/*MT6190T*/ l1d_rf.obb_if_sign = -1;
12360/*MT6190T*/ }
12361/*MT6190T*/ /* =========================================================================== */
12362/*MT6190T*/
12363/*MT6190T*/ void L1D_RF_GetTxPLLSetting( int rf_band, int arfcn, unsigned long *freq_hsb, unsigned long *freq_lsb )
12364/*MT6190T*/ {
12365/*MT6190T*/ unsigned short CH_freq =0;
12366/*MT6190T*/ int64 FLO_scale_freq=0;
12367/*MT6190T*/
12368/*MT6190T*/ l1d_rf2.arfcn = arfcn; //for L1D_RF_TxGainSetting
12369/*MT6190T*/ CH_freq = L1D_RF_ARFCN_CH_to_TxFreq( rf_band, arfcn );
12370/*MT6190T*/ FLO_scale_freq = (((int64)CH_freq)*SET_FLO_UNIT)<<L1D_FLO_SCALE_NUM; // FLO_scale_freq = FLO * (5*200000)* (2^11) (Hz), (2^11) is scale
12371/*MT6190T*/ *freq_hsb = (unsigned long)GET_FREQ_HSB(FLO_scale_freq);
12372/*MT6190T*/ *freq_lsb = (unsigned long)GET_FREQ_LSB(FLO_scale_freq);
12373/*MT6190T*/ }
12374/*MT6190T*/ /* =========================================================================== */
12375/*MT6190T*/
12376/*MT6190T*/ unsigned short L1D_RF_ARFCN_CH_to_RxFreq( int rf_band, int arfcn )
12377/*MT6190T*/ {
12378/*MT6190T*/ unsigned short freq=4450+225;
12379/*MT6190T*/ switch( rf_band )
12380/*MT6190T*/ {
12381/*MT6190T*/ case FrequencyBand850 :
12382/*MT6190T*/ {
12383/*MT6190T*/ freq=4121+(arfcn-128)+225; //freq = f_ch*SYNTH_SCALE
12384/*MT6190T*/ break;
12385/*MT6190T*/ }
12386/*MT6190T*/ case FrequencyBand900 :
12387/*MT6190T*/ {
12388/*MT6190T*/ if( arfcn<=124 )
12389/*MT6190T*/ { freq=4450+arfcn+225; }
12390/*MT6190T*/ else
12391/*MT6190T*/ { freq=4450+(arfcn-1024)+225; }
12392/*MT6190T*/ break;
12393/*MT6190T*/ }
12394/*MT6190T*/ case FrequencyBand1800 :
12395/*MT6190T*/ {
12396/*MT6190T*/ freq=8551+(arfcn-512)+475;
12397/*MT6190T*/ break;
12398/*MT6190T*/ }
12399/*MT6190T*/ case FrequencyBand1900 :
12400/*MT6190T*/ {
12401/*MT6190T*/ freq=9251+(arfcn-512)+400;
12402/*MT6190T*/ break;
12403/*MT6190T*/ }
12404/*MT6190T*/ default :
12405/*MT6190T*/ {
12406/*MT6190T*/ break;
12407/*MT6190T*/ }
12408/*MT6190T*/ }
12409/*MT6190T*/
12410/*MT6190T*/ return freq;
12411/*MT6190T*/ }
12412/*MT6190T*/ /* =========================================================================== */
12413/*MT6190T*/
12414/*MT6190T*/ unsigned short L1D_RF_ARFCN_CH_to_TxFreq( int rf_band, int arfcn )
12415/*MT6190T*/ {
12416/*MT6190T*/ unsigned short freq=4450;
12417/*MT6190T*/ switch( rf_band )
12418/*MT6190T*/ {
12419/*MT6190T*/ case FrequencyBand850 :
12420/*MT6190T*/ {
12421/*MT6190T*/ freq=4121+(arfcn-128); //freq = f_ch*SYNTH_SCALE
12422/*MT6190T*/ break;
12423/*MT6190T*/ }
12424/*MT6190T*/ case FrequencyBand900 :
12425/*MT6190T*/ {
12426/*MT6190T*/ if( arfcn<=124 )
12427/*MT6190T*/ { freq=4450+arfcn; }
12428/*MT6190T*/ else
12429/*MT6190T*/ { freq=4450+(arfcn-1024); }
12430/*MT6190T*/ break;
12431/*MT6190T*/ }
12432/*MT6190T*/ case FrequencyBand1800 :
12433/*MT6190T*/ {
12434/*MT6190T*/ freq=8551+(arfcn-512);
12435/*MT6190T*/ break;
12436/*MT6190T*/ }
12437/*MT6190T*/ case FrequencyBand1900 :
12438/*MT6190T*/ {
12439/*MT6190T*/ freq=9251+(arfcn-512);
12440/*MT6190T*/ break;
12441/*MT6190T*/ }
12442/*MT6190T*/ default :
12443/*MT6190T*/ {
12444/*MT6190T*/ break;
12445/*MT6190T*/ }
12446/*MT6190T*/ }
12447/*MT6190T*/
12448/*MT6190T*/ return freq;
12449/*MT6190T*/ }
12450/*MT6190T*/ /* =========================================================================== */
12451/*MT6190T*/
12452/*MT6190T*/ unsigned short L1D_RF_GetTxDCOSCACodeTypeSetting(unsigned short Nint, unsigned long Nfrac)
12453/*MT6190T*/ {
12454/*MT6190T*/ return 0;
12455/*MT6190T*/ }
12456/*MT6190T*/ /* =========================================================================== */
12457/*MT6190T*/
12458/*MT6190T*/ void L1D_RF_GetTxKDCOCAL2ndSetting(int rf_band, int arfcn, long *rfN, long *ifN )
12459/*MT6190T*/ {
12460/*MT6190T*/
12461/*MT6190T*/ *rfN = 0;
12462/*MT6190T*/ *ifN = 0;
12463/*MT6190T*/ }
12464/*MT6190T*/
12465/*MT6190T*/ /* =========================================================================== */
12466/*MT6190T*/ unsigned short L1D_RF_GetTxDEMChunkSetting(int rf_band, unsigned short Nint)
12467/*MT6190T*/ {
12468/*MT6190T*/ return 0;
12469/*MT6190T*/ }
12470/*MT6190T*/ /* =========================================================================== */
12471/*MT6190T*/
12472#endif
12473
12474
12475
12476
12477