← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to drivers/staging/winbond/phy_calibration.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/staging/winbond/phy_calibration.c
24
24
 
25
25
#define AG_CONST        0.6072529350
26
26
#define FIXED(X)        ((s32)((X) * 32768.0))
27
 
#define DEG2RAD(X)      0.017453 * (X)
 
27
#define DEG2RAD(X)      (0.017453 * (X))
28
28
 
29
29
static const s32 Angles[] = {
30
30
        FIXED(DEG2RAD(45.0)),     FIXED(DEG2RAD(26.565)),   FIXED(DEG2RAD(14.0362)),
44
44
 
45
45
s32 _s13_to_s32(u32 data)
46
46
{
47
 
    u32     val;
48
 
 
49
 
    val = (data & 0x0FFF);
50
 
 
51
 
    if ((data & BIT(12)) != 0)
52
 
        val |= 0xFFFFF000;
53
 
 
54
 
    return ((s32) val);
 
47
        u32     val;
 
48
 
 
49
        val = (data & 0x0FFF);
 
50
 
 
51
        if ((data & BIT(12)) != 0)
 
52
                val |= 0xFFFFF000;
 
53
 
 
54
        return (s32) val;
55
55
}
56
56
 
57
57
u32 _s32_to_s13(s32 data)
58
58
{
59
 
    u32     val;
60
 
 
61
 
    if (data > 4095)
62
 
        data = 4095;
63
 
    else if (data < -4096)
64
 
        data = -4096;
65
 
 
66
 
    val = data & 0x1FFF;
67
 
 
68
 
    return val;
 
59
        u32     val;
 
60
 
 
61
        if (data > 4095)
 
62
                data = 4095;
 
63
        else if (data < -4096)
 
64
                data = -4096;
 
65
 
 
66
        val = data & 0x1FFF;
 
67
 
 
68
        return val;
69
69
}
70
70
 
71
71
/****************************************************************************/
72
72
s32 _s4_to_s32(u32 data)
73
73
{
74
 
    s32     val;
75
 
 
76
 
    val = (data & 0x0007);
77
 
 
78
 
    if ((data & BIT(3)) != 0)
79
 
        val |= 0xFFFFFFF8;
80
 
 
81
 
    return val;
 
74
        s32     val;
 
75
 
 
76
        val = (data & 0x0007);
 
77
 
 
78
        if ((data & BIT(3)) != 0)
 
79
                val |= 0xFFFFFFF8;
 
80
 
 
81
        return val;
82
82
}
83
83
 
84
84
u32 _s32_to_s4(s32 data)
85
85
{
86
 
    u32     val;
87
 
 
88
 
    if (data > 7)
89
 
        data = 7;
90
 
    else if (data < -8)
91
 
        data = -8;
92
 
 
93
 
    val = data & 0x000F;
94
 
 
95
 
    return val;
 
86
        u32     val;
 
87
 
 
88
        if (data > 7)
 
89
                data = 7;
 
90
        else if (data < -8)
 
91
                data = -8;
 
92
 
 
93
        val = data & 0x000F;
 
94
 
 
95
        return val;
96
96
}
97
97
 
98
98
/****************************************************************************/
99
99
s32 _s5_to_s32(u32 data)
100
100
{
101
 
    s32     val;
102
 
 
103
 
    val = (data & 0x000F);
104
 
 
105
 
    if ((data & BIT(4)) != 0)
106
 
        val |= 0xFFFFFFF0;
107
 
 
108
 
    return val;
 
101
        s32     val;
 
102
 
 
103
        val = (data & 0x000F);
 
104
 
 
105
        if ((data & BIT(4)) != 0)
 
106
                val |= 0xFFFFFFF0;
 
107
 
 
108
        return val;
109
109
}
110
110
 
111
111
u32 _s32_to_s5(s32 data)
112
112
{
113
 
    u32     val;
114
 
 
115
 
    if (data > 15)
116
 
        data = 15;
117
 
    else if (data < -16)
118
 
        data = -16;
119
 
 
120
 
    val = data & 0x001F;
121
 
 
122
 
    return val;
 
113
        u32     val;
 
114
 
 
115
        if (data > 15)
 
116
                data = 15;
 
117
        else if (data < -16)
 
118
                data = -16;
 
119
 
 
120
        val = data & 0x001F;
 
121
 
 
122
        return val;
123
123
}
124
124
 
125
125
/****************************************************************************/
126
126
s32 _s6_to_s32(u32 data)
127
127
{
128
 
    s32     val;
129
 
 
130
 
    val = (data & 0x001F);
131
 
 
132
 
    if ((data & BIT(5)) != 0)
133
 
        val |= 0xFFFFFFE0;
134
 
 
135
 
    return val;
 
128
        s32     val;
 
129
 
 
130
        val = (data & 0x001F);
 
131
 
 
132
        if ((data & BIT(5)) != 0)
 
133
                val |= 0xFFFFFFE0;
 
134
 
 
135
        return val;
136
136
}
137
137
 
138
138
u32 _s32_to_s6(s32 data)
139
139
{
140
 
    u32     val;
141
 
 
142
 
    if (data > 31)
143
 
        data = 31;
144
 
    else if (data < -32)
145
 
        data = -32;
146
 
 
147
 
    val = data & 0x003F;
148
 
 
149
 
    return val;
 
140
        u32     val;
 
141
 
 
142
        if (data > 31)
 
143
                data = 31;
 
144
        else if (data < -32)
 
145
                data = -32;
 
146
 
 
147
        val = data & 0x003F;
 
148
 
 
149
        return val;
150
150
}
151
151
 
152
152
/****************************************************************************/
153
153
s32 _s9_to_s32(u32 data)
154
154
{
155
 
    s32     val;
156
 
 
157
 
    val = data & 0x00FF;
158
 
 
159
 
    if ((data & BIT(8)) != 0)
160
 
        val |= 0xFFFFFF00;
161
 
 
162
 
    return val;
 
155
        s32     val;
 
156
 
 
157
        val = data & 0x00FF;
 
158
 
 
159
        if ((data & BIT(8)) != 0)
 
160
                val |= 0xFFFFFF00;
 
161
 
 
162
        return val;
163
163
}
164
164
 
165
165
u32 _s32_to_s9(s32 data)
166
166
{
167
 
    u32     val;
168
 
 
169
 
    if (data > 255)
170
 
        data = 255;
171
 
    else if (data < -256)
172
 
        data = -256;
173
 
 
174
 
    val = data & 0x01FF;
175
 
 
176
 
    return val;
 
167
        u32     val;
 
168
 
 
169
        if (data > 255)
 
170
                data = 255;
 
171
        else if (data < -256)
 
172
                data = -256;
 
173
 
 
174
        val = data & 0x01FF;
 
175
 
 
176
        return val;
177
177
}
178
178
 
179
179
/****************************************************************************/
180
180
s32 _floor(s32 n)
181
181
{
182
 
    if (n > 0)
183
 
        n += 5;
184
 
    else
185
 
        n -= 5;
 
182
        if (n > 0)
 
183
                n += 5;
 
184
        else
 
185
                n -= 5;
186
186
 
187
 
    return (n/10);
 
187
        return n/10;
188
188
}
189
189
 
190
190
/****************************************************************************/
195
195
 */
196
196
u32 _sqrt(u32 sqsum)
197
197
{
198
 
    u32     sq_rt;
199
 
 
200
 
    int     g0, g1, g2, g3, g4;
201
 
    int     seed;
202
 
    int     next;
203
 
    int     step;
204
 
 
205
 
    g4 =  sqsum / 100000000;
206
 
    g3 = (sqsum - g4*100000000) / 1000000;
207
 
    g2 = (sqsum - g4*100000000 - g3*1000000) / 10000;
208
 
    g1 = (sqsum - g4*100000000 - g3*1000000 - g2*10000) / 100;
209
 
    g0 = (sqsum - g4*100000000 - g3*1000000 - g2*10000 - g1*100);
210
 
 
211
 
    next = g4;
212
 
    step = 0;
213
 
    seed = 0;
214
 
    while (((seed+1)*(step+1)) <= next) {
215
 
        step++;
216
 
        seed++;
217
 
    }
218
 
 
219
 
    sq_rt = seed * 10000;
220
 
    next = (next-(seed*step))*100 + g3;
221
 
 
222
 
    step = 0;
223
 
    seed = 2 * seed * 10;
224
 
    while (((seed+1)*(step+1)) <= next) {
225
 
        step++;
226
 
        seed++;
227
 
    }
228
 
 
229
 
    sq_rt = sq_rt + step * 1000;
230
 
    next = (next - seed * step) * 100 + g2;
231
 
    seed = (seed + step) * 10;
232
 
    step = 0;
233
 
    while (((seed+1)*(step+1)) <= next) {
234
 
        step++;
235
 
        seed++;
236
 
    }
237
 
 
238
 
    sq_rt = sq_rt + step * 100;
239
 
    next = (next - seed * step) * 100 + g1;
240
 
    seed = (seed + step) * 10;
241
 
    step = 0;
242
 
 
243
 
    while (((seed+1)*(step+1)) <= next) {
244
 
        step++;
245
 
        seed++;
246
 
    }
247
 
 
248
 
    sq_rt = sq_rt + step * 10;
249
 
    next = (next - seed * step) * 100 + g0;
250
 
    seed = (seed + step) * 10;
251
 
    step = 0;
252
 
 
253
 
    while (((seed+1)*(step+1)) <= next) {
254
 
        step++;
255
 
        seed++;
256
 
    }
257
 
 
258
 
    sq_rt = sq_rt + step;
259
 
 
260
 
    return sq_rt;
 
198
        u32     sq_rt;
 
199
 
 
200
        int     g0, g1, g2, g3, g4;
 
201
        int     seed;
 
202
        int     next;
 
203
        int     step;
 
204
 
 
205
        g4 =  sqsum / 100000000;
 
206
        g3 = (sqsum - g4*100000000) / 1000000;
 
207
        g2 = (sqsum - g4*100000000 - g3*1000000) / 10000;
 
208
        g1 = (sqsum - g4*100000000 - g3*1000000 - g2*10000) / 100;
 
209
        g0 = (sqsum - g4*100000000 - g3*1000000 - g2*10000 - g1*100);
 
210
 
 
211
        next = g4;
 
212
        step = 0;
 
213
        seed = 0;
 
214
        while (((seed+1)*(step+1)) <= next) {
 
215
                step++;
 
216
                seed++;
 
217
        }
 
218
 
 
219
        sq_rt = seed * 10000;
 
220
        next = (next-(seed*step))*100 + g3;
 
221
 
 
222
        step = 0;
 
223
        seed = 2 * seed * 10;
 
224
        while (((seed+1)*(step+1)) <= next) {
 
225
                step++;
 
226
                seed++;
 
227
        }
 
228
 
 
229
        sq_rt = sq_rt + step * 1000;
 
230
        next = (next - seed * step) * 100 + g2;
 
231
        seed = (seed + step) * 10;
 
232
        step = 0;
 
233
        while (((seed+1)*(step+1)) <= next) {
 
234
                step++;
 
235
                seed++;
 
236
        }
 
237
 
 
238
        sq_rt = sq_rt + step * 100;
 
239
        next = (next - seed * step) * 100 + g1;
 
240
        seed = (seed + step) * 10;
 
241
        step = 0;
 
242
 
 
243
        while (((seed+1)*(step+1)) <= next) {
 
244
                step++;
 
245
                seed++;
 
246
        }
 
247
 
 
248
        sq_rt = sq_rt + step * 10;
 
249
        next = (next - seed * step) * 100 + g0;
 
250
        seed = (seed + step) * 10;
 
251
        step = 0;
 
252
 
 
253
        while (((seed+1)*(step+1)) <= next) {
 
254
                step++;
 
255
                seed++;
 
256
        }
 
257
 
 
258
        sq_rt = sq_rt + step;
 
259
 
 
260
        return sq_rt;
261
261
}
262
262
 
263
263
/****************************************************************************/
264
264
void _sin_cos(s32 angle, s32 *sin, s32 *cos)
265
265
{
266
 
    s32 X, Y, TargetAngle, CurrAngle;
267
 
    unsigned    Step;
268
 
 
269
 
    X = FIXED(AG_CONST);      /* AG_CONST * cos(0) */
270
 
    Y = 0;                    /* AG_CONST * sin(0) */
271
 
    TargetAngle = abs(angle);
272
 
    CurrAngle = 0;
273
 
 
274
 
    for (Step = 0; Step < 12; Step++) {
275
 
        s32 NewX;
276
 
 
277
 
        if (TargetAngle > CurrAngle) {
278
 
            NewX = X - (Y >> Step);
279
 
            Y = (X >> Step) + Y;
280
 
            X = NewX;
281
 
            CurrAngle += Angles[Step];
282
 
        } else {
283
 
            NewX = X + (Y >> Step);
284
 
            Y = -(X >> Step) + Y;
285
 
            X = NewX;
286
 
            CurrAngle -= Angles[Step];
287
 
        }
288
 
    }
289
 
 
290
 
    if (angle > 0) {
291
 
        *cos = X;
292
 
        *sin = Y;
293
 
    } else {
294
 
        *cos = X;
295
 
        *sin = -Y;
296
 
    }
 
266
        s32 X, Y, TargetAngle, CurrAngle;
 
267
        unsigned    Step;
 
268
 
 
269
        X = FIXED(AG_CONST);      /* AG_CONST * cos(0) */
 
270
        Y = 0;                    /* AG_CONST * sin(0) */
 
271
        TargetAngle = abs(angle);
 
272
        CurrAngle = 0;
 
273
 
 
274
        for (Step = 0; Step < 12; Step++) {
 
275
                s32 NewX;
 
276
 
 
277
                if (TargetAngle > CurrAngle) {
 
278
                        NewX = X - (Y >> Step);
 
279
                        Y = (X >> Step) + Y;
 
280
                        X = NewX;
 
281
                        CurrAngle += Angles[Step];
 
282
                } else {
 
283
                        NewX = X + (Y >> Step);
 
284
                        Y = -(X >> Step) + Y;
 
285
                        X = NewX;
 
286
                        CurrAngle -= Angles[Step];
 
287
                }
 
288
        }
 
289
 
 
290
        if (angle > 0) {
 
291
                *cos = X;
 
292
                *sin = Y;
 
293
        } else {
 
294
                *cos = X;
 
295
                *sin = -Y;
 
296
        }
297
297
}
298
298
 
299
299
static unsigned char hal_get_dxx_reg(struct hw_data *pHwData, u16 number, u32 * pValue)
338
338
/**********************************************/
339
339
void _rxadc_dc_offset_cancellation_winbond(struct hw_data *phw_data, u32 frequency)
340
340
{
341
 
    u32     reg_agc_ctrl3;
342
 
    u32     reg_a_acq_ctrl;
343
 
    u32     reg_b_acq_ctrl;
344
 
    u32     val;
345
 
 
346
 
    PHY_DEBUG(("[CAL] -> [1]_rxadc_dc_offset_cancellation()\n"));
347
 
    phy_init_rf(phw_data);
348
 
 
349
 
    /* set calibration channel */
350
 
    if ((RF_WB_242 == phw_data->phy_type) ||
 
341
        u32     reg_agc_ctrl3;
 
342
        u32     reg_a_acq_ctrl;
 
343
        u32     reg_b_acq_ctrl;
 
344
        u32     val;
 
345
 
 
346
        PHY_DEBUG(("[CAL] -> [1]_rxadc_dc_offset_cancellation()\n"));
 
347
        phy_init_rf(phw_data);
 
348
 
 
349
        /* set calibration channel */
 
350
        if ((RF_WB_242 == phw_data->phy_type) ||
351
351
                (RF_WB_242_1 == phw_data->phy_type)) /* 20060619.5 Add */{
352
 
        if ((frequency >= 2412) && (frequency <= 2484)) {
353
 
            /* w89rf242 change frequency to 2390Mhz */
354
 
            PHY_DEBUG(("[CAL] W89RF242/11G/Channel=2390Mhz\n"));
 
352
                if ((frequency >= 2412) && (frequency <= 2484)) {
 
353
                        /* w89rf242 change frequency to 2390Mhz */
 
354
                        PHY_DEBUG(("[CAL] W89RF242/11G/Channel=2390Mhz\n"));
355
355
                        phy_set_rf_data(phw_data, 3, (3<<24)|0x025586);
356
356
 
357
 
        }
358
 
    } else {
 
357
                }
 
358
        } else {
359
359
 
360
360
        }
361
361
 
455
455
        phy_set_rf_data(phw_data, 11, (11<<24)|0x1901D6);
456
456
        /* 0x05 0x24C60A  ; 09318  ; Calibration (6c). setting TX-VGA gain: TXGCH=2 & GPK=110 --> to be optimized */
457
457
        phy_set_rf_data(phw_data, 5, (5<<24)|0x24C48A);
458
 
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
 
458
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
459
459
        phy_set_rf_data(phw_data, 6, (6<<24)|0x06890C);
460
460
        /* 0x00 0xFDF1C0  ; 3F7C7  ; Calibration (6e). turn on IQ imbalance/Test mode */
461
461
        phy_set_rf_data(phw_data, 0, (0<<24)|0xFDF1C0);
542
542
        }
543
543
 
544
544
        if (loop >= 19)
545
 
           fix_cancel_dc_i = 0;
 
545
                fix_cancel_dc_i = 0;
546
546
 
547
547
        reg_dc_cancel &= ~(0x03FF);
548
548
        reg_dc_cancel |= (_s32_to_s5(fix_cancel_dc_i) << CANCEL_DC_I_SHIFT);
577
577
        phy_set_rf_data(phw_data, 11, (11<<24)|0x1901D6);
578
578
        /* 0x05 0x24C60A  ; 09318  ; Calibration (6c). setting TX-VGA gain: TXGCH=2 & GPK=110 --> to be optimized */
579
579
        phy_set_rf_data(phw_data, 5, (5<<24)|0x24C48A);
580
 
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
 
580
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
581
581
        phy_set_rf_data(phw_data, 6, (6<<24)|0x06890C);
582
582
        /* 0x00 0xFDF1C0  ; 3F7C7  ; Calibration (6e). turn on IQ imbalance/Test mode */
583
583
        phy_set_rf_data(phw_data, 0, (0<<24)|0xFDF1C0);
657
657
        }
658
658
 
659
659
        if (loop >= 19)
660
 
           fix_cancel_dc_q = 0;
 
660
                fix_cancel_dc_q = 0;
661
661
 
662
662
        reg_dc_cancel &= ~(0x001F);
663
663
        reg_dc_cancel |= (_s32_to_s5(fix_cancel_dc_q) << CANCEL_DC_Q_SHIFT);
974
974
        phy_set_rf_data(phw_data, 11, (11<<24)|0x19BDD6); /* 20060612.1.a 0x1905D6); */
975
975
        /* 0x05 0x24C60A  ; 09318  ; Calibration (6c). setting TX-VGA gain: TXGCH=2 & GPK=110 --> to be optimized */
976
976
        phy_set_rf_data(phw_data, 5, (5<<24)|0x24C60A); /* 0x24C60A (high temperature) */
977
 
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
 
977
        /* 0x06 0x06880C  ; 01A20  ; Calibration (6d). RXGCH=00; RXGCL=100 000 (RXVGA=32) --> to be optimized */
978
978
        phy_set_rf_data(phw_data, 6, (6<<24)|0x34880C); /* 20060612.1.a 0x06890C); */
979
979
        /* 0x00 0xFDF1C0  ; 3F7C7  ; Calibration (6e). turn on IQ imbalance/Test mode */
980
980
        phy_set_rf_data(phw_data, 0, (0<<24)|0xFDF1C0);
1154
1154
                capture_time = 0;
1155
1155
 
1156
1156
                for (capture_time = 0; capture_time < 10; capture_time++) {
1157
 
                /* i. Set "calib_start" to 0x0 */
1158
 
                reg_mode_ctrl &= ~MASK_CALIB_START;
1159
 
                if (!hw_set_dxx_reg(phw_data, REG_MODE_CTRL, reg_mode_ctrl))/*20060718.1 modify */
1160
 
                        return 0;
1161
 
                PHY_DEBUG(("[CAL]    MODE_CTRL (write) = 0x%08X\n", reg_mode_ctrl));
1162
 
 
1163
 
                reg_mode_ctrl &= ~MASK_IQCAL_MODE;
1164
 
                reg_mode_ctrl |= (MASK_CALIB_START|0x1);
1165
 
                hw_set_dxx_reg(phw_data, REG_MODE_CTRL, reg_mode_ctrl);
1166
 
                PHY_DEBUG(("[CAL]    MODE_CTRL (write) = 0x%08X\n", reg_mode_ctrl));
1167
 
 
1168
 
                /* c. */
1169
 
                hw_get_dxx_reg(phw_data, REG_CALIB_READ1, &val);
1170
 
                PHY_DEBUG(("[CAL]    CALIB_READ1 = 0x%08X\n", val));
1171
 
 
1172
 
                iqcal_tone_i = _s13_to_s32(val & 0x00001FFF);
1173
 
                iqcal_tone_q = _s13_to_s32((val & 0x03FFE000) >> 13);
1174
 
                PHY_DEBUG(("[CAL]    ** iqcal_tone_i = %d, iqcal_tone_q = %d\n",
1175
 
                                   iqcal_tone_i, iqcal_tone_q));
1176
 
 
1177
 
                hw_get_dxx_reg(phw_data, REG_CALIB_READ2, &val);
1178
 
                PHY_DEBUG(("[CAL]    CALIB_READ2 = 0x%08X\n", val));
1179
 
 
1180
 
                iqcal_image_i = _s13_to_s32(val & 0x00001FFF);
1181
 
                iqcal_image_q = _s13_to_s32((val & 0x03FFE000) >> 13);
1182
 
                PHY_DEBUG(("[CAL]    ** iqcal_image_i = %d, iqcal_image_q = %d\n",
1183
 
                                   iqcal_image_i, iqcal_image_q));
 
1157
                        /* i. Set "calib_start" to 0x0 */
 
1158
                        reg_mode_ctrl &= ~MASK_CALIB_START;
 
1159
                        if (!hw_set_dxx_reg(phw_data, REG_MODE_CTRL, reg_mode_ctrl))/*20060718.1 modify */
 
1160
                                return 0;
 
1161
                        PHY_DEBUG(("[CAL]    MODE_CTRL (write) = 0x%08X\n", reg_mode_ctrl));
 
1162
 
 
1163
                        reg_mode_ctrl &= ~MASK_IQCAL_MODE;
 
1164
                        reg_mode_ctrl |= (MASK_CALIB_START|0x1);
 
1165
                        hw_set_dxx_reg(phw_data, REG_MODE_CTRL, reg_mode_ctrl);
 
1166
                        PHY_DEBUG(("[CAL]    MODE_CTRL (write) = 0x%08X\n", reg_mode_ctrl));
 
1167
 
 
1168
                        /* c. */
 
1169
                        hw_get_dxx_reg(phw_data, REG_CALIB_READ1, &val);
 
1170
                        PHY_DEBUG(("[CAL]    CALIB_READ1 = 0x%08X\n", val));
 
1171
 
 
1172
                        iqcal_tone_i = _s13_to_s32(val & 0x00001FFF);
 
1173
                        iqcal_tone_q = _s13_to_s32((val & 0x03FFE000) >> 13);
 
1174
                        PHY_DEBUG(("[CAL]    ** iqcal_tone_i = %d, iqcal_tone_q = %d\n",
 
1175
                                iqcal_tone_i, iqcal_tone_q));
 
1176
 
 
1177
                        hw_get_dxx_reg(phw_data, REG_CALIB_READ2, &val);
 
1178
                        PHY_DEBUG(("[CAL]    CALIB_READ2 = 0x%08X\n", val));
 
1179
 
 
1180
                        iqcal_image_i = _s13_to_s32(val & 0x00001FFF);
 
1181
                        iqcal_image_q = _s13_to_s32((val & 0x03FFE000) >> 13);
 
1182
                        PHY_DEBUG(("[CAL]    ** iqcal_image_i = %d, iqcal_image_q = %d\n",
 
1183
                                iqcal_image_i, iqcal_image_q));
1184
1184
                        if (capture_time == 0)
1185
1185
                                continue;
1186
1186
                        else {
1358
1358
                        hw_set_dxx_reg(phw_data, 0x54, val);
1359
1359
 
1360
1360
                        if (loop == 3)
1361
 
                        return 0;
 
1361
                                return 0;
1362
1362
                }
1363
1363
                PHY_DEBUG(("[CAL]    ** CALIB_DATA = 0x%08X\n", val));
1364
1364
 
1476
1476
/******************/
1477
1477
void phy_set_rf_data(struct hw_data *pHwData, u32 index, u32 value)
1478
1478
{
1479
 
   u32 ltmp = 0;
1480
 
 
1481
 
    switch (pHwData->phy_type) {
1482
 
    case RF_MAXIM_2825:
1483
 
    case RF_MAXIM_V1: /* 11g Winbond 2nd BB(with Phy board (v1) + Maxim 331) */
1484
 
            ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
1485
 
            break;
1486
 
 
1487
 
    case RF_MAXIM_2827:
1488
 
            ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
1489
 
            break;
1490
 
 
1491
 
    case RF_MAXIM_2828:
1492
 
            ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
1493
 
            break;
1494
 
 
1495
 
    case RF_MAXIM_2829:
1496
 
            ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
1497
 
            break;
1498
 
 
1499
 
    case RF_AIROHA_2230:
1500
 
    case RF_AIROHA_2230S: /* 20060420 Add this */
1501
 
            ltmp = (1 << 31) | (0 << 30) | (20 << 24) | BitReverse(value, 20);
1502
 
            break;
1503
 
 
1504
 
    case RF_AIROHA_7230:
1505
 
            ltmp = (1 << 31) | (0 << 30) | (24 << 24) | (value&0xffffff);
1506
 
            break;
1507
 
 
1508
 
    case RF_WB_242:
1509
 
    case RF_WB_242_1:/* 20060619.5 Add */
1510
 
            ltmp = (1 << 31) | (0 << 30) | (24 << 24) | BitReverse(value, 24);
1511
 
            break;
1512
 
    }
 
1479
        u32 ltmp = 0;
 
1480
 
 
1481
        switch (pHwData->phy_type) {
 
1482
        case RF_MAXIM_2825:
 
1483
        case RF_MAXIM_V1: /* 11g Winbond 2nd BB(with Phy board (v1) + Maxim 331) */
 
1484
                ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
 
1485
                break;
 
1486
 
 
1487
        case RF_MAXIM_2827:
 
1488
                ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
 
1489
                break;
 
1490
 
 
1491
        case RF_MAXIM_2828:
 
1492
                ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
 
1493
                break;
 
1494
 
 
1495
        case RF_MAXIM_2829:
 
1496
                ltmp = (1 << 31) | (0 << 30) | (18 << 24) | BitReverse(value, 18);
 
1497
                break;
 
1498
 
 
1499
        case RF_AIROHA_2230:
 
1500
        case RF_AIROHA_2230S: /* 20060420 Add this */
 
1501
                ltmp = (1 << 31) | (0 << 30) | (20 << 24) | BitReverse(value, 20);
 
1502
                break;
 
1503
 
 
1504
        case RF_AIROHA_7230:
 
1505
                ltmp = (1 << 31) | (0 << 30) | (24 << 24) | (value&0xffffff);
 
1506
                break;
 
1507
 
 
1508
        case RF_WB_242:
 
1509
        case RF_WB_242_1:/* 20060619.5 Add */
 
1510
                ltmp = (1 << 31) | (0 << 30) | (24 << 24) | BitReverse(value, 24);
 
1511
                break;
 
1512
        }
1513
1513
 
1514
1514
        Wb35Reg_WriteSync(pHwData, 0x0864, ltmp);
1515
1515
}