2 * Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
22 * Purpose: rf function code
29 * vnt_rf_write_embedded - Embedded write RF register via MAC
32 * RF_VT3226: RobertYu:20051111, VT3226C0 and before
33 * RF_VT3226D0: RobertYu:20051228
34 * RF_VT3342A0: RobertYu:20060609
43 #define CB_AL2230_INIT_SEQ 15
44 #define AL2230_PWR_IDX_LEN 64
46 #define CB_AL7230_INIT_SEQ 16
47 #define AL7230_PWR_IDX_LEN 64
49 #define CB_VT3226_INIT_SEQ 11
50 #define VT3226_PWR_IDX_LEN 64
52 #define CB_VT3342_INIT_SEQ 13
53 #define VT3342_PWR_IDX_LEN 64
55 static u8 al2230_init_table[CB_AL2230_INIT_SEQ][3] = {
73 static u8 al2230_channel_table0[CB_MAX_CHANNEL_24G][3] = {
90 static u8 al2230_channel_table1[CB_MAX_CHANNEL_24G][3] = {
107 static u8 al7230_init_table[CB_AL7230_INIT_SEQ][3] = {
126 static u8 al7230_init_table_amode[CB_AL7230_INIT_SEQ][3] = {
145 static u8 al7230_channel_table0[CB_MAX_CHANNEL][3] = {
160 {0x0f, 0xf5, 0x20}, /* channel 15 Tf = 4915MHz */
204 static u8 al7230_channel_table1[CB_MAX_CHANNEL][3] = {
219 {0x1d, 0x55, 0x51}, /* channel = 15, Tf = 4915MHz */
263 static u8 al7230_channel_table2[CB_MAX_CHANNEL][3] = {
278 {0x7f, 0xd7, 0x84}, /* channel = 15 Tf = 4915MHz */
322 static u8 vt3226_init_table[CB_VT3226_INIT_SEQ][3] = {
336 static u8 vt3226d0_init_table[CB_VT3226_INIT_SEQ][3] = {
350 static u8 vt3226_channel_table0[CB_MAX_CHANNEL_24G][3] = {
367 static u8 vt3226_channel_table1[CB_MAX_CHANNEL_24G][3] = {
384 static const u32 vt3226d0_lo_current_table[CB_MAX_CHANNEL_24G] = {
401 static u8 vt3342a0_init_table[CB_VT3342_INIT_SEQ][3] = { /* 11b/g mode */
417 static u8 vt3342_channel_table0[CB_MAX_CHANNEL][3] = {
432 {0x01, 0x15, 0x13}, /* channel = 15 Tf = 4915MHz */
476 static u8 vt3342_channel_table1[CB_MAX_CHANNEL][3] = {
491 {0x00, 0x44, 0x44}, /* channel = 15 Tf = 4915MHz */
536 static const u32 al2230_power_table[AL2230_PWR_IDX_LEN] = {
604 * Description: Write to IF/RF, by embedded programming
606 int vnt_rf_write_embedded(struct vnt_private *priv, u32 data)
610 data |= (VNT_RF_REG_LEN << 3) | IFREGCTL_REGW;
612 reg_data[0] = (u8)data;
613 reg_data[1] = (u8)(data >> 8);
614 reg_data[2] = (u8)(data >> 16);
615 reg_data[3] = (u8)(data >> 24);
617 vnt_control_out(priv, MESSAGE_TYPE_WRITE_IFRF,
618 0, 0, ARRAY_SIZE(reg_data), reg_data);
623 /* Set Tx power by rate and channel number */
624 int vnt_rf_setpower(struct vnt_private *priv, u32 rate, u32 channel)
626 u8 power = priv->cck_pwr;
638 if (channel < sizeof(priv->cck_pwr_tbl))
639 power = priv->cck_pwr_tbl[channel];
649 if (channel > CB_MAX_CHANNEL_24G)
650 power = priv->ofdm_a_pwr_tbl[channel-15];
652 power = priv->ofdm_pwr_tbl[channel-1];
656 return vnt_rf_set_txpower(priv, power, rate);
659 static u8 vnt_rf_addpower(struct vnt_private *priv)
661 s32 rssi = -priv->current_rssi;
666 if (priv->rf_type == RF_VT3226D0) {
685 /* Set Tx power by power level and rate */
686 int vnt_rf_set_txpower(struct vnt_private *priv, u8 power, u32 rate)
688 u32 power_setting = 0;
691 power += vnt_rf_addpower(priv);
692 if (power > VNT_RF_MAX_POWER)
693 power = VNT_RF_MAX_POWER;
695 if (priv->power == power)
700 switch (priv->rf_type) {
702 if (power >= AL2230_PWR_IDX_LEN)
705 ret &= vnt_rf_write_embedded(priv, al2230_power_table[power]);
707 if (rate <= RATE_11M)
708 ret &= vnt_rf_write_embedded(priv, 0x0001b400);
710 ret &= vnt_rf_write_embedded(priv, 0x0005a400);
713 if (power >= AL2230_PWR_IDX_LEN)
716 ret &= vnt_rf_write_embedded(priv, al2230_power_table[power]);
718 if (rate <= RATE_11M) {
719 ret &= vnt_rf_write_embedded(priv, 0x040c1400);
720 ret &= vnt_rf_write_embedded(priv, 0x00299b00);
722 ret &= vnt_rf_write_embedded(priv, 0x0005a400);
723 ret &= vnt_rf_write_embedded(priv, 0x00099b00);
728 if (rate <= RATE_11M)
729 ret &= vnt_rf_write_embedded(priv, 0x111bb900);
731 ret &= vnt_rf_write_embedded(priv, 0x221bb900);
733 if (power >= AL7230_PWR_IDX_LEN)
737 * 0x080F1B00 for 3 wire control TxGain(D10)
738 * and 0x31 as TX Gain value
740 power_setting = 0x080c0b00 | (power << 12);
742 ret &= vnt_rf_write_embedded(priv, power_setting);
747 if (power >= VT3226_PWR_IDX_LEN)
749 power_setting = ((0x3f - power) << 20) | (0x17 << 8);
751 ret &= vnt_rf_write_embedded(priv, power_setting);
755 if (power >= VT3226_PWR_IDX_LEN)
758 if (rate <= RATE_11M) {
759 u16 hw_value = priv->hw->conf.chandef.chan->hw_value;
761 power_setting = ((0x3f - power) << 20) | (0xe07 << 8);
763 ret &= vnt_rf_write_embedded(priv, power_setting);
764 ret &= vnt_rf_write_embedded(priv, 0x03c6a200);
766 dev_dbg(&priv->usb->dev,
767 "%s 11b channel [%d]\n", __func__, hw_value);
771 if (hw_value < ARRAY_SIZE(vt3226d0_lo_current_table))
772 ret &= vnt_rf_write_embedded(priv,
773 vt3226d0_lo_current_table[hw_value]);
775 ret &= vnt_rf_write_embedded(priv, 0x015C0800);
777 dev_dbg(&priv->usb->dev,
778 "@@@@ vnt_rf_set_txpower> 11G mode\n");
780 power_setting = ((0x3f - power) << 20) | (0x7 << 8);
782 ret &= vnt_rf_write_embedded(priv, power_setting);
783 ret &= vnt_rf_write_embedded(priv, 0x00C6A200);
784 ret &= vnt_rf_write_embedded(priv, 0x016BC600);
785 ret &= vnt_rf_write_embedded(priv, 0x00900800);
790 if (power >= VT3342_PWR_IDX_LEN)
793 power_setting = ((0x3f - power) << 20) | (0x27 << 8);
795 ret &= vnt_rf_write_embedded(priv, power_setting);
804 /* Convert rssi to dbm */
805 void vnt_rf_rssi_to_dbm(struct vnt_private *priv, u8 rssi, long *dbm)
807 u8 idx = (((rssi & 0xc0) >> 6) & 0x03);
808 long b = (rssi & 0x3f);
810 u8 airoharf[4] = {0, 18, 0, 40};
812 switch (priv->rf_type) {
825 *dbm = -1 * (a + b * 2);
828 void vnt_rf_table_download(struct vnt_private *priv)
830 u16 length1 = 0, length2 = 0, length3 = 0;
831 u8 *addr1 = NULL, *addr2 = NULL, *addr3 = NULL;
835 switch (priv->rf_type) {
838 length1 = CB_AL2230_INIT_SEQ * 3;
839 length2 = CB_MAX_CHANNEL_24G * 3;
840 length3 = CB_MAX_CHANNEL_24G * 3;
841 addr1 = &al2230_init_table[0][0];
842 addr2 = &al2230_channel_table0[0][0];
843 addr3 = &al2230_channel_table1[0][0];
846 length1 = CB_AL7230_INIT_SEQ * 3;
847 length2 = CB_MAX_CHANNEL * 3;
848 length3 = CB_MAX_CHANNEL * 3;
849 addr1 = &al7230_init_table[0][0];
850 addr2 = &al7230_channel_table0[0][0];
851 addr3 = &al7230_channel_table1[0][0];
854 length1 = CB_VT3226_INIT_SEQ * 3;
855 length2 = CB_MAX_CHANNEL_24G * 3;
856 length3 = CB_MAX_CHANNEL_24G * 3;
857 addr1 = &vt3226_init_table[0][0];
858 addr2 = &vt3226_channel_table0[0][0];
859 addr3 = &vt3226_channel_table1[0][0];
862 length1 = CB_VT3226_INIT_SEQ * 3;
863 length2 = CB_MAX_CHANNEL_24G * 3;
864 length3 = CB_MAX_CHANNEL_24G * 3;
865 addr1 = &vt3226d0_init_table[0][0];
866 addr2 = &vt3226_channel_table0[0][0];
867 addr3 = &vt3226_channel_table1[0][0];
870 length1 = CB_VT3342_INIT_SEQ * 3;
871 length2 = CB_MAX_CHANNEL * 3;
872 length3 = CB_MAX_CHANNEL * 3;
873 addr1 = &vt3342a0_init_table[0][0];
874 addr2 = &vt3342_channel_table0[0][0];
875 addr3 = &vt3342_channel_table1[0][0];
880 memcpy(array, addr1, length1);
882 vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,
883 MESSAGE_REQUEST_RF_INIT, length1, array);
885 /* Channel Table 0 */
887 while (length2 > 0) {
893 memcpy(array, addr2, length);
895 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
896 value, MESSAGE_REQUEST_RF_CH0, length, array);
903 /* Channel table 1 */
905 while (length3 > 0) {
911 memcpy(array, addr3, length);
913 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
914 value, MESSAGE_REQUEST_RF_CH1, length, array);
921 if (priv->rf_type == RF_AIROHA7230) {
922 length1 = CB_AL7230_INIT_SEQ * 3;
923 length2 = CB_MAX_CHANNEL * 3;
924 addr1 = &(al7230_init_table_amode[0][0]);
925 addr2 = &(al7230_channel_table2[0][0]);
927 memcpy(array, addr1, length1);
930 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
931 0, MESSAGE_REQUEST_RF_INIT2, length1, array);
933 /* Channel Table 0 */
935 while (length2 > 0) {
941 memcpy(array, addr2, length);
943 vnt_control_out(priv, MESSAGE_TYPE_WRITE,
944 value, MESSAGE_REQUEST_RF_CH2, length, array);