1 /* ZD1211 USB-WLAN driver for Linux 2 * 3 * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de> 4 * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, see <http://www.gnu.org/licenses/>. 18 */ 19 20 #include <linux/errno.h> 21 #include <linux/string.h> 22 23 #include "zd_def.h" 24 #include "zd_rf.h" 25 #include "zd_mac.h" 26 #include "zd_chip.h" 27 28 static const char * const rfs[] = { 29 [0] = "unknown RF0", 30 [1] = "unknown RF1", 31 [UW2451_RF] = "UW2451_RF", 32 [UCHIP_RF] = "UCHIP_RF", 33 [AL2230_RF] = "AL2230_RF", 34 [AL7230B_RF] = "AL7230B_RF", 35 [THETA_RF] = "THETA_RF", 36 [AL2210_RF] = "AL2210_RF", 37 [MAXIM_NEW_RF] = "MAXIM_NEW_RF", 38 [UW2453_RF] = "UW2453_RF", 39 [AL2230S_RF] = "AL2230S_RF", 40 [RALINK_RF] = "RALINK_RF", 41 [INTERSIL_RF] = "INTERSIL_RF", 42 [RF2959_RF] = "RF2959_RF", 43 [MAXIM_NEW2_RF] = "MAXIM_NEW2_RF", 44 [PHILIPS_RF] = "PHILIPS_RF", 45 }; 46 47 const char *zd_rf_name(u8 type) 48 { 49 if (type & 0xf0) 50 type = 0; 51 return rfs[type]; 52 } 53 54 void zd_rf_init(struct zd_rf *rf) 55 { 56 memset(rf, 0, sizeof(*rf)); 57 58 /* default to update channel integration, as almost all RF's do want 59 * this */ 60 rf->update_channel_int = 1; 61 } 62 63 void zd_rf_clear(struct zd_rf *rf) 64 { 65 if (rf->clear) 66 rf->clear(rf); 67 ZD_MEMCLEAR(rf, sizeof(*rf)); 68 } 69 70 int zd_rf_init_hw(struct zd_rf *rf, u8 type) 71 { 72 int r = 0; 73 int t; 74 struct zd_chip *chip = zd_rf_to_chip(rf); 75 76 ZD_ASSERT(mutex_is_locked(&chip->mutex)); 77 switch (type) { 78 case RF2959_RF: 79 r = zd_rf_init_rf2959(rf); 80 break; 81 case AL2230_RF: 82 case AL2230S_RF: 83 r = zd_rf_init_al2230(rf); 84 break; 85 case AL7230B_RF: 86 r = zd_rf_init_al7230b(rf); 87 break; 88 case MAXIM_NEW_RF: 89 case UW2453_RF: 90 r = zd_rf_init_uw2453(rf); 91 break; 92 default: 93 dev_err(zd_chip_dev(chip), 94 "RF %s %#x is not supported\n", zd_rf_name(type), type); 95 rf->type = 0; 96 return -ENODEV; 97 } 98 99 if (r) 100 return r; 101 102 rf->type = type; 103 104 r = zd_chip_lock_phy_regs(chip); 105 if (r) 106 return r; 107 t = rf->init_hw(rf); 108 r = zd_chip_unlock_phy_regs(chip); 109 if (t) 110 r = t; 111 return r; 112 } 113 114 int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size) 115 { 116 return scnprintf(buffer, size, "%s", zd_rf_name(rf->type)); 117 } 118 119 int zd_rf_set_channel(struct zd_rf *rf, u8 channel) 120 { 121 int r; 122 123 ZD_ASSERT(mutex_is_locked(&zd_rf_to_chip(rf)->mutex)); 124 if (channel < MIN_CHANNEL24) 125 return -EINVAL; 126 if (channel > MAX_CHANNEL24) 127 return -EINVAL; 128 dev_dbg_f(zd_chip_dev(zd_rf_to_chip(rf)), "channel: %d\n", channel); 129 130 r = rf->set_channel(rf, channel); 131 if (r >= 0) 132 rf->channel = channel; 133 return r; 134 } 135 136 int zd_switch_radio_on(struct zd_rf *rf) 137 { 138 int r, t; 139 struct zd_chip *chip = zd_rf_to_chip(rf); 140 141 ZD_ASSERT(mutex_is_locked(&chip->mutex)); 142 r = zd_chip_lock_phy_regs(chip); 143 if (r) 144 return r; 145 t = rf->switch_radio_on(rf); 146 r = zd_chip_unlock_phy_regs(chip); 147 if (t) 148 r = t; 149 return r; 150 } 151 152 int zd_switch_radio_off(struct zd_rf *rf) 153 { 154 int r, t; 155 struct zd_chip *chip = zd_rf_to_chip(rf); 156 157 /* TODO: move phy regs handling to zd_chip */ 158 ZD_ASSERT(mutex_is_locked(&chip->mutex)); 159 r = zd_chip_lock_phy_regs(chip); 160 if (r) 161 return r; 162 t = rf->switch_radio_off(rf); 163 r = zd_chip_unlock_phy_regs(chip); 164 if (t) 165 r = t; 166 return r; 167 } 168 169 int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel) 170 { 171 if (!rf->patch_6m_band_edge) 172 return 0; 173 174 return rf->patch_6m_band_edge(rf, channel); 175 } 176 177 int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel) 178 { 179 return zd_chip_generic_patch_6m_band(zd_rf_to_chip(rf), channel); 180 } 181 182