Part of reorganising wireless drivers directory and Kconfig.
Signed-off-by: Kalle Valo <kvalo@codeaurora.org>
L: linux-wireless@vger.kernel.org
L: zd1211-devs@lists.sourceforge.net (subscribers-only)
S: Maintained
-F: drivers/net/wireless/zd1211rw/
+F: drivers/net/wireless/zydas/zd1211rw/
ZPOOL COMPRESSED PAGE STORAGE API
M: Dan Streetman <ddstreet@ieee.org>
source "drivers/net/wireless/realtek/rtlwifi/Kconfig"
source "drivers/net/wireless/realtek/rtl8xxxu/Kconfig"
source "drivers/net/wireless/ti/Kconfig"
-source "drivers/net/wireless/zd1211rw/Kconfig"
source "drivers/net/wireless/rsi/Kconfig"
endif # WLAN
obj-$(CONFIG_PRISM54) += prism54/
obj-$(CONFIG_HOSTAP) += hostap/
-obj-$(CONFIG_ZD1211RW) += zd1211rw/
obj-$(CONFIG_WLAN) += realtek/
# 16-bit wireless PCMCIA client drivers
+++ /dev/null
-config ZD1211RW
- tristate "ZyDAS ZD1211/ZD1211B USB-wireless support"
- depends on USB && MAC80211
- select FW_LOADER
- ---help---
- This is a driver for the ZyDAS ZD1211/ZD1211B wireless
- chip, present in many USB-wireless adapters.
-
- Device firmware is required alongside this driver. You can download
- the firmware distribution from http://sf.net/projects/zd1211/files/
-
-config ZD1211RW_DEBUG
- bool "ZyDAS ZD1211 debugging"
- depends on ZD1211RW
- ---help---
- ZD1211 debugging messages. Choosing Y will result in additional debug
- messages being saved to your kernel logs, which may help debug any
- problems.
-
+++ /dev/null
-obj-$(CONFIG_ZD1211RW) += zd1211rw.o
-
-zd1211rw-objs := zd_chip.o zd_mac.o \
- zd_rf_al2230.o zd_rf_rf2959.o \
- zd_rf_al7230b.o zd_rf_uw2453.o \
- zd_rf.o zd_usb.o
-
-ccflags-$(CONFIG_ZD1211RW_DEBUG) := -DDEBUG
-
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-/* This file implements all the hardware specific functions for the ZD1211
- * and ZD1211B chips. Support for the ZD1211B was possible after Timothy
- * Legge sent me a ZD1211B device. Thank you Tim. -- Uli
- */
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-
-#include "zd_def.h"
-#include "zd_chip.h"
-#include "zd_mac.h"
-#include "zd_rf.h"
-
-void zd_chip_init(struct zd_chip *chip,
- struct ieee80211_hw *hw,
- struct usb_interface *intf)
-{
- memset(chip, 0, sizeof(*chip));
- mutex_init(&chip->mutex);
- zd_usb_init(&chip->usb, hw, intf);
- zd_rf_init(&chip->rf);
-}
-
-void zd_chip_clear(struct zd_chip *chip)
-{
- ZD_ASSERT(!mutex_is_locked(&chip->mutex));
- zd_usb_clear(&chip->usb);
- zd_rf_clear(&chip->rf);
- mutex_destroy(&chip->mutex);
- ZD_MEMCLEAR(chip, sizeof(*chip));
-}
-
-static int scnprint_mac_oui(struct zd_chip *chip, char *buffer, size_t size)
-{
- u8 *addr = zd_mac_get_perm_addr(zd_chip_to_mac(chip));
- return scnprintf(buffer, size, "%02x-%02x-%02x",
- addr[0], addr[1], addr[2]);
-}
-
-/* Prints an identifier line, which will support debugging. */
-static int scnprint_id(struct zd_chip *chip, char *buffer, size_t size)
-{
- int i = 0;
-
- i = scnprintf(buffer, size, "zd1211%s chip ",
- zd_chip_is_zd1211b(chip) ? "b" : "");
- i += zd_usb_scnprint_id(&chip->usb, buffer+i, size-i);
- i += scnprintf(buffer+i, size-i, " ");
- i += scnprint_mac_oui(chip, buffer+i, size-i);
- i += scnprintf(buffer+i, size-i, " ");
- i += zd_rf_scnprint_id(&chip->rf, buffer+i, size-i);
- i += scnprintf(buffer+i, size-i, " pa%1x %c%c%c%c%c", chip->pa_type,
- chip->patch_cck_gain ? 'g' : '-',
- chip->patch_cr157 ? '7' : '-',
- chip->patch_6m_band_edge ? '6' : '-',
- chip->new_phy_layout ? 'N' : '-',
- chip->al2230s_bit ? 'S' : '-');
- return i;
-}
-
-static void print_id(struct zd_chip *chip)
-{
- char buffer[80];
-
- scnprint_id(chip, buffer, sizeof(buffer));
- buffer[sizeof(buffer)-1] = 0;
- dev_info(zd_chip_dev(chip), "%s\n", buffer);
-}
-
-static zd_addr_t inc_addr(zd_addr_t addr)
-{
- u16 a = (u16)addr;
- /* Control registers use byte addressing, but everything else uses word
- * addressing. */
- if ((a & 0xf000) == CR_START)
- a += 2;
- else
- a += 1;
- return (zd_addr_t)a;
-}
-
-/* Read a variable number of 32-bit values. Parameter count is not allowed to
- * exceed USB_MAX_IOREAD32_COUNT.
- */
-int zd_ioread32v_locked(struct zd_chip *chip, u32 *values, const zd_addr_t *addr,
- unsigned int count)
-{
- int r;
- int i;
- zd_addr_t a16[USB_MAX_IOREAD32_COUNT * 2];
- u16 v16[USB_MAX_IOREAD32_COUNT * 2];
- unsigned int count16;
-
- if (count > USB_MAX_IOREAD32_COUNT)
- return -EINVAL;
-
- /* Use stack for values and addresses. */
- count16 = 2 * count;
- BUG_ON(count16 * sizeof(zd_addr_t) > sizeof(a16));
- BUG_ON(count16 * sizeof(u16) > sizeof(v16));
-
- for (i = 0; i < count; i++) {
- int j = 2*i;
- /* We read the high word always first. */
- a16[j] = inc_addr(addr[i]);
- a16[j+1] = addr[i];
- }
-
- r = zd_ioread16v_locked(chip, v16, a16, count16);
- if (r) {
- dev_dbg_f(zd_chip_dev(chip),
- "error: %s. Error number %d\n", __func__, r);
- return r;
- }
-
- for (i = 0; i < count; i++) {
- int j = 2*i;
- values[i] = (v16[j] << 16) | v16[j+1];
- }
-
- return 0;
-}
-
-static int _zd_iowrite32v_async_locked(struct zd_chip *chip,
- const struct zd_ioreq32 *ioreqs,
- unsigned int count)
-{
- int i, j, r;
- struct zd_ioreq16 ioreqs16[USB_MAX_IOWRITE32_COUNT * 2];
- unsigned int count16;
-
- /* Use stack for values and addresses. */
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
-
- if (count == 0)
- return 0;
- if (count > USB_MAX_IOWRITE32_COUNT)
- return -EINVAL;
-
- count16 = 2 * count;
- BUG_ON(count16 * sizeof(struct zd_ioreq16) > sizeof(ioreqs16));
-
- for (i = 0; i < count; i++) {
- j = 2*i;
- /* We write the high word always first. */
- ioreqs16[j].value = ioreqs[i].value >> 16;
- ioreqs16[j].addr = inc_addr(ioreqs[i].addr);
- ioreqs16[j+1].value = ioreqs[i].value;
- ioreqs16[j+1].addr = ioreqs[i].addr;
- }
-
- r = zd_usb_iowrite16v_async(&chip->usb, ioreqs16, count16);
-#ifdef DEBUG
- if (r) {
- dev_dbg_f(zd_chip_dev(chip),
- "error %d in zd_usb_write16v\n", r);
- }
-#endif /* DEBUG */
- return r;
-}
-
-int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
- unsigned int count)
-{
- int r;
-
- zd_usb_iowrite16v_async_start(&chip->usb);
- r = _zd_iowrite32v_async_locked(chip, ioreqs, count);
- if (r) {
- zd_usb_iowrite16v_async_end(&chip->usb, 0);
- return r;
- }
- return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
-}
-
-int zd_iowrite16a_locked(struct zd_chip *chip,
- const struct zd_ioreq16 *ioreqs, unsigned int count)
-{
- int r;
- unsigned int i, j, t, max;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- zd_usb_iowrite16v_async_start(&chip->usb);
-
- for (i = 0; i < count; i += j + t) {
- t = 0;
- max = count-i;
- if (max > USB_MAX_IOWRITE16_COUNT)
- max = USB_MAX_IOWRITE16_COUNT;
- for (j = 0; j < max; j++) {
- if (!ioreqs[i+j].addr) {
- t = 1;
- break;
- }
- }
-
- r = zd_usb_iowrite16v_async(&chip->usb, &ioreqs[i], j);
- if (r) {
- zd_usb_iowrite16v_async_end(&chip->usb, 0);
- dev_dbg_f(zd_chip_dev(chip),
- "error zd_usb_iowrite16v. Error number %d\n",
- r);
- return r;
- }
- }
-
- return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
-}
-
-/* Writes a variable number of 32 bit registers. The functions will split
- * that in several USB requests. A split can be forced by inserting an IO
- * request with an zero address field.
- */
-int zd_iowrite32a_locked(struct zd_chip *chip,
- const struct zd_ioreq32 *ioreqs, unsigned int count)
-{
- int r;
- unsigned int i, j, t, max;
-
- zd_usb_iowrite16v_async_start(&chip->usb);
-
- for (i = 0; i < count; i += j + t) {
- t = 0;
- max = count-i;
- if (max > USB_MAX_IOWRITE32_COUNT)
- max = USB_MAX_IOWRITE32_COUNT;
- for (j = 0; j < max; j++) {
- if (!ioreqs[i+j].addr) {
- t = 1;
- break;
- }
- }
-
- r = _zd_iowrite32v_async_locked(chip, &ioreqs[i], j);
- if (r) {
- zd_usb_iowrite16v_async_end(&chip->usb, 0);
- dev_dbg_f(zd_chip_dev(chip),
- "error _%s. Error number %d\n", __func__,
- r);
- return r;
- }
- }
-
- return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
-}
-
-int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread16_locked(chip, value, addr);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread32_locked(chip, value, addr);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite16_locked(chip, value, addr);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite32_locked(chip, value, addr);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
- u32 *values, unsigned int count)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread32v_locked(chip, values, addresses, count);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
- unsigned int count)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite32a_locked(chip, ioreqs, count);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static int read_pod(struct zd_chip *chip, u8 *rf_type)
-{
- int r;
- u32 value;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_ioread32_locked(chip, &value, E2P_POD);
- if (r)
- goto error;
- dev_dbg_f(zd_chip_dev(chip), "E2P_POD %#010x\n", value);
-
- /* FIXME: AL2230 handling (Bit 7 in POD) */
- *rf_type = value & 0x0f;
- chip->pa_type = (value >> 16) & 0x0f;
- chip->patch_cck_gain = (value >> 8) & 0x1;
- chip->patch_cr157 = (value >> 13) & 0x1;
- chip->patch_6m_band_edge = (value >> 21) & 0x1;
- chip->new_phy_layout = (value >> 31) & 0x1;
- chip->al2230s_bit = (value >> 7) & 0x1;
- chip->link_led = ((value >> 4) & 1) ? LED1 : LED2;
- chip->supports_tx_led = 1;
- if (value & (1 << 24)) { /* LED scenario */
- if (value & (1 << 29))
- chip->supports_tx_led = 0;
- }
-
- dev_dbg_f(zd_chip_dev(chip),
- "RF %s %#01x PA type %#01x patch CCK %d patch CR157 %d "
- "patch 6M %d new PHY %d link LED%d tx led %d\n",
- zd_rf_name(*rf_type), *rf_type,
- chip->pa_type, chip->patch_cck_gain,
- chip->patch_cr157, chip->patch_6m_band_edge,
- chip->new_phy_layout,
- chip->link_led == LED1 ? 1 : 2,
- chip->supports_tx_led);
- return 0;
-error:
- *rf_type = 0;
- chip->pa_type = 0;
- chip->patch_cck_gain = 0;
- chip->patch_cr157 = 0;
- chip->patch_6m_band_edge = 0;
- chip->new_phy_layout = 0;
- return r;
-}
-
-static int zd_write_mac_addr_common(struct zd_chip *chip, const u8 *mac_addr,
- const struct zd_ioreq32 *in_reqs,
- const char *type)
-{
- int r;
- struct zd_ioreq32 reqs[2] = {in_reqs[0], in_reqs[1]};
-
- if (mac_addr) {
- reqs[0].value = (mac_addr[3] << 24)
- | (mac_addr[2] << 16)
- | (mac_addr[1] << 8)
- | mac_addr[0];
- reqs[1].value = (mac_addr[5] << 8)
- | mac_addr[4];
- dev_dbg_f(zd_chip_dev(chip), "%s addr %pM\n", type, mac_addr);
- } else {
- dev_dbg_f(zd_chip_dev(chip), "set NULL %s\n", type);
- }
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-/* MAC address: if custom mac addresses are to be used CR_MAC_ADDR_P1 and
- * CR_MAC_ADDR_P2 must be overwritten
- */
-int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr)
-{
- static const struct zd_ioreq32 reqs[2] = {
- [0] = { .addr = CR_MAC_ADDR_P1 },
- [1] = { .addr = CR_MAC_ADDR_P2 },
- };
-
- return zd_write_mac_addr_common(chip, mac_addr, reqs, "mac");
-}
-
-int zd_write_bssid(struct zd_chip *chip, const u8 *bssid)
-{
- static const struct zd_ioreq32 reqs[2] = {
- [0] = { .addr = CR_BSSID_P1 },
- [1] = { .addr = CR_BSSID_P2 },
- };
-
- return zd_write_mac_addr_common(chip, bssid, reqs, "bssid");
-}
-
-int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain)
-{
- int r;
- u32 value;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread32_locked(chip, &value, E2P_SUBID);
- mutex_unlock(&chip->mutex);
- if (r)
- return r;
-
- *regdomain = value >> 16;
- dev_dbg_f(zd_chip_dev(chip), "regdomain: %#04x\n", *regdomain);
-
- return 0;
-}
-
-static int read_values(struct zd_chip *chip, u8 *values, size_t count,
- zd_addr_t e2p_addr, u32 guard)
-{
- int r;
- int i;
- u32 v;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- for (i = 0;;) {
- r = zd_ioread32_locked(chip, &v,
- (zd_addr_t)((u16)e2p_addr+i/2));
- if (r)
- return r;
- v -= guard;
- if (i+4 < count) {
- values[i++] = v;
- values[i++] = v >> 8;
- values[i++] = v >> 16;
- values[i++] = v >> 24;
- continue;
- }
- for (;i < count; i++)
- values[i] = v >> (8*(i%3));
- return 0;
- }
-}
-
-static int read_pwr_cal_values(struct zd_chip *chip)
-{
- return read_values(chip, chip->pwr_cal_values,
- E2P_CHANNEL_COUNT, E2P_PWR_CAL_VALUE1,
- 0);
-}
-
-static int read_pwr_int_values(struct zd_chip *chip)
-{
- return read_values(chip, chip->pwr_int_values,
- E2P_CHANNEL_COUNT, E2P_PWR_INT_VALUE1,
- E2P_PWR_INT_GUARD);
-}
-
-static int read_ofdm_cal_values(struct zd_chip *chip)
-{
- int r;
- int i;
- static const zd_addr_t addresses[] = {
- E2P_36M_CAL_VALUE1,
- E2P_48M_CAL_VALUE1,
- E2P_54M_CAL_VALUE1,
- };
-
- for (i = 0; i < 3; i++) {
- r = read_values(chip, chip->ofdm_cal_values[i],
- E2P_CHANNEL_COUNT, addresses[i], 0);
- if (r)
- return r;
- }
- return 0;
-}
-
-static int read_cal_int_tables(struct zd_chip *chip)
-{
- int r;
-
- r = read_pwr_cal_values(chip);
- if (r)
- return r;
- r = read_pwr_int_values(chip);
- if (r)
- return r;
- r = read_ofdm_cal_values(chip);
- if (r)
- return r;
- return 0;
-}
-
-/* phy means physical registers */
-int zd_chip_lock_phy_regs(struct zd_chip *chip)
-{
- int r;
- u32 tmp;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_ioread32_locked(chip, &tmp, CR_REG1);
- if (r) {
- dev_err(zd_chip_dev(chip), "error ioread32(CR_REG1): %d\n", r);
- return r;
- }
-
- tmp &= ~UNLOCK_PHY_REGS;
-
- r = zd_iowrite32_locked(chip, tmp, CR_REG1);
- if (r)
- dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
- return r;
-}
-
-int zd_chip_unlock_phy_regs(struct zd_chip *chip)
-{
- int r;
- u32 tmp;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_ioread32_locked(chip, &tmp, CR_REG1);
- if (r) {
- dev_err(zd_chip_dev(chip),
- "error ioread32(CR_REG1): %d\n", r);
- return r;
- }
-
- tmp |= UNLOCK_PHY_REGS;
-
- r = zd_iowrite32_locked(chip, tmp, CR_REG1);
- if (r)
- dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
- return r;
-}
-
-/* ZD_CR157 can be optionally patched by the EEPROM for original ZD1211 */
-static int patch_cr157(struct zd_chip *chip)
-{
- int r;
- u16 value;
-
- if (!chip->patch_cr157)
- return 0;
-
- r = zd_ioread16_locked(chip, &value, E2P_PHY_REG);
- if (r)
- return r;
-
- dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value >> 8);
- return zd_iowrite32_locked(chip, value >> 8, ZD_CR157);
-}
-
-/*
- * 6M band edge can be optionally overwritten for certain RF's
- * Vendor driver says: for FCC regulation, enabled per HWFeature 6M band edge
- * bit (for AL2230, AL2230S)
- */
-static int patch_6m_band_edge(struct zd_chip *chip, u8 channel)
-{
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- if (!chip->patch_6m_band_edge)
- return 0;
-
- return zd_rf_patch_6m_band_edge(&chip->rf, channel);
-}
-
-/* Generic implementation of 6M band edge patching, used by most RFs via
- * zd_rf_generic_patch_6m() */
-int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel)
-{
- struct zd_ioreq16 ioreqs[] = {
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- { ZD_CR47, 0x1e },
- };
-
- /* FIXME: Channel 11 is not the edge for all regulatory domains. */
- if (channel == 1 || channel == 11)
- ioreqs[0].value = 0x12;
-
- dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211_hw_reset_phy(struct zd_chip *chip)
-{
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR0, 0x0a }, { ZD_CR1, 0x06 }, { ZD_CR2, 0x26 },
- { ZD_CR3, 0x38 }, { ZD_CR4, 0x80 }, { ZD_CR9, 0xa0 },
- { ZD_CR10, 0x81 }, { ZD_CR11, 0x00 }, { ZD_CR12, 0x7f },
- { ZD_CR13, 0x8c }, { ZD_CR14, 0x80 }, { ZD_CR15, 0x3d },
- { ZD_CR16, 0x20 }, { ZD_CR17, 0x1e }, { ZD_CR18, 0x0a },
- { ZD_CR19, 0x48 }, { ZD_CR20, 0x0c }, { ZD_CR21, 0x0c },
- { ZD_CR22, 0x23 }, { ZD_CR23, 0x90 }, { ZD_CR24, 0x14 },
- { ZD_CR25, 0x40 }, { ZD_CR26, 0x10 }, { ZD_CR27, 0x19 },
- { ZD_CR28, 0x7f }, { ZD_CR29, 0x80 }, { ZD_CR30, 0x4b },
- { ZD_CR31, 0x60 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x08 },
- { ZD_CR34, 0x06 }, { ZD_CR35, 0x0a }, { ZD_CR36, 0x00 },
- { ZD_CR37, 0x00 }, { ZD_CR38, 0x38 }, { ZD_CR39, 0x0c },
- { ZD_CR40, 0x84 }, { ZD_CR41, 0x2a }, { ZD_CR42, 0x80 },
- { ZD_CR43, 0x10 }, { ZD_CR44, 0x12 }, { ZD_CR46, 0xff },
- { ZD_CR47, 0x1E }, { ZD_CR48, 0x26 }, { ZD_CR49, 0x5b },
- { ZD_CR64, 0xd0 }, { ZD_CR65, 0x04 }, { ZD_CR66, 0x58 },
- { ZD_CR67, 0xc9 }, { ZD_CR68, 0x88 }, { ZD_CR69, 0x41 },
- { ZD_CR70, 0x23 }, { ZD_CR71, 0x10 }, { ZD_CR72, 0xff },
- { ZD_CR73, 0x32 }, { ZD_CR74, 0x30 }, { ZD_CR75, 0x65 },
- { ZD_CR76, 0x41 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x30 },
- { ZD_CR79, 0x68 }, { ZD_CR80, 0x64 }, { ZD_CR81, 0x64 },
- { ZD_CR82, 0x00 }, { ZD_CR83, 0x00 }, { ZD_CR84, 0x00 },
- { ZD_CR85, 0x02 }, { ZD_CR86, 0x00 }, { ZD_CR87, 0x00 },
- { ZD_CR88, 0xff }, { ZD_CR89, 0xfc }, { ZD_CR90, 0x00 },
- { ZD_CR91, 0x00 }, { ZD_CR92, 0x00 }, { ZD_CR93, 0x08 },
- { ZD_CR94, 0x00 }, { ZD_CR95, 0x00 }, { ZD_CR96, 0xff },
- { ZD_CR97, 0xe7 }, { ZD_CR98, 0x00 }, { ZD_CR99, 0x00 },
- { ZD_CR100, 0x00 }, { ZD_CR101, 0xae }, { ZD_CR102, 0x02 },
- { ZD_CR103, 0x00 }, { ZD_CR104, 0x03 }, { ZD_CR105, 0x65 },
- { ZD_CR106, 0x04 }, { ZD_CR107, 0x00 }, { ZD_CR108, 0x0a },
- { ZD_CR109, 0xaa }, { ZD_CR110, 0xaa }, { ZD_CR111, 0x25 },
- { ZD_CR112, 0x25 }, { ZD_CR113, 0x00 }, { ZD_CR119, 0x1e },
- { ZD_CR125, 0x90 }, { ZD_CR126, 0x00 }, { ZD_CR127, 0x00 },
- { },
- { ZD_CR5, 0x00 }, { ZD_CR6, 0x00 }, { ZD_CR7, 0x00 },
- { ZD_CR8, 0x00 }, { ZD_CR9, 0x20 }, { ZD_CR12, 0xf0 },
- { ZD_CR20, 0x0e }, { ZD_CR21, 0x0e }, { ZD_CR27, 0x10 },
- { ZD_CR44, 0x33 }, { ZD_CR47, 0x1E }, { ZD_CR83, 0x24 },
- { ZD_CR84, 0x04 }, { ZD_CR85, 0x00 }, { ZD_CR86, 0x0C },
- { ZD_CR87, 0x12 }, { ZD_CR88, 0x0C }, { ZD_CR89, 0x00 },
- { ZD_CR90, 0x10 }, { ZD_CR91, 0x08 }, { ZD_CR93, 0x00 },
- { ZD_CR94, 0x01 }, { ZD_CR95, 0x00 }, { ZD_CR96, 0x50 },
- { ZD_CR97, 0x37 }, { ZD_CR98, 0x35 }, { ZD_CR101, 0x13 },
- { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 }, { ZD_CR104, 0x18 },
- { ZD_CR105, 0x12 }, { ZD_CR109, 0x27 }, { ZD_CR110, 0x27 },
- { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x27 }, { ZD_CR115, 0x26 }, { ZD_CR116, 0x24 },
- { ZD_CR117, 0xfc }, { ZD_CR118, 0xfa }, { ZD_CR120, 0x4f },
- { ZD_CR125, 0xaa }, { ZD_CR127, 0x03 }, { ZD_CR128, 0x14 },
- { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 }, { ZD_CR131, 0x0C },
- { ZD_CR136, 0xdf }, { ZD_CR137, 0x40 }, { ZD_CR138, 0xa0 },
- { ZD_CR139, 0xb0 }, { ZD_CR140, 0x99 }, { ZD_CR141, 0x82 },
- { ZD_CR142, 0x54 }, { ZD_CR143, 0x1c }, { ZD_CR144, 0x6c },
- { ZD_CR147, 0x07 }, { ZD_CR148, 0x4c }, { ZD_CR149, 0x50 },
- { ZD_CR150, 0x0e }, { ZD_CR151, 0x18 }, { ZD_CR160, 0xfe },
- { ZD_CR161, 0xee }, { ZD_CR162, 0xaa }, { ZD_CR163, 0xfa },
- { ZD_CR164, 0xfa }, { ZD_CR165, 0xea }, { ZD_CR166, 0xbe },
- { ZD_CR167, 0xbe }, { ZD_CR168, 0x6a }, { ZD_CR169, 0xba },
- { ZD_CR170, 0xba }, { ZD_CR171, 0xba },
- /* Note: ZD_CR204 must lead the ZD_CR203 */
- { ZD_CR204, 0x7d },
- { },
- { ZD_CR203, 0x30 },
- };
-
- int r, t;
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
-
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- goto out;
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- goto unlock;
-
- r = patch_cr157(chip);
-unlock:
- t = zd_chip_unlock_phy_regs(chip);
- if (t && !r)
- r = t;
-out:
- return r;
-}
-
-static int zd1211b_hw_reset_phy(struct zd_chip *chip)
-{
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR0, 0x14 }, { ZD_CR1, 0x06 }, { ZD_CR2, 0x26 },
- { ZD_CR3, 0x38 }, { ZD_CR4, 0x80 }, { ZD_CR9, 0xe0 },
- { ZD_CR10, 0x81 },
- /* power control { { ZD_CR11, 1 << 6 }, */
- { ZD_CR11, 0x00 },
- { ZD_CR12, 0xf0 }, { ZD_CR13, 0x8c }, { ZD_CR14, 0x80 },
- { ZD_CR15, 0x3d }, { ZD_CR16, 0x20 }, { ZD_CR17, 0x1e },
- { ZD_CR18, 0x0a }, { ZD_CR19, 0x48 },
- { ZD_CR20, 0x10 }, /* Org:0x0E, ComTrend:RalLink AP */
- { ZD_CR21, 0x0e }, { ZD_CR22, 0x23 }, { ZD_CR23, 0x90 },
- { ZD_CR24, 0x14 }, { ZD_CR25, 0x40 }, { ZD_CR26, 0x10 },
- { ZD_CR27, 0x10 }, { ZD_CR28, 0x7f }, { ZD_CR29, 0x80 },
- { ZD_CR30, 0x4b }, /* ASIC/FWT, no jointly decoder */
- { ZD_CR31, 0x60 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x08 },
- { ZD_CR34, 0x06 }, { ZD_CR35, 0x0a }, { ZD_CR36, 0x00 },
- { ZD_CR37, 0x00 }, { ZD_CR38, 0x38 }, { ZD_CR39, 0x0c },
- { ZD_CR40, 0x84 }, { ZD_CR41, 0x2a }, { ZD_CR42, 0x80 },
- { ZD_CR43, 0x10 }, { ZD_CR44, 0x33 }, { ZD_CR46, 0xff },
- { ZD_CR47, 0x1E }, { ZD_CR48, 0x26 }, { ZD_CR49, 0x5b },
- { ZD_CR64, 0xd0 }, { ZD_CR65, 0x04 }, { ZD_CR66, 0x58 },
- { ZD_CR67, 0xc9 }, { ZD_CR68, 0x88 }, { ZD_CR69, 0x41 },
- { ZD_CR70, 0x23 }, { ZD_CR71, 0x10 }, { ZD_CR72, 0xff },
- { ZD_CR73, 0x32 }, { ZD_CR74, 0x30 }, { ZD_CR75, 0x65 },
- { ZD_CR76, 0x41 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x30 },
- { ZD_CR79, 0xf0 }, { ZD_CR80, 0x64 }, { ZD_CR81, 0x64 },
- { ZD_CR82, 0x00 }, { ZD_CR83, 0x24 }, { ZD_CR84, 0x04 },
- { ZD_CR85, 0x00 }, { ZD_CR86, 0x0c }, { ZD_CR87, 0x12 },
- { ZD_CR88, 0x0c }, { ZD_CR89, 0x00 }, { ZD_CR90, 0x58 },
- { ZD_CR91, 0x04 }, { ZD_CR92, 0x00 }, { ZD_CR93, 0x00 },
- { ZD_CR94, 0x01 },
- { ZD_CR95, 0x20 }, /* ZD1211B */
- { ZD_CR96, 0x50 }, { ZD_CR97, 0x37 }, { ZD_CR98, 0x35 },
- { ZD_CR99, 0x00 }, { ZD_CR100, 0x01 }, { ZD_CR101, 0x13 },
- { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 }, { ZD_CR104, 0x18 },
- { ZD_CR105, 0x12 }, { ZD_CR106, 0x04 }, { ZD_CR107, 0x00 },
- { ZD_CR108, 0x0a }, { ZD_CR109, 0x27 }, { ZD_CR110, 0x27 },
- { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x27 }, { ZD_CR115, 0x26 }, { ZD_CR116, 0x24 },
- { ZD_CR117, 0xfc }, { ZD_CR118, 0xfa }, { ZD_CR119, 0x1e },
- { ZD_CR125, 0x90 }, { ZD_CR126, 0x00 }, { ZD_CR127, 0x00 },
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- { ZD_CR131, 0x0c }, { ZD_CR136, 0xdf }, { ZD_CR137, 0xa0 },
- { ZD_CR138, 0xa8 }, { ZD_CR139, 0xb4 }, { ZD_CR140, 0x98 },
- { ZD_CR141, 0x82 }, { ZD_CR142, 0x53 }, { ZD_CR143, 0x1c },
- { ZD_CR144, 0x6c }, { ZD_CR147, 0x07 }, { ZD_CR148, 0x40 },
- { ZD_CR149, 0x40 }, /* Org:0x50 ComTrend:RalLink AP */
- { ZD_CR150, 0x14 }, /* Org:0x0E ComTrend:RalLink AP */
- { ZD_CR151, 0x18 }, { ZD_CR159, 0x70 }, { ZD_CR160, 0xfe },
- { ZD_CR161, 0xee }, { ZD_CR162, 0xaa }, { ZD_CR163, 0xfa },
- { ZD_CR164, 0xfa }, { ZD_CR165, 0xea }, { ZD_CR166, 0xbe },
- { ZD_CR167, 0xbe }, { ZD_CR168, 0x6a }, { ZD_CR169, 0xba },
- { ZD_CR170, 0xba }, { ZD_CR171, 0xba },
- /* Note: ZD_CR204 must lead the ZD_CR203 */
- { ZD_CR204, 0x7d },
- {},
- { ZD_CR203, 0x30 },
- };
-
- int r, t;
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
-
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- goto out;
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- t = zd_chip_unlock_phy_regs(chip);
- if (t && !r)
- r = t;
-out:
- return r;
-}
-
-static int hw_reset_phy(struct zd_chip *chip)
-{
- return zd_chip_is_zd1211b(chip) ? zd1211b_hw_reset_phy(chip) :
- zd1211_hw_reset_phy(chip);
-}
-
-static int zd1211_hw_init_hmac(struct zd_chip *chip)
-{
- static const struct zd_ioreq32 ioreqs[] = {
- { CR_ZD1211_RETRY_MAX, ZD1211_RETRY_COUNT },
- { CR_RX_THRESHOLD, 0x000c0640 },
- };
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211b_hw_init_hmac(struct zd_chip *chip)
-{
- static const struct zd_ioreq32 ioreqs[] = {
- { CR_ZD1211B_RETRY_MAX, ZD1211B_RETRY_COUNT },
- { CR_ZD1211B_CWIN_MAX_MIN_AC0, 0x007f003f },
- { CR_ZD1211B_CWIN_MAX_MIN_AC1, 0x007f003f },
- { CR_ZD1211B_CWIN_MAX_MIN_AC2, 0x003f001f },
- { CR_ZD1211B_CWIN_MAX_MIN_AC3, 0x001f000f },
- { CR_ZD1211B_AIFS_CTL1, 0x00280028 },
- { CR_ZD1211B_AIFS_CTL2, 0x008C003C },
- { CR_ZD1211B_TXOP, 0x01800824 },
- { CR_RX_THRESHOLD, 0x000c0eff, },
- };
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int hw_init_hmac(struct zd_chip *chip)
-{
- int r;
- static const struct zd_ioreq32 ioreqs[] = {
- { CR_ACK_TIMEOUT_EXT, 0x20 },
- { CR_ADDA_MBIAS_WARMTIME, 0x30000808 },
- { CR_SNIFFER_ON, 0 },
- { CR_RX_FILTER, STA_RX_FILTER },
- { CR_GROUP_HASH_P1, 0x00 },
- { CR_GROUP_HASH_P2, 0x80000000 },
- { CR_REG1, 0xa4 },
- { CR_ADDA_PWR_DWN, 0x7f },
- { CR_BCN_PLCP_CFG, 0x00f00401 },
- { CR_PHY_DELAY, 0x00 },
- { CR_ACK_TIMEOUT_EXT, 0x80 },
- { CR_ADDA_PWR_DWN, 0x00 },
- { CR_ACK_TIME_80211, 0x100 },
- { CR_RX_PE_DELAY, 0x70 },
- { CR_PS_CTRL, 0x10000000 },
- { CR_RTS_CTS_RATE, 0x02030203 },
- { CR_AFTER_PNP, 0x1 },
- { CR_WEP_PROTECT, 0x114 },
- { CR_IFS_VALUE, IFS_VALUE_DEFAULT },
- { CR_CAM_MODE, MODE_AP_WDS},
- };
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- return zd_chip_is_zd1211b(chip) ?
- zd1211b_hw_init_hmac(chip) : zd1211_hw_init_hmac(chip);
-}
-
-struct aw_pt_bi {
- u32 atim_wnd_period;
- u32 pre_tbtt;
- u32 beacon_interval;
-};
-
-static int get_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
-{
- int r;
- static const zd_addr_t aw_pt_bi_addr[] =
- { CR_ATIM_WND_PERIOD, CR_PRE_TBTT, CR_BCN_INTERVAL };
- u32 values[3];
-
- r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
- ARRAY_SIZE(aw_pt_bi_addr));
- if (r) {
- memset(s, 0, sizeof(*s));
- return r;
- }
-
- s->atim_wnd_period = values[0];
- s->pre_tbtt = values[1];
- s->beacon_interval = values[2];
- return 0;
-}
-
-static int set_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
-{
- struct zd_ioreq32 reqs[3];
- u16 b_interval = s->beacon_interval & 0xffff;
-
- if (b_interval <= 5)
- b_interval = 5;
- if (s->pre_tbtt < 4 || s->pre_tbtt >= b_interval)
- s->pre_tbtt = b_interval - 1;
- if (s->atim_wnd_period >= s->pre_tbtt)
- s->atim_wnd_period = s->pre_tbtt - 1;
-
- reqs[0].addr = CR_ATIM_WND_PERIOD;
- reqs[0].value = s->atim_wnd_period;
- reqs[1].addr = CR_PRE_TBTT;
- reqs[1].value = s->pre_tbtt;
- reqs[2].addr = CR_BCN_INTERVAL;
- reqs[2].value = (s->beacon_interval & ~0xffff) | b_interval;
-
- return zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
-}
-
-
-static int set_beacon_interval(struct zd_chip *chip, u16 interval,
- u8 dtim_period, int type)
-{
- int r;
- struct aw_pt_bi s;
- u32 b_interval, mode_flag;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
-
- if (interval > 0) {
- switch (type) {
- case NL80211_IFTYPE_ADHOC:
- case NL80211_IFTYPE_MESH_POINT:
- mode_flag = BCN_MODE_IBSS;
- break;
- case NL80211_IFTYPE_AP:
- mode_flag = BCN_MODE_AP;
- break;
- default:
- mode_flag = 0;
- break;
- }
- } else {
- dtim_period = 0;
- mode_flag = 0;
- }
-
- b_interval = mode_flag | (dtim_period << 16) | interval;
-
- r = zd_iowrite32_locked(chip, b_interval, CR_BCN_INTERVAL);
- if (r)
- return r;
- r = get_aw_pt_bi(chip, &s);
- if (r)
- return r;
- return set_aw_pt_bi(chip, &s);
-}
-
-int zd_set_beacon_interval(struct zd_chip *chip, u16 interval, u8 dtim_period,
- int type)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = set_beacon_interval(chip, interval, dtim_period, type);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static int hw_init(struct zd_chip *chip)
-{
- int r;
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = hw_reset_phy(chip);
- if (r)
- return r;
-
- r = hw_init_hmac(chip);
- if (r)
- return r;
-
- return set_beacon_interval(chip, 100, 0, NL80211_IFTYPE_UNSPECIFIED);
-}
-
-static zd_addr_t fw_reg_addr(struct zd_chip *chip, u16 offset)
-{
- return (zd_addr_t)((u16)chip->fw_regs_base + offset);
-}
-
-#ifdef DEBUG
-static int dump_cr(struct zd_chip *chip, const zd_addr_t addr,
- const char *addr_string)
-{
- int r;
- u32 value;
-
- r = zd_ioread32_locked(chip, &value, addr);
- if (r) {
- dev_dbg_f(zd_chip_dev(chip),
- "error reading %s. Error number %d\n", addr_string, r);
- return r;
- }
-
- dev_dbg_f(zd_chip_dev(chip), "%s %#010x\n",
- addr_string, (unsigned int)value);
- return 0;
-}
-
-static int test_init(struct zd_chip *chip)
-{
- int r;
-
- r = dump_cr(chip, CR_AFTER_PNP, "CR_AFTER_PNP");
- if (r)
- return r;
- r = dump_cr(chip, CR_GPI_EN, "CR_GPI_EN");
- if (r)
- return r;
- return dump_cr(chip, CR_INTERRUPT, "CR_INTERRUPT");
-}
-
-static void dump_fw_registers(struct zd_chip *chip)
-{
- const zd_addr_t addr[4] = {
- fw_reg_addr(chip, FW_REG_FIRMWARE_VER),
- fw_reg_addr(chip, FW_REG_USB_SPEED),
- fw_reg_addr(chip, FW_REG_FIX_TX_RATE),
- fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
- };
-
- int r;
- u16 values[4];
-
- r = zd_ioread16v_locked(chip, values, (const zd_addr_t*)addr,
- ARRAY_SIZE(addr));
- if (r) {
- dev_dbg_f(zd_chip_dev(chip), "error %d zd_ioread16v_locked\n",
- r);
- return;
- }
-
- dev_dbg_f(zd_chip_dev(chip), "FW_FIRMWARE_VER %#06hx\n", values[0]);
- dev_dbg_f(zd_chip_dev(chip), "FW_USB_SPEED %#06hx\n", values[1]);
- dev_dbg_f(zd_chip_dev(chip), "FW_FIX_TX_RATE %#06hx\n", values[2]);
- dev_dbg_f(zd_chip_dev(chip), "FW_LINK_STATUS %#06hx\n", values[3]);
-}
-#endif /* DEBUG */
-
-static int print_fw_version(struct zd_chip *chip)
-{
- struct wiphy *wiphy = zd_chip_to_mac(chip)->hw->wiphy;
- int r;
- u16 version;
-
- r = zd_ioread16_locked(chip, &version,
- fw_reg_addr(chip, FW_REG_FIRMWARE_VER));
- if (r)
- return r;
-
- dev_info(zd_chip_dev(chip),"firmware version %04hx\n", version);
-
- snprintf(wiphy->fw_version, sizeof(wiphy->fw_version),
- "%04hx", version);
-
- return 0;
-}
-
-static int set_mandatory_rates(struct zd_chip *chip, int gmode)
-{
- u32 rates;
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- /* This sets the mandatory rates, which only depend from the standard
- * that the device is supporting. Until further notice we should try
- * to support 802.11g also for full speed USB.
- */
- if (!gmode)
- rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M;
- else
- rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M|
- CR_RATE_6M|CR_RATE_12M|CR_RATE_24M;
-
- return zd_iowrite32_locked(chip, rates, CR_MANDATORY_RATE_TBL);
-}
-
-int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
- int preamble)
-{
- u32 value = 0;
-
- dev_dbg_f(zd_chip_dev(chip), "preamble=%x\n", preamble);
- value |= preamble << RTSCTS_SH_RTS_PMB_TYPE;
- value |= preamble << RTSCTS_SH_CTS_PMB_TYPE;
-
- /* We always send 11M RTS/self-CTS messages, like the vendor driver. */
- value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_RTS_RATE;
- value |= ZD_RX_CCK << RTSCTS_SH_RTS_MOD_TYPE;
- value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_CTS_RATE;
- value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE;
-
- return zd_iowrite32_locked(chip, value, CR_RTS_CTS_RATE);
-}
-
-int zd_chip_enable_hwint(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite32_locked(chip, HWINT_ENABLED, CR_INTERRUPT);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static int disable_hwint(struct zd_chip *chip)
-{
- return zd_iowrite32_locked(chip, HWINT_DISABLED, CR_INTERRUPT);
-}
-
-int zd_chip_disable_hwint(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = disable_hwint(chip);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static int read_fw_regs_offset(struct zd_chip *chip)
-{
- int r;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_ioread16_locked(chip, (u16*)&chip->fw_regs_base,
- FWRAW_REGS_ADDR);
- if (r)
- return r;
- dev_dbg_f(zd_chip_dev(chip), "fw_regs_base: %#06hx\n",
- (u16)chip->fw_regs_base);
-
- return 0;
-}
-
-/* Read mac address using pre-firmware interface */
-int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr)
-{
- dev_dbg_f(zd_chip_dev(chip), "\n");
- return zd_usb_read_fw(&chip->usb, E2P_MAC_ADDR_P1, addr,
- ETH_ALEN);
-}
-
-int zd_chip_init_hw(struct zd_chip *chip)
-{
- int r;
- u8 rf_type;
-
- dev_dbg_f(zd_chip_dev(chip), "\n");
-
- mutex_lock(&chip->mutex);
-
-#ifdef DEBUG
- r = test_init(chip);
- if (r)
- goto out;
-#endif
- r = zd_iowrite32_locked(chip, 1, CR_AFTER_PNP);
- if (r)
- goto out;
-
- r = read_fw_regs_offset(chip);
- if (r)
- goto out;
-
- /* GPI is always disabled, also in the other driver.
- */
- r = zd_iowrite32_locked(chip, 0, CR_GPI_EN);
- if (r)
- goto out;
- r = zd_iowrite32_locked(chip, CWIN_SIZE, CR_CWMIN_CWMAX);
- if (r)
- goto out;
- /* Currently we support IEEE 802.11g for full and high speed USB.
- * It might be discussed, whether we should support pure b mode for
- * full speed USB.
- */
- r = set_mandatory_rates(chip, 1);
- if (r)
- goto out;
- /* Disabling interrupts is certainly a smart thing here.
- */
- r = disable_hwint(chip);
- if (r)
- goto out;
- r = read_pod(chip, &rf_type);
- if (r)
- goto out;
- r = hw_init(chip);
- if (r)
- goto out;
- r = zd_rf_init_hw(&chip->rf, rf_type);
- if (r)
- goto out;
-
- r = print_fw_version(chip);
- if (r)
- goto out;
-
-#ifdef DEBUG
- dump_fw_registers(chip);
- r = test_init(chip);
- if (r)
- goto out;
-#endif /* DEBUG */
-
- r = read_cal_int_tables(chip);
- if (r)
- goto out;
-
- print_id(chip);
-out:
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static int update_pwr_int(struct zd_chip *chip, u8 channel)
-{
- u8 value = chip->pwr_int_values[channel - 1];
- return zd_iowrite16_locked(chip, value, ZD_CR31);
-}
-
-static int update_pwr_cal(struct zd_chip *chip, u8 channel)
-{
- u8 value = chip->pwr_cal_values[channel-1];
- return zd_iowrite16_locked(chip, value, ZD_CR68);
-}
-
-static int update_ofdm_cal(struct zd_chip *chip, u8 channel)
-{
- struct zd_ioreq16 ioreqs[3];
-
- ioreqs[0].addr = ZD_CR67;
- ioreqs[0].value = chip->ofdm_cal_values[OFDM_36M_INDEX][channel-1];
- ioreqs[1].addr = ZD_CR66;
- ioreqs[1].value = chip->ofdm_cal_values[OFDM_48M_INDEX][channel-1];
- ioreqs[2].addr = ZD_CR65;
- ioreqs[2].value = chip->ofdm_cal_values[OFDM_54M_INDEX][channel-1];
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int update_channel_integration_and_calibration(struct zd_chip *chip,
- u8 channel)
-{
- int r;
-
- if (!zd_rf_should_update_pwr_int(&chip->rf))
- return 0;
-
- r = update_pwr_int(chip, channel);
- if (r)
- return r;
- if (zd_chip_is_zd1211b(chip)) {
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR69, 0x28 },
- {},
- { ZD_CR69, 0x2a },
- };
-
- r = update_ofdm_cal(chip, channel);
- if (r)
- return r;
- r = update_pwr_cal(chip, channel);
- if (r)
- return r;
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
- }
-
- return 0;
-}
-
-/* The CCK baseband gain can be optionally patched by the EEPROM */
-static int patch_cck_gain(struct zd_chip *chip)
-{
- int r;
- u32 value;
-
- if (!chip->patch_cck_gain || !zd_rf_should_patch_cck_gain(&chip->rf))
- return 0;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_ioread32_locked(chip, &value, E2P_PHY_REG);
- if (r)
- return r;
- dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value & 0xff);
- return zd_iowrite16_locked(chip, value & 0xff, ZD_CR47);
-}
-
-int zd_chip_set_channel(struct zd_chip *chip, u8 channel)
-{
- int r, t;
-
- mutex_lock(&chip->mutex);
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- goto out;
- r = zd_rf_set_channel(&chip->rf, channel);
- if (r)
- goto unlock;
- r = update_channel_integration_and_calibration(chip, channel);
- if (r)
- goto unlock;
- r = patch_cck_gain(chip);
- if (r)
- goto unlock;
- r = patch_6m_band_edge(chip, channel);
- if (r)
- goto unlock;
- r = zd_iowrite32_locked(chip, 0, CR_CONFIG_PHILIPS);
-unlock:
- t = zd_chip_unlock_phy_regs(chip);
- if (t && !r)
- r = t;
-out:
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-u8 zd_chip_get_channel(struct zd_chip *chip)
-{
- u8 channel;
-
- mutex_lock(&chip->mutex);
- channel = chip->rf.channel;
- mutex_unlock(&chip->mutex);
- return channel;
-}
-
-int zd_chip_control_leds(struct zd_chip *chip, enum led_status status)
-{
- const zd_addr_t a[] = {
- fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
- CR_LED,
- };
-
- int r;
- u16 v[ARRAY_SIZE(a)];
- struct zd_ioreq16 ioreqs[ARRAY_SIZE(a)] = {
- [0] = { fw_reg_addr(chip, FW_REG_LED_LINK_STATUS) },
- [1] = { CR_LED },
- };
- u16 other_led;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread16v_locked(chip, v, (const zd_addr_t *)a, ARRAY_SIZE(a));
- if (r)
- goto out;
-
- other_led = chip->link_led == LED1 ? LED2 : LED1;
-
- switch (status) {
- case ZD_LED_OFF:
- ioreqs[0].value = FW_LINK_OFF;
- ioreqs[1].value = v[1] & ~(LED1|LED2);
- break;
- case ZD_LED_SCANNING:
- ioreqs[0].value = FW_LINK_OFF;
- ioreqs[1].value = v[1] & ~other_led;
- if (get_seconds() % 3 == 0) {
- ioreqs[1].value &= ~chip->link_led;
- } else {
- ioreqs[1].value |= chip->link_led;
- }
- break;
- case ZD_LED_ASSOCIATED:
- ioreqs[0].value = FW_LINK_TX;
- ioreqs[1].value = v[1] & ~other_led;
- ioreqs[1].value |= chip->link_led;
- break;
- default:
- r = -EINVAL;
- goto out;
- }
-
- if (v[0] != ioreqs[0].value || v[1] != ioreqs[1].value) {
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- goto out;
- }
- r = 0;
-out:
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates)
-{
- int r;
-
- if (cr_rates & ~(CR_RATES_80211B|CR_RATES_80211G))
- return -EINVAL;
-
- mutex_lock(&chip->mutex);
- r = zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-static inline u8 zd_rate_from_ofdm_plcp_header(const void *rx_frame)
-{
- return ZD_OFDM | zd_ofdm_plcp_header_rate(rx_frame);
-}
-
-/**
- * zd_rx_rate - report zd-rate
- * @rx_frame - received frame
- * @rx_status - rx_status as given by the device
- *
- * This function converts the rate as encoded in the received packet to the
- * zd-rate, we are using on other places in the driver.
- */
-u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status)
-{
- u8 zd_rate;
- if (status->frame_status & ZD_RX_OFDM) {
- zd_rate = zd_rate_from_ofdm_plcp_header(rx_frame);
- } else {
- switch (zd_cck_plcp_header_signal(rx_frame)) {
- case ZD_CCK_PLCP_SIGNAL_1M:
- zd_rate = ZD_CCK_RATE_1M;
- break;
- case ZD_CCK_PLCP_SIGNAL_2M:
- zd_rate = ZD_CCK_RATE_2M;
- break;
- case ZD_CCK_PLCP_SIGNAL_5M5:
- zd_rate = ZD_CCK_RATE_5_5M;
- break;
- case ZD_CCK_PLCP_SIGNAL_11M:
- zd_rate = ZD_CCK_RATE_11M;
- break;
- default:
- zd_rate = 0;
- }
- }
-
- return zd_rate;
-}
-
-int zd_chip_switch_radio_on(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_switch_radio_on(&chip->rf);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_chip_switch_radio_off(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_switch_radio_off(&chip->rf);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-int zd_chip_enable_int(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- r = zd_usb_enable_int(&chip->usb);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-void zd_chip_disable_int(struct zd_chip *chip)
-{
- mutex_lock(&chip->mutex);
- zd_usb_disable_int(&chip->usb);
- mutex_unlock(&chip->mutex);
-
- /* cancel pending interrupt work */
- cancel_work_sync(&zd_chip_to_mac(chip)->process_intr);
-}
-
-int zd_chip_enable_rxtx(struct zd_chip *chip)
-{
- int r;
-
- mutex_lock(&chip->mutex);
- zd_usb_enable_tx(&chip->usb);
- r = zd_usb_enable_rx(&chip->usb);
- zd_tx_watchdog_enable(&chip->usb);
- mutex_unlock(&chip->mutex);
- return r;
-}
-
-void zd_chip_disable_rxtx(struct zd_chip *chip)
-{
- mutex_lock(&chip->mutex);
- zd_tx_watchdog_disable(&chip->usb);
- zd_usb_disable_rx(&chip->usb);
- zd_usb_disable_tx(&chip->usb);
- mutex_unlock(&chip->mutex);
-}
-
-int zd_rfwritev_locked(struct zd_chip *chip,
- const u32* values, unsigned int count, u8 bits)
-{
- int r;
- unsigned int i;
-
- for (i = 0; i < count; i++) {
- r = zd_rfwrite_locked(chip, values[i], bits);
- if (r)
- return r;
- }
-
- return 0;
-}
-
-/*
- * We can optionally program the RF directly through CR regs, if supported by
- * the hardware. This is much faster than the older method.
- */
-int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value)
-{
- const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR244, (value >> 16) & 0xff },
- { ZD_CR243, (value >> 8) & 0xff },
- { ZD_CR242, value & 0xff },
- };
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-int zd_rfwritev_cr_locked(struct zd_chip *chip,
- const u32 *values, unsigned int count)
-{
- int r;
- unsigned int i;
-
- for (i = 0; i < count; i++) {
- r = zd_rfwrite_cr_locked(chip, values[i]);
- if (r)
- return r;
- }
-
- return 0;
-}
-
-int zd_chip_set_multicast_hash(struct zd_chip *chip,
- struct zd_mc_hash *hash)
-{
- const struct zd_ioreq32 ioreqs[] = {
- { CR_GROUP_HASH_P1, hash->low },
- { CR_GROUP_HASH_P2, hash->high },
- };
-
- return zd_iowrite32a(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-u64 zd_chip_get_tsf(struct zd_chip *chip)
-{
- int r;
- static const zd_addr_t aw_pt_bi_addr[] =
- { CR_TSF_LOW_PART, CR_TSF_HIGH_PART };
- u32 values[2];
- u64 tsf;
-
- mutex_lock(&chip->mutex);
- r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
- ARRAY_SIZE(aw_pt_bi_addr));
- mutex_unlock(&chip->mutex);
- if (r)
- return 0;
-
- tsf = values[1];
- tsf = (tsf << 32) | values[0];
-
- return tsf;
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _ZD_CHIP_H
-#define _ZD_CHIP_H
-
-#include <net/mac80211.h>
-
-#include "zd_rf.h"
-#include "zd_usb.h"
-
-/* Header for the Media Access Controller (MAC) and the Baseband Processor
- * (BBP). It appears that the ZD1211 wraps the old ZD1205 with USB glue and
- * adds a processor for handling the USB protocol.
- */
-
-/* Address space */
-enum {
- /* CONTROL REGISTERS */
- CR_START = 0x9000,
-
-
- /* FIRMWARE */
- FW_START = 0xee00,
-
-
- /* EEPROM */
- E2P_START = 0xf800,
- E2P_LEN = 0x800,
-
- /* EEPROM layout */
- E2P_LOAD_CODE_LEN = 0xe, /* base 0xf800 */
- E2P_LOAD_VECT_LEN = 0x9, /* base 0xf80e */
- /* E2P_DATA indexes into this */
- E2P_DATA_LEN = 0x7e, /* base 0xf817 */
- E2P_BOOT_CODE_LEN = 0x760, /* base 0xf895 */
- E2P_INTR_VECT_LEN = 0xb, /* base 0xfff5 */
-
- /* Some precomputed offsets into the EEPROM */
- E2P_DATA_OFFSET = E2P_LOAD_CODE_LEN + E2P_LOAD_VECT_LEN,
- E2P_BOOT_CODE_OFFSET = E2P_DATA_OFFSET + E2P_DATA_LEN,
-};
-
-#define CTL_REG(offset) ((zd_addr_t)(CR_START + (offset)))
-#define E2P_DATA(offset) ((zd_addr_t)(E2P_START + E2P_DATA_OFFSET + (offset)))
-#define FWRAW_DATA(offset) ((zd_addr_t)(FW_START + (offset)))
-
-/* 8-bit hardware registers */
-#define ZD_CR0 CTL_REG(0x0000)
-#define ZD_CR1 CTL_REG(0x0004)
-#define ZD_CR2 CTL_REG(0x0008)
-#define ZD_CR3 CTL_REG(0x000C)
-
-#define ZD_CR5 CTL_REG(0x0010)
-/* bit 5: if set short preamble used
- * bit 6: filter band - Japan channel 14 on, else off
- */
-#define ZD_CR6 CTL_REG(0x0014)
-#define ZD_CR7 CTL_REG(0x0018)
-#define ZD_CR8 CTL_REG(0x001C)
-
-#define ZD_CR4 CTL_REG(0x0020)
-
-#define ZD_CR9 CTL_REG(0x0024)
-/* bit 2: antenna switch (together with ZD_CR10) */
-#define ZD_CR10 CTL_REG(0x0028)
-/* bit 1: antenna switch (together with ZD_CR9)
- * RF2959 controls with ZD_CR11 radion on and off
- */
-#define ZD_CR11 CTL_REG(0x002C)
-/* bit 6: TX power control for OFDM
- * RF2959 controls with ZD_CR10 radio on and off
- */
-#define ZD_CR12 CTL_REG(0x0030)
-#define ZD_CR13 CTL_REG(0x0034)
-#define ZD_CR14 CTL_REG(0x0038)
-#define ZD_CR15 CTL_REG(0x003C)
-#define ZD_CR16 CTL_REG(0x0040)
-#define ZD_CR17 CTL_REG(0x0044)
-#define ZD_CR18 CTL_REG(0x0048)
-#define ZD_CR19 CTL_REG(0x004C)
-#define ZD_CR20 CTL_REG(0x0050)
-#define ZD_CR21 CTL_REG(0x0054)
-#define ZD_CR22 CTL_REG(0x0058)
-#define ZD_CR23 CTL_REG(0x005C)
-#define ZD_CR24 CTL_REG(0x0060) /* CCA threshold */
-#define ZD_CR25 CTL_REG(0x0064)
-#define ZD_CR26 CTL_REG(0x0068)
-#define ZD_CR27 CTL_REG(0x006C)
-#define ZD_CR28 CTL_REG(0x0070)
-#define ZD_CR29 CTL_REG(0x0074)
-#define ZD_CR30 CTL_REG(0x0078)
-#define ZD_CR31 CTL_REG(0x007C) /* TX power control for RF in
- * CCK mode
- */
-#define ZD_CR32 CTL_REG(0x0080)
-#define ZD_CR33 CTL_REG(0x0084)
-#define ZD_CR34 CTL_REG(0x0088)
-#define ZD_CR35 CTL_REG(0x008C)
-#define ZD_CR36 CTL_REG(0x0090)
-#define ZD_CR37 CTL_REG(0x0094)
-#define ZD_CR38 CTL_REG(0x0098)
-#define ZD_CR39 CTL_REG(0x009C)
-#define ZD_CR40 CTL_REG(0x00A0)
-#define ZD_CR41 CTL_REG(0x00A4)
-#define ZD_CR42 CTL_REG(0x00A8)
-#define ZD_CR43 CTL_REG(0x00AC)
-#define ZD_CR44 CTL_REG(0x00B0)
-#define ZD_CR45 CTL_REG(0x00B4)
-#define ZD_CR46 CTL_REG(0x00B8)
-#define ZD_CR47 CTL_REG(0x00BC) /* CCK baseband gain
- * (patch value might be in EEPROM)
- */
-#define ZD_CR48 CTL_REG(0x00C0)
-#define ZD_CR49 CTL_REG(0x00C4)
-#define ZD_CR50 CTL_REG(0x00C8)
-#define ZD_CR51 CTL_REG(0x00CC) /* TX power control for RF in
- * 6-36M modes
- */
-#define ZD_CR52 CTL_REG(0x00D0) /* TX power control for RF in
- * 48M mode
- */
-#define ZD_CR53 CTL_REG(0x00D4) /* TX power control for RF in
- * 54M mode
- */
-#define ZD_CR54 CTL_REG(0x00D8)
-#define ZD_CR55 CTL_REG(0x00DC)
-#define ZD_CR56 CTL_REG(0x00E0)
-#define ZD_CR57 CTL_REG(0x00E4)
-#define ZD_CR58 CTL_REG(0x00E8)
-#define ZD_CR59 CTL_REG(0x00EC)
-#define ZD_CR60 CTL_REG(0x00F0)
-#define ZD_CR61 CTL_REG(0x00F4)
-#define ZD_CR62 CTL_REG(0x00F8)
-#define ZD_CR63 CTL_REG(0x00FC)
-#define ZD_CR64 CTL_REG(0x0100)
-#define ZD_CR65 CTL_REG(0x0104) /* OFDM 54M calibration */
-#define ZD_CR66 CTL_REG(0x0108) /* OFDM 48M calibration */
-#define ZD_CR67 CTL_REG(0x010C) /* OFDM 36M calibration */
-#define ZD_CR68 CTL_REG(0x0110) /* CCK calibration */
-#define ZD_CR69 CTL_REG(0x0114)
-#define ZD_CR70 CTL_REG(0x0118)
-#define ZD_CR71 CTL_REG(0x011C)
-#define ZD_CR72 CTL_REG(0x0120)
-#define ZD_CR73 CTL_REG(0x0124)
-#define ZD_CR74 CTL_REG(0x0128)
-#define ZD_CR75 CTL_REG(0x012C)
-#define ZD_CR76 CTL_REG(0x0130)
-#define ZD_CR77 CTL_REG(0x0134)
-#define ZD_CR78 CTL_REG(0x0138)
-#define ZD_CR79 CTL_REG(0x013C)
-#define ZD_CR80 CTL_REG(0x0140)
-#define ZD_CR81 CTL_REG(0x0144)
-#define ZD_CR82 CTL_REG(0x0148)
-#define ZD_CR83 CTL_REG(0x014C)
-#define ZD_CR84 CTL_REG(0x0150)
-#define ZD_CR85 CTL_REG(0x0154)
-#define ZD_CR86 CTL_REG(0x0158)
-#define ZD_CR87 CTL_REG(0x015C)
-#define ZD_CR88 CTL_REG(0x0160)
-#define ZD_CR89 CTL_REG(0x0164)
-#define ZD_CR90 CTL_REG(0x0168)
-#define ZD_CR91 CTL_REG(0x016C)
-#define ZD_CR92 CTL_REG(0x0170)
-#define ZD_CR93 CTL_REG(0x0174)
-#define ZD_CR94 CTL_REG(0x0178)
-#define ZD_CR95 CTL_REG(0x017C)
-#define ZD_CR96 CTL_REG(0x0180)
-#define ZD_CR97 CTL_REG(0x0184)
-#define ZD_CR98 CTL_REG(0x0188)
-#define ZD_CR99 CTL_REG(0x018C)
-#define ZD_CR100 CTL_REG(0x0190)
-#define ZD_CR101 CTL_REG(0x0194)
-#define ZD_CR102 CTL_REG(0x0198)
-#define ZD_CR103 CTL_REG(0x019C)
-#define ZD_CR104 CTL_REG(0x01A0)
-#define ZD_CR105 CTL_REG(0x01A4)
-#define ZD_CR106 CTL_REG(0x01A8)
-#define ZD_CR107 CTL_REG(0x01AC)
-#define ZD_CR108 CTL_REG(0x01B0)
-#define ZD_CR109 CTL_REG(0x01B4)
-#define ZD_CR110 CTL_REG(0x01B8)
-#define ZD_CR111 CTL_REG(0x01BC)
-#define ZD_CR112 CTL_REG(0x01C0)
-#define ZD_CR113 CTL_REG(0x01C4)
-#define ZD_CR114 CTL_REG(0x01C8)
-#define ZD_CR115 CTL_REG(0x01CC)
-#define ZD_CR116 CTL_REG(0x01D0)
-#define ZD_CR117 CTL_REG(0x01D4)
-#define ZD_CR118 CTL_REG(0x01D8)
-#define ZD_CR119 CTL_REG(0x01DC)
-#define ZD_CR120 CTL_REG(0x01E0)
-#define ZD_CR121 CTL_REG(0x01E4)
-#define ZD_CR122 CTL_REG(0x01E8)
-#define ZD_CR123 CTL_REG(0x01EC)
-#define ZD_CR124 CTL_REG(0x01F0)
-#define ZD_CR125 CTL_REG(0x01F4)
-#define ZD_CR126 CTL_REG(0x01F8)
-#define ZD_CR127 CTL_REG(0x01FC)
-#define ZD_CR128 CTL_REG(0x0200)
-#define ZD_CR129 CTL_REG(0x0204)
-#define ZD_CR130 CTL_REG(0x0208)
-#define ZD_CR131 CTL_REG(0x020C)
-#define ZD_CR132 CTL_REG(0x0210)
-#define ZD_CR133 CTL_REG(0x0214)
-#define ZD_CR134 CTL_REG(0x0218)
-#define ZD_CR135 CTL_REG(0x021C)
-#define ZD_CR136 CTL_REG(0x0220)
-#define ZD_CR137 CTL_REG(0x0224)
-#define ZD_CR138 CTL_REG(0x0228)
-#define ZD_CR139 CTL_REG(0x022C)
-#define ZD_CR140 CTL_REG(0x0230)
-#define ZD_CR141 CTL_REG(0x0234)
-#define ZD_CR142 CTL_REG(0x0238)
-#define ZD_CR143 CTL_REG(0x023C)
-#define ZD_CR144 CTL_REG(0x0240)
-#define ZD_CR145 CTL_REG(0x0244)
-#define ZD_CR146 CTL_REG(0x0248)
-#define ZD_CR147 CTL_REG(0x024C)
-#define ZD_CR148 CTL_REG(0x0250)
-#define ZD_CR149 CTL_REG(0x0254)
-#define ZD_CR150 CTL_REG(0x0258)
-#define ZD_CR151 CTL_REG(0x025C)
-#define ZD_CR152 CTL_REG(0x0260)
-#define ZD_CR153 CTL_REG(0x0264)
-#define ZD_CR154 CTL_REG(0x0268)
-#define ZD_CR155 CTL_REG(0x026C)
-#define ZD_CR156 CTL_REG(0x0270)
-#define ZD_CR157 CTL_REG(0x0274)
-#define ZD_CR158 CTL_REG(0x0278)
-#define ZD_CR159 CTL_REG(0x027C)
-#define ZD_CR160 CTL_REG(0x0280)
-#define ZD_CR161 CTL_REG(0x0284)
-#define ZD_CR162 CTL_REG(0x0288)
-#define ZD_CR163 CTL_REG(0x028C)
-#define ZD_CR164 CTL_REG(0x0290)
-#define ZD_CR165 CTL_REG(0x0294)
-#define ZD_CR166 CTL_REG(0x0298)
-#define ZD_CR167 CTL_REG(0x029C)
-#define ZD_CR168 CTL_REG(0x02A0)
-#define ZD_CR169 CTL_REG(0x02A4)
-#define ZD_CR170 CTL_REG(0x02A8)
-#define ZD_CR171 CTL_REG(0x02AC)
-#define ZD_CR172 CTL_REG(0x02B0)
-#define ZD_CR173 CTL_REG(0x02B4)
-#define ZD_CR174 CTL_REG(0x02B8)
-#define ZD_CR175 CTL_REG(0x02BC)
-#define ZD_CR176 CTL_REG(0x02C0)
-#define ZD_CR177 CTL_REG(0x02C4)
-#define ZD_CR178 CTL_REG(0x02C8)
-#define ZD_CR179 CTL_REG(0x02CC)
-#define ZD_CR180 CTL_REG(0x02D0)
-#define ZD_CR181 CTL_REG(0x02D4)
-#define ZD_CR182 CTL_REG(0x02D8)
-#define ZD_CR183 CTL_REG(0x02DC)
-#define ZD_CR184 CTL_REG(0x02E0)
-#define ZD_CR185 CTL_REG(0x02E4)
-#define ZD_CR186 CTL_REG(0x02E8)
-#define ZD_CR187 CTL_REG(0x02EC)
-#define ZD_CR188 CTL_REG(0x02F0)
-#define ZD_CR189 CTL_REG(0x02F4)
-#define ZD_CR190 CTL_REG(0x02F8)
-#define ZD_CR191 CTL_REG(0x02FC)
-#define ZD_CR192 CTL_REG(0x0300)
-#define ZD_CR193 CTL_REG(0x0304)
-#define ZD_CR194 CTL_REG(0x0308)
-#define ZD_CR195 CTL_REG(0x030C)
-#define ZD_CR196 CTL_REG(0x0310)
-#define ZD_CR197 CTL_REG(0x0314)
-#define ZD_CR198 CTL_REG(0x0318)
-#define ZD_CR199 CTL_REG(0x031C)
-#define ZD_CR200 CTL_REG(0x0320)
-#define ZD_CR201 CTL_REG(0x0324)
-#define ZD_CR202 CTL_REG(0x0328)
-#define ZD_CR203 CTL_REG(0x032C) /* I2C bus template value & flash
- * control
- */
-#define ZD_CR204 CTL_REG(0x0330)
-#define ZD_CR205 CTL_REG(0x0334)
-#define ZD_CR206 CTL_REG(0x0338)
-#define ZD_CR207 CTL_REG(0x033C)
-#define ZD_CR208 CTL_REG(0x0340)
-#define ZD_CR209 CTL_REG(0x0344)
-#define ZD_CR210 CTL_REG(0x0348)
-#define ZD_CR211 CTL_REG(0x034C)
-#define ZD_CR212 CTL_REG(0x0350)
-#define ZD_CR213 CTL_REG(0x0354)
-#define ZD_CR214 CTL_REG(0x0358)
-#define ZD_CR215 CTL_REG(0x035C)
-#define ZD_CR216 CTL_REG(0x0360)
-#define ZD_CR217 CTL_REG(0x0364)
-#define ZD_CR218 CTL_REG(0x0368)
-#define ZD_CR219 CTL_REG(0x036C)
-#define ZD_CR220 CTL_REG(0x0370)
-#define ZD_CR221 CTL_REG(0x0374)
-#define ZD_CR222 CTL_REG(0x0378)
-#define ZD_CR223 CTL_REG(0x037C)
-#define ZD_CR224 CTL_REG(0x0380)
-#define ZD_CR225 CTL_REG(0x0384)
-#define ZD_CR226 CTL_REG(0x0388)
-#define ZD_CR227 CTL_REG(0x038C)
-#define ZD_CR228 CTL_REG(0x0390)
-#define ZD_CR229 CTL_REG(0x0394)
-#define ZD_CR230 CTL_REG(0x0398)
-#define ZD_CR231 CTL_REG(0x039C)
-#define ZD_CR232 CTL_REG(0x03A0)
-#define ZD_CR233 CTL_REG(0x03A4)
-#define ZD_CR234 CTL_REG(0x03A8)
-#define ZD_CR235 CTL_REG(0x03AC)
-#define ZD_CR236 CTL_REG(0x03B0)
-
-#define ZD_CR240 CTL_REG(0x03C0)
-/* bit 7: host-controlled RF register writes
- * ZD_CR241-ZD_CR245: for hardware controlled writing of RF bits, not needed for
- * USB
- */
-#define ZD_CR241 CTL_REG(0x03C4)
-#define ZD_CR242 CTL_REG(0x03C8)
-#define ZD_CR243 CTL_REG(0x03CC)
-#define ZD_CR244 CTL_REG(0x03D0)
-#define ZD_CR245 CTL_REG(0x03D4)
-
-#define ZD_CR251 CTL_REG(0x03EC) /* only used for activation and
- * deactivation of Airoha RFs AL2230
- * and AL7230B
- */
-#define ZD_CR252 CTL_REG(0x03F0)
-#define ZD_CR253 CTL_REG(0x03F4)
-#define ZD_CR254 CTL_REG(0x03F8)
-#define ZD_CR255 CTL_REG(0x03FC)
-
-#define CR_MAX_PHY_REG 255
-
-/* Taken from the ZYDAS driver, not all of them are relevant for the ZD1211
- * driver.
- */
-
-#define CR_RF_IF_CLK CTL_REG(0x0400)
-#define CR_RF_IF_DATA CTL_REG(0x0404)
-#define CR_PE1_PE2 CTL_REG(0x0408)
-#define CR_PE2_DLY CTL_REG(0x040C)
-#define CR_LE1 CTL_REG(0x0410)
-#define CR_LE2 CTL_REG(0x0414)
-/* Seems to enable/disable GPI (General Purpose IO?) */
-#define CR_GPI_EN CTL_REG(0x0418)
-#define CR_RADIO_PD CTL_REG(0x042C)
-#define CR_RF2948_PD CTL_REG(0x042C)
-#define CR_ENABLE_PS_MANUAL_AGC CTL_REG(0x043C)
-#define CR_CONFIG_PHILIPS CTL_REG(0x0440)
-#define CR_SA2400_SER_AP CTL_REG(0x0444)
-#define CR_I2C_WRITE CTL_REG(0x0444)
-#define CR_SA2400_SER_RP CTL_REG(0x0448)
-#define CR_RADIO_PE CTL_REG(0x0458)
-#define CR_RST_BUS_MASTER CTL_REG(0x045C)
-#define CR_RFCFG CTL_REG(0x0464)
-#define CR_HSTSCHG CTL_REG(0x046C)
-#define CR_PHY_ON CTL_REG(0x0474)
-#define CR_RX_DELAY CTL_REG(0x0478)
-#define CR_RX_PE_DELAY CTL_REG(0x047C)
-#define CR_GPIO_1 CTL_REG(0x0490)
-#define CR_GPIO_2 CTL_REG(0x0494)
-#define CR_EncryBufMux CTL_REG(0x04A8)
-#define CR_PS_CTRL CTL_REG(0x0500)
-#define CR_ADDA_PWR_DWN CTL_REG(0x0504)
-#define CR_ADDA_MBIAS_WARMTIME CTL_REG(0x0508)
-#define CR_MAC_PS_STATE CTL_REG(0x050C)
-
-#define CR_INTERRUPT CTL_REG(0x0510)
-#define INT_TX_COMPLETE (1 << 0)
-#define INT_RX_COMPLETE (1 << 1)
-#define INT_RETRY_FAIL (1 << 2)
-#define INT_WAKEUP (1 << 3)
-#define INT_DTIM_NOTIFY (1 << 5)
-#define INT_CFG_NEXT_BCN (1 << 6)
-#define INT_BUS_ABORT (1 << 7)
-#define INT_TX_FIFO_READY (1 << 8)
-#define INT_UART (1 << 9)
-#define INT_TX_COMPLETE_EN (1 << 16)
-#define INT_RX_COMPLETE_EN (1 << 17)
-#define INT_RETRY_FAIL_EN (1 << 18)
-#define INT_WAKEUP_EN (1 << 19)
-#define INT_DTIM_NOTIFY_EN (1 << 21)
-#define INT_CFG_NEXT_BCN_EN (1 << 22)
-#define INT_BUS_ABORT_EN (1 << 23)
-#define INT_TX_FIFO_READY_EN (1 << 24)
-#define INT_UART_EN (1 << 25)
-
-#define CR_TSF_LOW_PART CTL_REG(0x0514)
-#define CR_TSF_HIGH_PART CTL_REG(0x0518)
-
-/* Following three values are in time units (1024us)
- * Following condition must be met:
- * atim < tbtt < bcn
- */
-#define CR_ATIM_WND_PERIOD CTL_REG(0x051C)
-#define CR_BCN_INTERVAL CTL_REG(0x0520)
-#define CR_PRE_TBTT CTL_REG(0x0524)
-/* in units of TU(1024us) */
-
-/* for UART support */
-#define CR_UART_RBR_THR_DLL CTL_REG(0x0540)
-#define CR_UART_DLM_IER CTL_REG(0x0544)
-#define CR_UART_IIR_FCR CTL_REG(0x0548)
-#define CR_UART_LCR CTL_REG(0x054c)
-#define CR_UART_MCR CTL_REG(0x0550)
-#define CR_UART_LSR CTL_REG(0x0554)
-#define CR_UART_MSR CTL_REG(0x0558)
-#define CR_UART_ECR CTL_REG(0x055c)
-#define CR_UART_STATUS CTL_REG(0x0560)
-
-#define CR_PCI_TX_ADDR_P1 CTL_REG(0x0600)
-#define CR_PCI_TX_AddR_P2 CTL_REG(0x0604)
-#define CR_PCI_RX_AddR_P1 CTL_REG(0x0608)
-#define CR_PCI_RX_AddR_P2 CTL_REG(0x060C)
-
-/* must be overwritten if custom MAC address will be used */
-#define CR_MAC_ADDR_P1 CTL_REG(0x0610)
-#define CR_MAC_ADDR_P2 CTL_REG(0x0614)
-#define CR_BSSID_P1 CTL_REG(0x0618)
-#define CR_BSSID_P2 CTL_REG(0x061C)
-#define CR_BCN_PLCP_CFG CTL_REG(0x0620)
-
-/* Group hash table for filtering incoming packets.
- *
- * The group hash table is 64 bit large and split over two parts. The first
- * part is the lower part. The upper 6 bits of the last byte of the target
- * address are used as index. Packets are received if the hash table bit is
- * set. This is used for multicast handling, but for broadcasts (address
- * ff:ff:ff:ff:ff:ff) the highest bit in the second table must also be set.
- */
-#define CR_GROUP_HASH_P1 CTL_REG(0x0624)
-#define CR_GROUP_HASH_P2 CTL_REG(0x0628)
-
-#define CR_RX_TIMEOUT CTL_REG(0x062C)
-
-/* Basic rates supported by the BSS. When producing ACK or CTS messages, the
- * device will use a rate in this table that is less than or equal to the rate
- * of the incoming frame which prompted the response. */
-#define CR_BASIC_RATE_TBL CTL_REG(0x0630)
-#define CR_RATE_1M (1 << 0) /* 802.11b */
-#define CR_RATE_2M (1 << 1) /* 802.11b */
-#define CR_RATE_5_5M (1 << 2) /* 802.11b */
-#define CR_RATE_11M (1 << 3) /* 802.11b */
-#define CR_RATE_6M (1 << 8) /* 802.11g */
-#define CR_RATE_9M (1 << 9) /* 802.11g */
-#define CR_RATE_12M (1 << 10) /* 802.11g */
-#define CR_RATE_18M (1 << 11) /* 802.11g */
-#define CR_RATE_24M (1 << 12) /* 802.11g */
-#define CR_RATE_36M (1 << 13) /* 802.11g */
-#define CR_RATE_48M (1 << 14) /* 802.11g */
-#define CR_RATE_54M (1 << 15) /* 802.11g */
-#define CR_RATES_80211G 0xff00
-#define CR_RATES_80211B 0x000f
-
-/* Mandatory rates required in the BSS. When producing ACK or CTS messages, if
- * the device could not find an appropriate rate in CR_BASIC_RATE_TBL, it will
- * look for a rate in this table that is less than or equal to the rate of
- * the incoming frame. */
-#define CR_MANDATORY_RATE_TBL CTL_REG(0x0634)
-#define CR_RTS_CTS_RATE CTL_REG(0x0638)
-
-/* These are all bit indexes in CR_RTS_CTS_RATE, so remember to shift. */
-#define RTSCTS_SH_RTS_RATE 0
-#define RTSCTS_SH_EXP_CTS_RATE 4
-#define RTSCTS_SH_RTS_MOD_TYPE 8
-#define RTSCTS_SH_RTS_PMB_TYPE 9
-#define RTSCTS_SH_CTS_RATE 16
-#define RTSCTS_SH_CTS_MOD_TYPE 24
-#define RTSCTS_SH_CTS_PMB_TYPE 25
-
-#define CR_WEP_PROTECT CTL_REG(0x063C)
-#define CR_RX_THRESHOLD CTL_REG(0x0640)
-
-/* register for controlling the LEDS */
-#define CR_LED CTL_REG(0x0644)
-/* masks for controlling LEDs */
-#define LED1 (1 << 8)
-#define LED2 (1 << 9)
-#define LED_SW (1 << 10)
-
-/* Seems to indicate that the configuration is over.
- */
-#define CR_AFTER_PNP CTL_REG(0x0648)
-#define CR_ACK_TIME_80211 CTL_REG(0x0658)
-
-#define CR_RX_OFFSET CTL_REG(0x065c)
-
-#define CR_BCN_LENGTH CTL_REG(0x0664)
-#define CR_PHY_DELAY CTL_REG(0x066C)
-#define CR_BCN_FIFO CTL_REG(0x0670)
-#define CR_SNIFFER_ON CTL_REG(0x0674)
-
-#define CR_ENCRYPTION_TYPE CTL_REG(0x0678)
-#define NO_WEP 0
-#define WEP64 1
-#define WEP128 5
-#define WEP256 6
-#define ENC_SNIFFER 8
-
-#define CR_ZD1211_RETRY_MAX CTL_REG(0x067C)
-
-#define CR_REG1 CTL_REG(0x0680)
-/* Setting the bit UNLOCK_PHY_REGS disallows the write access to physical
- * registers, so one could argue it is a LOCK bit. But calling it
- * LOCK_PHY_REGS makes it confusing.
- */
-#define UNLOCK_PHY_REGS (1 << 7)
-
-#define CR_DEVICE_STATE CTL_REG(0x0684)
-#define CR_UNDERRUN_CNT CTL_REG(0x0688)
-
-#define CR_RX_FILTER CTL_REG(0x068c)
-#define RX_FILTER_ASSOC_REQUEST (1 << 0)
-#define RX_FILTER_ASSOC_RESPONSE (1 << 1)
-#define RX_FILTER_REASSOC_REQUEST (1 << 2)
-#define RX_FILTER_REASSOC_RESPONSE (1 << 3)
-#define RX_FILTER_PROBE_REQUEST (1 << 4)
-#define RX_FILTER_PROBE_RESPONSE (1 << 5)
-/* bits 6 and 7 reserved */
-#define RX_FILTER_BEACON (1 << 8)
-#define RX_FILTER_ATIM (1 << 9)
-#define RX_FILTER_DISASSOC (1 << 10)
-#define RX_FILTER_AUTH (1 << 11)
-#define RX_FILTER_DEAUTH (1 << 12)
-#define RX_FILTER_PSPOLL (1 << 26)
-#define RX_FILTER_RTS (1 << 27)
-#define RX_FILTER_CTS (1 << 28)
-#define RX_FILTER_ACK (1 << 29)
-#define RX_FILTER_CFEND (1 << 30)
-#define RX_FILTER_CFACK (1 << 31)
-
-/* Enable bits for all frames you are interested in. */
-#define STA_RX_FILTER (RX_FILTER_ASSOC_REQUEST | RX_FILTER_ASSOC_RESPONSE | \
- RX_FILTER_REASSOC_REQUEST | RX_FILTER_REASSOC_RESPONSE | \
- RX_FILTER_PROBE_REQUEST | RX_FILTER_PROBE_RESPONSE | \
- (0x3 << 6) /* vendor driver sets these reserved bits */ | \
- RX_FILTER_BEACON | RX_FILTER_ATIM | RX_FILTER_DISASSOC | \
- RX_FILTER_AUTH | RX_FILTER_DEAUTH | \
- (0x7 << 13) /* vendor driver sets these reserved bits */ | \
- RX_FILTER_PSPOLL | RX_FILTER_ACK) /* 0x2400ffff */
-
-#define RX_FILTER_CTRL (RX_FILTER_RTS | RX_FILTER_CTS | \
- RX_FILTER_CFEND | RX_FILTER_CFACK)
-
-#define BCN_MODE_AP 0x1000000
-#define BCN_MODE_IBSS 0x2000000
-
-/* Monitor mode sets filter to 0xfffff */
-
-#define CR_ACK_TIMEOUT_EXT CTL_REG(0x0690)
-#define CR_BCN_FIFO_SEMAPHORE CTL_REG(0x0694)
-
-#define CR_IFS_VALUE CTL_REG(0x0698)
-#define IFS_VALUE_DIFS_SH 0
-#define IFS_VALUE_EIFS_SH 12
-#define IFS_VALUE_SIFS_SH 24
-#define IFS_VALUE_DEFAULT (( 50 << IFS_VALUE_DIFS_SH) | \
- (1148 << IFS_VALUE_EIFS_SH) | \
- ( 10 << IFS_VALUE_SIFS_SH))
-
-#define CR_RX_TIME_OUT CTL_REG(0x069C)
-#define CR_TOTAL_RX_FRM CTL_REG(0x06A0)
-#define CR_CRC32_CNT CTL_REG(0x06A4)
-#define CR_CRC16_CNT CTL_REG(0x06A8)
-#define CR_DECRYPTION_ERR_UNI CTL_REG(0x06AC)
-#define CR_RX_FIFO_OVERRUN CTL_REG(0x06B0)
-
-#define CR_DECRYPTION_ERR_MUL CTL_REG(0x06BC)
-
-#define CR_NAV_CNT CTL_REG(0x06C4)
-#define CR_NAV_CCA CTL_REG(0x06C8)
-#define CR_RETRY_CNT CTL_REG(0x06CC)
-
-#define CR_READ_TCB_ADDR CTL_REG(0x06E8)
-#define CR_READ_RFD_ADDR CTL_REG(0x06EC)
-#define CR_CWMIN_CWMAX CTL_REG(0x06F0)
-#define CR_TOTAL_TX_FRM CTL_REG(0x06F4)
-
-/* CAM: Continuous Access Mode (power management) */
-#define CR_CAM_MODE CTL_REG(0x0700)
-#define MODE_IBSS 0x0
-#define MODE_AP 0x1
-#define MODE_STA 0x2
-#define MODE_AP_WDS 0x3
-
-#define CR_CAM_ROLL_TB_LOW CTL_REG(0x0704)
-#define CR_CAM_ROLL_TB_HIGH CTL_REG(0x0708)
-#define CR_CAM_ADDRESS CTL_REG(0x070C)
-#define CR_CAM_DATA CTL_REG(0x0710)
-
-#define CR_ROMDIR CTL_REG(0x0714)
-
-#define CR_DECRY_ERR_FLG_LOW CTL_REG(0x0714)
-#define CR_DECRY_ERR_FLG_HIGH CTL_REG(0x0718)
-
-#define CR_WEPKEY0 CTL_REG(0x0720)
-#define CR_WEPKEY1 CTL_REG(0x0724)
-#define CR_WEPKEY2 CTL_REG(0x0728)
-#define CR_WEPKEY3 CTL_REG(0x072C)
-#define CR_WEPKEY4 CTL_REG(0x0730)
-#define CR_WEPKEY5 CTL_REG(0x0734)
-#define CR_WEPKEY6 CTL_REG(0x0738)
-#define CR_WEPKEY7 CTL_REG(0x073C)
-#define CR_WEPKEY8 CTL_REG(0x0740)
-#define CR_WEPKEY9 CTL_REG(0x0744)
-#define CR_WEPKEY10 CTL_REG(0x0748)
-#define CR_WEPKEY11 CTL_REG(0x074C)
-#define CR_WEPKEY12 CTL_REG(0x0750)
-#define CR_WEPKEY13 CTL_REG(0x0754)
-#define CR_WEPKEY14 CTL_REG(0x0758)
-#define CR_WEPKEY15 CTL_REG(0x075c)
-#define CR_TKIP_MODE CTL_REG(0x0760)
-
-#define CR_EEPROM_PROTECT0 CTL_REG(0x0758)
-#define CR_EEPROM_PROTECT1 CTL_REG(0x075C)
-
-#define CR_DBG_FIFO_RD CTL_REG(0x0800)
-#define CR_DBG_SELECT CTL_REG(0x0804)
-#define CR_FIFO_Length CTL_REG(0x0808)
-
-
-#define CR_RSSI_MGC CTL_REG(0x0810)
-
-#define CR_PON CTL_REG(0x0818)
-#define CR_RX_ON CTL_REG(0x081C)
-#define CR_TX_ON CTL_REG(0x0820)
-#define CR_CHIP_EN CTL_REG(0x0824)
-#define CR_LO_SW CTL_REG(0x0828)
-#define CR_TXRX_SW CTL_REG(0x082C)
-#define CR_S_MD CTL_REG(0x0830)
-
-#define CR_USB_DEBUG_PORT CTL_REG(0x0888)
-#define CR_ZD1211B_CWIN_MAX_MIN_AC0 CTL_REG(0x0b00)
-#define CR_ZD1211B_CWIN_MAX_MIN_AC1 CTL_REG(0x0b04)
-#define CR_ZD1211B_CWIN_MAX_MIN_AC2 CTL_REG(0x0b08)
-#define CR_ZD1211B_CWIN_MAX_MIN_AC3 CTL_REG(0x0b0c)
-#define CR_ZD1211B_AIFS_CTL1 CTL_REG(0x0b10)
-#define CR_ZD1211B_AIFS_CTL2 CTL_REG(0x0b14)
-#define CR_ZD1211B_TXOP CTL_REG(0x0b20)
-#define CR_ZD1211B_RETRY_MAX CTL_REG(0x0b28)
-
-/* Value for CR_ZD1211_RETRY_MAX & CR_ZD1211B_RETRY_MAX. Vendor driver uses 2,
- * we use 0. The first rate is tried (count+2), then all next rates are tried
- * twice, until 1 Mbits is tried. */
-#define ZD1211_RETRY_COUNT 0
-#define ZD1211B_RETRY_COUNT \
- (ZD1211_RETRY_COUNT << 0)| \
- (ZD1211_RETRY_COUNT << 8)| \
- (ZD1211_RETRY_COUNT << 16)| \
- (ZD1211_RETRY_COUNT << 24)
-
-/* Used to detect PLL lock */
-#define UW2453_INTR_REG ((zd_addr_t)0x85c1)
-
-#define CWIN_SIZE 0x007f043f
-
-
-#define HWINT_ENABLED \
- (INT_TX_COMPLETE_EN| \
- INT_RX_COMPLETE_EN| \
- INT_RETRY_FAIL_EN| \
- INT_WAKEUP_EN| \
- INT_CFG_NEXT_BCN_EN)
-
-#define HWINT_DISABLED 0
-
-#define E2P_PWR_INT_GUARD 8
-#define E2P_CHANNEL_COUNT 14
-
-/* If you compare this addresses with the ZYDAS orignal driver, please notify
- * that we use word mapping for the EEPROM.
- */
-
-/*
- * Upper 16 bit contains the regulatory domain.
- */
-#define E2P_SUBID E2P_DATA(0x00)
-#define E2P_POD E2P_DATA(0x02)
-#define E2P_MAC_ADDR_P1 E2P_DATA(0x04)
-#define E2P_MAC_ADDR_P2 E2P_DATA(0x06)
-#define E2P_PWR_CAL_VALUE1 E2P_DATA(0x08)
-#define E2P_PWR_CAL_VALUE2 E2P_DATA(0x0a)
-#define E2P_PWR_CAL_VALUE3 E2P_DATA(0x0c)
-#define E2P_PWR_CAL_VALUE4 E2P_DATA(0x0e)
-#define E2P_PWR_INT_VALUE1 E2P_DATA(0x10)
-#define E2P_PWR_INT_VALUE2 E2P_DATA(0x12)
-#define E2P_PWR_INT_VALUE3 E2P_DATA(0x14)
-#define E2P_PWR_INT_VALUE4 E2P_DATA(0x16)
-
-/* Contains a bit for each allowed channel. It gives for Europe (ETSI 0x30)
- * also only 11 channels. */
-#define E2P_ALLOWED_CHANNEL E2P_DATA(0x18)
-
-#define E2P_DEVICE_VER E2P_DATA(0x20)
-#define E2P_PHY_REG E2P_DATA(0x25)
-#define E2P_36M_CAL_VALUE1 E2P_DATA(0x28)
-#define E2P_36M_CAL_VALUE2 E2P_DATA(0x2a)
-#define E2P_36M_CAL_VALUE3 E2P_DATA(0x2c)
-#define E2P_36M_CAL_VALUE4 E2P_DATA(0x2e)
-#define E2P_11A_INT_VALUE1 E2P_DATA(0x30)
-#define E2P_11A_INT_VALUE2 E2P_DATA(0x32)
-#define E2P_11A_INT_VALUE3 E2P_DATA(0x34)
-#define E2P_11A_INT_VALUE4 E2P_DATA(0x36)
-#define E2P_48M_CAL_VALUE1 E2P_DATA(0x38)
-#define E2P_48M_CAL_VALUE2 E2P_DATA(0x3a)
-#define E2P_48M_CAL_VALUE3 E2P_DATA(0x3c)
-#define E2P_48M_CAL_VALUE4 E2P_DATA(0x3e)
-#define E2P_48M_INT_VALUE1 E2P_DATA(0x40)
-#define E2P_48M_INT_VALUE2 E2P_DATA(0x42)
-#define E2P_48M_INT_VALUE3 E2P_DATA(0x44)
-#define E2P_48M_INT_VALUE4 E2P_DATA(0x46)
-#define E2P_54M_CAL_VALUE1 E2P_DATA(0x48) /* ??? */
-#define E2P_54M_CAL_VALUE2 E2P_DATA(0x4a)
-#define E2P_54M_CAL_VALUE3 E2P_DATA(0x4c)
-#define E2P_54M_CAL_VALUE4 E2P_DATA(0x4e)
-#define E2P_54M_INT_VALUE1 E2P_DATA(0x50)
-#define E2P_54M_INT_VALUE2 E2P_DATA(0x52)
-#define E2P_54M_INT_VALUE3 E2P_DATA(0x54)
-#define E2P_54M_INT_VALUE4 E2P_DATA(0x56)
-
-/* This word contains the base address of the FW_REG_ registers below */
-#define FWRAW_REGS_ADDR FWRAW_DATA(0x1d)
-
-/* All 16 bit values, offset from the address in FWRAW_REGS_ADDR */
-enum {
- FW_REG_FIRMWARE_VER = 0,
- /* non-zero if USB high speed connection */
- FW_REG_USB_SPEED = 1,
- FW_REG_FIX_TX_RATE = 2,
- /* Seems to be able to control LEDs over the firmware */
- FW_REG_LED_LINK_STATUS = 3,
- FW_REG_SOFT_RESET = 4,
- FW_REG_FLASH_CHK = 5,
-};
-
-/* Values for FW_LINK_STATUS */
-#define FW_LINK_OFF 0x0
-#define FW_LINK_TX 0x1
-/* 0x2 - link led on? */
-
-enum {
- /* indices for ofdm_cal_values */
- OFDM_36M_INDEX = 0,
- OFDM_48M_INDEX = 1,
- OFDM_54M_INDEX = 2,
-};
-
-struct zd_chip {
- struct zd_usb usb;
- struct zd_rf rf;
- struct mutex mutex;
- /* Base address of FW_REG_ registers */
- zd_addr_t fw_regs_base;
- /* EepSetPoint in the vendor driver */
- u8 pwr_cal_values[E2P_CHANNEL_COUNT];
- /* integration values in the vendor driver */
- u8 pwr_int_values[E2P_CHANNEL_COUNT];
- /* SetPointOFDM in the vendor driver */
- u8 ofdm_cal_values[3][E2P_CHANNEL_COUNT];
- u16 link_led;
- unsigned int pa_type:4,
- patch_cck_gain:1, patch_cr157:1, patch_6m_band_edge:1,
- new_phy_layout:1, al2230s_bit:1,
- supports_tx_led:1;
-};
-
-static inline struct zd_chip *zd_usb_to_chip(struct zd_usb *usb)
-{
- return container_of(usb, struct zd_chip, usb);
-}
-
-static inline struct zd_chip *zd_rf_to_chip(struct zd_rf *rf)
-{
- return container_of(rf, struct zd_chip, rf);
-}
-
-#define zd_chip_dev(chip) (&(chip)->usb.intf->dev)
-
-void zd_chip_init(struct zd_chip *chip,
- struct ieee80211_hw *hw,
- struct usb_interface *intf);
-void zd_chip_clear(struct zd_chip *chip);
-int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr);
-int zd_chip_init_hw(struct zd_chip *chip);
-int zd_chip_reset(struct zd_chip *chip);
-
-static inline int zd_chip_is_zd1211b(struct zd_chip *chip)
-{
- return chip->usb.is_zd1211b;
-}
-
-static inline int zd_ioread16v_locked(struct zd_chip *chip, u16 *values,
- const zd_addr_t *addresses,
- unsigned int count)
-{
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_usb_ioread16v(&chip->usb, values, addresses, count);
-}
-
-static inline int zd_ioread16_locked(struct zd_chip *chip, u16 *value,
- const zd_addr_t addr)
-{
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_usb_ioread16(&chip->usb, value, addr);
-}
-
-int zd_ioread32v_locked(struct zd_chip *chip, u32 *values,
- const zd_addr_t *addresses, unsigned int count);
-
-static inline int zd_ioread32_locked(struct zd_chip *chip, u32 *value,
- const zd_addr_t addr)
-{
- return zd_ioread32v_locked(chip, value, &addr, 1);
-}
-
-static inline int zd_iowrite16_locked(struct zd_chip *chip, u16 value,
- zd_addr_t addr)
-{
- struct zd_ioreq16 ioreq;
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- ioreq.addr = addr;
- ioreq.value = value;
-
- return zd_usb_iowrite16v(&chip->usb, &ioreq, 1);
-}
-
-int zd_iowrite16a_locked(struct zd_chip *chip,
- const struct zd_ioreq16 *ioreqs, unsigned int count);
-
-int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
- unsigned int count);
-
-static inline int zd_iowrite32_locked(struct zd_chip *chip, u32 value,
- zd_addr_t addr)
-{
- struct zd_ioreq32 ioreq;
-
- ioreq.addr = addr;
- ioreq.value = value;
-
- return _zd_iowrite32v_locked(chip, &ioreq, 1);
-}
-
-int zd_iowrite32a_locked(struct zd_chip *chip,
- const struct zd_ioreq32 *ioreqs, unsigned int count);
-
-static inline int zd_rfwrite_locked(struct zd_chip *chip, u32 value, u8 bits)
-{
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- return zd_usb_rfwrite(&chip->usb, value, bits);
-}
-
-int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value);
-
-int zd_rfwritev_locked(struct zd_chip *chip,
- const u32* values, unsigned int count, u8 bits);
-int zd_rfwritev_cr_locked(struct zd_chip *chip,
- const u32* values, unsigned int count);
-
-/* Locking functions for reading and writing registers.
- * The different parameters are intentional.
- */
-int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value);
-int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value);
-int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value);
-int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value);
-int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
- u32 *values, unsigned int count);
-int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
- unsigned int count);
-
-int zd_chip_set_channel(struct zd_chip *chip, u8 channel);
-static inline u8 _zd_chip_get_channel(struct zd_chip *chip)
-{
- return chip->rf.channel;
-}
-u8 zd_chip_get_channel(struct zd_chip *chip);
-int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain);
-int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr);
-int zd_write_bssid(struct zd_chip *chip, const u8 *bssid);
-int zd_chip_switch_radio_on(struct zd_chip *chip);
-int zd_chip_switch_radio_off(struct zd_chip *chip);
-int zd_chip_enable_int(struct zd_chip *chip);
-void zd_chip_disable_int(struct zd_chip *chip);
-int zd_chip_enable_rxtx(struct zd_chip *chip);
-void zd_chip_disable_rxtx(struct zd_chip *chip);
-int zd_chip_enable_hwint(struct zd_chip *chip);
-int zd_chip_disable_hwint(struct zd_chip *chip);
-int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel);
-int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip, int preamble);
-
-static inline int zd_get_encryption_type(struct zd_chip *chip, u32 *type)
-{
- return zd_ioread32(chip, CR_ENCRYPTION_TYPE, type);
-}
-
-static inline int zd_set_encryption_type(struct zd_chip *chip, u32 type)
-{
- return zd_iowrite32(chip, CR_ENCRYPTION_TYPE, type);
-}
-
-static inline int zd_chip_get_basic_rates(struct zd_chip *chip, u16 *cr_rates)
-{
- return zd_ioread16(chip, CR_BASIC_RATE_TBL, cr_rates);
-}
-
-int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates);
-
-int zd_chip_lock_phy_regs(struct zd_chip *chip);
-int zd_chip_unlock_phy_regs(struct zd_chip *chip);
-
-enum led_status {
- ZD_LED_OFF = 0,
- ZD_LED_SCANNING = 1,
- ZD_LED_ASSOCIATED = 2,
-};
-
-int zd_chip_control_leds(struct zd_chip *chip, enum led_status status);
-
-int zd_set_beacon_interval(struct zd_chip *chip, u16 interval, u8 dtim_period,
- int type);
-
-static inline int zd_get_beacon_interval(struct zd_chip *chip, u32 *interval)
-{
- return zd_ioread32(chip, CR_BCN_INTERVAL, interval);
-}
-
-struct rx_status;
-
-u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status);
-
-struct zd_mc_hash {
- u32 low;
- u32 high;
-};
-
-static inline void zd_mc_clear(struct zd_mc_hash *hash)
-{
- hash->low = 0;
- /* The interfaces must always received broadcasts.
- * The hash of the broadcast address ff:ff:ff:ff:ff:ff is 63.
- */
- hash->high = 0x80000000;
-}
-
-static inline void zd_mc_add_all(struct zd_mc_hash *hash)
-{
- hash->low = hash->high = 0xffffffff;
-}
-
-static inline void zd_mc_add_addr(struct zd_mc_hash *hash, u8 *addr)
-{
- unsigned int i = addr[5] >> 2;
- if (i < 32) {
- hash->low |= 1 << i;
- } else {
- hash->high |= 1 << (i-32);
- }
-}
-
-int zd_chip_set_multicast_hash(struct zd_chip *chip,
- struct zd_mc_hash *hash);
-
-u64 zd_chip_get_tsf(struct zd_chip *chip);
-
-#endif /* _ZD_CHIP_H */
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _ZD_DEF_H
-#define _ZD_DEF_H
-
-#include <linux/kernel.h>
-#include <linux/stringify.h>
-#include <linux/device.h>
-
-typedef u16 __nocast zd_addr_t;
-
-#define dev_printk_f(level, dev, fmt, args...) \
- dev_printk(level, dev, "%s() " fmt, __func__, ##args)
-
-#ifdef DEBUG
-# define dev_dbg_f(dev, fmt, args...) \
- dev_printk_f(KERN_DEBUG, dev, fmt, ## args)
-# define dev_dbg_f_limit(dev, fmt, args...) do { \
- if (net_ratelimit()) \
- dev_printk_f(KERN_DEBUG, dev, fmt, ## args); \
-} while (0)
-# define dev_dbg_f_cond(dev, cond, fmt, args...) ({ \
- bool __cond = !!(cond); \
- if (unlikely(__cond)) \
- dev_printk_f(KERN_DEBUG, dev, fmt, ## args); \
-})
-#else
-# define dev_dbg_f(dev, fmt, args...) do { (void)(dev); } while (0)
-# define dev_dbg_f_limit(dev, fmt, args...) do { (void)(dev); } while (0)
-# define dev_dbg_f_cond(dev, cond, fmt, args...) do { (void)(dev); } while (0)
-#endif /* DEBUG */
-
-#ifdef DEBUG
-# define ZD_ASSERT(x) \
-do { \
- if (unlikely(!(x))) { \
- pr_debug("%s:%d ASSERT %s VIOLATED!\n", \
- __FILE__, __LINE__, __stringify(x)); \
- dump_stack(); \
- } \
-} while (0)
-#else
-# define ZD_ASSERT(x) do { } while (0)
-#endif
-
-#ifdef DEBUG
-# define ZD_MEMCLEAR(pointer, size) memset((pointer), 0xff, (size))
-#else
-# define ZD_MEMCLEAR(pointer, size) do { } while (0)
-#endif
-
-#endif /* _ZD_DEF_H */
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
- * Copyright (C) 2007-2008 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/netdevice.h>
-#include <linux/etherdevice.h>
-#include <linux/slab.h>
-#include <linux/usb.h>
-#include <linux/jiffies.h>
-#include <net/ieee80211_radiotap.h>
-
-#include "zd_def.h"
-#include "zd_chip.h"
-#include "zd_mac.h"
-#include "zd_rf.h"
-
-struct zd_reg_alpha2_map {
- u32 reg;
- char alpha2[2];
-};
-
-static struct zd_reg_alpha2_map reg_alpha2_map[] = {
- { ZD_REGDOMAIN_FCC, "US" },
- { ZD_REGDOMAIN_IC, "CA" },
- { ZD_REGDOMAIN_ETSI, "DE" }, /* Generic ETSI, use most restrictive */
- { ZD_REGDOMAIN_JAPAN, "JP" },
- { ZD_REGDOMAIN_JAPAN_2, "JP" },
- { ZD_REGDOMAIN_JAPAN_3, "JP" },
- { ZD_REGDOMAIN_SPAIN, "ES" },
- { ZD_REGDOMAIN_FRANCE, "FR" },
-};
-
-/* This table contains the hardware specific values for the modulation rates. */
-static const struct ieee80211_rate zd_rates[] = {
- { .bitrate = 10,
- .hw_value = ZD_CCK_RATE_1M, },
- { .bitrate = 20,
- .hw_value = ZD_CCK_RATE_2M,
- .hw_value_short = ZD_CCK_RATE_2M | ZD_CCK_PREA_SHORT,
- .flags = IEEE80211_RATE_SHORT_PREAMBLE },
- { .bitrate = 55,
- .hw_value = ZD_CCK_RATE_5_5M,
- .hw_value_short = ZD_CCK_RATE_5_5M | ZD_CCK_PREA_SHORT,
- .flags = IEEE80211_RATE_SHORT_PREAMBLE },
- { .bitrate = 110,
- .hw_value = ZD_CCK_RATE_11M,
- .hw_value_short = ZD_CCK_RATE_11M | ZD_CCK_PREA_SHORT,
- .flags = IEEE80211_RATE_SHORT_PREAMBLE },
- { .bitrate = 60,
- .hw_value = ZD_OFDM_RATE_6M,
- .flags = 0 },
- { .bitrate = 90,
- .hw_value = ZD_OFDM_RATE_9M,
- .flags = 0 },
- { .bitrate = 120,
- .hw_value = ZD_OFDM_RATE_12M,
- .flags = 0 },
- { .bitrate = 180,
- .hw_value = ZD_OFDM_RATE_18M,
- .flags = 0 },
- { .bitrate = 240,
- .hw_value = ZD_OFDM_RATE_24M,
- .flags = 0 },
- { .bitrate = 360,
- .hw_value = ZD_OFDM_RATE_36M,
- .flags = 0 },
- { .bitrate = 480,
- .hw_value = ZD_OFDM_RATE_48M,
- .flags = 0 },
- { .bitrate = 540,
- .hw_value = ZD_OFDM_RATE_54M,
- .flags = 0 },
-};
-
-/*
- * Zydas retry rates table. Each line is listed in the same order as
- * in zd_rates[] and contains all the rate used when a packet is sent
- * starting with a given rates. Let's consider an example :
- *
- * "11 Mbits : 4, 3, 2, 1, 0" means :
- * - packet is sent using 4 different rates
- * - 1st rate is index 3 (ie 11 Mbits)
- * - 2nd rate is index 2 (ie 5.5 Mbits)
- * - 3rd rate is index 1 (ie 2 Mbits)
- * - 4th rate is index 0 (ie 1 Mbits)
- */
-
-static const struct tx_retry_rate zd_retry_rates[] = {
- { /* 1 Mbits */ 1, { 0 }},
- { /* 2 Mbits */ 2, { 1, 0 }},
- { /* 5.5 Mbits */ 3, { 2, 1, 0 }},
- { /* 11 Mbits */ 4, { 3, 2, 1, 0 }},
- { /* 6 Mbits */ 5, { 4, 3, 2, 1, 0 }},
- { /* 9 Mbits */ 6, { 5, 4, 3, 2, 1, 0}},
- { /* 12 Mbits */ 5, { 6, 3, 2, 1, 0 }},
- { /* 18 Mbits */ 6, { 7, 6, 3, 2, 1, 0 }},
- { /* 24 Mbits */ 6, { 8, 6, 3, 2, 1, 0 }},
- { /* 36 Mbits */ 7, { 9, 8, 6, 3, 2, 1, 0 }},
- { /* 48 Mbits */ 8, {10, 9, 8, 6, 3, 2, 1, 0 }},
- { /* 54 Mbits */ 9, {11, 10, 9, 8, 6, 3, 2, 1, 0 }}
-};
-
-static const struct ieee80211_channel zd_channels[] = {
- { .center_freq = 2412, .hw_value = 1 },
- { .center_freq = 2417, .hw_value = 2 },
- { .center_freq = 2422, .hw_value = 3 },
- { .center_freq = 2427, .hw_value = 4 },
- { .center_freq = 2432, .hw_value = 5 },
- { .center_freq = 2437, .hw_value = 6 },
- { .center_freq = 2442, .hw_value = 7 },
- { .center_freq = 2447, .hw_value = 8 },
- { .center_freq = 2452, .hw_value = 9 },
- { .center_freq = 2457, .hw_value = 10 },
- { .center_freq = 2462, .hw_value = 11 },
- { .center_freq = 2467, .hw_value = 12 },
- { .center_freq = 2472, .hw_value = 13 },
- { .center_freq = 2484, .hw_value = 14 },
-};
-
-static void housekeeping_init(struct zd_mac *mac);
-static void housekeeping_enable(struct zd_mac *mac);
-static void housekeeping_disable(struct zd_mac *mac);
-static void beacon_init(struct zd_mac *mac);
-static void beacon_enable(struct zd_mac *mac);
-static void beacon_disable(struct zd_mac *mac);
-static void set_rts_cts(struct zd_mac *mac, unsigned int short_preamble);
-static int zd_mac_config_beacon(struct ieee80211_hw *hw,
- struct sk_buff *beacon, bool in_intr);
-
-static int zd_reg2alpha2(u8 regdomain, char *alpha2)
-{
- unsigned int i;
- struct zd_reg_alpha2_map *reg_map;
- for (i = 0; i < ARRAY_SIZE(reg_alpha2_map); i++) {
- reg_map = ®_alpha2_map[i];
- if (regdomain == reg_map->reg) {
- alpha2[0] = reg_map->alpha2[0];
- alpha2[1] = reg_map->alpha2[1];
- return 0;
- }
- }
- return 1;
-}
-
-static int zd_check_signal(struct ieee80211_hw *hw, int signal)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
-
- dev_dbg_f_cond(zd_mac_dev(mac), signal < 0 || signal > 100,
- "%s: signal value from device not in range 0..100, "
- "but %d.\n", __func__, signal);
-
- if (signal < 0)
- signal = 0;
- else if (signal > 100)
- signal = 100;
-
- return signal;
-}
-
-int zd_mac_preinit_hw(struct ieee80211_hw *hw)
-{
- int r;
- u8 addr[ETH_ALEN];
- struct zd_mac *mac = zd_hw_mac(hw);
-
- r = zd_chip_read_mac_addr_fw(&mac->chip, addr);
- if (r)
- return r;
-
- SET_IEEE80211_PERM_ADDR(hw, addr);
-
- return 0;
-}
-
-int zd_mac_init_hw(struct ieee80211_hw *hw)
-{
- int r;
- struct zd_mac *mac = zd_hw_mac(hw);
- struct zd_chip *chip = &mac->chip;
- char alpha2[2];
- u8 default_regdomain;
-
- r = zd_chip_enable_int(chip);
- if (r)
- goto out;
- r = zd_chip_init_hw(chip);
- if (r)
- goto disable_int;
-
- ZD_ASSERT(!irqs_disabled());
-
- r = zd_read_regdomain(chip, &default_regdomain);
- if (r)
- goto disable_int;
- spin_lock_irq(&mac->lock);
- mac->regdomain = mac->default_regdomain = default_regdomain;
- spin_unlock_irq(&mac->lock);
-
- /* We must inform the device that we are doing encryption/decryption in
- * software at the moment. */
- r = zd_set_encryption_type(chip, ENC_SNIFFER);
- if (r)
- goto disable_int;
-
- r = zd_reg2alpha2(mac->regdomain, alpha2);
- if (r)
- goto disable_int;
-
- r = regulatory_hint(hw->wiphy, alpha2);
-disable_int:
- zd_chip_disable_int(chip);
-out:
- return r;
-}
-
-void zd_mac_clear(struct zd_mac *mac)
-{
- flush_workqueue(zd_workqueue);
- zd_chip_clear(&mac->chip);
- ZD_ASSERT(!spin_is_locked(&mac->lock));
- ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
-}
-
-static int set_rx_filter(struct zd_mac *mac)
-{
- unsigned long flags;
- u32 filter = STA_RX_FILTER;
-
- spin_lock_irqsave(&mac->lock, flags);
- if (mac->pass_ctrl)
- filter |= RX_FILTER_CTRL;
- spin_unlock_irqrestore(&mac->lock, flags);
-
- return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
-}
-
-static int set_mac_and_bssid(struct zd_mac *mac)
-{
- int r;
-
- if (!mac->vif)
- return -1;
-
- r = zd_write_mac_addr(&mac->chip, mac->vif->addr);
- if (r)
- return r;
-
- /* Vendor driver after setting MAC either sets BSSID for AP or
- * filter for other modes.
- */
- if (mac->type != NL80211_IFTYPE_AP)
- return set_rx_filter(mac);
- else
- return zd_write_bssid(&mac->chip, mac->vif->addr);
-}
-
-static int set_mc_hash(struct zd_mac *mac)
-{
- struct zd_mc_hash hash;
- zd_mc_clear(&hash);
- return zd_chip_set_multicast_hash(&mac->chip, &hash);
-}
-
-int zd_op_start(struct ieee80211_hw *hw)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct zd_chip *chip = &mac->chip;
- struct zd_usb *usb = &chip->usb;
- int r;
-
- if (!usb->initialized) {
- r = zd_usb_init_hw(usb);
- if (r)
- goto out;
- }
-
- r = zd_chip_enable_int(chip);
- if (r < 0)
- goto out;
-
- r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G);
- if (r < 0)
- goto disable_int;
- r = set_rx_filter(mac);
- if (r)
- goto disable_int;
- r = set_mc_hash(mac);
- if (r)
- goto disable_int;
-
- /* Wait after setting the multicast hash table and powering on
- * the radio otherwise interface bring up will fail. This matches
- * what the vendor driver did.
- */
- msleep(10);
-
- r = zd_chip_switch_radio_on(chip);
- if (r < 0) {
- dev_err(zd_chip_dev(chip),
- "%s: failed to set radio on\n", __func__);
- goto disable_int;
- }
- r = zd_chip_enable_rxtx(chip);
- if (r < 0)
- goto disable_radio;
- r = zd_chip_enable_hwint(chip);
- if (r < 0)
- goto disable_rxtx;
-
- housekeeping_enable(mac);
- beacon_enable(mac);
- set_bit(ZD_DEVICE_RUNNING, &mac->flags);
- return 0;
-disable_rxtx:
- zd_chip_disable_rxtx(chip);
-disable_radio:
- zd_chip_switch_radio_off(chip);
-disable_int:
- zd_chip_disable_int(chip);
-out:
- return r;
-}
-
-void zd_op_stop(struct ieee80211_hw *hw)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct zd_chip *chip = &mac->chip;
- struct sk_buff *skb;
- struct sk_buff_head *ack_wait_queue = &mac->ack_wait_queue;
-
- clear_bit(ZD_DEVICE_RUNNING, &mac->flags);
-
- /* The order here deliberately is a little different from the open()
- * method, since we need to make sure there is no opportunity for RX
- * frames to be processed by mac80211 after we have stopped it.
- */
-
- zd_chip_disable_rxtx(chip);
- beacon_disable(mac);
- housekeeping_disable(mac);
- flush_workqueue(zd_workqueue);
-
- zd_chip_disable_hwint(chip);
- zd_chip_switch_radio_off(chip);
- zd_chip_disable_int(chip);
-
-
- while ((skb = skb_dequeue(ack_wait_queue)))
- dev_kfree_skb_any(skb);
-}
-
-int zd_restore_settings(struct zd_mac *mac)
-{
- struct sk_buff *beacon;
- struct zd_mc_hash multicast_hash;
- unsigned int short_preamble;
- int r, beacon_interval, beacon_period;
- u8 channel;
-
- dev_dbg_f(zd_mac_dev(mac), "\n");
-
- spin_lock_irq(&mac->lock);
- multicast_hash = mac->multicast_hash;
- short_preamble = mac->short_preamble;
- beacon_interval = mac->beacon.interval;
- beacon_period = mac->beacon.period;
- channel = mac->channel;
- spin_unlock_irq(&mac->lock);
-
- r = set_mac_and_bssid(mac);
- if (r < 0) {
- dev_dbg_f(zd_mac_dev(mac), "set_mac_and_bssid failed, %d\n", r);
- return r;
- }
-
- r = zd_chip_set_channel(&mac->chip, channel);
- if (r < 0) {
- dev_dbg_f(zd_mac_dev(mac), "zd_chip_set_channel failed, %d\n",
- r);
- return r;
- }
-
- set_rts_cts(mac, short_preamble);
-
- r = zd_chip_set_multicast_hash(&mac->chip, &multicast_hash);
- if (r < 0) {
- dev_dbg_f(zd_mac_dev(mac),
- "zd_chip_set_multicast_hash failed, %d\n", r);
- return r;
- }
-
- if (mac->type == NL80211_IFTYPE_MESH_POINT ||
- mac->type == NL80211_IFTYPE_ADHOC ||
- mac->type == NL80211_IFTYPE_AP) {
- if (mac->vif != NULL) {
- beacon = ieee80211_beacon_get(mac->hw, mac->vif);
- if (beacon)
- zd_mac_config_beacon(mac->hw, beacon, false);
- }
-
- zd_set_beacon_interval(&mac->chip, beacon_interval,
- beacon_period, mac->type);
-
- spin_lock_irq(&mac->lock);
- mac->beacon.last_update = jiffies;
- spin_unlock_irq(&mac->lock);
- }
-
- return 0;
-}
-
-/**
- * zd_mac_tx_status - reports tx status of a packet if required
- * @hw - a &struct ieee80211_hw pointer
- * @skb - a sk-buffer
- * @flags: extra flags to set in the TX status info
- * @ackssi: ACK signal strength
- * @success - True for successful transmission of the frame
- *
- * This information calls ieee80211_tx_status_irqsafe() if required by the
- * control information. It copies the control information into the status
- * information.
- *
- * If no status information has been requested, the skb is freed.
- */
-static void zd_mac_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb,
- int ackssi, struct tx_status *tx_status)
-{
- struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
- int i;
- int success = 1, retry = 1;
- int first_idx;
- const struct tx_retry_rate *retries;
-
- ieee80211_tx_info_clear_status(info);
-
- if (tx_status) {
- success = !tx_status->failure;
- retry = tx_status->retry + success;
- }
-
- if (success) {
- /* success */
- info->flags |= IEEE80211_TX_STAT_ACK;
- } else {
- /* failure */
- info->flags &= ~IEEE80211_TX_STAT_ACK;
- }
-
- first_idx = info->status.rates[0].idx;
- ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
- retries = &zd_retry_rates[first_idx];
- ZD_ASSERT(1 <= retry && retry <= retries->count);
-
- info->status.rates[0].idx = retries->rate[0];
- info->status.rates[0].count = 1; // (retry > 1 ? 2 : 1);
-
- for (i=1; i<IEEE80211_TX_MAX_RATES-1 && i<retry; i++) {
- info->status.rates[i].idx = retries->rate[i];
- info->status.rates[i].count = 1; // ((i==retry-1) && success ? 1:2);
- }
- for (; i<IEEE80211_TX_MAX_RATES && i<retry; i++) {
- info->status.rates[i].idx = retries->rate[retry - 1];
- info->status.rates[i].count = 1; // (success ? 1:2);
- }
- if (i<IEEE80211_TX_MAX_RATES)
- info->status.rates[i].idx = -1; /* terminate */
-
- info->status.ack_signal = zd_check_signal(hw, ackssi);
- ieee80211_tx_status_irqsafe(hw, skb);
-}
-
-/**
- * zd_mac_tx_failed - callback for failed frames
- * @dev: the mac80211 wireless device
- *
- * This function is called if a frame couldn't be successfully
- * transferred. The first frame from the tx queue, will be selected and
- * reported as error to the upper layers.
- */
-void zd_mac_tx_failed(struct urb *urb)
-{
- struct ieee80211_hw * hw = zd_usb_to_hw(urb->context);
- struct zd_mac *mac = zd_hw_mac(hw);
- struct sk_buff_head *q = &mac->ack_wait_queue;
- struct sk_buff *skb;
- struct tx_status *tx_status = (struct tx_status *)urb->transfer_buffer;
- unsigned long flags;
- int success = !tx_status->failure;
- int retry = tx_status->retry + success;
- int found = 0;
- int i, position = 0;
-
- q = &mac->ack_wait_queue;
- spin_lock_irqsave(&q->lock, flags);
-
- skb_queue_walk(q, skb) {
- struct ieee80211_hdr *tx_hdr;
- struct ieee80211_tx_info *info;
- int first_idx, final_idx;
- const struct tx_retry_rate *retries;
- u8 final_rate;
-
- position ++;
-
- /* if the hardware reports a failure and we had a 802.11 ACK
- * pending, then we skip the first skb when searching for a
- * matching frame */
- if (tx_status->failure && mac->ack_pending &&
- skb_queue_is_first(q, skb)) {
- continue;
- }
-
- tx_hdr = (struct ieee80211_hdr *)skb->data;
-
- /* we skip all frames not matching the reported destination */
- if (unlikely(!ether_addr_equal(tx_hdr->addr1, tx_status->mac)))
- continue;
-
- /* we skip all frames not matching the reported final rate */
-
- info = IEEE80211_SKB_CB(skb);
- first_idx = info->status.rates[0].idx;
- ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
- retries = &zd_retry_rates[first_idx];
- if (retry <= 0 || retry > retries->count)
- continue;
-
- final_idx = retries->rate[retry - 1];
- final_rate = zd_rates[final_idx].hw_value;
-
- if (final_rate != tx_status->rate) {
- continue;
- }
-
- found = 1;
- break;
- }
-
- if (found) {
- for (i=1; i<=position; i++) {
- skb = __skb_dequeue(q);
- zd_mac_tx_status(hw, skb,
- mac->ack_pending ? mac->ack_signal : 0,
- i == position ? tx_status : NULL);
- mac->ack_pending = 0;
- }
- }
-
- spin_unlock_irqrestore(&q->lock, flags);
-}
-
-/**
- * zd_mac_tx_to_dev - callback for USB layer
- * @skb: a &sk_buff pointer
- * @error: error value, 0 if transmission successful
- *
- * Informs the MAC layer that the frame has successfully transferred to the
- * device. If an ACK is required and the transfer to the device has been
- * successful, the packets are put on the @ack_wait_queue with
- * the control set removed.
- */
-void zd_mac_tx_to_dev(struct sk_buff *skb, int error)
-{
- struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
- struct ieee80211_hw *hw = info->rate_driver_data[0];
- struct zd_mac *mac = zd_hw_mac(hw);
-
- ieee80211_tx_info_clear_status(info);
-
- skb_pull(skb, sizeof(struct zd_ctrlset));
- if (unlikely(error ||
- (info->flags & IEEE80211_TX_CTL_NO_ACK))) {
- /*
- * FIXME : do we need to fill in anything ?
- */
- ieee80211_tx_status_irqsafe(hw, skb);
- } else {
- struct sk_buff_head *q = &mac->ack_wait_queue;
-
- skb_queue_tail(q, skb);
- while (skb_queue_len(q) > ZD_MAC_MAX_ACK_WAITERS) {
- zd_mac_tx_status(hw, skb_dequeue(q),
- mac->ack_pending ? mac->ack_signal : 0,
- NULL);
- mac->ack_pending = 0;
- }
- }
-}
-
-static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
-{
- /* ZD_PURE_RATE() must be used to remove the modulation type flag of
- * the zd-rate values.
- */
- static const u8 rate_divisor[] = {
- [ZD_PURE_RATE(ZD_CCK_RATE_1M)] = 1,
- [ZD_PURE_RATE(ZD_CCK_RATE_2M)] = 2,
- /* Bits must be doubled. */
- [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)] = 11,
- [ZD_PURE_RATE(ZD_CCK_RATE_11M)] = 11,
- [ZD_PURE_RATE(ZD_OFDM_RATE_6M)] = 6,
- [ZD_PURE_RATE(ZD_OFDM_RATE_9M)] = 9,
- [ZD_PURE_RATE(ZD_OFDM_RATE_12M)] = 12,
- [ZD_PURE_RATE(ZD_OFDM_RATE_18M)] = 18,
- [ZD_PURE_RATE(ZD_OFDM_RATE_24M)] = 24,
- [ZD_PURE_RATE(ZD_OFDM_RATE_36M)] = 36,
- [ZD_PURE_RATE(ZD_OFDM_RATE_48M)] = 48,
- [ZD_PURE_RATE(ZD_OFDM_RATE_54M)] = 54,
- };
-
- u32 bits = (u32)tx_length * 8;
- u32 divisor;
-
- divisor = rate_divisor[ZD_PURE_RATE(zd_rate)];
- if (divisor == 0)
- return -EINVAL;
-
- switch (zd_rate) {
- case ZD_CCK_RATE_5_5M:
- bits = (2*bits) + 10; /* round up to the next integer */
- break;
- case ZD_CCK_RATE_11M:
- if (service) {
- u32 t = bits % 11;
- *service &= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION;
- if (0 < t && t <= 3) {
- *service |= ZD_PLCP_SERVICE_LENGTH_EXTENSION;
- }
- }
- bits += 10; /* round up to the next integer */
- break;
- }
-
- return bits/divisor;
-}
-
-static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
- struct ieee80211_hdr *header,
- struct ieee80211_tx_info *info)
-{
- /*
- * CONTROL TODO:
- * - if backoff needed, enable bit 0
- * - if burst (backoff not needed) disable bit 0
- */
-
- cs->control = 0;
-
- /* First fragment */
- if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
- cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
-
- /* No ACK expected (multicast, etc.) */
- if (info->flags & IEEE80211_TX_CTL_NO_ACK)
- cs->control |= ZD_CS_NO_ACK;
-
- /* PS-POLL */
- if (ieee80211_is_pspoll(header->frame_control))
- cs->control |= ZD_CS_PS_POLL_FRAME;
-
- if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
- cs->control |= ZD_CS_RTS;
-
- if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
- cs->control |= ZD_CS_SELF_CTS;
-
- /* FIXME: Management frame? */
-}
-
-static bool zd_mac_match_cur_beacon(struct zd_mac *mac, struct sk_buff *beacon)
-{
- if (!mac->beacon.cur_beacon)
- return false;
-
- if (mac->beacon.cur_beacon->len != beacon->len)
- return false;
-
- return !memcmp(beacon->data, mac->beacon.cur_beacon->data, beacon->len);
-}
-
-static void zd_mac_free_cur_beacon_locked(struct zd_mac *mac)
-{
- ZD_ASSERT(mutex_is_locked(&mac->chip.mutex));
-
- kfree_skb(mac->beacon.cur_beacon);
- mac->beacon.cur_beacon = NULL;
-}
-
-static void zd_mac_free_cur_beacon(struct zd_mac *mac)
-{
- mutex_lock(&mac->chip.mutex);
- zd_mac_free_cur_beacon_locked(mac);
- mutex_unlock(&mac->chip.mutex);
-}
-
-static int zd_mac_config_beacon(struct ieee80211_hw *hw, struct sk_buff *beacon,
- bool in_intr)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- int r, ret, num_cmds, req_pos = 0;
- u32 tmp, j = 0;
- /* 4 more bytes for tail CRC */
- u32 full_len = beacon->len + 4;
- unsigned long end_jiffies, message_jiffies;
- struct zd_ioreq32 *ioreqs;
-
- mutex_lock(&mac->chip.mutex);
-
- /* Check if hw already has this beacon. */
- if (zd_mac_match_cur_beacon(mac, beacon)) {
- r = 0;
- goto out_nofree;
- }
-
- /* Alloc memory for full beacon write at once. */
- num_cmds = 1 + zd_chip_is_zd1211b(&mac->chip) + full_len;
- ioreqs = kmalloc(num_cmds * sizeof(struct zd_ioreq32), GFP_KERNEL);
- if (!ioreqs) {
- r = -ENOMEM;
- goto out_nofree;
- }
-
- r = zd_iowrite32_locked(&mac->chip, 0, CR_BCN_FIFO_SEMAPHORE);
- if (r < 0)
- goto out;
- r = zd_ioread32_locked(&mac->chip, &tmp, CR_BCN_FIFO_SEMAPHORE);
- if (r < 0)
- goto release_sema;
- if (in_intr && tmp & 0x2) {
- r = -EBUSY;
- goto release_sema;
- }
-
- end_jiffies = jiffies + HZ / 2; /*~500ms*/
- message_jiffies = jiffies + HZ / 10; /*~100ms*/
- while (tmp & 0x2) {
- r = zd_ioread32_locked(&mac->chip, &tmp, CR_BCN_FIFO_SEMAPHORE);
- if (r < 0)
- goto release_sema;
- if (time_is_before_eq_jiffies(message_jiffies)) {
- message_jiffies = jiffies + HZ / 10;
- dev_err(zd_mac_dev(mac),
- "CR_BCN_FIFO_SEMAPHORE not ready\n");
- if (time_is_before_eq_jiffies(end_jiffies)) {
- dev_err(zd_mac_dev(mac),
- "Giving up beacon config.\n");
- r = -ETIMEDOUT;
- goto reset_device;
- }
- }
- msleep(20);
- }
-
- ioreqs[req_pos].addr = CR_BCN_FIFO;
- ioreqs[req_pos].value = full_len - 1;
- req_pos++;
- if (zd_chip_is_zd1211b(&mac->chip)) {
- ioreqs[req_pos].addr = CR_BCN_LENGTH;
- ioreqs[req_pos].value = full_len - 1;
- req_pos++;
- }
-
- for (j = 0 ; j < beacon->len; j++) {
- ioreqs[req_pos].addr = CR_BCN_FIFO;
- ioreqs[req_pos].value = *((u8 *)(beacon->data + j));
- req_pos++;
- }
-
- for (j = 0; j < 4; j++) {
- ioreqs[req_pos].addr = CR_BCN_FIFO;
- ioreqs[req_pos].value = 0x0;
- req_pos++;
- }
-
- BUG_ON(req_pos != num_cmds);
-
- r = zd_iowrite32a_locked(&mac->chip, ioreqs, num_cmds);
-
-release_sema:
- /*
- * Try very hard to release device beacon semaphore, as otherwise
- * device/driver can be left in unusable state.
- */
- end_jiffies = jiffies + HZ / 2; /*~500ms*/
- ret = zd_iowrite32_locked(&mac->chip, 1, CR_BCN_FIFO_SEMAPHORE);
- while (ret < 0) {
- if (in_intr || time_is_before_eq_jiffies(end_jiffies)) {
- ret = -ETIMEDOUT;
- break;
- }
-
- msleep(20);
- ret = zd_iowrite32_locked(&mac->chip, 1, CR_BCN_FIFO_SEMAPHORE);
- }
-
- if (ret < 0)
- dev_err(zd_mac_dev(mac), "Could not release "
- "CR_BCN_FIFO_SEMAPHORE!\n");
- if (r < 0 || ret < 0) {
- if (r >= 0)
- r = ret;
-
- /* We don't know if beacon was written successfully or not,
- * so clear current. */
- zd_mac_free_cur_beacon_locked(mac);
-
- goto out;
- }
-
- /* Beacon has now been written successfully, update current. */
- zd_mac_free_cur_beacon_locked(mac);
- mac->beacon.cur_beacon = beacon;
- beacon = NULL;
-
- /* 802.11b/g 2.4G CCK 1Mb
- * 802.11a, not yet implemented, uses different values (see GPL vendor
- * driver)
- */
- r = zd_iowrite32_locked(&mac->chip, 0x00000400 | (full_len << 19),
- CR_BCN_PLCP_CFG);
-out:
- kfree(ioreqs);
-out_nofree:
- kfree_skb(beacon);
- mutex_unlock(&mac->chip.mutex);
-
- return r;
-
-reset_device:
- zd_mac_free_cur_beacon_locked(mac);
- kfree_skb(beacon);
-
- mutex_unlock(&mac->chip.mutex);
- kfree(ioreqs);
-
- /* semaphore stuck, reset device to avoid fw freeze later */
- dev_warn(zd_mac_dev(mac), "CR_BCN_FIFO_SEMAPHORE stuck, "
- "resetting device...");
- usb_queue_reset_device(mac->chip.usb.intf);
-
- return r;
-}
-
-static int fill_ctrlset(struct zd_mac *mac,
- struct sk_buff *skb)
-{
- int r;
- struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
- unsigned int frag_len = skb->len + FCS_LEN;
- unsigned int packet_length;
- struct ieee80211_rate *txrate;
- struct zd_ctrlset *cs = (struct zd_ctrlset *)
- skb_push(skb, sizeof(struct zd_ctrlset));
- struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
-
- ZD_ASSERT(frag_len <= 0xffff);
-
- /*
- * Firmware computes the duration itself (for all frames except PSPoll)
- * and needs the field set to 0 at input, otherwise firmware messes up
- * duration_id and sets bits 14 and 15 on.
- */
- if (!ieee80211_is_pspoll(hdr->frame_control))
- hdr->duration_id = 0;
-
- txrate = ieee80211_get_tx_rate(mac->hw, info);
-
- cs->modulation = txrate->hw_value;
- if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
- cs->modulation = txrate->hw_value_short;
-
- cs->tx_length = cpu_to_le16(frag_len);
-
- cs_set_control(mac, cs, hdr, info);
-
- packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
- ZD_ASSERT(packet_length <= 0xffff);
- /* ZD1211B: Computing the length difference this way, gives us
- * flexibility to compute the packet length.
- */
- cs->packet_length = cpu_to_le16(zd_chip_is_zd1211b(&mac->chip) ?
- packet_length - frag_len : packet_length);
-
- /*
- * CURRENT LENGTH:
- * - transmit frame length in microseconds
- * - seems to be derived from frame length
- * - see Cal_Us_Service() in zdinlinef.h
- * - if macp->bTxBurstEnable is enabled, then multiply by 4
- * - bTxBurstEnable is never set in the vendor driver
- *
- * SERVICE:
- * - "for PLCP configuration"
- * - always 0 except in some situations at 802.11b 11M
- * - see line 53 of zdinlinef.h
- */
- cs->service = 0;
- r = zd_calc_tx_length_us(&cs->service, ZD_RATE(cs->modulation),
- le16_to_cpu(cs->tx_length));
- if (r < 0)
- return r;
- cs->current_length = cpu_to_le16(r);
- cs->next_frame_length = 0;
-
- return 0;
-}
-
-/**
- * zd_op_tx - transmits a network frame to the device
- *
- * @dev: mac80211 hardware device
- * @skb: socket buffer
- * @control: the control structure
- *
- * This function transmit an IEEE 802.11 network frame to the device. The
- * control block of the skbuff will be initialized. If necessary the incoming
- * mac80211 queues will be stopped.
- */
-static void zd_op_tx(struct ieee80211_hw *hw,
- struct ieee80211_tx_control *control,
- struct sk_buff *skb)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
- int r;
-
- r = fill_ctrlset(mac, skb);
- if (r)
- goto fail;
-
- info->rate_driver_data[0] = hw;
-
- r = zd_usb_tx(&mac->chip.usb, skb);
- if (r)
- goto fail;
- return;
-
-fail:
- dev_kfree_skb(skb);
-}
-
-/**
- * filter_ack - filters incoming packets for acknowledgements
- * @dev: the mac80211 device
- * @rx_hdr: received header
- * @stats: the status for the received packet
- *
- * This functions looks for ACK packets and tries to match them with the
- * frames in the tx queue. If a match is found the frame will be dequeued and
- * the upper layers is informed about the successful transmission. If
- * mac80211 queues have been stopped and the number of frames still to be
- * transmitted is low the queues will be opened again.
- *
- * Returns 1 if the frame was an ACK, 0 if it was ignored.
- */
-static int filter_ack(struct ieee80211_hw *hw, struct ieee80211_hdr *rx_hdr,
- struct ieee80211_rx_status *stats)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct sk_buff *skb;
- struct sk_buff_head *q;
- unsigned long flags;
- int found = 0;
- int i, position = 0;
-
- if (!ieee80211_is_ack(rx_hdr->frame_control))
- return 0;
-
- q = &mac->ack_wait_queue;
- spin_lock_irqsave(&q->lock, flags);
- skb_queue_walk(q, skb) {
- struct ieee80211_hdr *tx_hdr;
-
- position ++;
-
- if (mac->ack_pending && skb_queue_is_first(q, skb))
- continue;
-
- tx_hdr = (struct ieee80211_hdr *)skb->data;
- if (likely(ether_addr_equal(tx_hdr->addr2, rx_hdr->addr1)))
- {
- found = 1;
- break;
- }
- }
-
- if (found) {
- for (i=1; i<position; i++) {
- skb = __skb_dequeue(q);
- zd_mac_tx_status(hw, skb,
- mac->ack_pending ? mac->ack_signal : 0,
- NULL);
- mac->ack_pending = 0;
- }
-
- mac->ack_pending = 1;
- mac->ack_signal = stats->signal;
-
- /* Prevent pending tx-packet on AP-mode */
- if (mac->type == NL80211_IFTYPE_AP) {
- skb = __skb_dequeue(q);
- zd_mac_tx_status(hw, skb, mac->ack_signal, NULL);
- mac->ack_pending = 0;
- }
- }
-
- spin_unlock_irqrestore(&q->lock, flags);
- return 1;
-}
-
-int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct ieee80211_rx_status stats;
- const struct rx_status *status;
- struct sk_buff *skb;
- int bad_frame = 0;
- __le16 fc;
- int need_padding;
- int i;
- u8 rate;
-
- if (length < ZD_PLCP_HEADER_SIZE + 10 /* IEEE80211_1ADDR_LEN */ +
- FCS_LEN + sizeof(struct rx_status))
- return -EINVAL;
-
- memset(&stats, 0, sizeof(stats));
-
- /* Note about pass_failed_fcs and pass_ctrl access below:
- * mac locking intentionally omitted here, as this is the only unlocked
- * reader and the only writer is configure_filter. Plus, if there were
- * any races accessing these variables, it wouldn't really matter.
- * If mac80211 ever provides a way for us to access filter flags
- * from outside configure_filter, we could improve on this. Also, this
- * situation may change once we implement some kind of DMA-into-skb
- * RX path. */
-
- /* Caller has to ensure that length >= sizeof(struct rx_status). */
- status = (struct rx_status *)
- (buffer + (length - sizeof(struct rx_status)));
- if (status->frame_status & ZD_RX_ERROR) {
- if (mac->pass_failed_fcs &&
- (status->frame_status & ZD_RX_CRC32_ERROR)) {
- stats.flag |= RX_FLAG_FAILED_FCS_CRC;
- bad_frame = 1;
- } else {
- return -EINVAL;
- }
- }
-
- stats.freq = zd_channels[_zd_chip_get_channel(&mac->chip) - 1].center_freq;
- stats.band = IEEE80211_BAND_2GHZ;
- stats.signal = zd_check_signal(hw, status->signal_strength);
-
- rate = zd_rx_rate(buffer, status);
-
- /* todo: return index in the big switches in zd_rx_rate instead */
- for (i = 0; i < mac->band.n_bitrates; i++)
- if (rate == mac->band.bitrates[i].hw_value)
- stats.rate_idx = i;
-
- length -= ZD_PLCP_HEADER_SIZE + sizeof(struct rx_status);
- buffer += ZD_PLCP_HEADER_SIZE;
-
- /* Except for bad frames, filter each frame to see if it is an ACK, in
- * which case our internal TX tracking is updated. Normally we then
- * bail here as there's no need to pass ACKs on up to the stack, but
- * there is also the case where the stack has requested us to pass
- * control frames on up (pass_ctrl) which we must consider. */
- if (!bad_frame &&
- filter_ack(hw, (struct ieee80211_hdr *)buffer, &stats)
- && !mac->pass_ctrl)
- return 0;
-
- fc = get_unaligned((__le16*)buffer);
- need_padding = ieee80211_is_data_qos(fc) ^ ieee80211_has_a4(fc);
-
- skb = dev_alloc_skb(length + (need_padding ? 2 : 0));
- if (skb == NULL)
- return -ENOMEM;
- if (need_padding) {
- /* Make sure the payload data is 4 byte aligned. */
- skb_reserve(skb, 2);
- }
-
- /* FIXME : could we avoid this big memcpy ? */
- memcpy(skb_put(skb, length), buffer, length);
-
- memcpy(IEEE80211_SKB_RXCB(skb), &stats, sizeof(stats));
- ieee80211_rx_irqsafe(hw, skb);
- return 0;
-}
-
-static int zd_op_add_interface(struct ieee80211_hw *hw,
- struct ieee80211_vif *vif)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
-
- /* using NL80211_IFTYPE_UNSPECIFIED to indicate no mode selected */
- if (mac->type != NL80211_IFTYPE_UNSPECIFIED)
- return -EOPNOTSUPP;
-
- switch (vif->type) {
- case NL80211_IFTYPE_MONITOR:
- case NL80211_IFTYPE_MESH_POINT:
- case NL80211_IFTYPE_STATION:
- case NL80211_IFTYPE_ADHOC:
- case NL80211_IFTYPE_AP:
- mac->type = vif->type;
- break;
- default:
- return -EOPNOTSUPP;
- }
-
- mac->vif = vif;
-
- return set_mac_and_bssid(mac);
-}
-
-static void zd_op_remove_interface(struct ieee80211_hw *hw,
- struct ieee80211_vif *vif)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- mac->type = NL80211_IFTYPE_UNSPECIFIED;
- mac->vif = NULL;
- zd_set_beacon_interval(&mac->chip, 0, 0, NL80211_IFTYPE_UNSPECIFIED);
- zd_write_mac_addr(&mac->chip, NULL);
-
- zd_mac_free_cur_beacon(mac);
-}
-
-static int zd_op_config(struct ieee80211_hw *hw, u32 changed)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct ieee80211_conf *conf = &hw->conf;
-
- spin_lock_irq(&mac->lock);
- mac->channel = conf->chandef.chan->hw_value;
- spin_unlock_irq(&mac->lock);
-
- return zd_chip_set_channel(&mac->chip, conf->chandef.chan->hw_value);
-}
-
-static void zd_beacon_done(struct zd_mac *mac)
-{
- struct sk_buff *skb, *beacon;
-
- if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
- return;
- if (!mac->vif || mac->vif->type != NL80211_IFTYPE_AP)
- return;
-
- /*
- * Send out buffered broad- and multicast frames.
- */
- while (!ieee80211_queue_stopped(mac->hw, 0)) {
- skb = ieee80211_get_buffered_bc(mac->hw, mac->vif);
- if (!skb)
- break;
- zd_op_tx(mac->hw, NULL, skb);
- }
-
- /*
- * Fetch next beacon so that tim_count is updated.
- */
- beacon = ieee80211_beacon_get(mac->hw, mac->vif);
- if (beacon)
- zd_mac_config_beacon(mac->hw, beacon, true);
-
- spin_lock_irq(&mac->lock);
- mac->beacon.last_update = jiffies;
- spin_unlock_irq(&mac->lock);
-}
-
-static void zd_process_intr(struct work_struct *work)
-{
- u16 int_status;
- unsigned long flags;
- struct zd_mac *mac = container_of(work, struct zd_mac, process_intr);
-
- spin_lock_irqsave(&mac->lock, flags);
- int_status = le16_to_cpu(*(__le16 *)(mac->intr_buffer + 4));
- spin_unlock_irqrestore(&mac->lock, flags);
-
- if (int_status & INT_CFG_NEXT_BCN) {
- /*dev_dbg_f_limit(zd_mac_dev(mac), "INT_CFG_NEXT_BCN\n");*/
- zd_beacon_done(mac);
- } else {
- dev_dbg_f(zd_mac_dev(mac), "Unsupported interrupt\n");
- }
-
- zd_chip_enable_hwint(&mac->chip);
-}
-
-
-static u64 zd_op_prepare_multicast(struct ieee80211_hw *hw,
- struct netdev_hw_addr_list *mc_list)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- struct zd_mc_hash hash;
- struct netdev_hw_addr *ha;
-
- zd_mc_clear(&hash);
-
- netdev_hw_addr_list_for_each(ha, mc_list) {
- dev_dbg_f(zd_mac_dev(mac), "mc addr %pM\n", ha->addr);
- zd_mc_add_addr(&hash, ha->addr);
- }
-
- return hash.low | ((u64)hash.high << 32);
-}
-
-#define SUPPORTED_FIF_FLAGS \
- (FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
- FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)
-static void zd_op_configure_filter(struct ieee80211_hw *hw,
- unsigned int changed_flags,
- unsigned int *new_flags,
- u64 multicast)
-{
- struct zd_mc_hash hash = {
- .low = multicast,
- .high = multicast >> 32,
- };
- struct zd_mac *mac = zd_hw_mac(hw);
- unsigned long flags;
- int r;
-
- /* Only deal with supported flags */
- changed_flags &= SUPPORTED_FIF_FLAGS;
- *new_flags &= SUPPORTED_FIF_FLAGS;
-
- /*
- * If multicast parameter (as returned by zd_op_prepare_multicast)
- * has changed, no bit in changed_flags is set. To handle this
- * situation, we do not return if changed_flags is 0. If we do so,
- * we will have some issue with IPv6 which uses multicast for link
- * layer address resolution.
- */
- if (*new_flags & FIF_ALLMULTI)
- zd_mc_add_all(&hash);
-
- spin_lock_irqsave(&mac->lock, flags);
- mac->pass_failed_fcs = !!(*new_flags & FIF_FCSFAIL);
- mac->pass_ctrl = !!(*new_flags & FIF_CONTROL);
- mac->multicast_hash = hash;
- spin_unlock_irqrestore(&mac->lock, flags);
-
- zd_chip_set_multicast_hash(&mac->chip, &hash);
-
- if (changed_flags & FIF_CONTROL) {
- r = set_rx_filter(mac);
- if (r)
- dev_err(zd_mac_dev(mac), "set_rx_filter error %d\n", r);
- }
-
- /* no handling required for FIF_OTHER_BSS as we don't currently
- * do BSSID filtering */
- /* FIXME: in future it would be nice to enable the probe response
- * filter (so that the driver doesn't see them) until
- * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
- * have to schedule work to enable prbresp reception, which might
- * happen too late. For now we'll just listen and forward them all the
- * time. */
-}
-
-static void set_rts_cts(struct zd_mac *mac, unsigned int short_preamble)
-{
- mutex_lock(&mac->chip.mutex);
- zd_chip_set_rts_cts_rate_locked(&mac->chip, short_preamble);
- mutex_unlock(&mac->chip.mutex);
-}
-
-static void zd_op_bss_info_changed(struct ieee80211_hw *hw,
- struct ieee80211_vif *vif,
- struct ieee80211_bss_conf *bss_conf,
- u32 changes)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- int associated;
-
- dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes);
-
- if (mac->type == NL80211_IFTYPE_MESH_POINT ||
- mac->type == NL80211_IFTYPE_ADHOC ||
- mac->type == NL80211_IFTYPE_AP) {
- associated = true;
- if (changes & BSS_CHANGED_BEACON) {
- struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
-
- if (beacon) {
- zd_chip_disable_hwint(&mac->chip);
- zd_mac_config_beacon(hw, beacon, false);
- zd_chip_enable_hwint(&mac->chip);
- }
- }
-
- if (changes & BSS_CHANGED_BEACON_ENABLED) {
- u16 interval = 0;
- u8 period = 0;
-
- if (bss_conf->enable_beacon) {
- period = bss_conf->dtim_period;
- interval = bss_conf->beacon_int;
- }
-
- spin_lock_irq(&mac->lock);
- mac->beacon.period = period;
- mac->beacon.interval = interval;
- mac->beacon.last_update = jiffies;
- spin_unlock_irq(&mac->lock);
-
- zd_set_beacon_interval(&mac->chip, interval, period,
- mac->type);
- }
- } else
- associated = is_valid_ether_addr(bss_conf->bssid);
-
- spin_lock_irq(&mac->lock);
- mac->associated = associated;
- spin_unlock_irq(&mac->lock);
-
- /* TODO: do hardware bssid filtering */
-
- if (changes & BSS_CHANGED_ERP_PREAMBLE) {
- spin_lock_irq(&mac->lock);
- mac->short_preamble = bss_conf->use_short_preamble;
- spin_unlock_irq(&mac->lock);
-
- set_rts_cts(mac, bss_conf->use_short_preamble);
- }
-}
-
-static u64 zd_op_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
-{
- struct zd_mac *mac = zd_hw_mac(hw);
- return zd_chip_get_tsf(&mac->chip);
-}
-
-static const struct ieee80211_ops zd_ops = {
- .tx = zd_op_tx,
- .start = zd_op_start,
- .stop = zd_op_stop,
- .add_interface = zd_op_add_interface,
- .remove_interface = zd_op_remove_interface,
- .config = zd_op_config,
- .prepare_multicast = zd_op_prepare_multicast,
- .configure_filter = zd_op_configure_filter,
- .bss_info_changed = zd_op_bss_info_changed,
- .get_tsf = zd_op_get_tsf,
-};
-
-struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
-{
- struct zd_mac *mac;
- struct ieee80211_hw *hw;
-
- hw = ieee80211_alloc_hw(sizeof(struct zd_mac), &zd_ops);
- if (!hw) {
- dev_dbg_f(&intf->dev, "out of memory\n");
- return NULL;
- }
-
- mac = zd_hw_mac(hw);
-
- memset(mac, 0, sizeof(*mac));
- spin_lock_init(&mac->lock);
- mac->hw = hw;
-
- mac->type = NL80211_IFTYPE_UNSPECIFIED;
-
- memcpy(mac->channels, zd_channels, sizeof(zd_channels));
- memcpy(mac->rates, zd_rates, sizeof(zd_rates));
- mac->band.n_bitrates = ARRAY_SIZE(zd_rates);
- mac->band.bitrates = mac->rates;
- mac->band.n_channels = ARRAY_SIZE(zd_channels);
- mac->band.channels = mac->channels;
-
- hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band;
-
- ieee80211_hw_set(hw, MFP_CAPABLE);
- ieee80211_hw_set(hw, HOST_BROADCAST_PS_BUFFERING);
- ieee80211_hw_set(hw, RX_INCLUDES_FCS);
- ieee80211_hw_set(hw, SIGNAL_UNSPEC);
-
- hw->wiphy->interface_modes =
- BIT(NL80211_IFTYPE_MESH_POINT) |
- BIT(NL80211_IFTYPE_STATION) |
- BIT(NL80211_IFTYPE_ADHOC) |
- BIT(NL80211_IFTYPE_AP);
-
- hw->max_signal = 100;
- hw->queues = 1;
- hw->extra_tx_headroom = sizeof(struct zd_ctrlset);
-
- /*
- * Tell mac80211 that we support multi rate retries
- */
- hw->max_rates = IEEE80211_TX_MAX_RATES;
- hw->max_rate_tries = 18; /* 9 rates * 2 retries/rate */
-
- skb_queue_head_init(&mac->ack_wait_queue);
- mac->ack_pending = 0;
-
- zd_chip_init(&mac->chip, hw, intf);
- housekeeping_init(mac);
- beacon_init(mac);
- INIT_WORK(&mac->process_intr, zd_process_intr);
-
- SET_IEEE80211_DEV(hw, &intf->dev);
- return hw;
-}
-
-#define BEACON_WATCHDOG_DELAY round_jiffies_relative(HZ)
-
-static void beacon_watchdog_handler(struct work_struct *work)
-{
- struct zd_mac *mac =
- container_of(work, struct zd_mac, beacon.watchdog_work.work);
- struct sk_buff *beacon;
- unsigned long timeout;
- int interval, period;
-
- if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
- goto rearm;
- if (mac->type != NL80211_IFTYPE_AP || !mac->vif)
- goto rearm;
-
- spin_lock_irq(&mac->lock);
- interval = mac->beacon.interval;
- period = mac->beacon.period;
- timeout = mac->beacon.last_update +
- msecs_to_jiffies(interval * 1024 / 1000) * 3;
- spin_unlock_irq(&mac->lock);
-
- if (interval > 0 && time_is_before_jiffies(timeout)) {
- dev_dbg_f(zd_mac_dev(mac), "beacon interrupt stalled, "
- "restarting. "
- "(interval: %d, dtim: %d)\n",
- interval, period);
-
- zd_chip_disable_hwint(&mac->chip);
-
- beacon = ieee80211_beacon_get(mac->hw, mac->vif);
- if (beacon) {
- zd_mac_free_cur_beacon(mac);
-
- zd_mac_config_beacon(mac->hw, beacon, false);
- }
-
- zd_set_beacon_interval(&mac->chip, interval, period, mac->type);
-
- zd_chip_enable_hwint(&mac->chip);
-
- spin_lock_irq(&mac->lock);
- mac->beacon.last_update = jiffies;
- spin_unlock_irq(&mac->lock);
- }
-
-rearm:
- queue_delayed_work(zd_workqueue, &mac->beacon.watchdog_work,
- BEACON_WATCHDOG_DELAY);
-}
-
-static void beacon_init(struct zd_mac *mac)
-{
- INIT_DELAYED_WORK(&mac->beacon.watchdog_work, beacon_watchdog_handler);
-}
-
-static void beacon_enable(struct zd_mac *mac)
-{
- dev_dbg_f(zd_mac_dev(mac), "\n");
-
- mac->beacon.last_update = jiffies;
- queue_delayed_work(zd_workqueue, &mac->beacon.watchdog_work,
- BEACON_WATCHDOG_DELAY);
-}
-
-static void beacon_disable(struct zd_mac *mac)
-{
- dev_dbg_f(zd_mac_dev(mac), "\n");
- cancel_delayed_work_sync(&mac->beacon.watchdog_work);
-
- zd_mac_free_cur_beacon(mac);
-}
-
-#define LINK_LED_WORK_DELAY HZ
-
-static void link_led_handler(struct work_struct *work)
-{
- struct zd_mac *mac =
- container_of(work, struct zd_mac, housekeeping.link_led_work.work);
- struct zd_chip *chip = &mac->chip;
- int is_associated;
- int r;
-
- if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
- goto requeue;
-
- spin_lock_irq(&mac->lock);
- is_associated = mac->associated;
- spin_unlock_irq(&mac->lock);
-
- r = zd_chip_control_leds(chip,
- is_associated ? ZD_LED_ASSOCIATED : ZD_LED_SCANNING);
- if (r)
- dev_dbg_f(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r);
-
-requeue:
- queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
- LINK_LED_WORK_DELAY);
-}
-
-static void housekeeping_init(struct zd_mac *mac)
-{
- INIT_DELAYED_WORK(&mac->housekeeping.link_led_work, link_led_handler);
-}
-
-static void housekeeping_enable(struct zd_mac *mac)
-{
- dev_dbg_f(zd_mac_dev(mac), "\n");
- queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
- 0);
-}
-
-static void housekeeping_disable(struct zd_mac *mac)
-{
- dev_dbg_f(zd_mac_dev(mac), "\n");
- cancel_delayed_work_sync(&mac->housekeeping.link_led_work);
- zd_chip_control_leds(&mac->chip, ZD_LED_OFF);
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _ZD_MAC_H
-#define _ZD_MAC_H
-
-#include <linux/kernel.h>
-#include <net/mac80211.h>
-
-#include "zd_chip.h"
-
-struct zd_ctrlset {
- u8 modulation;
- __le16 tx_length;
- u8 control;
- /* stores only the difference to tx_length on ZD1211B */
- __le16 packet_length;
- __le16 current_length;
- u8 service;
- __le16 next_frame_length;
-} __packed;
-
-#define ZD_CS_RESERVED_SIZE 25
-
-/* The field modulation of struct zd_ctrlset controls the bit rate, the use
- * of short or long preambles in 802.11b (CCK mode) or the use of 802.11a or
- * 802.11g in OFDM mode.
- *
- * The term zd-rate is used for the combination of the modulation type flag
- * and the "pure" rate value.
- */
-#define ZD_PURE_RATE_MASK 0x0f
-#define ZD_MODULATION_TYPE_MASK 0x10
-#define ZD_RATE_MASK (ZD_PURE_RATE_MASK|ZD_MODULATION_TYPE_MASK)
-#define ZD_PURE_RATE(modulation) ((modulation) & ZD_PURE_RATE_MASK)
-#define ZD_MODULATION_TYPE(modulation) ((modulation) & ZD_MODULATION_TYPE_MASK)
-#define ZD_RATE(modulation) ((modulation) & ZD_RATE_MASK)
-
-/* The two possible modulation types. Notify that 802.11b doesn't use the CCK
- * codeing for the 1 and 2 MBit/s rate. We stay with the term here to remain
- * consistent with uses the term at other places.
- */
-#define ZD_CCK 0x00
-#define ZD_OFDM 0x10
-
-/* The ZD1211 firmware uses proprietary encodings of the 802.11b (CCK) rates.
- * For OFDM the PLCP rate encodings are used. We combine these "pure" rates
- * with the modulation type flag and call the resulting values zd-rates.
- */
-#define ZD_CCK_RATE_1M (ZD_CCK|0x00)
-#define ZD_CCK_RATE_2M (ZD_CCK|0x01)
-#define ZD_CCK_RATE_5_5M (ZD_CCK|0x02)
-#define ZD_CCK_RATE_11M (ZD_CCK|0x03)
-#define ZD_OFDM_RATE_6M (ZD_OFDM|ZD_OFDM_PLCP_RATE_6M)
-#define ZD_OFDM_RATE_9M (ZD_OFDM|ZD_OFDM_PLCP_RATE_9M)
-#define ZD_OFDM_RATE_12M (ZD_OFDM|ZD_OFDM_PLCP_RATE_12M)
-#define ZD_OFDM_RATE_18M (ZD_OFDM|ZD_OFDM_PLCP_RATE_18M)
-#define ZD_OFDM_RATE_24M (ZD_OFDM|ZD_OFDM_PLCP_RATE_24M)
-#define ZD_OFDM_RATE_36M (ZD_OFDM|ZD_OFDM_PLCP_RATE_36M)
-#define ZD_OFDM_RATE_48M (ZD_OFDM|ZD_OFDM_PLCP_RATE_48M)
-#define ZD_OFDM_RATE_54M (ZD_OFDM|ZD_OFDM_PLCP_RATE_54M)
-
-/* The bit 5 of the zd_ctrlset modulation field controls the preamble in CCK
- * mode or the 802.11a/802.11g selection in OFDM mode.
- */
-#define ZD_CCK_PREA_LONG 0x00
-#define ZD_CCK_PREA_SHORT 0x20
-#define ZD_OFDM_MODE_11G 0x00
-#define ZD_OFDM_MODE_11A 0x20
-
-/* zd_ctrlset control field */
-#define ZD_CS_NEED_RANDOM_BACKOFF 0x01
-#define ZD_CS_NO_ACK 0x02
-
-#define ZD_CS_FRAME_TYPE_MASK 0x0c
-#define ZD_CS_DATA_FRAME 0x00
-#define ZD_CS_PS_POLL_FRAME 0x04
-#define ZD_CS_MANAGEMENT_FRAME 0x08
-#define ZD_CS_NO_SEQUENCE_CTL_FRAME 0x0c
-
-#define ZD_CS_WAKE_DESTINATION 0x10
-#define ZD_CS_RTS 0x20
-#define ZD_CS_ENCRYPT 0x40
-#define ZD_CS_SELF_CTS 0x80
-
-/* Incoming frames are prepended by a PLCP header */
-#define ZD_PLCP_HEADER_SIZE 5
-
-struct rx_length_info {
- __le16 length[3];
- __le16 tag;
-} __packed;
-
-#define RX_LENGTH_INFO_TAG 0x697e
-
-struct rx_status {
- u8 signal_quality_cck;
- /* rssi */
- u8 signal_strength;
- u8 signal_quality_ofdm;
- u8 decryption_type;
- u8 frame_status;
-} __packed;
-
-/* rx_status field decryption_type */
-#define ZD_RX_NO_WEP 0
-#define ZD_RX_WEP64 1
-#define ZD_RX_TKIP 2
-#define ZD_RX_AES 4
-#define ZD_RX_WEP128 5
-#define ZD_RX_WEP256 6
-
-/* rx_status field frame_status */
-#define ZD_RX_FRAME_MODULATION_MASK 0x01
-#define ZD_RX_CCK 0x00
-#define ZD_RX_OFDM 0x01
-
-#define ZD_RX_TIMEOUT_ERROR 0x02
-#define ZD_RX_FIFO_OVERRUN_ERROR 0x04
-#define ZD_RX_DECRYPTION_ERROR 0x08
-#define ZD_RX_CRC32_ERROR 0x10
-#define ZD_RX_NO_ADDR1_MATCH_ERROR 0x20
-#define ZD_RX_CRC16_ERROR 0x40
-#define ZD_RX_ERROR 0x80
-
-struct tx_retry_rate {
- int count; /* number of valid element in rate[] array */
- int rate[10]; /* retry rates, described by an index in zd_rates[] */
-};
-
-struct tx_status {
- u8 type; /* must always be 0x01 : USB_INT_TYPE */
- u8 id; /* must always be 0xa0 : USB_INT_ID_RETRY_FAILED */
- u8 rate;
- u8 pad;
- u8 mac[ETH_ALEN];
- u8 retry;
- u8 failure;
-} __packed;
-
-enum mac_flags {
- MAC_FIXED_CHANNEL = 0x01,
-};
-
-struct housekeeping {
- struct delayed_work link_led_work;
-};
-
-struct beacon {
- struct delayed_work watchdog_work;
- struct sk_buff *cur_beacon;
- unsigned long last_update;
- u16 interval;
- u8 period;
-};
-
-enum zd_device_flags {
- ZD_DEVICE_RUNNING,
-};
-
-#define ZD_MAC_STATS_BUFFER_SIZE 16
-
-#define ZD_MAC_MAX_ACK_WAITERS 50
-
-struct zd_mac {
- struct zd_chip chip;
- spinlock_t lock;
- spinlock_t intr_lock;
- struct ieee80211_hw *hw;
- struct ieee80211_vif *vif;
- struct housekeeping housekeeping;
- struct beacon beacon;
- struct work_struct set_rts_cts_work;
- struct work_struct process_intr;
- struct zd_mc_hash multicast_hash;
- u8 intr_buffer[USB_MAX_EP_INT_BUFFER];
- u8 regdomain;
- u8 default_regdomain;
- u8 channel;
- int type;
- int associated;
- unsigned long flags;
- struct sk_buff_head ack_wait_queue;
- struct ieee80211_channel channels[14];
- struct ieee80211_rate rates[12];
- struct ieee80211_supported_band band;
-
- /* Short preamble (used for RTS/CTS) */
- unsigned int short_preamble:1;
-
- /* whether to pass frames with CRC errors to stack */
- unsigned int pass_failed_fcs:1;
-
- /* whether to pass control frames to stack */
- unsigned int pass_ctrl:1;
-
- /* whether we have received a 802.11 ACK that is pending */
- unsigned int ack_pending:1;
-
- /* signal strength of the last 802.11 ACK received */
- int ack_signal;
-};
-
-#define ZD_REGDOMAIN_FCC 0x10
-#define ZD_REGDOMAIN_IC 0x20
-#define ZD_REGDOMAIN_ETSI 0x30
-#define ZD_REGDOMAIN_SPAIN 0x31
-#define ZD_REGDOMAIN_FRANCE 0x32
-#define ZD_REGDOMAIN_JAPAN_2 0x40
-#define ZD_REGDOMAIN_JAPAN 0x41
-#define ZD_REGDOMAIN_JAPAN_3 0x49
-
-enum {
- MIN_CHANNEL24 = 1,
- MAX_CHANNEL24 = 14,
-};
-
-#define ZD_PLCP_SERVICE_LENGTH_EXTENSION 0x80
-
-struct ofdm_plcp_header {
- u8 prefix[3];
- __le16 service;
-} __packed;
-
-static inline u8 zd_ofdm_plcp_header_rate(const struct ofdm_plcp_header *header)
-{
- return header->prefix[0] & 0xf;
-}
-
-/* The following defines give the encoding of the 4-bit rate field in the
- * OFDM (802.11a/802.11g) PLCP header. Notify that these values are used to
- * define the zd-rate values for OFDM.
- *
- * See the struct zd_ctrlset definition in zd_mac.h.
- */
-#define ZD_OFDM_PLCP_RATE_6M 0xb
-#define ZD_OFDM_PLCP_RATE_9M 0xf
-#define ZD_OFDM_PLCP_RATE_12M 0xa
-#define ZD_OFDM_PLCP_RATE_18M 0xe
-#define ZD_OFDM_PLCP_RATE_24M 0x9
-#define ZD_OFDM_PLCP_RATE_36M 0xd
-#define ZD_OFDM_PLCP_RATE_48M 0x8
-#define ZD_OFDM_PLCP_RATE_54M 0xc
-
-struct cck_plcp_header {
- u8 signal;
- u8 service;
- __le16 length;
- __le16 crc16;
-} __packed;
-
-static inline u8 zd_cck_plcp_header_signal(const struct cck_plcp_header *header)
-{
- return header->signal;
-}
-
-/* These defines give the encodings of the signal field in the 802.11b PLCP
- * header. The signal field gives the bit rate of the following packet. Even
- * if technically wrong we use CCK here also for the 1 MBit/s and 2 MBit/s
- * rate to stay consistent with Zydas and our use of the term.
- *
- * Notify that these values are *not* used in the zd-rates.
- */
-#define ZD_CCK_PLCP_SIGNAL_1M 0x0a
-#define ZD_CCK_PLCP_SIGNAL_2M 0x14
-#define ZD_CCK_PLCP_SIGNAL_5M5 0x37
-#define ZD_CCK_PLCP_SIGNAL_11M 0x6e
-
-static inline struct zd_mac *zd_hw_mac(struct ieee80211_hw *hw)
-{
- return hw->priv;
-}
-
-static inline struct zd_mac *zd_chip_to_mac(struct zd_chip *chip)
-{
- return container_of(chip, struct zd_mac, chip);
-}
-
-static inline struct zd_mac *zd_usb_to_mac(struct zd_usb *usb)
-{
- return zd_chip_to_mac(zd_usb_to_chip(usb));
-}
-
-static inline u8 *zd_mac_get_perm_addr(struct zd_mac *mac)
-{
- return mac->hw->wiphy->perm_addr;
-}
-
-#define zd_mac_dev(mac) (zd_chip_dev(&(mac)->chip))
-
-struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf);
-void zd_mac_clear(struct zd_mac *mac);
-
-int zd_mac_preinit_hw(struct ieee80211_hw *hw);
-int zd_mac_init_hw(struct ieee80211_hw *hw);
-
-int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length);
-void zd_mac_tx_failed(struct urb *urb);
-void zd_mac_tx_to_dev(struct sk_buff *skb, int error);
-
-int zd_op_start(struct ieee80211_hw *hw);
-void zd_op_stop(struct ieee80211_hw *hw);
-int zd_restore_settings(struct zd_mac *mac);
-
-#ifdef DEBUG
-void zd_dump_rx_status(const struct rx_status *status);
-#else
-#define zd_dump_rx_status(status)
-#endif /* DEBUG */
-
-#endif /* _ZD_MAC_H */
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/errno.h>
-#include <linux/string.h>
-
-#include "zd_def.h"
-#include "zd_rf.h"
-#include "zd_mac.h"
-#include "zd_chip.h"
-
-static const char * const rfs[] = {
- [0] = "unknown RF0",
- [1] = "unknown RF1",
- [UW2451_RF] = "UW2451_RF",
- [UCHIP_RF] = "UCHIP_RF",
- [AL2230_RF] = "AL2230_RF",
- [AL7230B_RF] = "AL7230B_RF",
- [THETA_RF] = "THETA_RF",
- [AL2210_RF] = "AL2210_RF",
- [MAXIM_NEW_RF] = "MAXIM_NEW_RF",
- [UW2453_RF] = "UW2453_RF",
- [AL2230S_RF] = "AL2230S_RF",
- [RALINK_RF] = "RALINK_RF",
- [INTERSIL_RF] = "INTERSIL_RF",
- [RF2959_RF] = "RF2959_RF",
- [MAXIM_NEW2_RF] = "MAXIM_NEW2_RF",
- [PHILIPS_RF] = "PHILIPS_RF",
-};
-
-const char *zd_rf_name(u8 type)
-{
- if (type & 0xf0)
- type = 0;
- return rfs[type];
-}
-
-void zd_rf_init(struct zd_rf *rf)
-{
- memset(rf, 0, sizeof(*rf));
-
- /* default to update channel integration, as almost all RF's do want
- * this */
- rf->update_channel_int = 1;
-}
-
-void zd_rf_clear(struct zd_rf *rf)
-{
- if (rf->clear)
- rf->clear(rf);
- ZD_MEMCLEAR(rf, sizeof(*rf));
-}
-
-int zd_rf_init_hw(struct zd_rf *rf, u8 type)
-{
- int r = 0;
- int t;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- switch (type) {
- case RF2959_RF:
- r = zd_rf_init_rf2959(rf);
- break;
- case AL2230_RF:
- case AL2230S_RF:
- r = zd_rf_init_al2230(rf);
- break;
- case AL7230B_RF:
- r = zd_rf_init_al7230b(rf);
- break;
- case MAXIM_NEW_RF:
- case UW2453_RF:
- r = zd_rf_init_uw2453(rf);
- break;
- default:
- dev_err(zd_chip_dev(chip),
- "RF %s %#x is not supported\n", zd_rf_name(type), type);
- rf->type = 0;
- return -ENODEV;
- }
-
- if (r)
- return r;
-
- rf->type = type;
-
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- return r;
- t = rf->init_hw(rf);
- r = zd_chip_unlock_phy_regs(chip);
- if (t)
- r = t;
- return r;
-}
-
-int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size)
-{
- return scnprintf(buffer, size, "%s", zd_rf_name(rf->type));
-}
-
-int zd_rf_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
-
- ZD_ASSERT(mutex_is_locked(&zd_rf_to_chip(rf)->mutex));
- if (channel < MIN_CHANNEL24)
- return -EINVAL;
- if (channel > MAX_CHANNEL24)
- return -EINVAL;
- dev_dbg_f(zd_chip_dev(zd_rf_to_chip(rf)), "channel: %d\n", channel);
-
- r = rf->set_channel(rf, channel);
- if (r >= 0)
- rf->channel = channel;
- return r;
-}
-
-int zd_switch_radio_on(struct zd_rf *rf)
-{
- int r, t;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- return r;
- t = rf->switch_radio_on(rf);
- r = zd_chip_unlock_phy_regs(chip);
- if (t)
- r = t;
- return r;
-}
-
-int zd_switch_radio_off(struct zd_rf *rf)
-{
- int r, t;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- /* TODO: move phy regs handling to zd_chip */
- ZD_ASSERT(mutex_is_locked(&chip->mutex));
- r = zd_chip_lock_phy_regs(chip);
- if (r)
- return r;
- t = rf->switch_radio_off(rf);
- r = zd_chip_unlock_phy_regs(chip);
- if (t)
- r = t;
- return r;
-}
-
-int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel)
-{
- if (!rf->patch_6m_band_edge)
- return 0;
-
- return rf->patch_6m_band_edge(rf, channel);
-}
-
-int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel)
-{
- return zd_chip_generic_patch_6m_band(zd_rf_to_chip(rf), channel);
-}
-
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _ZD_RF_H
-#define _ZD_RF_H
-
-#define UW2451_RF 0x2
-#define UCHIP_RF 0x3
-#define AL2230_RF 0x4
-#define AL7230B_RF 0x5 /* a,b,g */
-#define THETA_RF 0x6
-#define AL2210_RF 0x7
-#define MAXIM_NEW_RF 0x8
-#define UW2453_RF 0x9
-#define AL2230S_RF 0xa
-#define RALINK_RF 0xb
-#define INTERSIL_RF 0xc
-#define RF2959_RF 0xd
-#define MAXIM_NEW2_RF 0xe
-#define PHILIPS_RF 0xf
-
-#define RF_CHANNEL(ch) [(ch)-1]
-
-/* Provides functions of the RF transceiver. */
-
-enum {
- RF_REG_BITS = 6,
- RF_VALUE_BITS = 18,
- RF_RV_BITS = RF_REG_BITS + RF_VALUE_BITS,
-};
-
-struct zd_rf {
- u8 type;
-
- u8 channel;
-
- /* whether channel integration and calibration should be updated
- * defaults to 1 (yes) */
- u8 update_channel_int:1;
-
- /* whether ZD_CR47 should be patched from the EEPROM, if the appropriate
- * flag is set in the POD. The vendor driver suggests that this should
- * be done for all RF's, but a bug in their code prevents but their
- * HW_OverWritePhyRegFromE2P() routine from ever taking effect. */
- u8 patch_cck_gain:1;
-
- /* private RF driver data */
- void *priv;
-
- /* RF-specific functions */
- int (*init_hw)(struct zd_rf *rf);
- int (*set_channel)(struct zd_rf *rf, u8 channel);
- int (*switch_radio_on)(struct zd_rf *rf);
- int (*switch_radio_off)(struct zd_rf *rf);
- int (*patch_6m_band_edge)(struct zd_rf *rf, u8 channel);
- void (*clear)(struct zd_rf *rf);
-};
-
-const char *zd_rf_name(u8 type);
-void zd_rf_init(struct zd_rf *rf);
-void zd_rf_clear(struct zd_rf *rf);
-int zd_rf_init_hw(struct zd_rf *rf, u8 type);
-
-int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size);
-
-int zd_rf_set_channel(struct zd_rf *rf, u8 channel);
-
-int zd_switch_radio_on(struct zd_rf *rf);
-int zd_switch_radio_off(struct zd_rf *rf);
-
-int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel);
-int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel);
-
-static inline int zd_rf_should_update_pwr_int(struct zd_rf *rf)
-{
- return rf->update_channel_int;
-}
-
-static inline int zd_rf_should_patch_cck_gain(struct zd_rf *rf)
-{
- return rf->patch_cck_gain;
-}
-
-int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel);
-int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel);
-
-/* Functions for individual RF chips */
-
-int zd_rf_init_rf2959(struct zd_rf *rf);
-int zd_rf_init_al2230(struct zd_rf *rf);
-int zd_rf_init_al7230b(struct zd_rf *rf);
-int zd_rf_init_uw2453(struct zd_rf *rf);
-
-#endif /* _ZD_RF_H */
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/kernel.h>
-
-#include "zd_rf.h"
-#include "zd_usb.h"
-#include "zd_chip.h"
-
-#define IS_AL2230S(chip) ((chip)->al2230s_bit || (chip)->rf.type == AL2230S_RF)
-
-static const u32 zd1211_al2230_table[][3] = {
- RF_CHANNEL( 1) = { 0x03f790, 0x033331, 0x00000d, },
- RF_CHANNEL( 2) = { 0x03f790, 0x0b3331, 0x00000d, },
- RF_CHANNEL( 3) = { 0x03e790, 0x033331, 0x00000d, },
- RF_CHANNEL( 4) = { 0x03e790, 0x0b3331, 0x00000d, },
- RF_CHANNEL( 5) = { 0x03f7a0, 0x033331, 0x00000d, },
- RF_CHANNEL( 6) = { 0x03f7a0, 0x0b3331, 0x00000d, },
- RF_CHANNEL( 7) = { 0x03e7a0, 0x033331, 0x00000d, },
- RF_CHANNEL( 8) = { 0x03e7a0, 0x0b3331, 0x00000d, },
- RF_CHANNEL( 9) = { 0x03f7b0, 0x033331, 0x00000d, },
- RF_CHANNEL(10) = { 0x03f7b0, 0x0b3331, 0x00000d, },
- RF_CHANNEL(11) = { 0x03e7b0, 0x033331, 0x00000d, },
- RF_CHANNEL(12) = { 0x03e7b0, 0x0b3331, 0x00000d, },
- RF_CHANNEL(13) = { 0x03f7c0, 0x033331, 0x00000d, },
- RF_CHANNEL(14) = { 0x03e7c0, 0x066661, 0x00000d, },
-};
-
-static const u32 zd1211b_al2230_table[][3] = {
- RF_CHANNEL( 1) = { 0x09efc0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL( 2) = { 0x09efc0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL( 3) = { 0x09e7c0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL( 4) = { 0x09e7c0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL( 5) = { 0x05efc0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL( 6) = { 0x05efc0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL( 7) = { 0x05e7c0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL( 8) = { 0x05e7c0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL( 9) = { 0x0defc0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL(10) = { 0x0defc0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL(11) = { 0x0de7c0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL(12) = { 0x0de7c0, 0x8cccd0, 0xb00000, },
- RF_CHANNEL(13) = { 0x03efc0, 0x8cccc0, 0xb00000, },
- RF_CHANNEL(14) = { 0x03e7c0, 0x866660, 0xb00000, },
-};
-
-static const struct zd_ioreq16 zd1211b_ioreqs_shared_1[] = {
- { ZD_CR240, 0x57 }, { ZD_CR9, 0xe0 },
-};
-
-static const struct zd_ioreq16 ioreqs_init_al2230s[] = {
- { ZD_CR47, 0x1e }, /* MARK_002 */
- { ZD_CR106, 0x22 },
- { ZD_CR107, 0x2a }, /* MARK_002 */
- { ZD_CR109, 0x13 }, /* MARK_002 */
- { ZD_CR118, 0xf8 }, /* MARK_002 */
- { ZD_CR119, 0x12 }, { ZD_CR122, 0xe0 },
- { ZD_CR128, 0x10 }, /* MARK_001 from 0xe->0x10 */
- { ZD_CR129, 0x0e }, /* MARK_001 from 0xd->0x0e */
- { ZD_CR130, 0x10 }, /* MARK_001 from 0xb->0x0d */
-};
-
-static int zd1211b_al2230_finalize_rf(struct zd_chip *chip)
-{
- int r;
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
- { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
- { ZD_CR203, 0x06 },
- { },
-
- { ZD_CR240, 0x80 },
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- /* related to antenna selection? */
- if (chip->new_phy_layout) {
- r = zd_iowrite16_locked(chip, 0xe1, ZD_CR9);
- if (r)
- return r;
- }
-
- return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
-}
-
-static int zd1211_al2230_init_hw(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs_init[] = {
- { ZD_CR15, 0x20 }, { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 },
- { ZD_CR26, 0x11 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
- { ZD_CR44, 0x33 }, { ZD_CR106, 0x2a }, { ZD_CR107, 0x1a },
- { ZD_CR109, 0x09 }, { ZD_CR110, 0x27 }, { ZD_CR111, 0x2b },
- { ZD_CR112, 0x2b }, { ZD_CR119, 0x0a }, { ZD_CR10, 0x89 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR17, 0x28 },
- { ZD_CR26, 0x93 }, { ZD_CR34, 0x30 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR35, 0x3e },
- { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR46, 0x96 },
- { ZD_CR47, 0x1e }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
- { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
- { ZD_CR92, 0x0a }, { ZD_CR99, 0x28 }, { ZD_CR100, 0x00 },
- { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 }, { ZD_CR106, 0x24 },
- { ZD_CR107, 0x2a }, { ZD_CR109, 0x09 }, { ZD_CR110, 0x13 },
- { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x27 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR115, 0x24 },
- { ZD_CR116, 0x24 }, { ZD_CR117, 0xf4 }, { ZD_CR118, 0xfc },
- { ZD_CR119, 0x10 }, { ZD_CR120, 0x4f }, { ZD_CR121, 0x77 },
- { ZD_CR122, 0xe0 }, { ZD_CR137, 0x88 }, { ZD_CR252, 0xff },
- { ZD_CR253, 0xff },
- };
-
- static const struct zd_ioreq16 ioreqs_pll[] = {
- /* shdnb(PLL_ON)=0 */
- { ZD_CR251, 0x2f },
- /* shdnb(PLL_ON)=1 */
- { ZD_CR251, 0x3f },
- { ZD_CR138, 0x28 }, { ZD_CR203, 0x06 },
- };
-
- static const u32 rv1[] = {
- /* Channel 1 */
- 0x03f790,
- 0x033331,
- 0x00000d,
-
- 0x0b3331,
- 0x03b812,
- 0x00fff3,
- };
-
- static const u32 rv2[] = {
- 0x000da4,
- 0x0f4dc5, /* fix freq shift, 0x04edc5 */
- 0x0805b6,
- 0x011687,
- 0x000688,
- 0x0403b9, /* external control TX power (ZD_CR31) */
- 0x00dbba,
- 0x00099b,
- 0x0bdffc,
- 0x00000d,
- 0x00500f,
- };
-
- static const u32 rv3[] = {
- 0x00d00f,
- 0x004c0f,
- 0x00540f,
- 0x00700f,
- 0x00500f,
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs_init, ARRAY_SIZE(ioreqs_init));
- if (r)
- return r;
-
- if (IS_AL2230S(chip)) {
- r = zd_iowrite16a_locked(chip, ioreqs_init_al2230s,
- ARRAY_SIZE(ioreqs_init_al2230s));
- if (r)
- return r;
- }
-
- r = zd_rfwritev_locked(chip, rv1, ARRAY_SIZE(rv1), RF_RV_BITS);
- if (r)
- return r;
-
- /* improve band edge for AL2230S */
- if (IS_AL2230S(chip))
- r = zd_rfwrite_locked(chip, 0x000824, RF_RV_BITS);
- else
- r = zd_rfwrite_locked(chip, 0x0005a4, RF_RV_BITS);
- if (r)
- return r;
-
- r = zd_rfwritev_locked(chip, rv2, ARRAY_SIZE(rv2), RF_RV_BITS);
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_pll, ARRAY_SIZE(ioreqs_pll));
- if (r)
- return r;
-
- r = zd_rfwritev_locked(chip, rv3, ARRAY_SIZE(rv3), RF_RV_BITS);
- if (r)
- return r;
-
- return 0;
-}
-
-static int zd1211b_al2230_init_hw(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs1[] = {
- { ZD_CR10, 0x89 }, { ZD_CR15, 0x20 },
- { ZD_CR17, 0x2B }, /* for newest(3rd cut) AL2230 */
- { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
- { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
- { ZD_CR33, 0x28 }, /* 5621 */
- { ZD_CR34, 0x30 },
- { ZD_CR35, 0x3e }, /* for newest(3rd cut) AL2230 */
- { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
- { ZD_CR46, 0x99 }, /* for newest(3rd cut) AL2230 */
- { ZD_CR47, 0x1e },
-
- /* ZD1211B 05.06.10 */
- { ZD_CR48, 0x06 }, { ZD_CR49, 0xf9 }, { ZD_CR51, 0x01 },
- { ZD_CR52, 0x80 }, { ZD_CR53, 0x7e }, { ZD_CR65, 0x00 },
- { ZD_CR66, 0x00 }, { ZD_CR67, 0x00 }, { ZD_CR68, 0x00 },
- { ZD_CR69, 0x28 },
-
- { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
- { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
- { ZD_CR91, 0x00 }, /* 5621 */
- { ZD_CR92, 0x0a },
- { ZD_CR98, 0x8d }, /* 4804, for 1212 new algorithm */
- { ZD_CR99, 0x00 }, /* 5621 */
- { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 },
- { ZD_CR106, 0x24 }, /* for newest(3rd cut) AL2230 */
- { ZD_CR107, 0x2a },
- { ZD_CR109, 0x13 }, /* 4804, for 1212 new algorithm */
- { ZD_CR110, 0x1f }, /* 4804, for 1212 new algorithm */
- { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x27 },
- { ZD_CR115, 0x26 }, /* 24->26 at 4902 for newest(3rd cut)
- * AL2230
- */
- { ZD_CR116, 0x24 },
- { ZD_CR117, 0xfa }, /* for 1211b */
- { ZD_CR118, 0xfa }, /* for 1211b */
- { ZD_CR119, 0x10 },
- { ZD_CR120, 0x4f },
- { ZD_CR121, 0x6c }, /* for 1211b */
- { ZD_CR122, 0xfc }, /* E0->FC at 4902 */
- { ZD_CR123, 0x57 }, /* 5623 */
- { ZD_CR125, 0xad }, /* 4804, for 1212 new algorithm */
- { ZD_CR126, 0x6c }, /* 5614 */
- { ZD_CR127, 0x03 }, /* 4804, for 1212 new algorithm */
- { ZD_CR137, 0x50 }, /* 5614 */
- { ZD_CR138, 0xa8 },
- { ZD_CR144, 0xac }, /* 5621 */
- { ZD_CR150, 0x0d }, { ZD_CR252, 0x34 }, { ZD_CR253, 0x34 },
- };
-
- static const u32 rv1[] = {
- 0x8cccd0,
- 0x481dc0,
- 0xcfff00,
- 0x25a000,
- };
-
- static const u32 rv2[] = {
- /* To improve AL2230 yield, improve phase noise, 4713 */
- 0x25a000,
- 0xa3b2f0,
-
- 0x6da010, /* Reg6 update for MP versio */
- 0xe36280, /* Modified by jxiao for Bor-Chin on 2004/08/02 */
- 0x116000,
- 0x9dc020, /* External control TX power (ZD_CR31) */
- 0x5ddb00, /* RegA update for MP version */
- 0xd99000, /* RegB update for MP version */
- 0x3ffbd0, /* RegC update for MP version */
- 0xb00000, /* RegD update for MP version */
-
- /* improve phase noise and remove phase calibration,4713 */
- 0xf01a00,
- };
-
- static const struct zd_ioreq16 ioreqs2[] = {
- { ZD_CR251, 0x2f }, /* shdnb(PLL_ON)=0 */
- { ZD_CR251, 0x7f }, /* shdnb(PLL_ON)=1 */
- };
-
- static const u32 rv3[] = {
- /* To improve AL2230 yield, 4713 */
- 0xf01b00,
- 0xf01e00,
- 0xf01a00,
- };
-
- static const struct zd_ioreq16 ioreqs3[] = {
- /* related to 6M band edge patching, happens unconditionally */
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- };
-
- r = zd_iowrite16a_locked(chip, zd1211b_ioreqs_shared_1,
- ARRAY_SIZE(zd1211b_ioreqs_shared_1));
- if (r)
- return r;
- r = zd_iowrite16a_locked(chip, ioreqs1, ARRAY_SIZE(ioreqs1));
- if (r)
- return r;
-
- if (IS_AL2230S(chip)) {
- r = zd_iowrite16a_locked(chip, ioreqs_init_al2230s,
- ARRAY_SIZE(ioreqs_init_al2230s));
- if (r)
- return r;
- }
-
- r = zd_rfwritev_cr_locked(chip, zd1211b_al2230_table[0], 3);
- if (r)
- return r;
- r = zd_rfwritev_cr_locked(chip, rv1, ARRAY_SIZE(rv1));
- if (r)
- return r;
-
- if (IS_AL2230S(chip))
- r = zd_rfwrite_locked(chip, 0x241000, RF_RV_BITS);
- else
- r = zd_rfwrite_locked(chip, 0x25a000, RF_RV_BITS);
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv2, ARRAY_SIZE(rv2));
- if (r)
- return r;
- r = zd_iowrite16a_locked(chip, ioreqs2, ARRAY_SIZE(ioreqs2));
- if (r)
- return r;
- r = zd_rfwritev_cr_locked(chip, rv3, ARRAY_SIZE(rv3));
- if (r)
- return r;
- r = zd_iowrite16a_locked(chip, ioreqs3, ARRAY_SIZE(ioreqs3));
- if (r)
- return r;
- return zd1211b_al2230_finalize_rf(chip);
-}
-
-static int zd1211_al2230_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
- const u32 *rv = zd1211_al2230_table[channel-1];
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR138, 0x28 },
- { ZD_CR203, 0x06 },
- };
-
- r = zd_rfwritev_locked(chip, rv, 3, RF_RV_BITS);
- if (r)
- return r;
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211b_al2230_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
- const u32 *rv = zd1211b_al2230_table[channel-1];
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- r = zd_iowrite16a_locked(chip, zd1211b_ioreqs_shared_1,
- ARRAY_SIZE(zd1211b_ioreqs_shared_1));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv, 3);
- if (r)
- return r;
-
- return zd1211b_al2230_finalize_rf(chip);
-}
-
-static int zd1211_al2230_switch_radio_on(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x00 },
- { ZD_CR251, 0x3f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211b_al2230_switch_radio_on(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x00 },
- { ZD_CR251, 0x7f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int al2230_switch_radio_off(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x04 },
- { ZD_CR251, 0x2f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-int zd_rf_init_al2230(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- rf->switch_radio_off = al2230_switch_radio_off;
- if (zd_chip_is_zd1211b(chip)) {
- rf->init_hw = zd1211b_al2230_init_hw;
- rf->set_channel = zd1211b_al2230_set_channel;
- rf->switch_radio_on = zd1211b_al2230_switch_radio_on;
- } else {
- rf->init_hw = zd1211_al2230_init_hw;
- rf->set_channel = zd1211_al2230_set_channel;
- rf->switch_radio_on = zd1211_al2230_switch_radio_on;
- }
- rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
- rf->patch_cck_gain = 1;
- return 0;
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/kernel.h>
-
-#include "zd_rf.h"
-#include "zd_usb.h"
-#include "zd_chip.h"
-
-static const u32 chan_rv[][2] = {
- RF_CHANNEL( 1) = { 0x09ec00, 0x8cccc8 },
- RF_CHANNEL( 2) = { 0x09ec00, 0x8cccd8 },
- RF_CHANNEL( 3) = { 0x09ec00, 0x8cccc0 },
- RF_CHANNEL( 4) = { 0x09ec00, 0x8cccd0 },
- RF_CHANNEL( 5) = { 0x05ec00, 0x8cccc8 },
- RF_CHANNEL( 6) = { 0x05ec00, 0x8cccd8 },
- RF_CHANNEL( 7) = { 0x05ec00, 0x8cccc0 },
- RF_CHANNEL( 8) = { 0x05ec00, 0x8cccd0 },
- RF_CHANNEL( 9) = { 0x0dec00, 0x8cccc8 },
- RF_CHANNEL(10) = { 0x0dec00, 0x8cccd8 },
- RF_CHANNEL(11) = { 0x0dec00, 0x8cccc0 },
- RF_CHANNEL(12) = { 0x0dec00, 0x8cccd0 },
- RF_CHANNEL(13) = { 0x03ec00, 0x8cccc8 },
- RF_CHANNEL(14) = { 0x03ec00, 0x866660 },
-};
-
-static const u32 std_rv[] = {
- 0x4ff821,
- 0xc5fbfc,
- 0x21ebfe,
- 0xafd401, /* freq shift 0xaad401 */
- 0x6cf56a,
- 0xe04073,
- 0x193d76,
- 0x9dd844,
- 0x500007,
- 0xd8c010,
-};
-
-static const u32 rv_init1[] = {
- 0x3c9000,
- 0xbfffff,
- 0x700000,
- 0xf15d58,
-};
-
-static const u32 rv_init2[] = {
- 0xf15d59,
- 0xf15d5c,
- 0xf15d58,
-};
-
-static const struct zd_ioreq16 ioreqs_sw[] = {
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
-};
-
-static int zd1211b_al7230b_finalize(struct zd_chip *chip)
-{
- int r;
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
- { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
- { ZD_CR203, 0x04 },
- { },
- { ZD_CR240, 0x80 },
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- if (chip->new_phy_layout) {
- /* antenna selection? */
- r = zd_iowrite16_locked(chip, 0xe5, ZD_CR9);
- if (r)
- return r;
- }
-
- return zd_iowrite16_locked(chip, 0x04, ZD_CR203);
-}
-
-static int zd1211_al7230b_init_hw(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- /* All of these writes are identical to AL2230 unless otherwise
- * specified */
- static const struct zd_ioreq16 ioreqs_1[] = {
- /* This one is 7230-specific, and happens before the rest */
- { ZD_CR240, 0x57 },
- { },
-
- { ZD_CR15, 0x20 }, { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 },
- { ZD_CR26, 0x11 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
- { ZD_CR44, 0x33 },
- /* This value is different for 7230 (was: 0x2a) */
- { ZD_CR106, 0x22 },
- { ZD_CR107, 0x1a }, { ZD_CR109, 0x09 }, { ZD_CR110, 0x27 },
- { ZD_CR111, 0x2b }, { ZD_CR112, 0x2b }, { ZD_CR119, 0x0a },
- /* This happened further down in AL2230,
- * and the value changed (was: 0xe0) */
- { ZD_CR122, 0xfc },
- { ZD_CR10, 0x89 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR17, 0x28 },
- { ZD_CR26, 0x93 }, { ZD_CR34, 0x30 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR35, 0x3e },
- { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR46, 0x96 },
- { ZD_CR47, 0x1e }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
- { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
- { ZD_CR92, 0x0a }, { ZD_CR99, 0x28 },
- /* This value is different for 7230 (was: 0x00) */
- { ZD_CR100, 0x02 },
- { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 },
- /* This value is different for 7230 (was: 0x24) */
- { ZD_CR106, 0x22 },
- /* This value is different for 7230 (was: 0x2a) */
- { ZD_CR107, 0x3f },
- { ZD_CR109, 0x09 },
- /* This value is different for 7230 (was: 0x13) */
- { ZD_CR110, 0x1f },
- { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x27 },
- /* for newest (3rd cut) AL2300 */
- { ZD_CR115, 0x24 },
- /* This value is different for 7230 (was: 0x24) */
- { ZD_CR116, 0x3f },
- /* This value is different for 7230 (was: 0xf4) */
- { ZD_CR117, 0xfa },
- { ZD_CR118, 0xfc }, { ZD_CR119, 0x10 }, { ZD_CR120, 0x4f },
- { ZD_CR121, 0x77 }, { ZD_CR137, 0x88 },
- /* This one is 7230-specific */
- { ZD_CR138, 0xa8 },
- /* This value is different for 7230 (was: 0xff) */
- { ZD_CR252, 0x34 },
- /* This value is different for 7230 (was: 0xff) */
- { ZD_CR253, 0x34 },
-
- /* PLL_OFF */
- { ZD_CR251, 0x2f },
- };
-
- static const struct zd_ioreq16 ioreqs_2[] = {
- { ZD_CR251, 0x3f }, /* PLL_ON */
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
- if (r)
- return r;
-
- r = zd_iowrite16_locked(chip, 0x06, ZD_CR203);
- if (r)
- return r;
- r = zd_iowrite16_locked(chip, 0x80, ZD_CR240);
- if (r)
- return r;
-
- return 0;
-}
-
-static int zd1211b_al7230b_init_hw(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs_1[] = {
- { ZD_CR240, 0x57 }, { ZD_CR9, 0x9 },
- { },
- { ZD_CR10, 0x8b }, { ZD_CR15, 0x20 },
- { ZD_CR17, 0x2B }, /* for newest (3rd cut) AL2230 */
- { ZD_CR20, 0x10 }, /* 4N25->Stone Request */
- { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
- { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
- { ZD_CR33, 0x28 }, /* 5613 */
- { ZD_CR34, 0x30 },
- { ZD_CR35, 0x3e }, /* for newest (3rd cut) AL2230 */
- { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
- { ZD_CR46, 0x99 }, /* for newest (3rd cut) AL2230 */
- { ZD_CR47, 0x1e },
-
- /* ZD1215 5610 */
- { ZD_CR48, 0x00 }, { ZD_CR49, 0x00 }, { ZD_CR51, 0x01 },
- { ZD_CR52, 0x80 }, { ZD_CR53, 0x7e }, { ZD_CR65, 0x00 },
- { ZD_CR66, 0x00 }, { ZD_CR67, 0x00 }, { ZD_CR68, 0x00 },
- { ZD_CR69, 0x28 },
-
- { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
- { ZD_CR87, 0x0A }, { ZD_CR89, 0x04 },
- { ZD_CR90, 0x58 }, /* 5112 */
- { ZD_CR91, 0x00 }, /* 5613 */
- { ZD_CR92, 0x0a },
- { ZD_CR98, 0x8d }, /* 4804, for 1212 new algorithm */
- { ZD_CR99, 0x00 }, { ZD_CR100, 0x02 }, { ZD_CR101, 0x13 },
- { ZD_CR102, 0x27 },
- { ZD_CR106, 0x20 }, /* change to 0x24 for AL7230B */
- { ZD_CR109, 0x13 }, /* 4804, for 1212 new algorithm */
- { ZD_CR112, 0x1f },
- };
-
- static const struct zd_ioreq16 ioreqs_new_phy[] = {
- { ZD_CR107, 0x28 },
- { ZD_CR110, 0x1f }, /* 5127, 0x13->0x1f */
- { ZD_CR111, 0x1f }, /* 0x13 to 0x1f for AL7230B */
- { ZD_CR116, 0x2a }, { ZD_CR118, 0xfa }, { ZD_CR119, 0x12 },
- { ZD_CR121, 0x6c }, /* 5613 */
- };
-
- static const struct zd_ioreq16 ioreqs_old_phy[] = {
- { ZD_CR107, 0x24 },
- { ZD_CR110, 0x13 }, /* 5127, 0x13->0x1f */
- { ZD_CR111, 0x13 }, /* 0x13 to 0x1f for AL7230B */
- { ZD_CR116, 0x24 }, { ZD_CR118, 0xfc }, { ZD_CR119, 0x11 },
- { ZD_CR121, 0x6a }, /* 5613 */
- };
-
- static const struct zd_ioreq16 ioreqs_2[] = {
- { ZD_CR113, 0x27 }, { ZD_CR114, 0x27 }, { ZD_CR115, 0x24 },
- { ZD_CR117, 0xfa }, { ZD_CR120, 0x4f },
- { ZD_CR122, 0xfc }, /* E0->FCh at 4901 */
- { ZD_CR123, 0x57 }, /* 5613 */
- { ZD_CR125, 0xad }, /* 4804, for 1212 new algorithm */
- { ZD_CR126, 0x6c }, /* 5613 */
- { ZD_CR127, 0x03 }, /* 4804, for 1212 new algorithm */
- { ZD_CR130, 0x10 },
- { ZD_CR131, 0x00 }, /* 5112 */
- { ZD_CR137, 0x50 }, /* 5613 */
- { ZD_CR138, 0xa8 }, /* 5112 */
- { ZD_CR144, 0xac }, /* 5613 */
- { ZD_CR148, 0x40 }, /* 5112 */
- { ZD_CR149, 0x40 }, /* 4O07, 50->40 */
- { ZD_CR150, 0x1a }, /* 5112, 0C->1A */
- { ZD_CR252, 0x34 }, { ZD_CR253, 0x34 },
- { ZD_CR251, 0x2f }, /* PLL_OFF */
- };
-
- static const struct zd_ioreq16 ioreqs_3[] = {
- { ZD_CR251, 0x7f }, /* PLL_ON */
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
- { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
- if (r)
- return r;
-
- if (chip->new_phy_layout)
- r = zd_iowrite16a_locked(chip, ioreqs_new_phy,
- ARRAY_SIZE(ioreqs_new_phy));
- else
- r = zd_iowrite16a_locked(chip, ioreqs_old_phy,
- ARRAY_SIZE(ioreqs_old_phy));
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_3, ARRAY_SIZE(ioreqs_3));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
- if (r)
- return r;
-
- return zd1211b_al7230b_finalize(chip);
-}
-
-static int zd1211_al7230b_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
- const u32 *rv = chan_rv[channel-1];
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs[] = {
- /* PLL_ON */
- { ZD_CR251, 0x3f },
- { ZD_CR203, 0x06 }, { ZD_CR240, 0x08 },
- };
-
- r = zd_iowrite16_locked(chip, 0x57, ZD_CR240);
- if (r)
- return r;
-
- /* PLL_OFF */
- r = zd_iowrite16_locked(chip, 0x2f, ZD_CR251);
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
- if (r)
- return r;
-
- r = zd_rfwrite_cr_locked(chip, 0x3c9000);
- if (r)
- return r;
- r = zd_rfwrite_cr_locked(chip, 0xf15d58);
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv, 2);
- if (r)
- return r;
-
- r = zd_rfwrite_cr_locked(chip, 0x3c9000);
- if (r)
- return r;
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211b_al7230b_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
- const u32 *rv = chan_rv[channel-1];
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- r = zd_iowrite16_locked(chip, 0x57, ZD_CR240);
- if (r)
- return r;
- r = zd_iowrite16_locked(chip, 0xe4, ZD_CR9);
- if (r)
- return r;
-
- /* PLL_OFF */
- r = zd_iowrite16_locked(chip, 0x2f, ZD_CR251);
- if (r)
- return r;
- r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
- if (r)
- return r;
-
- r = zd_rfwrite_cr_locked(chip, 0x3c9000);
- if (r)
- return r;
- r = zd_rfwrite_cr_locked(chip, 0xf15d58);
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
- if (r)
- return r;
-
- r = zd_rfwritev_cr_locked(chip, rv, 2);
- if (r)
- return r;
-
- r = zd_rfwrite_cr_locked(chip, 0x3c9000);
- if (r)
- return r;
-
- r = zd_iowrite16_locked(chip, 0x7f, ZD_CR251);
- if (r)
- return r;
-
- return zd1211b_al7230b_finalize(chip);
-}
-
-static int zd1211_al7230b_switch_radio_on(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x00 },
- { ZD_CR251, 0x3f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int zd1211b_al7230b_switch_radio_on(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x00 },
- { ZD_CR251, 0x7f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int al7230b_switch_radio_off(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x04 },
- { ZD_CR251, 0x2f },
- };
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-/* ZD1211B+AL7230B 6m band edge patching differs slightly from other
- * configurations */
-static int zd1211b_al7230b_patch_6m(struct zd_rf *rf, u8 channel)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
- struct zd_ioreq16 ioreqs[] = {
- { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 },
- };
-
- /* FIXME: Channel 11 is not the edge for all regulatory domains. */
- if (channel == 1) {
- ioreqs[0].value = 0x0e;
- ioreqs[1].value = 0x10;
- } else if (channel == 11) {
- ioreqs[0].value = 0x10;
- ioreqs[1].value = 0x10;
- }
-
- dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-int zd_rf_init_al7230b(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- if (zd_chip_is_zd1211b(chip)) {
- rf->init_hw = zd1211b_al7230b_init_hw;
- rf->switch_radio_on = zd1211b_al7230b_switch_radio_on;
- rf->set_channel = zd1211b_al7230b_set_channel;
- rf->patch_6m_band_edge = zd1211b_al7230b_patch_6m;
- } else {
- rf->init_hw = zd1211_al7230b_init_hw;
- rf->switch_radio_on = zd1211_al7230b_switch_radio_on;
- rf->set_channel = zd1211_al7230b_set_channel;
- rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
- rf->patch_cck_gain = 1;
- }
-
- rf->switch_radio_off = al7230b_switch_radio_off;
-
- return 0;
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/kernel.h>
-
-#include "zd_rf.h"
-#include "zd_usb.h"
-#include "zd_chip.h"
-
-static const u32 rf2959_table[][2] = {
- RF_CHANNEL( 1) = { 0x181979, 0x1e6666 },
- RF_CHANNEL( 2) = { 0x181989, 0x1e6666 },
- RF_CHANNEL( 3) = { 0x181999, 0x1e6666 },
- RF_CHANNEL( 4) = { 0x1819a9, 0x1e6666 },
- RF_CHANNEL( 5) = { 0x1819b9, 0x1e6666 },
- RF_CHANNEL( 6) = { 0x1819c9, 0x1e6666 },
- RF_CHANNEL( 7) = { 0x1819d9, 0x1e6666 },
- RF_CHANNEL( 8) = { 0x1819e9, 0x1e6666 },
- RF_CHANNEL( 9) = { 0x1819f9, 0x1e6666 },
- RF_CHANNEL(10) = { 0x181a09, 0x1e6666 },
- RF_CHANNEL(11) = { 0x181a19, 0x1e6666 },
- RF_CHANNEL(12) = { 0x181a29, 0x1e6666 },
- RF_CHANNEL(13) = { 0x181a39, 0x1e6666 },
- RF_CHANNEL(14) = { 0x181a60, 0x1c0000 },
-};
-
-#if 0
-static int bits(u32 rw, int from, int to)
-{
- rw &= ~(0xffffffffU << (to+1));
- rw >>= from;
- return rw;
-}
-
-static int bit(u32 rw, int bit)
-{
- return bits(rw, bit, bit);
-}
-
-static void dump_regwrite(u32 rw)
-{
- int reg = bits(rw, 18, 22);
- int rw_flag = bits(rw, 23, 23);
- PDEBUG("rf2959 %#010x reg %d rw %d", rw, reg, rw_flag);
-
- switch (reg) {
- case 0:
- PDEBUG("reg0 CFG1 ref_sel %d hybernate %d rf_vco_reg_en %d"
- " if_vco_reg_en %d if_vga_en %d",
- bits(rw, 14, 15), bit(rw, 3), bit(rw, 2), bit(rw, 1),
- bit(rw, 0));
- break;
- case 1:
- PDEBUG("reg1 IFPLL1 pll_en1 %d kv_en1 %d vtc_en1 %d lpf1 %d"
- " cpl1 %d pdp1 %d autocal_en1 %d ld_en1 %d ifloopr %d"
- " ifloopc %d dac1 %d",
- bit(rw, 17), bit(rw, 16), bit(rw, 15), bit(rw, 14),
- bit(rw, 13), bit(rw, 12), bit(rw, 11), bit(rw, 10),
- bits(rw, 7, 9), bits(rw, 4, 6), bits(rw, 0, 3));
- break;
- case 2:
- PDEBUG("reg2 IFPLL2 n1 %d num1 %d",
- bits(rw, 6, 17), bits(rw, 0, 5));
- break;
- case 3:
- PDEBUG("reg3 IFPLL3 num %d", bits(rw, 0, 17));
- break;
- case 4:
- PDEBUG("reg4 IFPLL4 dn1 %#04x ct_def1 %d kv_def1 %d",
- bits(rw, 8, 16), bits(rw, 4, 7), bits(rw, 0, 3));
- break;
- case 5:
- PDEBUG("reg5 RFPLL1 pll_en %d kv_en %d vtc_en %d lpf %d cpl %d"
- " pdp %d autocal_en %d ld_en %d rfloopr %d rfloopc %d"
- " dac %d",
- bit(rw, 17), bit(rw, 16), bit(rw, 15), bit(rw, 14),
- bit(rw, 13), bit(rw, 12), bit(rw, 11), bit(rw, 10),
- bits(rw, 7, 9), bits(rw, 4, 6), bits(rw, 0,3));
- break;
- case 6:
- PDEBUG("reg6 RFPLL2 n %d num %d",
- bits(rw, 6, 17), bits(rw, 0, 5));
- break;
- case 7:
- PDEBUG("reg7 RFPLL3 num2 %d", bits(rw, 0, 17));
- break;
- case 8:
- PDEBUG("reg8 RFPLL4 dn %#06x ct_def %d kv_def %d",
- bits(rw, 8, 16), bits(rw, 4, 7), bits(rw, 0, 3));
- break;
- case 9:
- PDEBUG("reg9 CAL1 tvco %d tlock %d m_ct_value %d ld_window %d",
- bits(rw, 13, 17), bits(rw, 8, 12), bits(rw, 3, 7),
- bits(rw, 0, 2));
- break;
- case 10:
- PDEBUG("reg10 TXRX1 rxdcfbbyps %d pcontrol %d txvgc %d"
- " rxlpfbw %d txlpfbw %d txdiffmode %d txenmode %d"
- " intbiasen %d tybypass %d",
- bit(rw, 17), bits(rw, 15, 16), bits(rw, 10, 14),
- bits(rw, 7, 9), bits(rw, 4, 6), bit(rw, 3), bit(rw, 2),
- bit(rw, 1), bit(rw, 0));
- break;
- case 11:
- PDEBUG("reg11 PCNT1 mid_bias %d p_desired %d pc_offset %d"
- " tx_delay %d",
- bits(rw, 15, 17), bits(rw, 9, 14), bits(rw, 3, 8),
- bits(rw, 0, 2));
- break;
- case 12:
- PDEBUG("reg12 PCNT2 max_power %d mid_power %d min_power %d",
- bits(rw, 12, 17), bits(rw, 6, 11), bits(rw, 0, 5));
- break;
- case 13:
- PDEBUG("reg13 VCOT1 rfpll vco comp %d ifpll vco comp %d"
- " lobias %d if_biasbuf %d if_biasvco %d rf_biasbuf %d"
- " rf_biasvco %d",
- bit(rw, 17), bit(rw, 16), bit(rw, 15),
- bits(rw, 8, 9), bits(rw, 5, 7), bits(rw, 3, 4),
- bits(rw, 0, 2));
- break;
- case 14:
- PDEBUG("reg14 IQCAL rx_acal %d rx_pcal %d"
- " tx_acal %d tx_pcal %d",
- bits(rw, 13, 17), bits(rw, 9, 12), bits(rw, 4, 8),
- bits(rw, 0, 3));
- break;
- }
-}
-#endif /* 0 */
-
-static int rf2959_init_hw(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR2, 0x1E }, { ZD_CR9, 0x20 }, { ZD_CR10, 0x89 },
- { ZD_CR11, 0x00 }, { ZD_CR15, 0xD0 }, { ZD_CR17, 0x68 },
- { ZD_CR19, 0x4a }, { ZD_CR20, 0x0c }, { ZD_CR21, 0x0E },
- { ZD_CR23, 0x48 },
- /* normal size for cca threshold */
- { ZD_CR24, 0x14 },
- /* { ZD_CR24, 0x20 }, */
- { ZD_CR26, 0x90 }, { ZD_CR27, 0x30 }, { ZD_CR29, 0x20 },
- { ZD_CR31, 0xb2 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x28 },
- { ZD_CR38, 0x30 }, { ZD_CR34, 0x0f }, { ZD_CR35, 0xF0 },
- { ZD_CR41, 0x2a }, { ZD_CR46, 0x7F }, { ZD_CR47, 0x1E },
- { ZD_CR51, 0xc5 }, { ZD_CR52, 0xc5 }, { ZD_CR53, 0xc5 },
- { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
- { ZD_CR82, 0x00 }, { ZD_CR83, 0x24 }, { ZD_CR84, 0x04 },
- { ZD_CR85, 0x00 }, { ZD_CR86, 0x10 }, { ZD_CR87, 0x2A },
- { ZD_CR88, 0x10 }, { ZD_CR89, 0x24 }, { ZD_CR90, 0x18 },
- /* { ZD_CR91, 0x18 }, */
- /* should solve continuous CTS frame problems */
- { ZD_CR91, 0x00 },
- { ZD_CR92, 0x0a }, { ZD_CR93, 0x00 }, { ZD_CR94, 0x01 },
- { ZD_CR95, 0x00 }, { ZD_CR96, 0x40 }, { ZD_CR97, 0x37 },
- { ZD_CR98, 0x05 }, { ZD_CR99, 0x28 }, { ZD_CR100, 0x00 },
- { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 },
- { ZD_CR104, 0x18 }, { ZD_CR105, 0x12 },
- /* normal size */
- { ZD_CR106, 0x1a },
- /* { ZD_CR106, 0x22 }, */
- { ZD_CR107, 0x24 }, { ZD_CR108, 0x0a }, { ZD_CR109, 0x13 },
- { ZD_CR110, 0x2F }, { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 },
- { ZD_CR113, 0x27 }, { ZD_CR114, 0x27 }, { ZD_CR115, 0x40 },
- { ZD_CR116, 0x40 }, { ZD_CR117, 0xF0 }, { ZD_CR118, 0xF0 },
- { ZD_CR119, 0x16 },
- /* no TX continuation */
- { ZD_CR122, 0x00 },
- /* { ZD_CR122, 0xff }, */
- { ZD_CR127, 0x03 }, { ZD_CR131, 0x08 }, { ZD_CR138, 0x28 },
- { ZD_CR148, 0x44 }, { ZD_CR150, 0x10 }, { ZD_CR169, 0xBB },
- { ZD_CR170, 0xBB },
- };
-
- static const u32 rv[] = {
- 0x000007, /* REG0(CFG1) */
- 0x07dd43, /* REG1(IFPLL1) */
- 0x080959, /* REG2(IFPLL2) */
- 0x0e6666,
- 0x116a57, /* REG4 */
- 0x17dd43, /* REG5 */
- 0x1819f9, /* REG6 */
- 0x1e6666,
- 0x214554,
- 0x25e7fa,
- 0x27fffa,
- /* The Zydas driver somehow forgets to set this value. It's
- * only set for Japan. We are using internal power control
- * for now.
- */
- 0x294128, /* internal power */
- /* 0x28252c, */ /* External control TX power */
- /* ZD_CR31_CCK, ZD_CR51_6-36M, ZD_CR52_48M, ZD_CR53_54M */
- 0x2c0000,
- 0x300000,
- 0x340000, /* REG13(0xD) */
- 0x381e0f, /* REG14(0xE) */
- /* Bogus, RF2959's data sheet doesn't know register 27, which is
- * actually referenced here. The commented 0x11 is 17.
- */
- 0x6c180f, /* REG27(0x11) */
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- return zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
-}
-
-static int rf2959_set_channel(struct zd_rf *rf, u8 channel)
-{
- int i, r;
- const u32 *rv = rf2959_table[channel-1];
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- for (i = 0; i < 2; i++) {
- r = zd_rfwrite_locked(chip, rv[i], RF_RV_BITS);
- if (r)
- return r;
- }
- return 0;
-}
-
-static int rf2959_switch_radio_on(struct zd_rf *rf)
-{
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR10, 0x89 },
- { ZD_CR11, 0x00 },
- };
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int rf2959_switch_radio_off(struct zd_rf *rf)
-{
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR10, 0x15 },
- { ZD_CR11, 0x81 },
- };
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-int zd_rf_init_rf2959(struct zd_rf *rf)
-{
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- if (zd_chip_is_zd1211b(chip)) {
- dev_err(zd_chip_dev(chip),
- "RF2959 is currently not supported for ZD1211B"
- " devices\n");
- return -ENODEV;
- }
- rf->init_hw = rf2959_init_hw;
- rf->set_channel = rf2959_set_channel;
- rf->switch_radio_on = rf2959_switch_radio_on;
- rf->switch_radio_off = rf2959_switch_radio_off;
- return 0;
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/kernel.h>
-#include <linux/slab.h>
-
-#include "zd_rf.h"
-#include "zd_usb.h"
-#include "zd_chip.h"
-
-/* This RF programming code is based upon the code found in v2.16.0.0 of the
- * ZyDAS vendor driver. Unlike other RF's, Ubec publish full technical specs
- * for this RF on their website, so we're able to understand more than
- * usual as to what is going on. Thumbs up for Ubec for doing that. */
-
-/* The 3-wire serial interface provides access to 8 write-only registers.
- * The data format is a 4 bit register address followed by a 20 bit value. */
-#define UW2453_REGWRITE(reg, val) ((((reg) & 0xf) << 20) | ((val) & 0xfffff))
-
-/* For channel tuning, we have to configure registers 1 (synthesizer), 2 (synth
- * fractional divide ratio) and 3 (VCO config).
- *
- * We configure the RF to produce an interrupt when the PLL is locked onto
- * the configured frequency. During initialization, we run through a variety
- * of different VCO configurations on channel 1 until we detect a PLL lock.
- * When this happens, we remember which VCO configuration produced the lock
- * and use it later. Actually, we use the configuration *after* the one that
- * produced the lock, which seems odd, but it works.
- *
- * If we do not see a PLL lock on any standard VCO config, we fall back on an
- * autocal configuration, which has a fixed (as opposed to per-channel) VCO
- * config and different synth values from the standard set (divide ratio
- * is still shared with the standard set). */
-
-/* The per-channel synth values for all standard VCO configurations. These get
- * written to register 1. */
-static const u8 uw2453_std_synth[] = {
- RF_CHANNEL( 1) = 0x47,
- RF_CHANNEL( 2) = 0x47,
- RF_CHANNEL( 3) = 0x67,
- RF_CHANNEL( 4) = 0x67,
- RF_CHANNEL( 5) = 0x67,
- RF_CHANNEL( 6) = 0x67,
- RF_CHANNEL( 7) = 0x57,
- RF_CHANNEL( 8) = 0x57,
- RF_CHANNEL( 9) = 0x57,
- RF_CHANNEL(10) = 0x57,
- RF_CHANNEL(11) = 0x77,
- RF_CHANNEL(12) = 0x77,
- RF_CHANNEL(13) = 0x77,
- RF_CHANNEL(14) = 0x4f,
-};
-
-/* This table stores the synthesizer fractional divide ratio for *all* VCO
- * configurations (both standard and autocal). These get written to register 2.
- */
-static const u16 uw2453_synth_divide[] = {
- RF_CHANNEL( 1) = 0x999,
- RF_CHANNEL( 2) = 0x99b,
- RF_CHANNEL( 3) = 0x998,
- RF_CHANNEL( 4) = 0x99a,
- RF_CHANNEL( 5) = 0x999,
- RF_CHANNEL( 6) = 0x99b,
- RF_CHANNEL( 7) = 0x998,
- RF_CHANNEL( 8) = 0x99a,
- RF_CHANNEL( 9) = 0x999,
- RF_CHANNEL(10) = 0x99b,
- RF_CHANNEL(11) = 0x998,
- RF_CHANNEL(12) = 0x99a,
- RF_CHANNEL(13) = 0x999,
- RF_CHANNEL(14) = 0xccc,
-};
-
-/* Here is the data for all the standard VCO configurations. We shrink our
- * table a little by observing that both channels in a consecutive pair share
- * the same value. We also observe that the high 4 bits ([0:3] in the specs)
- * are all 'Reserved' and are always set to 0x4 - we chop them off in the data
- * below. */
-#define CHAN_TO_PAIRIDX(a) ((a - 1) / 2)
-#define RF_CHANPAIR(a,b) [CHAN_TO_PAIRIDX(a)]
-static const u16 uw2453_std_vco_cfg[][7] = {
- { /* table 1 */
- RF_CHANPAIR( 1, 2) = 0x664d,
- RF_CHANPAIR( 3, 4) = 0x604d,
- RF_CHANPAIR( 5, 6) = 0x6675,
- RF_CHANPAIR( 7, 8) = 0x6475,
- RF_CHANPAIR( 9, 10) = 0x6655,
- RF_CHANPAIR(11, 12) = 0x6455,
- RF_CHANPAIR(13, 14) = 0x6665,
- },
- { /* table 2 */
- RF_CHANPAIR( 1, 2) = 0x666d,
- RF_CHANPAIR( 3, 4) = 0x606d,
- RF_CHANPAIR( 5, 6) = 0x664d,
- RF_CHANPAIR( 7, 8) = 0x644d,
- RF_CHANPAIR( 9, 10) = 0x6675,
- RF_CHANPAIR(11, 12) = 0x6475,
- RF_CHANPAIR(13, 14) = 0x6655,
- },
- { /* table 3 */
- RF_CHANPAIR( 1, 2) = 0x665d,
- RF_CHANPAIR( 3, 4) = 0x605d,
- RF_CHANPAIR( 5, 6) = 0x666d,
- RF_CHANPAIR( 7, 8) = 0x646d,
- RF_CHANPAIR( 9, 10) = 0x664d,
- RF_CHANPAIR(11, 12) = 0x644d,
- RF_CHANPAIR(13, 14) = 0x6675,
- },
- { /* table 4 */
- RF_CHANPAIR( 1, 2) = 0x667d,
- RF_CHANPAIR( 3, 4) = 0x607d,
- RF_CHANPAIR( 5, 6) = 0x665d,
- RF_CHANPAIR( 7, 8) = 0x645d,
- RF_CHANPAIR( 9, 10) = 0x666d,
- RF_CHANPAIR(11, 12) = 0x646d,
- RF_CHANPAIR(13, 14) = 0x664d,
- },
- { /* table 5 */
- RF_CHANPAIR( 1, 2) = 0x6643,
- RF_CHANPAIR( 3, 4) = 0x6043,
- RF_CHANPAIR( 5, 6) = 0x667d,
- RF_CHANPAIR( 7, 8) = 0x647d,
- RF_CHANPAIR( 9, 10) = 0x665d,
- RF_CHANPAIR(11, 12) = 0x645d,
- RF_CHANPAIR(13, 14) = 0x666d,
- },
- { /* table 6 */
- RF_CHANPAIR( 1, 2) = 0x6663,
- RF_CHANPAIR( 3, 4) = 0x6063,
- RF_CHANPAIR( 5, 6) = 0x6643,
- RF_CHANPAIR( 7, 8) = 0x6443,
- RF_CHANPAIR( 9, 10) = 0x667d,
- RF_CHANPAIR(11, 12) = 0x647d,
- RF_CHANPAIR(13, 14) = 0x665d,
- },
- { /* table 7 */
- RF_CHANPAIR( 1, 2) = 0x6653,
- RF_CHANPAIR( 3, 4) = 0x6053,
- RF_CHANPAIR( 5, 6) = 0x6663,
- RF_CHANPAIR( 7, 8) = 0x6463,
- RF_CHANPAIR( 9, 10) = 0x6643,
- RF_CHANPAIR(11, 12) = 0x6443,
- RF_CHANPAIR(13, 14) = 0x667d,
- },
- { /* table 8 */
- RF_CHANPAIR( 1, 2) = 0x6673,
- RF_CHANPAIR( 3, 4) = 0x6073,
- RF_CHANPAIR( 5, 6) = 0x6653,
- RF_CHANPAIR( 7, 8) = 0x6453,
- RF_CHANPAIR( 9, 10) = 0x6663,
- RF_CHANPAIR(11, 12) = 0x6463,
- RF_CHANPAIR(13, 14) = 0x6643,
- },
- { /* table 9 */
- RF_CHANPAIR( 1, 2) = 0x664b,
- RF_CHANPAIR( 3, 4) = 0x604b,
- RF_CHANPAIR( 5, 6) = 0x6673,
- RF_CHANPAIR( 7, 8) = 0x6473,
- RF_CHANPAIR( 9, 10) = 0x6653,
- RF_CHANPAIR(11, 12) = 0x6453,
- RF_CHANPAIR(13, 14) = 0x6663,
- },
- { /* table 10 */
- RF_CHANPAIR( 1, 2) = 0x666b,
- RF_CHANPAIR( 3, 4) = 0x606b,
- RF_CHANPAIR( 5, 6) = 0x664b,
- RF_CHANPAIR( 7, 8) = 0x644b,
- RF_CHANPAIR( 9, 10) = 0x6673,
- RF_CHANPAIR(11, 12) = 0x6473,
- RF_CHANPAIR(13, 14) = 0x6653,
- },
- { /* table 11 */
- RF_CHANPAIR( 1, 2) = 0x665b,
- RF_CHANPAIR( 3, 4) = 0x605b,
- RF_CHANPAIR( 5, 6) = 0x666b,
- RF_CHANPAIR( 7, 8) = 0x646b,
- RF_CHANPAIR( 9, 10) = 0x664b,
- RF_CHANPAIR(11, 12) = 0x644b,
- RF_CHANPAIR(13, 14) = 0x6673,
- },
-
-};
-
-/* The per-channel synth values for autocal. These get written to register 1. */
-static const u16 uw2453_autocal_synth[] = {
- RF_CHANNEL( 1) = 0x6847,
- RF_CHANNEL( 2) = 0x6847,
- RF_CHANNEL( 3) = 0x6867,
- RF_CHANNEL( 4) = 0x6867,
- RF_CHANNEL( 5) = 0x6867,
- RF_CHANNEL( 6) = 0x6867,
- RF_CHANNEL( 7) = 0x6857,
- RF_CHANNEL( 8) = 0x6857,
- RF_CHANNEL( 9) = 0x6857,
- RF_CHANNEL(10) = 0x6857,
- RF_CHANNEL(11) = 0x6877,
- RF_CHANNEL(12) = 0x6877,
- RF_CHANNEL(13) = 0x6877,
- RF_CHANNEL(14) = 0x684f,
-};
-
-/* The VCO configuration for autocal (all channels) */
-static const u16 UW2453_AUTOCAL_VCO_CFG = 0x6662;
-
-/* TX gain settings. The array index corresponds to the TX power integration
- * values found in the EEPROM. The values get written to register 7. */
-static u32 uw2453_txgain[] = {
- [0x00] = 0x0e313,
- [0x01] = 0x0fb13,
- [0x02] = 0x0e093,
- [0x03] = 0x0f893,
- [0x04] = 0x0ea93,
- [0x05] = 0x1f093,
- [0x06] = 0x1f493,
- [0x07] = 0x1f693,
- [0x08] = 0x1f393,
- [0x09] = 0x1f35b,
- [0x0a] = 0x1e6db,
- [0x0b] = 0x1ff3f,
- [0x0c] = 0x1ffff,
- [0x0d] = 0x361d7,
- [0x0e] = 0x37fbf,
- [0x0f] = 0x3ff8b,
- [0x10] = 0x3ff33,
- [0x11] = 0x3fb3f,
- [0x12] = 0x3ffff,
-};
-
-/* RF-specific structure */
-struct uw2453_priv {
- /* index into synth/VCO config tables where PLL lock was found
- * -1 means autocal */
- int config;
-};
-
-#define UW2453_PRIV(rf) ((struct uw2453_priv *) (rf)->priv)
-
-static int uw2453_synth_set_channel(struct zd_chip *chip, int channel,
- bool autocal)
-{
- int r;
- int idx = channel - 1;
- u32 val;
-
- if (autocal)
- val = UW2453_REGWRITE(1, uw2453_autocal_synth[idx]);
- else
- val = UW2453_REGWRITE(1, uw2453_std_synth[idx]);
-
- r = zd_rfwrite_locked(chip, val, RF_RV_BITS);
- if (r)
- return r;
-
- return zd_rfwrite_locked(chip,
- UW2453_REGWRITE(2, uw2453_synth_divide[idx]), RF_RV_BITS);
-}
-
-static int uw2453_write_vco_cfg(struct zd_chip *chip, u16 value)
-{
- /* vendor driver always sets these upper bits even though the specs say
- * they are reserved */
- u32 val = 0x40000 | value;
- return zd_rfwrite_locked(chip, UW2453_REGWRITE(3, val), RF_RV_BITS);
-}
-
-static int uw2453_init_mode(struct zd_chip *chip)
-{
- static const u32 rv[] = {
- UW2453_REGWRITE(0, 0x25f98), /* enter IDLE mode */
- UW2453_REGWRITE(0, 0x25f9a), /* enter CAL_VCO mode */
- UW2453_REGWRITE(0, 0x25f94), /* enter RX/TX mode */
- UW2453_REGWRITE(0, 0x27fd4), /* power down RSSI circuit */
- };
-
- return zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
-}
-
-static int uw2453_set_tx_gain_level(struct zd_chip *chip, int channel)
-{
- u8 int_value = chip->pwr_int_values[channel - 1];
-
- if (int_value >= ARRAY_SIZE(uw2453_txgain)) {
- dev_dbg_f(zd_chip_dev(chip), "can't configure TX gain for "
- "int value %x on channel %d\n", int_value, channel);
- return 0;
- }
-
- return zd_rfwrite_locked(chip,
- UW2453_REGWRITE(7, uw2453_txgain[int_value]), RF_RV_BITS);
-}
-
-static int uw2453_init_hw(struct zd_rf *rf)
-{
- int i, r;
- int found_config = -1;
- u16 intr_status;
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR10, 0x89 }, { ZD_CR15, 0x20 },
- { ZD_CR17, 0x28 }, /* 6112 no change */
- { ZD_CR23, 0x38 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
- { ZD_CR27, 0x15 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
- { ZD_CR33, 0x28 }, { ZD_CR34, 0x30 },
- { ZD_CR35, 0x43 }, /* 6112 3e->43 */
- { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
- { ZD_CR46, 0x92 }, /* 6112 96->92 */
- { ZD_CR47, 0x1e },
- { ZD_CR48, 0x04 }, /* 5602 Roger */
- { ZD_CR49, 0xfa }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
- { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
- { ZD_CR91, 0x00 }, { ZD_CR92, 0x0a }, { ZD_CR98, 0x8d },
- { ZD_CR99, 0x28 }, { ZD_CR100, 0x02 },
- { ZD_CR101, 0x09 }, /* 6112 13->1f 6220 1f->13 6407 13->9 */
- { ZD_CR102, 0x27 },
- { ZD_CR106, 0x1c }, /* 5d07 5112 1f->1c 6220 1c->1f
- * 6221 1f->1c
- */
- { ZD_CR107, 0x1c }, /* 6220 1c->1a 5221 1a->1c */
- { ZD_CR109, 0x13 },
- { ZD_CR110, 0x1f }, /* 6112 13->1f 6221 1f->13 6407 13->0x09 */
- { ZD_CR111, 0x13 }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
- { ZD_CR114, 0x23 }, /* 6221 27->23 */
- { ZD_CR115, 0x24 }, /* 6112 24->1c 6220 1c->24 */
- { ZD_CR116, 0x24 }, /* 6220 1c->24 */
- { ZD_CR117, 0xfa }, /* 6112 fa->f8 6220 f8->f4 6220 f4->fa */
- { ZD_CR118, 0xf0 }, /* 5d07 6112 f0->f2 6220 f2->f0 */
- { ZD_CR119, 0x1a }, /* 6112 1a->10 6220 10->14 6220 14->1a */
- { ZD_CR120, 0x4f },
- { ZD_CR121, 0x1f }, /* 6220 4f->1f */
- { ZD_CR122, 0xf0 }, { ZD_CR123, 0x57 }, { ZD_CR125, 0xad },
- { ZD_CR126, 0x6c }, { ZD_CR127, 0x03 },
- { ZD_CR128, 0x14 }, /* 6302 12->11 */
- { ZD_CR129, 0x12 }, /* 6301 10->0f */
- { ZD_CR130, 0x10 }, { ZD_CR137, 0x50 }, { ZD_CR138, 0xa8 },
- { ZD_CR144, 0xac }, { ZD_CR146, 0x20 }, { ZD_CR252, 0xff },
- { ZD_CR253, 0xff },
- };
-
- static const u32 rv[] = {
- UW2453_REGWRITE(4, 0x2b), /* configure receiver gain */
- UW2453_REGWRITE(5, 0x19e4f), /* configure transmitter gain */
- UW2453_REGWRITE(6, 0xf81ad), /* enable RX/TX filter tuning */
- UW2453_REGWRITE(7, 0x3fffe), /* disable TX gain in test mode */
-
- /* enter CAL_FIL mode, TX gain set by registers, RX gain set by pins,
- * RSSI circuit powered down, reduced RSSI range */
- UW2453_REGWRITE(0, 0x25f9c), /* 5d01 cal_fil */
-
- /* synthesizer configuration for channel 1 */
- UW2453_REGWRITE(1, 0x47),
- UW2453_REGWRITE(2, 0x999),
-
- /* disable manual VCO band selection */
- UW2453_REGWRITE(3, 0x7602),
-
- /* enable manual VCO band selection, configure current level */
- UW2453_REGWRITE(3, 0x46063),
- };
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- r = zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
- if (r)
- return r;
-
- r = uw2453_init_mode(chip);
- if (r)
- return r;
-
- /* Try all standard VCO configuration settings on channel 1 */
- for (i = 0; i < ARRAY_SIZE(uw2453_std_vco_cfg) - 1; i++) {
- /* Configure synthesizer for channel 1 */
- r = uw2453_synth_set_channel(chip, 1, false);
- if (r)
- return r;
-
- /* Write VCO config */
- r = uw2453_write_vco_cfg(chip, uw2453_std_vco_cfg[i][0]);
- if (r)
- return r;
-
- /* ack interrupt event */
- r = zd_iowrite16_locked(chip, 0x0f, UW2453_INTR_REG);
- if (r)
- return r;
-
- /* check interrupt status */
- r = zd_ioread16_locked(chip, &intr_status, UW2453_INTR_REG);
- if (r)
- return r;
-
- if (!(intr_status & 0xf)) {
- dev_dbg_f(zd_chip_dev(chip),
- "PLL locked on configuration %d\n", i);
- found_config = i;
- break;
- }
- }
-
- if (found_config == -1) {
- /* autocal */
- dev_dbg_f(zd_chip_dev(chip),
- "PLL did not lock, using autocal\n");
-
- r = uw2453_synth_set_channel(chip, 1, true);
- if (r)
- return r;
-
- r = uw2453_write_vco_cfg(chip, UW2453_AUTOCAL_VCO_CFG);
- if (r)
- return r;
- }
-
- /* To match the vendor driver behaviour, we use the configuration after
- * the one that produced a lock. */
- UW2453_PRIV(rf)->config = found_config + 1;
-
- return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
-}
-
-static int uw2453_set_channel(struct zd_rf *rf, u8 channel)
-{
- int r;
- u16 vco_cfg;
- int config = UW2453_PRIV(rf)->config;
- bool autocal = (config == -1);
- struct zd_chip *chip = zd_rf_to_chip(rf);
-
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
- { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
- };
-
- r = uw2453_synth_set_channel(chip, channel, autocal);
- if (r)
- return r;
-
- if (autocal)
- vco_cfg = UW2453_AUTOCAL_VCO_CFG;
- else
- vco_cfg = uw2453_std_vco_cfg[config][CHAN_TO_PAIRIDX(channel)];
-
- r = uw2453_write_vco_cfg(chip, vco_cfg);
- if (r)
- return r;
-
- r = uw2453_init_mode(chip);
- if (r)
- return r;
-
- r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
- if (r)
- return r;
-
- r = uw2453_set_tx_gain_level(chip, channel);
- if (r)
- return r;
-
- return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
-}
-
-static int uw2453_switch_radio_on(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
- struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x00 }, { ZD_CR251, 0x3f },
- };
-
- /* enter RXTX mode */
- r = zd_rfwrite_locked(chip, UW2453_REGWRITE(0, 0x25f94), RF_RV_BITS);
- if (r)
- return r;
-
- if (zd_chip_is_zd1211b(chip))
- ioreqs[1].value = 0x7f;
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static int uw2453_switch_radio_off(struct zd_rf *rf)
-{
- int r;
- struct zd_chip *chip = zd_rf_to_chip(rf);
- static const struct zd_ioreq16 ioreqs[] = {
- { ZD_CR11, 0x04 }, { ZD_CR251, 0x2f },
- };
-
- /* enter IDLE mode */
- /* FIXME: shouldn't we go to SLEEP? sent email to zydas */
- r = zd_rfwrite_locked(chip, UW2453_REGWRITE(0, 0x25f90), RF_RV_BITS);
- if (r)
- return r;
-
- return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
-}
-
-static void uw2453_clear(struct zd_rf *rf)
-{
- kfree(rf->priv);
-}
-
-int zd_rf_init_uw2453(struct zd_rf *rf)
-{
- rf->init_hw = uw2453_init_hw;
- rf->set_channel = uw2453_set_channel;
- rf->switch_radio_on = uw2453_switch_radio_on;
- rf->switch_radio_off = uw2453_switch_radio_off;
- rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
- rf->clear = uw2453_clear;
- /* we have our own TX integration code */
- rf->update_channel_int = 0;
-
- rf->priv = kmalloc(sizeof(struct uw2453_priv), GFP_KERNEL);
- if (rf->priv == NULL)
- return -ENOMEM;
-
- return 0;
-}
-
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/firmware.h>
-#include <linux/device.h>
-#include <linux/errno.h>
-#include <linux/slab.h>
-#include <linux/skbuff.h>
-#include <linux/usb.h>
-#include <linux/workqueue.h>
-#include <linux/module.h>
-#include <net/mac80211.h>
-#include <asm/unaligned.h>
-
-#include "zd_def.h"
-#include "zd_mac.h"
-#include "zd_usb.h"
-
-static struct usb_device_id usb_ids[] = {
- /* ZD1211 */
- { USB_DEVICE(0x0105, 0x145f), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0586, 0x3401), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0586, 0x3402), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0586, 0x3407), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0586, 0x3409), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x079b, 0x004a), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0ace, 0x1211), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0ace, 0xa211), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0b05, 0x170c), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0b3b, 0x1630), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0b3b, 0x5630), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0df6, 0x9071), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x0df6, 0x9075), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x126f, 0xa006), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x129b, 0x1666), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x13b1, 0x001e), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x1435, 0x0711), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x14ea, 0xab10), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x14ea, 0xab13), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x157e, 0x300a), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x157e, 0x300b), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x157e, 0x3204), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x157e, 0x3207), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x1740, 0x2000), .driver_info = DEVICE_ZD1211 },
- { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
- /* ZD1211B */
- { USB_DEVICE(0x0053, 0x5301), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0409, 0x0248), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0411, 0x00da), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0471, 0x1236), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x050d, 0x705c), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x054c, 0x0257), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0586, 0x340a), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0586, 0x340f), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0586, 0x3410), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0586, 0x3412), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0586, 0x3413), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x079b, 0x0062), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x083a, 0x4505), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x083a, 0xe501), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x083a, 0xe503), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x083a, 0xe506), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0ace, 0x1215), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0ace, 0xb215), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0b05, 0x171b), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0baf, 0x0121), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0cde, 0x001a), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x0df6, 0x0036), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x129b, 0x1667), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x13b1, 0x0024), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x157e, 0x300d), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x1582, 0x6003), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x2019, 0x5303), .driver_info = DEVICE_ZD1211B },
- { USB_DEVICE(0x2019, 0xed01), .driver_info = DEVICE_ZD1211B },
- /* "Driverless" devices that need ejecting */
- { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
- { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },
- {}
-};
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("USB driver for devices with the ZD1211 chip.");
-MODULE_AUTHOR("Ulrich Kunitz");
-MODULE_AUTHOR("Daniel Drake");
-MODULE_VERSION("1.0");
-MODULE_DEVICE_TABLE(usb, usb_ids);
-
-#define FW_ZD1211_PREFIX "zd1211/zd1211_"
-#define FW_ZD1211B_PREFIX "zd1211/zd1211b_"
-
-static bool check_read_regs(struct zd_usb *usb, struct usb_req_read_regs *req,
- unsigned int count);
-
-/* USB device initialization */
-static void int_urb_complete(struct urb *urb);
-
-static int request_fw_file(
- const struct firmware **fw, const char *name, struct device *device)
-{
- int r;
-
- dev_dbg_f(device, "fw name %s\n", name);
-
- r = request_firmware(fw, name, device);
- if (r)
- dev_err(device,
- "Could not load firmware file %s. Error number %d\n",
- name, r);
- return r;
-}
-
-static inline u16 get_bcdDevice(const struct usb_device *udev)
-{
- return le16_to_cpu(udev->descriptor.bcdDevice);
-}
-
-enum upload_code_flags {
- REBOOT = 1,
-};
-
-/* Ensures that MAX_TRANSFER_SIZE is even. */
-#define MAX_TRANSFER_SIZE (USB_MAX_TRANSFER_SIZE & ~1)
-
-static int upload_code(struct usb_device *udev,
- const u8 *data, size_t size, u16 code_offset, int flags)
-{
- u8 *p;
- int r;
-
- /* USB request blocks need "kmalloced" buffers.
- */
- p = kmalloc(MAX_TRANSFER_SIZE, GFP_KERNEL);
- if (!p) {
- r = -ENOMEM;
- goto error;
- }
-
- size &= ~1;
- while (size > 0) {
- size_t transfer_size = size <= MAX_TRANSFER_SIZE ?
- size : MAX_TRANSFER_SIZE;
-
- dev_dbg_f(&udev->dev, "transfer size %zu\n", transfer_size);
-
- memcpy(p, data, transfer_size);
- r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
- USB_REQ_FIRMWARE_DOWNLOAD,
- USB_DIR_OUT | USB_TYPE_VENDOR,
- code_offset, 0, p, transfer_size, 1000 /* ms */);
- if (r < 0) {
- dev_err(&udev->dev,
- "USB control request for firmware upload"
- " failed. Error number %d\n", r);
- goto error;
- }
- transfer_size = r & ~1;
-
- size -= transfer_size;
- data += transfer_size;
- code_offset += transfer_size/sizeof(u16);
- }
-
- if (flags & REBOOT) {
- u8 ret;
-
- /* Use "DMA-aware" buffer. */
- r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
- USB_REQ_FIRMWARE_CONFIRM,
- USB_DIR_IN | USB_TYPE_VENDOR,
- 0, 0, p, sizeof(ret), 5000 /* ms */);
- if (r != sizeof(ret)) {
- dev_err(&udev->dev,
- "control request firmeware confirmation failed."
- " Return value %d\n", r);
- if (r >= 0)
- r = -ENODEV;
- goto error;
- }
- ret = p[0];
- if (ret & 0x80) {
- dev_err(&udev->dev,
- "Internal error while downloading."
- " Firmware confirm return value %#04x\n",
- (unsigned int)ret);
- r = -ENODEV;
- goto error;
- }
- dev_dbg_f(&udev->dev, "firmware confirm return value %#04x\n",
- (unsigned int)ret);
- }
-
- r = 0;
-error:
- kfree(p);
- return r;
-}
-
-static u16 get_word(const void *data, u16 offset)
-{
- const __le16 *p = data;
- return le16_to_cpu(p[offset]);
-}
-
-static char *get_fw_name(struct zd_usb *usb, char *buffer, size_t size,
- const char* postfix)
-{
- scnprintf(buffer, size, "%s%s",
- usb->is_zd1211b ?
- FW_ZD1211B_PREFIX : FW_ZD1211_PREFIX,
- postfix);
- return buffer;
-}
-
-static int handle_version_mismatch(struct zd_usb *usb,
- const struct firmware *ub_fw)
-{
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- const struct firmware *ur_fw = NULL;
- int offset;
- int r = 0;
- char fw_name[128];
-
- r = request_fw_file(&ur_fw,
- get_fw_name(usb, fw_name, sizeof(fw_name), "ur"),
- &udev->dev);
- if (r)
- goto error;
-
- r = upload_code(udev, ur_fw->data, ur_fw->size, FW_START, REBOOT);
- if (r)
- goto error;
-
- offset = (E2P_BOOT_CODE_OFFSET * sizeof(u16));
- r = upload_code(udev, ub_fw->data + offset, ub_fw->size - offset,
- E2P_START + E2P_BOOT_CODE_OFFSET, REBOOT);
-
- /* At this point, the vendor driver downloads the whole firmware
- * image, hacks around with version IDs, and uploads it again,
- * completely overwriting the boot code. We do not do this here as
- * it is not required on any tested devices, and it is suspected to
- * cause problems. */
-error:
- release_firmware(ur_fw);
- return r;
-}
-
-static int upload_firmware(struct zd_usb *usb)
-{
- int r;
- u16 fw_bcdDevice;
- u16 bcdDevice;
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- const struct firmware *ub_fw = NULL;
- const struct firmware *uph_fw = NULL;
- char fw_name[128];
-
- bcdDevice = get_bcdDevice(udev);
-
- r = request_fw_file(&ub_fw,
- get_fw_name(usb, fw_name, sizeof(fw_name), "ub"),
- &udev->dev);
- if (r)
- goto error;
-
- fw_bcdDevice = get_word(ub_fw->data, E2P_DATA_OFFSET);
-
- if (fw_bcdDevice != bcdDevice) {
- dev_info(&udev->dev,
- "firmware version %#06x and device bootcode version "
- "%#06x differ\n", fw_bcdDevice, bcdDevice);
- if (bcdDevice <= 0x4313)
- dev_warn(&udev->dev, "device has old bootcode, please "
- "report success or failure\n");
-
- r = handle_version_mismatch(usb, ub_fw);
- if (r)
- goto error;
- } else {
- dev_dbg_f(&udev->dev,
- "firmware device id %#06x is equal to the "
- "actual device id\n", fw_bcdDevice);
- }
-
-
- r = request_fw_file(&uph_fw,
- get_fw_name(usb, fw_name, sizeof(fw_name), "uphr"),
- &udev->dev);
- if (r)
- goto error;
-
- r = upload_code(udev, uph_fw->data, uph_fw->size, FW_START, REBOOT);
- if (r) {
- dev_err(&udev->dev,
- "Could not upload firmware code uph. Error number %d\n",
- r);
- }
-
- /* FALL-THROUGH */
-error:
- release_firmware(ub_fw);
- release_firmware(uph_fw);
- return r;
-}
-
-MODULE_FIRMWARE(FW_ZD1211B_PREFIX "ur");
-MODULE_FIRMWARE(FW_ZD1211_PREFIX "ur");
-MODULE_FIRMWARE(FW_ZD1211B_PREFIX "ub");
-MODULE_FIRMWARE(FW_ZD1211_PREFIX "ub");
-MODULE_FIRMWARE(FW_ZD1211B_PREFIX "uphr");
-MODULE_FIRMWARE(FW_ZD1211_PREFIX "uphr");
-
-/* Read data from device address space using "firmware interface" which does
- * not require firmware to be loaded. */
-int zd_usb_read_fw(struct zd_usb *usb, zd_addr_t addr, u8 *data, u16 len)
-{
- int r;
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- u8 *buf;
-
- /* Use "DMA-aware" buffer. */
- buf = kmalloc(len, GFP_KERNEL);
- if (!buf)
- return -ENOMEM;
- r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
- USB_REQ_FIRMWARE_READ_DATA, USB_DIR_IN | 0x40, addr, 0,
- buf, len, 5000);
- if (r < 0) {
- dev_err(&udev->dev,
- "read over firmware interface failed: %d\n", r);
- goto exit;
- } else if (r != len) {
- dev_err(&udev->dev,
- "incomplete read over firmware interface: %d/%d\n",
- r, len);
- r = -EIO;
- goto exit;
- }
- r = 0;
- memcpy(data, buf, len);
-exit:
- kfree(buf);
- return r;
-}
-
-#define urb_dev(urb) (&(urb)->dev->dev)
-
-static inline void handle_regs_int_override(struct urb *urb)
-{
- struct zd_usb *usb = urb->context;
- struct zd_usb_interrupt *intr = &usb->intr;
-
- spin_lock(&intr->lock);
- if (atomic_read(&intr->read_regs_enabled)) {
- atomic_set(&intr->read_regs_enabled, 0);
- intr->read_regs_int_overridden = 1;
- complete(&intr->read_regs.completion);
- }
- spin_unlock(&intr->lock);
-}
-
-static inline void handle_regs_int(struct urb *urb)
-{
- struct zd_usb *usb = urb->context;
- struct zd_usb_interrupt *intr = &usb->intr;
- int len;
- u16 int_num;
-
- ZD_ASSERT(in_interrupt());
- spin_lock(&intr->lock);
-
- int_num = le16_to_cpu(*(__le16 *)(urb->transfer_buffer+2));
- if (int_num == CR_INTERRUPT) {
- struct zd_mac *mac = zd_hw_mac(zd_usb_to_hw(urb->context));
- spin_lock(&mac->lock);
- memcpy(&mac->intr_buffer, urb->transfer_buffer,
- USB_MAX_EP_INT_BUFFER);
- spin_unlock(&mac->lock);
- schedule_work(&mac->process_intr);
- } else if (atomic_read(&intr->read_regs_enabled)) {
- len = urb->actual_length;
- intr->read_regs.length = urb->actual_length;
- if (len > sizeof(intr->read_regs.buffer))
- len = sizeof(intr->read_regs.buffer);
-
- memcpy(intr->read_regs.buffer, urb->transfer_buffer, len);
-
- /* Sometimes USB_INT_ID_REGS is not overridden, but comes after
- * USB_INT_ID_RETRY_FAILED. Read-reg retry then gets this
- * delayed USB_INT_ID_REGS, but leaves USB_INT_ID_REGS of
- * retry unhandled. Next read-reg command then might catch
- * this wrong USB_INT_ID_REGS. Fix by ignoring wrong reads.
- */
- if (!check_read_regs(usb, intr->read_regs.req,
- intr->read_regs.req_count))
- goto out;
-
- atomic_set(&intr->read_regs_enabled, 0);
- intr->read_regs_int_overridden = 0;
- complete(&intr->read_regs.completion);
-
- goto out;
- }
-
-out:
- spin_unlock(&intr->lock);
-
- /* CR_INTERRUPT might override read_reg too. */
- if (int_num == CR_INTERRUPT && atomic_read(&intr->read_regs_enabled))
- handle_regs_int_override(urb);
-}
-
-static void int_urb_complete(struct urb *urb)
-{
- int r;
- struct usb_int_header *hdr;
- struct zd_usb *usb;
- struct zd_usb_interrupt *intr;
-
- switch (urb->status) {
- case 0:
- break;
- case -ESHUTDOWN:
- case -EINVAL:
- case -ENODEV:
- case -ENOENT:
- case -ECONNRESET:
- case -EPIPE:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- return;
- default:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- goto resubmit;
- }
-
- if (urb->actual_length < sizeof(hdr)) {
- dev_dbg_f(urb_dev(urb), "error: urb %p to small\n", urb);
- goto resubmit;
- }
-
- hdr = urb->transfer_buffer;
- if (hdr->type != USB_INT_TYPE) {
- dev_dbg_f(urb_dev(urb), "error: urb %p wrong type\n", urb);
- goto resubmit;
- }
-
- /* USB_INT_ID_RETRY_FAILED triggered by tx-urb submit can override
- * pending USB_INT_ID_REGS causing read command timeout.
- */
- usb = urb->context;
- intr = &usb->intr;
- if (hdr->id != USB_INT_ID_REGS && atomic_read(&intr->read_regs_enabled))
- handle_regs_int_override(urb);
-
- switch (hdr->id) {
- case USB_INT_ID_REGS:
- handle_regs_int(urb);
- break;
- case USB_INT_ID_RETRY_FAILED:
- zd_mac_tx_failed(urb);
- break;
- default:
- dev_dbg_f(urb_dev(urb), "error: urb %p unknown id %x\n", urb,
- (unsigned int)hdr->id);
- goto resubmit;
- }
-
-resubmit:
- r = usb_submit_urb(urb, GFP_ATOMIC);
- if (r) {
- dev_dbg_f(urb_dev(urb), "error: resubmit urb %p err code %d\n",
- urb, r);
- /* TODO: add worker to reset intr->urb */
- }
- return;
-}
-
-static inline int int_urb_interval(struct usb_device *udev)
-{
- switch (udev->speed) {
- case USB_SPEED_HIGH:
- return 4;
- case USB_SPEED_LOW:
- return 10;
- case USB_SPEED_FULL:
- default:
- return 1;
- }
-}
-
-static inline int usb_int_enabled(struct zd_usb *usb)
-{
- unsigned long flags;
- struct zd_usb_interrupt *intr = &usb->intr;
- struct urb *urb;
-
- spin_lock_irqsave(&intr->lock, flags);
- urb = intr->urb;
- spin_unlock_irqrestore(&intr->lock, flags);
- return urb != NULL;
-}
-
-int zd_usb_enable_int(struct zd_usb *usb)
-{
- int r;
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- struct zd_usb_interrupt *intr = &usb->intr;
- struct urb *urb;
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- urb = usb_alloc_urb(0, GFP_KERNEL);
- if (!urb) {
- r = -ENOMEM;
- goto out;
- }
-
- ZD_ASSERT(!irqs_disabled());
- spin_lock_irq(&intr->lock);
- if (intr->urb) {
- spin_unlock_irq(&intr->lock);
- r = 0;
- goto error_free_urb;
- }
- intr->urb = urb;
- spin_unlock_irq(&intr->lock);
-
- r = -ENOMEM;
- intr->buffer = usb_alloc_coherent(udev, USB_MAX_EP_INT_BUFFER,
- GFP_KERNEL, &intr->buffer_dma);
- if (!intr->buffer) {
- dev_dbg_f(zd_usb_dev(usb),
- "couldn't allocate transfer_buffer\n");
- goto error_set_urb_null;
- }
-
- usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),
- intr->buffer, USB_MAX_EP_INT_BUFFER,
- int_urb_complete, usb,
- intr->interval);
- urb->transfer_dma = intr->buffer_dma;
- urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
- dev_dbg_f(zd_usb_dev(usb), "submit urb %p\n", intr->urb);
- r = usb_submit_urb(urb, GFP_KERNEL);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "Couldn't submit urb. Error number %d\n", r);
- goto error;
- }
-
- return 0;
-error:
- usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
- intr->buffer, intr->buffer_dma);
-error_set_urb_null:
- spin_lock_irq(&intr->lock);
- intr->urb = NULL;
- spin_unlock_irq(&intr->lock);
-error_free_urb:
- usb_free_urb(urb);
-out:
- return r;
-}
-
-void zd_usb_disable_int(struct zd_usb *usb)
-{
- unsigned long flags;
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- struct zd_usb_interrupt *intr = &usb->intr;
- struct urb *urb;
- void *buffer;
- dma_addr_t buffer_dma;
-
- spin_lock_irqsave(&intr->lock, flags);
- urb = intr->urb;
- if (!urb) {
- spin_unlock_irqrestore(&intr->lock, flags);
- return;
- }
- intr->urb = NULL;
- buffer = intr->buffer;
- buffer_dma = intr->buffer_dma;
- intr->buffer = NULL;
- spin_unlock_irqrestore(&intr->lock, flags);
-
- usb_kill_urb(urb);
- dev_dbg_f(zd_usb_dev(usb), "urb %p killed\n", urb);
- usb_free_urb(urb);
-
- if (buffer)
- usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
- buffer, buffer_dma);
-}
-
-static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
- unsigned int length)
-{
- int i;
- const struct rx_length_info *length_info;
-
- if (length < sizeof(struct rx_length_info)) {
- /* It's not a complete packet anyhow. */
- dev_dbg_f(zd_usb_dev(usb), "invalid, small RX packet : %d\n",
- length);
- return;
- }
- length_info = (struct rx_length_info *)
- (buffer + length - sizeof(struct rx_length_info));
-
- /* It might be that three frames are merged into a single URB
- * transaction. We have to check for the length info tag.
- *
- * While testing we discovered that length_info might be unaligned,
- * because if USB transactions are merged, the last packet will not
- * be padded. Unaligned access might also happen if the length_info
- * structure is not present.
- */
- if (get_unaligned_le16(&length_info->tag) == RX_LENGTH_INFO_TAG)
- {
- unsigned int l, k, n;
- for (i = 0, l = 0;; i++) {
- k = get_unaligned_le16(&length_info->length[i]);
- if (k == 0)
- return;
- n = l+k;
- if (n > length)
- return;
- zd_mac_rx(zd_usb_to_hw(usb), buffer+l, k);
- if (i >= 2)
- return;
- l = (n+3) & ~3;
- }
- } else {
- zd_mac_rx(zd_usb_to_hw(usb), buffer, length);
- }
-}
-
-static void rx_urb_complete(struct urb *urb)
-{
- int r;
- struct zd_usb *usb;
- struct zd_usb_rx *rx;
- const u8 *buffer;
- unsigned int length;
-
- switch (urb->status) {
- case 0:
- break;
- case -ESHUTDOWN:
- case -EINVAL:
- case -ENODEV:
- case -ENOENT:
- case -ECONNRESET:
- case -EPIPE:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- return;
- default:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- goto resubmit;
- }
-
- buffer = urb->transfer_buffer;
- length = urb->actual_length;
- usb = urb->context;
- rx = &usb->rx;
-
- tasklet_schedule(&rx->reset_timer_tasklet);
-
- if (length%rx->usb_packet_size > rx->usb_packet_size-4) {
- /* If there is an old first fragment, we don't care. */
- dev_dbg_f(urb_dev(urb), "*** first fragment ***\n");
- ZD_ASSERT(length <= ARRAY_SIZE(rx->fragment));
- spin_lock(&rx->lock);
- memcpy(rx->fragment, buffer, length);
- rx->fragment_length = length;
- spin_unlock(&rx->lock);
- goto resubmit;
- }
-
- spin_lock(&rx->lock);
- if (rx->fragment_length > 0) {
- /* We are on a second fragment, we believe */
- ZD_ASSERT(length + rx->fragment_length <=
- ARRAY_SIZE(rx->fragment));
- dev_dbg_f(urb_dev(urb), "*** second fragment ***\n");
- memcpy(rx->fragment+rx->fragment_length, buffer, length);
- handle_rx_packet(usb, rx->fragment,
- rx->fragment_length + length);
- rx->fragment_length = 0;
- spin_unlock(&rx->lock);
- } else {
- spin_unlock(&rx->lock);
- handle_rx_packet(usb, buffer, length);
- }
-
-resubmit:
- r = usb_submit_urb(urb, GFP_ATOMIC);
- if (r)
- dev_dbg_f(urb_dev(urb), "urb %p resubmit error %d\n", urb, r);
-}
-
-static struct urb *alloc_rx_urb(struct zd_usb *usb)
-{
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- struct urb *urb;
- void *buffer;
-
- urb = usb_alloc_urb(0, GFP_KERNEL);
- if (!urb)
- return NULL;
- buffer = usb_alloc_coherent(udev, USB_MAX_RX_SIZE, GFP_KERNEL,
- &urb->transfer_dma);
- if (!buffer) {
- usb_free_urb(urb);
- return NULL;
- }
-
- usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN),
- buffer, USB_MAX_RX_SIZE,
- rx_urb_complete, usb);
- urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
- return urb;
-}
-
-static void free_rx_urb(struct urb *urb)
-{
- if (!urb)
- return;
- usb_free_coherent(urb->dev, urb->transfer_buffer_length,
- urb->transfer_buffer, urb->transfer_dma);
- usb_free_urb(urb);
-}
-
-static int __zd_usb_enable_rx(struct zd_usb *usb)
-{
- int i, r;
- struct zd_usb_rx *rx = &usb->rx;
- struct urb **urbs;
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- r = -ENOMEM;
- urbs = kcalloc(RX_URBS_COUNT, sizeof(struct urb *), GFP_KERNEL);
- if (!urbs)
- goto error;
- for (i = 0; i < RX_URBS_COUNT; i++) {
- urbs[i] = alloc_rx_urb(usb);
- if (!urbs[i])
- goto error;
- }
-
- ZD_ASSERT(!irqs_disabled());
- spin_lock_irq(&rx->lock);
- if (rx->urbs) {
- spin_unlock_irq(&rx->lock);
- r = 0;
- goto error;
- }
- rx->urbs = urbs;
- rx->urbs_count = RX_URBS_COUNT;
- spin_unlock_irq(&rx->lock);
-
- for (i = 0; i < RX_URBS_COUNT; i++) {
- r = usb_submit_urb(urbs[i], GFP_KERNEL);
- if (r)
- goto error_submit;
- }
-
- return 0;
-error_submit:
- for (i = 0; i < RX_URBS_COUNT; i++) {
- usb_kill_urb(urbs[i]);
- }
- spin_lock_irq(&rx->lock);
- rx->urbs = NULL;
- rx->urbs_count = 0;
- spin_unlock_irq(&rx->lock);
-error:
- if (urbs) {
- for (i = 0; i < RX_URBS_COUNT; i++)
- free_rx_urb(urbs[i]);
- }
- return r;
-}
-
-int zd_usb_enable_rx(struct zd_usb *usb)
-{
- int r;
- struct zd_usb_rx *rx = &usb->rx;
-
- mutex_lock(&rx->setup_mutex);
- r = __zd_usb_enable_rx(usb);
- mutex_unlock(&rx->setup_mutex);
-
- zd_usb_reset_rx_idle_timer(usb);
-
- return r;
-}
-
-static void __zd_usb_disable_rx(struct zd_usb *usb)
-{
- int i;
- unsigned long flags;
- struct urb **urbs;
- unsigned int count;
- struct zd_usb_rx *rx = &usb->rx;
-
- spin_lock_irqsave(&rx->lock, flags);
- urbs = rx->urbs;
- count = rx->urbs_count;
- spin_unlock_irqrestore(&rx->lock, flags);
- if (!urbs)
- return;
-
- for (i = 0; i < count; i++) {
- usb_kill_urb(urbs[i]);
- free_rx_urb(urbs[i]);
- }
- kfree(urbs);
-
- spin_lock_irqsave(&rx->lock, flags);
- rx->urbs = NULL;
- rx->urbs_count = 0;
- spin_unlock_irqrestore(&rx->lock, flags);
-}
-
-void zd_usb_disable_rx(struct zd_usb *usb)
-{
- struct zd_usb_rx *rx = &usb->rx;
-
- mutex_lock(&rx->setup_mutex);
- __zd_usb_disable_rx(usb);
- mutex_unlock(&rx->setup_mutex);
-
- tasklet_kill(&rx->reset_timer_tasklet);
- cancel_delayed_work_sync(&rx->idle_work);
-}
-
-static void zd_usb_reset_rx(struct zd_usb *usb)
-{
- bool do_reset;
- struct zd_usb_rx *rx = &usb->rx;
- unsigned long flags;
-
- mutex_lock(&rx->setup_mutex);
-
- spin_lock_irqsave(&rx->lock, flags);
- do_reset = rx->urbs != NULL;
- spin_unlock_irqrestore(&rx->lock, flags);
-
- if (do_reset) {
- __zd_usb_disable_rx(usb);
- __zd_usb_enable_rx(usb);
- }
-
- mutex_unlock(&rx->setup_mutex);
-
- if (do_reset)
- zd_usb_reset_rx_idle_timer(usb);
-}
-
-/**
- * zd_usb_disable_tx - disable transmission
- * @usb: the zd1211rw-private USB structure
- *
- * Frees all URBs in the free list and marks the transmission as disabled.
- */
-void zd_usb_disable_tx(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
- unsigned long flags;
-
- atomic_set(&tx->enabled, 0);
-
- /* kill all submitted tx-urbs */
- usb_kill_anchored_urbs(&tx->submitted);
-
- spin_lock_irqsave(&tx->lock, flags);
- WARN_ON(!skb_queue_empty(&tx->submitted_skbs));
- WARN_ON(tx->submitted_urbs != 0);
- tx->submitted_urbs = 0;
- spin_unlock_irqrestore(&tx->lock, flags);
-
- /* The stopped state is ignored, relying on ieee80211_wake_queues()
- * in a potentionally following zd_usb_enable_tx().
- */
-}
-
-/**
- * zd_usb_enable_tx - enables transmission
- * @usb: a &struct zd_usb pointer
- *
- * This function enables transmission and prepares the &zd_usb_tx data
- * structure.
- */
-void zd_usb_enable_tx(struct zd_usb *usb)
-{
- unsigned long flags;
- struct zd_usb_tx *tx = &usb->tx;
-
- spin_lock_irqsave(&tx->lock, flags);
- atomic_set(&tx->enabled, 1);
- tx->submitted_urbs = 0;
- ieee80211_wake_queues(zd_usb_to_hw(usb));
- tx->stopped = 0;
- spin_unlock_irqrestore(&tx->lock, flags);
-}
-
-static void tx_dec_submitted_urbs(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
- unsigned long flags;
-
- spin_lock_irqsave(&tx->lock, flags);
- --tx->submitted_urbs;
- if (tx->stopped && tx->submitted_urbs <= ZD_USB_TX_LOW) {
- ieee80211_wake_queues(zd_usb_to_hw(usb));
- tx->stopped = 0;
- }
- spin_unlock_irqrestore(&tx->lock, flags);
-}
-
-static void tx_inc_submitted_urbs(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
- unsigned long flags;
-
- spin_lock_irqsave(&tx->lock, flags);
- ++tx->submitted_urbs;
- if (!tx->stopped && tx->submitted_urbs > ZD_USB_TX_HIGH) {
- ieee80211_stop_queues(zd_usb_to_hw(usb));
- tx->stopped = 1;
- }
- spin_unlock_irqrestore(&tx->lock, flags);
-}
-
-/**
- * tx_urb_complete - completes the execution of an URB
- * @urb: a URB
- *
- * This function is called if the URB has been transferred to a device or an
- * error has happened.
- */
-static void tx_urb_complete(struct urb *urb)
-{
- int r;
- struct sk_buff *skb;
- struct ieee80211_tx_info *info;
- struct zd_usb *usb;
- struct zd_usb_tx *tx;
-
- skb = (struct sk_buff *)urb->context;
- info = IEEE80211_SKB_CB(skb);
- /*
- * grab 'usb' pointer before handing off the skb (since
- * it might be freed by zd_mac_tx_to_dev or mac80211)
- */
- usb = &zd_hw_mac(info->rate_driver_data[0])->chip.usb;
- tx = &usb->tx;
-
- switch (urb->status) {
- case 0:
- break;
- case -ESHUTDOWN:
- case -EINVAL:
- case -ENODEV:
- case -ENOENT:
- case -ECONNRESET:
- case -EPIPE:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- break;
- default:
- dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
- goto resubmit;
- }
-free_urb:
- skb_unlink(skb, &usb->tx.submitted_skbs);
- zd_mac_tx_to_dev(skb, urb->status);
- usb_free_urb(urb);
- tx_dec_submitted_urbs(usb);
- return;
-resubmit:
- usb_anchor_urb(urb, &tx->submitted);
- r = usb_submit_urb(urb, GFP_ATOMIC);
- if (r) {
- usb_unanchor_urb(urb);
- dev_dbg_f(urb_dev(urb), "error resubmit urb %p %d\n", urb, r);
- goto free_urb;
- }
-}
-
-/**
- * zd_usb_tx: initiates transfer of a frame of the device
- *
- * @usb: the zd1211rw-private USB structure
- * @skb: a &struct sk_buff pointer
- *
- * This function tranmits a frame to the device. It doesn't wait for
- * completion. The frame must contain the control set and have all the
- * control set information available.
- *
- * The function returns 0 if the transfer has been successfully initiated.
- */
-int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb)
-{
- int r;
- struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
- struct usb_device *udev = zd_usb_to_usbdev(usb);
- struct urb *urb;
- struct zd_usb_tx *tx = &usb->tx;
-
- if (!atomic_read(&tx->enabled)) {
- r = -ENOENT;
- goto out;
- }
-
- urb = usb_alloc_urb(0, GFP_ATOMIC);
- if (!urb) {
- r = -ENOMEM;
- goto out;
- }
-
- usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
- skb->data, skb->len, tx_urb_complete, skb);
-
- info->rate_driver_data[1] = (void *)jiffies;
- skb_queue_tail(&tx->submitted_skbs, skb);
- usb_anchor_urb(urb, &tx->submitted);
-
- r = usb_submit_urb(urb, GFP_ATOMIC);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb), "error submit urb %p %d\n", urb, r);
- usb_unanchor_urb(urb);
- skb_unlink(skb, &tx->submitted_skbs);
- goto error;
- }
- tx_inc_submitted_urbs(usb);
- return 0;
-error:
- usb_free_urb(urb);
-out:
- return r;
-}
-
-static bool zd_tx_timeout(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
- struct sk_buff_head *q = &tx->submitted_skbs;
- struct sk_buff *skb, *skbnext;
- struct ieee80211_tx_info *info;
- unsigned long flags, trans_start;
- bool have_timedout = false;
-
- spin_lock_irqsave(&q->lock, flags);
- skb_queue_walk_safe(q, skb, skbnext) {
- info = IEEE80211_SKB_CB(skb);
- trans_start = (unsigned long)info->rate_driver_data[1];
-
- if (time_is_before_jiffies(trans_start + ZD_TX_TIMEOUT)) {
- have_timedout = true;
- break;
- }
- }
- spin_unlock_irqrestore(&q->lock, flags);
-
- return have_timedout;
-}
-
-static void zd_tx_watchdog_handler(struct work_struct *work)
-{
- struct zd_usb *usb =
- container_of(work, struct zd_usb, tx.watchdog_work.work);
- struct zd_usb_tx *tx = &usb->tx;
-
- if (!atomic_read(&tx->enabled) || !tx->watchdog_enabled)
- goto out;
- if (!zd_tx_timeout(usb))
- goto out;
-
- /* TX halted, try reset */
- dev_warn(zd_usb_dev(usb), "TX-stall detected, resetting device...");
-
- usb_queue_reset_device(usb->intf);
-
- /* reset will stop this worker, don't rearm */
- return;
-out:
- queue_delayed_work(zd_workqueue, &tx->watchdog_work,
- ZD_TX_WATCHDOG_INTERVAL);
-}
-
-void zd_tx_watchdog_enable(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
-
- if (!tx->watchdog_enabled) {
- dev_dbg_f(zd_usb_dev(usb), "\n");
- queue_delayed_work(zd_workqueue, &tx->watchdog_work,
- ZD_TX_WATCHDOG_INTERVAL);
- tx->watchdog_enabled = 1;
- }
-}
-
-void zd_tx_watchdog_disable(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
-
- if (tx->watchdog_enabled) {
- dev_dbg_f(zd_usb_dev(usb), "\n");
- tx->watchdog_enabled = 0;
- cancel_delayed_work_sync(&tx->watchdog_work);
- }
-}
-
-static void zd_rx_idle_timer_handler(struct work_struct *work)
-{
- struct zd_usb *usb =
- container_of(work, struct zd_usb, rx.idle_work.work);
- struct zd_mac *mac = zd_usb_to_mac(usb);
-
- if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
- return;
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- /* 30 seconds since last rx, reset rx */
- zd_usb_reset_rx(usb);
-}
-
-static void zd_usb_reset_rx_idle_timer_tasklet(unsigned long param)
-{
- struct zd_usb *usb = (struct zd_usb *)param;
-
- zd_usb_reset_rx_idle_timer(usb);
-}
-
-void zd_usb_reset_rx_idle_timer(struct zd_usb *usb)
-{
- struct zd_usb_rx *rx = &usb->rx;
-
- mod_delayed_work(zd_workqueue, &rx->idle_work, ZD_RX_IDLE_INTERVAL);
-}
-
-static inline void init_usb_interrupt(struct zd_usb *usb)
-{
- struct zd_usb_interrupt *intr = &usb->intr;
-
- spin_lock_init(&intr->lock);
- intr->interval = int_urb_interval(zd_usb_to_usbdev(usb));
- init_completion(&intr->read_regs.completion);
- atomic_set(&intr->read_regs_enabled, 0);
- intr->read_regs.cr_int_addr = cpu_to_le16((u16)CR_INTERRUPT);
-}
-
-static inline void init_usb_rx(struct zd_usb *usb)
-{
- struct zd_usb_rx *rx = &usb->rx;
-
- spin_lock_init(&rx->lock);
- mutex_init(&rx->setup_mutex);
- if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH) {
- rx->usb_packet_size = 512;
- } else {
- rx->usb_packet_size = 64;
- }
- ZD_ASSERT(rx->fragment_length == 0);
- INIT_DELAYED_WORK(&rx->idle_work, zd_rx_idle_timer_handler);
- rx->reset_timer_tasklet.func = zd_usb_reset_rx_idle_timer_tasklet;
- rx->reset_timer_tasklet.data = (unsigned long)usb;
-}
-
-static inline void init_usb_tx(struct zd_usb *usb)
-{
- struct zd_usb_tx *tx = &usb->tx;
-
- spin_lock_init(&tx->lock);
- atomic_set(&tx->enabled, 0);
- tx->stopped = 0;
- skb_queue_head_init(&tx->submitted_skbs);
- init_usb_anchor(&tx->submitted);
- tx->submitted_urbs = 0;
- tx->watchdog_enabled = 0;
- INIT_DELAYED_WORK(&tx->watchdog_work, zd_tx_watchdog_handler);
-}
-
-void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
- struct usb_interface *intf)
-{
- memset(usb, 0, sizeof(*usb));
- usb->intf = usb_get_intf(intf);
- usb_set_intfdata(usb->intf, hw);
- init_usb_anchor(&usb->submitted_cmds);
- init_usb_interrupt(usb);
- init_usb_tx(usb);
- init_usb_rx(usb);
-}
-
-void zd_usb_clear(struct zd_usb *usb)
-{
- usb_set_intfdata(usb->intf, NULL);
- usb_put_intf(usb->intf);
- ZD_MEMCLEAR(usb, sizeof(*usb));
- /* FIXME: usb_interrupt, usb_tx, usb_rx? */
-}
-
-static const char *speed(enum usb_device_speed speed)
-{
- switch (speed) {
- case USB_SPEED_LOW:
- return "low";
- case USB_SPEED_FULL:
- return "full";
- case USB_SPEED_HIGH:
- return "high";
- default:
- return "unknown speed";
- }
-}
-
-static int scnprint_id(struct usb_device *udev, char *buffer, size_t size)
-{
- return scnprintf(buffer, size, "%04hx:%04hx v%04hx %s",
- le16_to_cpu(udev->descriptor.idVendor),
- le16_to_cpu(udev->descriptor.idProduct),
- get_bcdDevice(udev),
- speed(udev->speed));
-}
-
-int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size)
-{
- struct usb_device *udev = interface_to_usbdev(usb->intf);
- return scnprint_id(udev, buffer, size);
-}
-
-#ifdef DEBUG
-static void print_id(struct usb_device *udev)
-{
- char buffer[40];
-
- scnprint_id(udev, buffer, sizeof(buffer));
- buffer[sizeof(buffer)-1] = 0;
- dev_dbg_f(&udev->dev, "%s\n", buffer);
-}
-#else
-#define print_id(udev) do { } while (0)
-#endif
-
-static int eject_installer(struct usb_interface *intf)
-{
- struct usb_device *udev = interface_to_usbdev(intf);
- struct usb_host_interface *iface_desc = &intf->altsetting[0];
- struct usb_endpoint_descriptor *endpoint;
- unsigned char *cmd;
- u8 bulk_out_ep;
- int r;
-
- /* Find bulk out endpoint */
- for (r = 1; r >= 0; r--) {
- endpoint = &iface_desc->endpoint[r].desc;
- if (usb_endpoint_dir_out(endpoint) &&
- usb_endpoint_xfer_bulk(endpoint)) {
- bulk_out_ep = endpoint->bEndpointAddress;
- break;
- }
- }
- if (r == -1) {
- dev_err(&udev->dev,
- "zd1211rw: Could not find bulk out endpoint\n");
- return -ENODEV;
- }
-
- cmd = kzalloc(31, GFP_KERNEL);
- if (cmd == NULL)
- return -ENODEV;
-
- /* USB bulk command block */
- cmd[0] = 0x55; /* bulk command signature */
- cmd[1] = 0x53; /* bulk command signature */
- cmd[2] = 0x42; /* bulk command signature */
- cmd[3] = 0x43; /* bulk command signature */
- cmd[14] = 6; /* command length */
-
- cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */
- cmd[19] = 0x2; /* eject disc */
-
- dev_info(&udev->dev, "Ejecting virtual installer media...\n");
- r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep),
- cmd, 31, NULL, 2000);
- kfree(cmd);
- if (r)
- return r;
-
- /* At this point, the device disconnects and reconnects with the real
- * ID numbers. */
-
- usb_set_intfdata(intf, NULL);
- return 0;
-}
-
-int zd_usb_init_hw(struct zd_usb *usb)
-{
- int r;
- struct zd_mac *mac = zd_usb_to_mac(usb);
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- r = upload_firmware(usb);
- if (r) {
- dev_err(zd_usb_dev(usb),
- "couldn't load firmware. Error number %d\n", r);
- return r;
- }
-
- r = usb_reset_configuration(zd_usb_to_usbdev(usb));
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "couldn't reset configuration. Error number %d\n", r);
- return r;
- }
-
- r = zd_mac_init_hw(mac->hw);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "couldn't initialize mac. Error number %d\n", r);
- return r;
- }
-
- usb->initialized = 1;
- return 0;
-}
-
-static int probe(struct usb_interface *intf, const struct usb_device_id *id)
-{
- int r;
- struct usb_device *udev = interface_to_usbdev(intf);
- struct zd_usb *usb;
- struct ieee80211_hw *hw = NULL;
-
- print_id(udev);
-
- if (id->driver_info & DEVICE_INSTALLER)
- return eject_installer(intf);
-
- switch (udev->speed) {
- case USB_SPEED_LOW:
- case USB_SPEED_FULL:
- case USB_SPEED_HIGH:
- break;
- default:
- dev_dbg_f(&intf->dev, "Unknown USB speed\n");
- r = -ENODEV;
- goto error;
- }
-
- r = usb_reset_device(udev);
- if (r) {
- dev_err(&intf->dev,
- "couldn't reset usb device. Error number %d\n", r);
- goto error;
- }
-
- hw = zd_mac_alloc_hw(intf);
- if (hw == NULL) {
- r = -ENOMEM;
- goto error;
- }
-
- usb = &zd_hw_mac(hw)->chip.usb;
- usb->is_zd1211b = (id->driver_info == DEVICE_ZD1211B) != 0;
-
- r = zd_mac_preinit_hw(hw);
- if (r) {
- dev_dbg_f(&intf->dev,
- "couldn't initialize mac. Error number %d\n", r);
- goto error;
- }
-
- r = ieee80211_register_hw(hw);
- if (r) {
- dev_dbg_f(&intf->dev,
- "couldn't register device. Error number %d\n", r);
- goto error;
- }
-
- dev_dbg_f(&intf->dev, "successful\n");
- dev_info(&intf->dev, "%s\n", wiphy_name(hw->wiphy));
- return 0;
-error:
- usb_reset_device(interface_to_usbdev(intf));
- if (hw) {
- zd_mac_clear(zd_hw_mac(hw));
- ieee80211_free_hw(hw);
- }
- return r;
-}
-
-static void disconnect(struct usb_interface *intf)
-{
- struct ieee80211_hw *hw = zd_intf_to_hw(intf);
- struct zd_mac *mac;
- struct zd_usb *usb;
-
- /* Either something really bad happened, or we're just dealing with
- * a DEVICE_INSTALLER. */
- if (hw == NULL)
- return;
-
- mac = zd_hw_mac(hw);
- usb = &mac->chip.usb;
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- ieee80211_unregister_hw(hw);
-
- /* Just in case something has gone wrong! */
- zd_usb_disable_tx(usb);
- zd_usb_disable_rx(usb);
- zd_usb_disable_int(usb);
-
- /* If the disconnect has been caused by a removal of the
- * driver module, the reset allows reloading of the driver. If the
- * reset will not be executed here, the upload of the firmware in the
- * probe function caused by the reloading of the driver will fail.
- */
- usb_reset_device(interface_to_usbdev(intf));
-
- zd_mac_clear(mac);
- ieee80211_free_hw(hw);
- dev_dbg(&intf->dev, "disconnected\n");
-}
-
-static void zd_usb_resume(struct zd_usb *usb)
-{
- struct zd_mac *mac = zd_usb_to_mac(usb);
- int r;
-
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- r = zd_op_start(zd_usb_to_hw(usb));
- if (r < 0) {
- dev_warn(zd_usb_dev(usb), "Device resume failed "
- "with error code %d. Retrying...\n", r);
- if (usb->was_running)
- set_bit(ZD_DEVICE_RUNNING, &mac->flags);
- usb_queue_reset_device(usb->intf);
- return;
- }
-
- if (mac->type != NL80211_IFTYPE_UNSPECIFIED) {
- r = zd_restore_settings(mac);
- if (r < 0) {
- dev_dbg(zd_usb_dev(usb),
- "failed to restore settings, %d\n", r);
- return;
- }
- }
-}
-
-static void zd_usb_stop(struct zd_usb *usb)
-{
- dev_dbg_f(zd_usb_dev(usb), "\n");
-
- zd_op_stop(zd_usb_to_hw(usb));
-
- zd_usb_disable_tx(usb);
- zd_usb_disable_rx(usb);
- zd_usb_disable_int(usb);
-
- usb->initialized = 0;
-}
-
-static int pre_reset(struct usb_interface *intf)
-{
- struct ieee80211_hw *hw = usb_get_intfdata(intf);
- struct zd_mac *mac;
- struct zd_usb *usb;
-
- if (!hw || intf->condition != USB_INTERFACE_BOUND)
- return 0;
-
- mac = zd_hw_mac(hw);
- usb = &mac->chip.usb;
-
- usb->was_running = test_bit(ZD_DEVICE_RUNNING, &mac->flags);
-
- zd_usb_stop(usb);
-
- mutex_lock(&mac->chip.mutex);
- return 0;
-}
-
-static int post_reset(struct usb_interface *intf)
-{
- struct ieee80211_hw *hw = usb_get_intfdata(intf);
- struct zd_mac *mac;
- struct zd_usb *usb;
-
- if (!hw || intf->condition != USB_INTERFACE_BOUND)
- return 0;
-
- mac = zd_hw_mac(hw);
- usb = &mac->chip.usb;
-
- mutex_unlock(&mac->chip.mutex);
-
- if (usb->was_running)
- zd_usb_resume(usb);
- return 0;
-}
-
-static struct usb_driver driver = {
- .name = KBUILD_MODNAME,
- .id_table = usb_ids,
- .probe = probe,
- .disconnect = disconnect,
- .pre_reset = pre_reset,
- .post_reset = post_reset,
- .disable_hub_initiated_lpm = 1,
-};
-
-struct workqueue_struct *zd_workqueue;
-
-static int __init usb_init(void)
-{
- int r;
-
- pr_debug("%s usb_init()\n", driver.name);
-
- zd_workqueue = create_singlethread_workqueue(driver.name);
- if (zd_workqueue == NULL) {
- printk(KERN_ERR "%s couldn't create workqueue\n", driver.name);
- return -ENOMEM;
- }
-
- r = usb_register(&driver);
- if (r) {
- destroy_workqueue(zd_workqueue);
- printk(KERN_ERR "%s usb_register() failed. Error number %d\n",
- driver.name, r);
- return r;
- }
-
- pr_debug("%s initialized\n", driver.name);
- return 0;
-}
-
-static void __exit usb_exit(void)
-{
- pr_debug("%s usb_exit()\n", driver.name);
- usb_deregister(&driver);
- destroy_workqueue(zd_workqueue);
-}
-
-module_init(usb_init);
-module_exit(usb_exit);
-
-static int zd_ep_regs_out_msg(struct usb_device *udev, void *data, int len,
- int *actual_length, int timeout)
-{
- /* In USB 2.0 mode EP_REGS_OUT endpoint is interrupt type. However in
- * USB 1.1 mode endpoint is bulk. Select correct type URB by endpoint
- * descriptor.
- */
- struct usb_host_endpoint *ep;
- unsigned int pipe;
-
- pipe = usb_sndintpipe(udev, EP_REGS_OUT);
- ep = usb_pipe_endpoint(udev, pipe);
- if (!ep)
- return -EINVAL;
-
- if (usb_endpoint_xfer_int(&ep->desc)) {
- return usb_interrupt_msg(udev, pipe, data, len,
- actual_length, timeout);
- } else {
- pipe = usb_sndbulkpipe(udev, EP_REGS_OUT);
- return usb_bulk_msg(udev, pipe, data, len, actual_length,
- timeout);
- }
-}
-
-static int usb_int_regs_length(unsigned int count)
-{
- return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
-}
-
-static void prepare_read_regs_int(struct zd_usb *usb,
- struct usb_req_read_regs *req,
- unsigned int count)
-{
- struct zd_usb_interrupt *intr = &usb->intr;
-
- spin_lock_irq(&intr->lock);
- atomic_set(&intr->read_regs_enabled, 1);
- intr->read_regs.req = req;
- intr->read_regs.req_count = count;
- reinit_completion(&intr->read_regs.completion);
- spin_unlock_irq(&intr->lock);
-}
-
-static void disable_read_regs_int(struct zd_usb *usb)
-{
- struct zd_usb_interrupt *intr = &usb->intr;
-
- spin_lock_irq(&intr->lock);
- atomic_set(&intr->read_regs_enabled, 0);
- spin_unlock_irq(&intr->lock);
-}
-
-static bool check_read_regs(struct zd_usb *usb, struct usb_req_read_regs *req,
- unsigned int count)
-{
- int i;
- struct zd_usb_interrupt *intr = &usb->intr;
- struct read_regs_int *rr = &intr->read_regs;
- struct usb_int_regs *regs = (struct usb_int_regs *)rr->buffer;
-
- /* The created block size seems to be larger than expected.
- * However results appear to be correct.
- */
- if (rr->length < usb_int_regs_length(count)) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: actual length %d less than expected %d\n",
- rr->length, usb_int_regs_length(count));
- return false;
- }
-
- if (rr->length > sizeof(rr->buffer)) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: actual length %d exceeds buffer size %zu\n",
- rr->length, sizeof(rr->buffer));
- return false;
- }
-
- for (i = 0; i < count; i++) {
- struct reg_data *rd = ®s->regs[i];
- if (rd->addr != req->addr[i]) {
- dev_dbg_f(zd_usb_dev(usb),
- "rd[%d] addr %#06hx expected %#06hx\n", i,
- le16_to_cpu(rd->addr),
- le16_to_cpu(req->addr[i]));
- return false;
- }
- }
-
- return true;
-}
-
-static int get_results(struct zd_usb *usb, u16 *values,
- struct usb_req_read_regs *req, unsigned int count,
- bool *retry)
-{
- int r;
- int i;
- struct zd_usb_interrupt *intr = &usb->intr;
- struct read_regs_int *rr = &intr->read_regs;
- struct usb_int_regs *regs = (struct usb_int_regs *)rr->buffer;
-
- spin_lock_irq(&intr->lock);
-
- r = -EIO;
-
- /* Read failed because firmware bug? */
- *retry = !!intr->read_regs_int_overridden;
- if (*retry)
- goto error_unlock;
-
- if (!check_read_regs(usb, req, count)) {
- dev_dbg_f(zd_usb_dev(usb), "error: invalid read regs\n");
- goto error_unlock;
- }
-
- for (i = 0; i < count; i++) {
- struct reg_data *rd = ®s->regs[i];
- values[i] = le16_to_cpu(rd->value);
- }
-
- r = 0;
-error_unlock:
- spin_unlock_irq(&intr->lock);
- return r;
-}
-
-int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
- const zd_addr_t *addresses, unsigned int count)
-{
- int r, i, req_len, actual_req_len, try_count = 0;
- struct usb_device *udev;
- struct usb_req_read_regs *req = NULL;
- unsigned long timeout;
- bool retry = false;
-
- if (count < 1) {
- dev_dbg_f(zd_usb_dev(usb), "error: count is zero\n");
- return -EINVAL;
- }
- if (count > USB_MAX_IOREAD16_COUNT) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: count %u exceeds possible max %u\n",
- count, USB_MAX_IOREAD16_COUNT);
- return -EINVAL;
- }
- if (in_atomic()) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: io in atomic context not supported\n");
- return -EWOULDBLOCK;
- }
- if (!usb_int_enabled(usb)) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: usb interrupt not enabled\n");
- return -EWOULDBLOCK;
- }
-
- ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
- BUILD_BUG_ON(sizeof(struct usb_req_read_regs) + USB_MAX_IOREAD16_COUNT *
- sizeof(__le16) > sizeof(usb->req_buf));
- BUG_ON(sizeof(struct usb_req_read_regs) + count * sizeof(__le16) >
- sizeof(usb->req_buf));
-
- req_len = sizeof(struct usb_req_read_regs) + count * sizeof(__le16);
- req = (void *)usb->req_buf;
-
- req->id = cpu_to_le16(USB_REQ_READ_REGS);
- for (i = 0; i < count; i++)
- req->addr[i] = cpu_to_le16((u16)addresses[i]);
-
-retry_read:
- try_count++;
- udev = zd_usb_to_usbdev(usb);
- prepare_read_regs_int(usb, req, count);
- r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "error in zd_ep_regs_out_msg(). Error number %d\n", r);
- goto error;
- }
- if (req_len != actual_req_len) {
- dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()\n"
- " req_len %d != actual_req_len %d\n",
- req_len, actual_req_len);
- r = -EIO;
- goto error;
- }
-
- timeout = wait_for_completion_timeout(&usb->intr.read_regs.completion,
- msecs_to_jiffies(50));
- if (!timeout) {
- disable_read_regs_int(usb);
- dev_dbg_f(zd_usb_dev(usb), "read timed out\n");
- r = -ETIMEDOUT;
- goto error;
- }
-
- r = get_results(usb, values, req, count, &retry);
- if (retry && try_count < 20) {
- dev_dbg_f(zd_usb_dev(usb), "read retry, tries so far: %d\n",
- try_count);
- goto retry_read;
- }
-error:
- return r;
-}
-
-static void iowrite16v_urb_complete(struct urb *urb)
-{
- struct zd_usb *usb = urb->context;
-
- if (urb->status && !usb->cmd_error)
- usb->cmd_error = urb->status;
-
- if (!usb->cmd_error &&
- urb->actual_length != urb->transfer_buffer_length)
- usb->cmd_error = -EIO;
-}
-
-static int zd_submit_waiting_urb(struct zd_usb *usb, bool last)
-{
- int r = 0;
- struct urb *urb = usb->urb_async_waiting;
-
- if (!urb)
- return 0;
-
- usb->urb_async_waiting = NULL;
-
- if (!last)
- urb->transfer_flags |= URB_NO_INTERRUPT;
-
- usb_anchor_urb(urb, &usb->submitted_cmds);
- r = usb_submit_urb(urb, GFP_KERNEL);
- if (r) {
- usb_unanchor_urb(urb);
- dev_dbg_f(zd_usb_dev(usb),
- "error in usb_submit_urb(). Error number %d\n", r);
- goto error;
- }
-
- /* fall-through with r == 0 */
-error:
- usb_free_urb(urb);
- return r;
-}
-
-void zd_usb_iowrite16v_async_start(struct zd_usb *usb)
-{
- ZD_ASSERT(usb_anchor_empty(&usb->submitted_cmds));
- ZD_ASSERT(usb->urb_async_waiting == NULL);
- ZD_ASSERT(!usb->in_async);
-
- ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
-
- usb->in_async = 1;
- usb->cmd_error = 0;
- usb->urb_async_waiting = NULL;
-}
-
-int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout)
-{
- int r;
-
- ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
- ZD_ASSERT(usb->in_async);
-
- /* Submit last iowrite16v URB */
- r = zd_submit_waiting_urb(usb, true);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "error in zd_submit_waiting_usb(). "
- "Error number %d\n", r);
-
- usb_kill_anchored_urbs(&usb->submitted_cmds);
- goto error;
- }
-
- if (timeout)
- timeout = usb_wait_anchor_empty_timeout(&usb->submitted_cmds,
- timeout);
- if (!timeout) {
- usb_kill_anchored_urbs(&usb->submitted_cmds);
- if (usb->cmd_error == -ENOENT) {
- dev_dbg_f(zd_usb_dev(usb), "timed out");
- r = -ETIMEDOUT;
- goto error;
- }
- }
-
- r = usb->cmd_error;
-error:
- usb->in_async = 0;
- return r;
-}
-
-int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
- unsigned int count)
-{
- int r;
- struct usb_device *udev;
- struct usb_req_write_regs *req = NULL;
- int i, req_len;
- struct urb *urb;
- struct usb_host_endpoint *ep;
-
- ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
- ZD_ASSERT(usb->in_async);
-
- if (count == 0)
- return 0;
- if (count > USB_MAX_IOWRITE16_COUNT) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: count %u exceeds possible max %u\n",
- count, USB_MAX_IOWRITE16_COUNT);
- return -EINVAL;
- }
- if (in_atomic()) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: io in atomic context not supported\n");
- return -EWOULDBLOCK;
- }
-
- udev = zd_usb_to_usbdev(usb);
-
- ep = usb_pipe_endpoint(udev, usb_sndintpipe(udev, EP_REGS_OUT));
- if (!ep)
- return -ENOENT;
-
- urb = usb_alloc_urb(0, GFP_KERNEL);
- if (!urb)
- return -ENOMEM;
-
- req_len = sizeof(struct usb_req_write_regs) +
- count * sizeof(struct reg_data);
- req = kmalloc(req_len, GFP_KERNEL);
- if (!req) {
- r = -ENOMEM;
- goto error;
- }
-
- req->id = cpu_to_le16(USB_REQ_WRITE_REGS);
- for (i = 0; i < count; i++) {
- struct reg_data *rw = &req->reg_writes[i];
- rw->addr = cpu_to_le16((u16)ioreqs[i].addr);
- rw->value = cpu_to_le16(ioreqs[i].value);
- }
-
- /* In USB 2.0 mode endpoint is interrupt type. However in USB 1.1 mode
- * endpoint is bulk. Select correct type URB by endpoint descriptor.
- */
- if (usb_endpoint_xfer_int(&ep->desc))
- usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
- req, req_len, iowrite16v_urb_complete, usb,
- ep->desc.bInterval);
- else
- usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
- req, req_len, iowrite16v_urb_complete, usb);
-
- urb->transfer_flags |= URB_FREE_BUFFER;
-
- /* Submit previous URB */
- r = zd_submit_waiting_urb(usb, false);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "error in zd_submit_waiting_usb(). "
- "Error number %d\n", r);
- goto error;
- }
-
- /* Delay submit so that URB_NO_INTERRUPT flag can be set for all URBs
- * of currect batch except for very last.
- */
- usb->urb_async_waiting = urb;
- return 0;
-error:
- usb_free_urb(urb);
- return r;
-}
-
-int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
- unsigned int count)
-{
- int r;
-
- zd_usb_iowrite16v_async_start(usb);
- r = zd_usb_iowrite16v_async(usb, ioreqs, count);
- if (r) {
- zd_usb_iowrite16v_async_end(usb, 0);
- return r;
- }
- return zd_usb_iowrite16v_async_end(usb, 50 /* ms */);
-}
-
-int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits)
-{
- int r;
- struct usb_device *udev;
- struct usb_req_rfwrite *req = NULL;
- int i, req_len, actual_req_len;
- u16 bit_value_template;
-
- if (in_atomic()) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: io in atomic context not supported\n");
- return -EWOULDBLOCK;
- }
- if (bits < USB_MIN_RFWRITE_BIT_COUNT) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: bits %d are smaller than"
- " USB_MIN_RFWRITE_BIT_COUNT %d\n",
- bits, USB_MIN_RFWRITE_BIT_COUNT);
- return -EINVAL;
- }
- if (bits > USB_MAX_RFWRITE_BIT_COUNT) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: bits %d exceed USB_MAX_RFWRITE_BIT_COUNT %d\n",
- bits, USB_MAX_RFWRITE_BIT_COUNT);
- return -EINVAL;
- }
-#ifdef DEBUG
- if (value & (~0UL << bits)) {
- dev_dbg_f(zd_usb_dev(usb),
- "error: value %#09x has bits >= %d set\n",
- value, bits);
- return -EINVAL;
- }
-#endif /* DEBUG */
-
- dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d\n", value, bits);
-
- r = zd_usb_ioread16(usb, &bit_value_template, ZD_CR203);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "error %d: Couldn't read ZD_CR203\n", r);
- return r;
- }
- bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);
-
- ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
- BUILD_BUG_ON(sizeof(struct usb_req_rfwrite) +
- USB_MAX_RFWRITE_BIT_COUNT * sizeof(__le16) >
- sizeof(usb->req_buf));
- BUG_ON(sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16) >
- sizeof(usb->req_buf));
-
- req_len = sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16);
- req = (void *)usb->req_buf;
-
- req->id = cpu_to_le16(USB_REQ_WRITE_RF);
- /* 1: 3683a, but not used in ZYDAS driver */
- req->value = cpu_to_le16(2);
- req->bits = cpu_to_le16(bits);
-
- for (i = 0; i < bits; i++) {
- u16 bv = bit_value_template;
- if (value & (1 << (bits-1-i)))
- bv |= RF_DATA;
- req->bit_values[i] = cpu_to_le16(bv);
- }
-
- udev = zd_usb_to_usbdev(usb);
- r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
- if (r) {
- dev_dbg_f(zd_usb_dev(usb),
- "error in zd_ep_regs_out_msg(). Error number %d\n", r);
- goto out;
- }
- if (req_len != actual_req_len) {
- dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()"
- " req_len %d != actual_req_len %d\n",
- req_len, actual_req_len);
- r = -EIO;
- goto out;
- }
-
- /* FALL-THROUGH with r == 0 */
-out:
- return r;
-}
+++ /dev/null
-/* ZD1211 USB-WLAN driver for Linux
- *
- * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
- * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef _ZD_USB_H
-#define _ZD_USB_H
-
-#include <linux/completion.h>
-#include <linux/netdevice.h>
-#include <linux/spinlock.h>
-#include <linux/skbuff.h>
-#include <linux/usb.h>
-
-#include "zd_def.h"
-
-#define ZD_USB_TX_HIGH 5
-#define ZD_USB_TX_LOW 2
-
-#define ZD_TX_TIMEOUT (HZ * 5)
-#define ZD_TX_WATCHDOG_INTERVAL round_jiffies_relative(HZ)
-#define ZD_RX_IDLE_INTERVAL round_jiffies_relative(30 * HZ)
-
-enum devicetype {
- DEVICE_ZD1211 = 0,
- DEVICE_ZD1211B = 1,
- DEVICE_INSTALLER = 2,
-};
-
-enum endpoints {
- EP_CTRL = 0,
- EP_DATA_OUT = 1,
- EP_DATA_IN = 2,
- EP_INT_IN = 3,
- EP_REGS_OUT = 4,
-};
-
-enum {
- USB_MAX_TRANSFER_SIZE = 4096, /* bytes */
- /* FIXME: The original driver uses this value. We have to check,
- * whether the MAX_TRANSFER_SIZE is sufficient and this needs only be
- * used if one combined frame is split over two USB transactions.
- */
- USB_MAX_RX_SIZE = 4800, /* bytes */
- USB_MAX_IOWRITE16_COUNT = 15,
- USB_MAX_IOWRITE32_COUNT = USB_MAX_IOWRITE16_COUNT/2,
- USB_MAX_IOREAD16_COUNT = 15,
- USB_MAX_IOREAD32_COUNT = USB_MAX_IOREAD16_COUNT/2,
- USB_MIN_RFWRITE_BIT_COUNT = 16,
- USB_MAX_RFWRITE_BIT_COUNT = 28,
- USB_MAX_EP_INT_BUFFER = 64,
- USB_ZD1211B_BCD_DEVICE = 0x4810,
-};
-
-enum control_requests {
- USB_REQ_WRITE_REGS = 0x21,
- USB_REQ_READ_REGS = 0x22,
- USB_REQ_WRITE_RF = 0x23,
- USB_REQ_PROG_FLASH = 0x24,
- USB_REQ_EEPROM_START = 0x0128, /* ? request is a byte */
- USB_REQ_EEPROM_MID = 0x28,
- USB_REQ_EEPROM_END = 0x0228, /* ? request is a byte */
- USB_REQ_FIRMWARE_DOWNLOAD = 0x30,
- USB_REQ_FIRMWARE_CONFIRM = 0x31,
- USB_REQ_FIRMWARE_READ_DATA = 0x32,
-};
-
-struct usb_req_read_regs {
- __le16 id;
- __le16 addr[0];
-} __packed;
-
-struct reg_data {
- __le16 addr;
- __le16 value;
-} __packed;
-
-struct usb_req_write_regs {
- __le16 id;
- struct reg_data reg_writes[0];
-} __packed;
-
-enum {
- RF_IF_LE = 0x02,
- RF_CLK = 0x04,
- RF_DATA = 0x08,
-};
-
-struct usb_req_rfwrite {
- __le16 id;
- __le16 value;
- /* 1: 3683a */
- /* 2: other (default) */
- __le16 bits;
- /* RF2595: 24 */
- __le16 bit_values[0];
- /* (ZD_CR203 & ~(RF_IF_LE | RF_CLK | RF_DATA)) | (bit ? RF_DATA : 0) */
-} __packed;
-
-/* USB interrupt */
-
-enum usb_int_id {
- USB_INT_TYPE = 0x01,
- USB_INT_ID_REGS = 0x90,
- USB_INT_ID_RETRY_FAILED = 0xa0,
-};
-
-enum usb_int_flags {
- USB_INT_READ_REGS_EN = 0x01,
-};
-
-struct usb_int_header {
- u8 type; /* must always be 1 */
- u8 id;
-} __packed;
-
-struct usb_int_regs {
- struct usb_int_header hdr;
- struct reg_data regs[0];
-} __packed;
-
-struct usb_int_retry_fail {
- struct usb_int_header hdr;
- u8 new_rate;
- u8 _dummy;
- u8 addr[ETH_ALEN];
- u8 ibss_wakeup_dest;
-} __packed;
-
-struct read_regs_int {
- struct completion completion;
- struct usb_req_read_regs *req;
- unsigned int req_count;
- /* Stores the USB int structure and contains the USB address of the
- * first requested register before request.
- */
- u8 buffer[USB_MAX_EP_INT_BUFFER];
- int length;
- __le16 cr_int_addr;
-};
-
-struct zd_ioreq16 {
- zd_addr_t addr;
- u16 value;
-};
-
-struct zd_ioreq32 {
- zd_addr_t addr;
- u32 value;
-};
-
-struct zd_usb_interrupt {
- struct read_regs_int read_regs;
- spinlock_t lock;
- struct urb *urb;
- void *buffer;
- dma_addr_t buffer_dma;
- int interval;
- atomic_t read_regs_enabled;
- u8 read_regs_int_overridden:1;
-};
-
-static inline struct usb_int_regs *get_read_regs(struct zd_usb_interrupt *intr)
-{
- return (struct usb_int_regs *)intr->read_regs.buffer;
-}
-
-#define RX_URBS_COUNT 5
-
-struct zd_usb_rx {
- spinlock_t lock;
- struct mutex setup_mutex;
- struct delayed_work idle_work;
- struct tasklet_struct reset_timer_tasklet;
- u8 fragment[2 * USB_MAX_RX_SIZE];
- unsigned int fragment_length;
- unsigned int usb_packet_size;
- struct urb **urbs;
- int urbs_count;
-};
-
-/**
- * struct zd_usb_tx - structure used for transmitting frames
- * @enabled: atomic enabled flag, indicates whether tx is enabled
- * @lock: lock for transmission
- * @submitted: anchor for URBs sent to device
- * @submitted_urbs: atomic integer that counts the URBs having sent to the
- * device, which haven't been completed
- * @stopped: indicates whether higher level tx queues are stopped
- */
-struct zd_usb_tx {
- atomic_t enabled;
- spinlock_t lock;
- struct delayed_work watchdog_work;
- struct sk_buff_head submitted_skbs;
- struct usb_anchor submitted;
- int submitted_urbs;
- u8 stopped:1, watchdog_enabled:1;
-};
-
-/* Contains the usb parts. The structure doesn't require a lock because intf
- * will not be changed after initialization.
- */
-struct zd_usb {
- struct zd_usb_interrupt intr;
- struct zd_usb_rx rx;
- struct zd_usb_tx tx;
- struct usb_interface *intf;
- struct usb_anchor submitted_cmds;
- struct urb *urb_async_waiting;
- int cmd_error;
- u8 req_buf[64]; /* zd_usb_iowrite16v needs 62 bytes */
- u8 is_zd1211b:1, initialized:1, was_running:1, in_async:1;
-};
-
-#define zd_usb_dev(usb) (&usb->intf->dev)
-
-static inline struct usb_device *zd_usb_to_usbdev(struct zd_usb *usb)
-{
- return interface_to_usbdev(usb->intf);
-}
-
-static inline struct ieee80211_hw *zd_intf_to_hw(struct usb_interface *intf)
-{
- return usb_get_intfdata(intf);
-}
-
-static inline struct ieee80211_hw *zd_usb_to_hw(struct zd_usb *usb)
-{
- return zd_intf_to_hw(usb->intf);
-}
-
-void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
- struct usb_interface *intf);
-int zd_usb_init_hw(struct zd_usb *usb);
-void zd_usb_clear(struct zd_usb *usb);
-
-int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size);
-
-void zd_tx_watchdog_enable(struct zd_usb *usb);
-void zd_tx_watchdog_disable(struct zd_usb *usb);
-
-int zd_usb_enable_int(struct zd_usb *usb);
-void zd_usb_disable_int(struct zd_usb *usb);
-
-int zd_usb_enable_rx(struct zd_usb *usb);
-void zd_usb_disable_rx(struct zd_usb *usb);
-
-void zd_usb_reset_rx_idle_timer(struct zd_usb *usb);
-
-void zd_usb_enable_tx(struct zd_usb *usb);
-void zd_usb_disable_tx(struct zd_usb *usb);
-
-int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb);
-
-int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
- const zd_addr_t *addresses, unsigned int count);
-
-static inline int zd_usb_ioread16(struct zd_usb *usb, u16 *value,
- const zd_addr_t addr)
-{
- return zd_usb_ioread16v(usb, value, &addr, 1);
-}
-
-void zd_usb_iowrite16v_async_start(struct zd_usb *usb);
-int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout);
-int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
- unsigned int count);
-int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
- unsigned int count);
-
-int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits);
-
-int zd_usb_read_fw(struct zd_usb *usb, zd_addr_t addr, u8 *data, u16 len);
-
-extern struct workqueue_struct *zd_workqueue;
-
-#endif /* _ZD_USB_H */
To compile this driver as a module, choose M here: the
module will be called zd1201.
+source "drivers/net/wireless/zydas/zd1211rw/Kconfig"
+
endif # WLAN_VENDOR_ZYDAS
+obj-$(CONFIG_ZD1211RW) += zd1211rw/
+
obj-$(CONFIG_USB_ZD1201) += zd1201.o
--- /dev/null
+config ZD1211RW
+ tristate "ZyDAS ZD1211/ZD1211B USB-wireless support"
+ depends on USB && MAC80211
+ select FW_LOADER
+ ---help---
+ This is a driver for the ZyDAS ZD1211/ZD1211B wireless
+ chip, present in many USB-wireless adapters.
+
+ Device firmware is required alongside this driver. You can download
+ the firmware distribution from http://sf.net/projects/zd1211/files/
+
+config ZD1211RW_DEBUG
+ bool "ZyDAS ZD1211 debugging"
+ depends on ZD1211RW
+ ---help---
+ ZD1211 debugging messages. Choosing Y will result in additional debug
+ messages being saved to your kernel logs, which may help debug any
+ problems.
+
--- /dev/null
+obj-$(CONFIG_ZD1211RW) += zd1211rw.o
+
+zd1211rw-objs := zd_chip.o zd_mac.o \
+ zd_rf_al2230.o zd_rf_rf2959.o \
+ zd_rf_al7230b.o zd_rf_uw2453.o \
+ zd_rf.o zd_usb.o
+
+ccflags-$(CONFIG_ZD1211RW_DEBUG) := -DDEBUG
+
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/* This file implements all the hardware specific functions for the ZD1211
+ * and ZD1211B chips. Support for the ZD1211B was possible after Timothy
+ * Legge sent me a ZD1211B device. Thank you Tim. -- Uli
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+
+#include "zd_def.h"
+#include "zd_chip.h"
+#include "zd_mac.h"
+#include "zd_rf.h"
+
+void zd_chip_init(struct zd_chip *chip,
+ struct ieee80211_hw *hw,
+ struct usb_interface *intf)
+{
+ memset(chip, 0, sizeof(*chip));
+ mutex_init(&chip->mutex);
+ zd_usb_init(&chip->usb, hw, intf);
+ zd_rf_init(&chip->rf);
+}
+
+void zd_chip_clear(struct zd_chip *chip)
+{
+ ZD_ASSERT(!mutex_is_locked(&chip->mutex));
+ zd_usb_clear(&chip->usb);
+ zd_rf_clear(&chip->rf);
+ mutex_destroy(&chip->mutex);
+ ZD_MEMCLEAR(chip, sizeof(*chip));
+}
+
+static int scnprint_mac_oui(struct zd_chip *chip, char *buffer, size_t size)
+{
+ u8 *addr = zd_mac_get_perm_addr(zd_chip_to_mac(chip));
+ return scnprintf(buffer, size, "%02x-%02x-%02x",
+ addr[0], addr[1], addr[2]);
+}
+
+/* Prints an identifier line, which will support debugging. */
+static int scnprint_id(struct zd_chip *chip, char *buffer, size_t size)
+{
+ int i = 0;
+
+ i = scnprintf(buffer, size, "zd1211%s chip ",
+ zd_chip_is_zd1211b(chip) ? "b" : "");
+ i += zd_usb_scnprint_id(&chip->usb, buffer+i, size-i);
+ i += scnprintf(buffer+i, size-i, " ");
+ i += scnprint_mac_oui(chip, buffer+i, size-i);
+ i += scnprintf(buffer+i, size-i, " ");
+ i += zd_rf_scnprint_id(&chip->rf, buffer+i, size-i);
+ i += scnprintf(buffer+i, size-i, " pa%1x %c%c%c%c%c", chip->pa_type,
+ chip->patch_cck_gain ? 'g' : '-',
+ chip->patch_cr157 ? '7' : '-',
+ chip->patch_6m_band_edge ? '6' : '-',
+ chip->new_phy_layout ? 'N' : '-',
+ chip->al2230s_bit ? 'S' : '-');
+ return i;
+}
+
+static void print_id(struct zd_chip *chip)
+{
+ char buffer[80];
+
+ scnprint_id(chip, buffer, sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+ dev_info(zd_chip_dev(chip), "%s\n", buffer);
+}
+
+static zd_addr_t inc_addr(zd_addr_t addr)
+{
+ u16 a = (u16)addr;
+ /* Control registers use byte addressing, but everything else uses word
+ * addressing. */
+ if ((a & 0xf000) == CR_START)
+ a += 2;
+ else
+ a += 1;
+ return (zd_addr_t)a;
+}
+
+/* Read a variable number of 32-bit values. Parameter count is not allowed to
+ * exceed USB_MAX_IOREAD32_COUNT.
+ */
+int zd_ioread32v_locked(struct zd_chip *chip, u32 *values, const zd_addr_t *addr,
+ unsigned int count)
+{
+ int r;
+ int i;
+ zd_addr_t a16[USB_MAX_IOREAD32_COUNT * 2];
+ u16 v16[USB_MAX_IOREAD32_COUNT * 2];
+ unsigned int count16;
+
+ if (count > USB_MAX_IOREAD32_COUNT)
+ return -EINVAL;
+
+ /* Use stack for values and addresses. */
+ count16 = 2 * count;
+ BUG_ON(count16 * sizeof(zd_addr_t) > sizeof(a16));
+ BUG_ON(count16 * sizeof(u16) > sizeof(v16));
+
+ for (i = 0; i < count; i++) {
+ int j = 2*i;
+ /* We read the high word always first. */
+ a16[j] = inc_addr(addr[i]);
+ a16[j+1] = addr[i];
+ }
+
+ r = zd_ioread16v_locked(chip, v16, a16, count16);
+ if (r) {
+ dev_dbg_f(zd_chip_dev(chip),
+ "error: %s. Error number %d\n", __func__, r);
+ return r;
+ }
+
+ for (i = 0; i < count; i++) {
+ int j = 2*i;
+ values[i] = (v16[j] << 16) | v16[j+1];
+ }
+
+ return 0;
+}
+
+static int _zd_iowrite32v_async_locked(struct zd_chip *chip,
+ const struct zd_ioreq32 *ioreqs,
+ unsigned int count)
+{
+ int i, j, r;
+ struct zd_ioreq16 ioreqs16[USB_MAX_IOWRITE32_COUNT * 2];
+ unsigned int count16;
+
+ /* Use stack for values and addresses. */
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+
+ if (count == 0)
+ return 0;
+ if (count > USB_MAX_IOWRITE32_COUNT)
+ return -EINVAL;
+
+ count16 = 2 * count;
+ BUG_ON(count16 * sizeof(struct zd_ioreq16) > sizeof(ioreqs16));
+
+ for (i = 0; i < count; i++) {
+ j = 2*i;
+ /* We write the high word always first. */
+ ioreqs16[j].value = ioreqs[i].value >> 16;
+ ioreqs16[j].addr = inc_addr(ioreqs[i].addr);
+ ioreqs16[j+1].value = ioreqs[i].value;
+ ioreqs16[j+1].addr = ioreqs[i].addr;
+ }
+
+ r = zd_usb_iowrite16v_async(&chip->usb, ioreqs16, count16);
+#ifdef DEBUG
+ if (r) {
+ dev_dbg_f(zd_chip_dev(chip),
+ "error %d in zd_usb_write16v\n", r);
+ }
+#endif /* DEBUG */
+ return r;
+}
+
+int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
+ unsigned int count)
+{
+ int r;
+
+ zd_usb_iowrite16v_async_start(&chip->usb);
+ r = _zd_iowrite32v_async_locked(chip, ioreqs, count);
+ if (r) {
+ zd_usb_iowrite16v_async_end(&chip->usb, 0);
+ return r;
+ }
+ return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
+}
+
+int zd_iowrite16a_locked(struct zd_chip *chip,
+ const struct zd_ioreq16 *ioreqs, unsigned int count)
+{
+ int r;
+ unsigned int i, j, t, max;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ zd_usb_iowrite16v_async_start(&chip->usb);
+
+ for (i = 0; i < count; i += j + t) {
+ t = 0;
+ max = count-i;
+ if (max > USB_MAX_IOWRITE16_COUNT)
+ max = USB_MAX_IOWRITE16_COUNT;
+ for (j = 0; j < max; j++) {
+ if (!ioreqs[i+j].addr) {
+ t = 1;
+ break;
+ }
+ }
+
+ r = zd_usb_iowrite16v_async(&chip->usb, &ioreqs[i], j);
+ if (r) {
+ zd_usb_iowrite16v_async_end(&chip->usb, 0);
+ dev_dbg_f(zd_chip_dev(chip),
+ "error zd_usb_iowrite16v. Error number %d\n",
+ r);
+ return r;
+ }
+ }
+
+ return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
+}
+
+/* Writes a variable number of 32 bit registers. The functions will split
+ * that in several USB requests. A split can be forced by inserting an IO
+ * request with an zero address field.
+ */
+int zd_iowrite32a_locked(struct zd_chip *chip,
+ const struct zd_ioreq32 *ioreqs, unsigned int count)
+{
+ int r;
+ unsigned int i, j, t, max;
+
+ zd_usb_iowrite16v_async_start(&chip->usb);
+
+ for (i = 0; i < count; i += j + t) {
+ t = 0;
+ max = count-i;
+ if (max > USB_MAX_IOWRITE32_COUNT)
+ max = USB_MAX_IOWRITE32_COUNT;
+ for (j = 0; j < max; j++) {
+ if (!ioreqs[i+j].addr) {
+ t = 1;
+ break;
+ }
+ }
+
+ r = _zd_iowrite32v_async_locked(chip, &ioreqs[i], j);
+ if (r) {
+ zd_usb_iowrite16v_async_end(&chip->usb, 0);
+ dev_dbg_f(zd_chip_dev(chip),
+ "error _%s. Error number %d\n", __func__,
+ r);
+ return r;
+ }
+ }
+
+ return zd_usb_iowrite16v_async_end(&chip->usb, 50 /* ms */);
+}
+
+int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread16_locked(chip, value, addr);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread32_locked(chip, value, addr);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite16_locked(chip, value, addr);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite32_locked(chip, value, addr);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
+ u32 *values, unsigned int count)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread32v_locked(chip, values, addresses, count);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
+ unsigned int count)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite32a_locked(chip, ioreqs, count);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static int read_pod(struct zd_chip *chip, u8 *rf_type)
+{
+ int r;
+ u32 value;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_ioread32_locked(chip, &value, E2P_POD);
+ if (r)
+ goto error;
+ dev_dbg_f(zd_chip_dev(chip), "E2P_POD %#010x\n", value);
+
+ /* FIXME: AL2230 handling (Bit 7 in POD) */
+ *rf_type = value & 0x0f;
+ chip->pa_type = (value >> 16) & 0x0f;
+ chip->patch_cck_gain = (value >> 8) & 0x1;
+ chip->patch_cr157 = (value >> 13) & 0x1;
+ chip->patch_6m_band_edge = (value >> 21) & 0x1;
+ chip->new_phy_layout = (value >> 31) & 0x1;
+ chip->al2230s_bit = (value >> 7) & 0x1;
+ chip->link_led = ((value >> 4) & 1) ? LED1 : LED2;
+ chip->supports_tx_led = 1;
+ if (value & (1 << 24)) { /* LED scenario */
+ if (value & (1 << 29))
+ chip->supports_tx_led = 0;
+ }
+
+ dev_dbg_f(zd_chip_dev(chip),
+ "RF %s %#01x PA type %#01x patch CCK %d patch CR157 %d "
+ "patch 6M %d new PHY %d link LED%d tx led %d\n",
+ zd_rf_name(*rf_type), *rf_type,
+ chip->pa_type, chip->patch_cck_gain,
+ chip->patch_cr157, chip->patch_6m_band_edge,
+ chip->new_phy_layout,
+ chip->link_led == LED1 ? 1 : 2,
+ chip->supports_tx_led);
+ return 0;
+error:
+ *rf_type = 0;
+ chip->pa_type = 0;
+ chip->patch_cck_gain = 0;
+ chip->patch_cr157 = 0;
+ chip->patch_6m_band_edge = 0;
+ chip->new_phy_layout = 0;
+ return r;
+}
+
+static int zd_write_mac_addr_common(struct zd_chip *chip, const u8 *mac_addr,
+ const struct zd_ioreq32 *in_reqs,
+ const char *type)
+{
+ int r;
+ struct zd_ioreq32 reqs[2] = {in_reqs[0], in_reqs[1]};
+
+ if (mac_addr) {
+ reqs[0].value = (mac_addr[3] << 24)
+ | (mac_addr[2] << 16)
+ | (mac_addr[1] << 8)
+ | mac_addr[0];
+ reqs[1].value = (mac_addr[5] << 8)
+ | mac_addr[4];
+ dev_dbg_f(zd_chip_dev(chip), "%s addr %pM\n", type, mac_addr);
+ } else {
+ dev_dbg_f(zd_chip_dev(chip), "set NULL %s\n", type);
+ }
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+/* MAC address: if custom mac addresses are to be used CR_MAC_ADDR_P1 and
+ * CR_MAC_ADDR_P2 must be overwritten
+ */
+int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr)
+{
+ static const struct zd_ioreq32 reqs[2] = {
+ [0] = { .addr = CR_MAC_ADDR_P1 },
+ [1] = { .addr = CR_MAC_ADDR_P2 },
+ };
+
+ return zd_write_mac_addr_common(chip, mac_addr, reqs, "mac");
+}
+
+int zd_write_bssid(struct zd_chip *chip, const u8 *bssid)
+{
+ static const struct zd_ioreq32 reqs[2] = {
+ [0] = { .addr = CR_BSSID_P1 },
+ [1] = { .addr = CR_BSSID_P2 },
+ };
+
+ return zd_write_mac_addr_common(chip, bssid, reqs, "bssid");
+}
+
+int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain)
+{
+ int r;
+ u32 value;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread32_locked(chip, &value, E2P_SUBID);
+ mutex_unlock(&chip->mutex);
+ if (r)
+ return r;
+
+ *regdomain = value >> 16;
+ dev_dbg_f(zd_chip_dev(chip), "regdomain: %#04x\n", *regdomain);
+
+ return 0;
+}
+
+static int read_values(struct zd_chip *chip, u8 *values, size_t count,
+ zd_addr_t e2p_addr, u32 guard)
+{
+ int r;
+ int i;
+ u32 v;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ for (i = 0;;) {
+ r = zd_ioread32_locked(chip, &v,
+ (zd_addr_t)((u16)e2p_addr+i/2));
+ if (r)
+ return r;
+ v -= guard;
+ if (i+4 < count) {
+ values[i++] = v;
+ values[i++] = v >> 8;
+ values[i++] = v >> 16;
+ values[i++] = v >> 24;
+ continue;
+ }
+ for (;i < count; i++)
+ values[i] = v >> (8*(i%3));
+ return 0;
+ }
+}
+
+static int read_pwr_cal_values(struct zd_chip *chip)
+{
+ return read_values(chip, chip->pwr_cal_values,
+ E2P_CHANNEL_COUNT, E2P_PWR_CAL_VALUE1,
+ 0);
+}
+
+static int read_pwr_int_values(struct zd_chip *chip)
+{
+ return read_values(chip, chip->pwr_int_values,
+ E2P_CHANNEL_COUNT, E2P_PWR_INT_VALUE1,
+ E2P_PWR_INT_GUARD);
+}
+
+static int read_ofdm_cal_values(struct zd_chip *chip)
+{
+ int r;
+ int i;
+ static const zd_addr_t addresses[] = {
+ E2P_36M_CAL_VALUE1,
+ E2P_48M_CAL_VALUE1,
+ E2P_54M_CAL_VALUE1,
+ };
+
+ for (i = 0; i < 3; i++) {
+ r = read_values(chip, chip->ofdm_cal_values[i],
+ E2P_CHANNEL_COUNT, addresses[i], 0);
+ if (r)
+ return r;
+ }
+ return 0;
+}
+
+static int read_cal_int_tables(struct zd_chip *chip)
+{
+ int r;
+
+ r = read_pwr_cal_values(chip);
+ if (r)
+ return r;
+ r = read_pwr_int_values(chip);
+ if (r)
+ return r;
+ r = read_ofdm_cal_values(chip);
+ if (r)
+ return r;
+ return 0;
+}
+
+/* phy means physical registers */
+int zd_chip_lock_phy_regs(struct zd_chip *chip)
+{
+ int r;
+ u32 tmp;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_ioread32_locked(chip, &tmp, CR_REG1);
+ if (r) {
+ dev_err(zd_chip_dev(chip), "error ioread32(CR_REG1): %d\n", r);
+ return r;
+ }
+
+ tmp &= ~UNLOCK_PHY_REGS;
+
+ r = zd_iowrite32_locked(chip, tmp, CR_REG1);
+ if (r)
+ dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
+ return r;
+}
+
+int zd_chip_unlock_phy_regs(struct zd_chip *chip)
+{
+ int r;
+ u32 tmp;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_ioread32_locked(chip, &tmp, CR_REG1);
+ if (r) {
+ dev_err(zd_chip_dev(chip),
+ "error ioread32(CR_REG1): %d\n", r);
+ return r;
+ }
+
+ tmp |= UNLOCK_PHY_REGS;
+
+ r = zd_iowrite32_locked(chip, tmp, CR_REG1);
+ if (r)
+ dev_err(zd_chip_dev(chip), "error iowrite32(CR_REG1): %d\n", r);
+ return r;
+}
+
+/* ZD_CR157 can be optionally patched by the EEPROM for original ZD1211 */
+static int patch_cr157(struct zd_chip *chip)
+{
+ int r;
+ u16 value;
+
+ if (!chip->patch_cr157)
+ return 0;
+
+ r = zd_ioread16_locked(chip, &value, E2P_PHY_REG);
+ if (r)
+ return r;
+
+ dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value >> 8);
+ return zd_iowrite32_locked(chip, value >> 8, ZD_CR157);
+}
+
+/*
+ * 6M band edge can be optionally overwritten for certain RF's
+ * Vendor driver says: for FCC regulation, enabled per HWFeature 6M band edge
+ * bit (for AL2230, AL2230S)
+ */
+static int patch_6m_band_edge(struct zd_chip *chip, u8 channel)
+{
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ if (!chip->patch_6m_band_edge)
+ return 0;
+
+ return zd_rf_patch_6m_band_edge(&chip->rf, channel);
+}
+
+/* Generic implementation of 6M band edge patching, used by most RFs via
+ * zd_rf_generic_patch_6m() */
+int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel)
+{
+ struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ { ZD_CR47, 0x1e },
+ };
+
+ /* FIXME: Channel 11 is not the edge for all regulatory domains. */
+ if (channel == 1 || channel == 11)
+ ioreqs[0].value = 0x12;
+
+ dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211_hw_reset_phy(struct zd_chip *chip)
+{
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR0, 0x0a }, { ZD_CR1, 0x06 }, { ZD_CR2, 0x26 },
+ { ZD_CR3, 0x38 }, { ZD_CR4, 0x80 }, { ZD_CR9, 0xa0 },
+ { ZD_CR10, 0x81 }, { ZD_CR11, 0x00 }, { ZD_CR12, 0x7f },
+ { ZD_CR13, 0x8c }, { ZD_CR14, 0x80 }, { ZD_CR15, 0x3d },
+ { ZD_CR16, 0x20 }, { ZD_CR17, 0x1e }, { ZD_CR18, 0x0a },
+ { ZD_CR19, 0x48 }, { ZD_CR20, 0x0c }, { ZD_CR21, 0x0c },
+ { ZD_CR22, 0x23 }, { ZD_CR23, 0x90 }, { ZD_CR24, 0x14 },
+ { ZD_CR25, 0x40 }, { ZD_CR26, 0x10 }, { ZD_CR27, 0x19 },
+ { ZD_CR28, 0x7f }, { ZD_CR29, 0x80 }, { ZD_CR30, 0x4b },
+ { ZD_CR31, 0x60 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x08 },
+ { ZD_CR34, 0x06 }, { ZD_CR35, 0x0a }, { ZD_CR36, 0x00 },
+ { ZD_CR37, 0x00 }, { ZD_CR38, 0x38 }, { ZD_CR39, 0x0c },
+ { ZD_CR40, 0x84 }, { ZD_CR41, 0x2a }, { ZD_CR42, 0x80 },
+ { ZD_CR43, 0x10 }, { ZD_CR44, 0x12 }, { ZD_CR46, 0xff },
+ { ZD_CR47, 0x1E }, { ZD_CR48, 0x26 }, { ZD_CR49, 0x5b },
+ { ZD_CR64, 0xd0 }, { ZD_CR65, 0x04 }, { ZD_CR66, 0x58 },
+ { ZD_CR67, 0xc9 }, { ZD_CR68, 0x88 }, { ZD_CR69, 0x41 },
+ { ZD_CR70, 0x23 }, { ZD_CR71, 0x10 }, { ZD_CR72, 0xff },
+ { ZD_CR73, 0x32 }, { ZD_CR74, 0x30 }, { ZD_CR75, 0x65 },
+ { ZD_CR76, 0x41 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x30 },
+ { ZD_CR79, 0x68 }, { ZD_CR80, 0x64 }, { ZD_CR81, 0x64 },
+ { ZD_CR82, 0x00 }, { ZD_CR83, 0x00 }, { ZD_CR84, 0x00 },
+ { ZD_CR85, 0x02 }, { ZD_CR86, 0x00 }, { ZD_CR87, 0x00 },
+ { ZD_CR88, 0xff }, { ZD_CR89, 0xfc }, { ZD_CR90, 0x00 },
+ { ZD_CR91, 0x00 }, { ZD_CR92, 0x00 }, { ZD_CR93, 0x08 },
+ { ZD_CR94, 0x00 }, { ZD_CR95, 0x00 }, { ZD_CR96, 0xff },
+ { ZD_CR97, 0xe7 }, { ZD_CR98, 0x00 }, { ZD_CR99, 0x00 },
+ { ZD_CR100, 0x00 }, { ZD_CR101, 0xae }, { ZD_CR102, 0x02 },
+ { ZD_CR103, 0x00 }, { ZD_CR104, 0x03 }, { ZD_CR105, 0x65 },
+ { ZD_CR106, 0x04 }, { ZD_CR107, 0x00 }, { ZD_CR108, 0x0a },
+ { ZD_CR109, 0xaa }, { ZD_CR110, 0xaa }, { ZD_CR111, 0x25 },
+ { ZD_CR112, 0x25 }, { ZD_CR113, 0x00 }, { ZD_CR119, 0x1e },
+ { ZD_CR125, 0x90 }, { ZD_CR126, 0x00 }, { ZD_CR127, 0x00 },
+ { },
+ { ZD_CR5, 0x00 }, { ZD_CR6, 0x00 }, { ZD_CR7, 0x00 },
+ { ZD_CR8, 0x00 }, { ZD_CR9, 0x20 }, { ZD_CR12, 0xf0 },
+ { ZD_CR20, 0x0e }, { ZD_CR21, 0x0e }, { ZD_CR27, 0x10 },
+ { ZD_CR44, 0x33 }, { ZD_CR47, 0x1E }, { ZD_CR83, 0x24 },
+ { ZD_CR84, 0x04 }, { ZD_CR85, 0x00 }, { ZD_CR86, 0x0C },
+ { ZD_CR87, 0x12 }, { ZD_CR88, 0x0C }, { ZD_CR89, 0x00 },
+ { ZD_CR90, 0x10 }, { ZD_CR91, 0x08 }, { ZD_CR93, 0x00 },
+ { ZD_CR94, 0x01 }, { ZD_CR95, 0x00 }, { ZD_CR96, 0x50 },
+ { ZD_CR97, 0x37 }, { ZD_CR98, 0x35 }, { ZD_CR101, 0x13 },
+ { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 }, { ZD_CR104, 0x18 },
+ { ZD_CR105, 0x12 }, { ZD_CR109, 0x27 }, { ZD_CR110, 0x27 },
+ { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x27 }, { ZD_CR115, 0x26 }, { ZD_CR116, 0x24 },
+ { ZD_CR117, 0xfc }, { ZD_CR118, 0xfa }, { ZD_CR120, 0x4f },
+ { ZD_CR125, 0xaa }, { ZD_CR127, 0x03 }, { ZD_CR128, 0x14 },
+ { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 }, { ZD_CR131, 0x0C },
+ { ZD_CR136, 0xdf }, { ZD_CR137, 0x40 }, { ZD_CR138, 0xa0 },
+ { ZD_CR139, 0xb0 }, { ZD_CR140, 0x99 }, { ZD_CR141, 0x82 },
+ { ZD_CR142, 0x54 }, { ZD_CR143, 0x1c }, { ZD_CR144, 0x6c },
+ { ZD_CR147, 0x07 }, { ZD_CR148, 0x4c }, { ZD_CR149, 0x50 },
+ { ZD_CR150, 0x0e }, { ZD_CR151, 0x18 }, { ZD_CR160, 0xfe },
+ { ZD_CR161, 0xee }, { ZD_CR162, 0xaa }, { ZD_CR163, 0xfa },
+ { ZD_CR164, 0xfa }, { ZD_CR165, 0xea }, { ZD_CR166, 0xbe },
+ { ZD_CR167, 0xbe }, { ZD_CR168, 0x6a }, { ZD_CR169, 0xba },
+ { ZD_CR170, 0xba }, { ZD_CR171, 0xba },
+ /* Note: ZD_CR204 must lead the ZD_CR203 */
+ { ZD_CR204, 0x7d },
+ { },
+ { ZD_CR203, 0x30 },
+ };
+
+ int r, t;
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ goto out;
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ goto unlock;
+
+ r = patch_cr157(chip);
+unlock:
+ t = zd_chip_unlock_phy_regs(chip);
+ if (t && !r)
+ r = t;
+out:
+ return r;
+}
+
+static int zd1211b_hw_reset_phy(struct zd_chip *chip)
+{
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR0, 0x14 }, { ZD_CR1, 0x06 }, { ZD_CR2, 0x26 },
+ { ZD_CR3, 0x38 }, { ZD_CR4, 0x80 }, { ZD_CR9, 0xe0 },
+ { ZD_CR10, 0x81 },
+ /* power control { { ZD_CR11, 1 << 6 }, */
+ { ZD_CR11, 0x00 },
+ { ZD_CR12, 0xf0 }, { ZD_CR13, 0x8c }, { ZD_CR14, 0x80 },
+ { ZD_CR15, 0x3d }, { ZD_CR16, 0x20 }, { ZD_CR17, 0x1e },
+ { ZD_CR18, 0x0a }, { ZD_CR19, 0x48 },
+ { ZD_CR20, 0x10 }, /* Org:0x0E, ComTrend:RalLink AP */
+ { ZD_CR21, 0x0e }, { ZD_CR22, 0x23 }, { ZD_CR23, 0x90 },
+ { ZD_CR24, 0x14 }, { ZD_CR25, 0x40 }, { ZD_CR26, 0x10 },
+ { ZD_CR27, 0x10 }, { ZD_CR28, 0x7f }, { ZD_CR29, 0x80 },
+ { ZD_CR30, 0x4b }, /* ASIC/FWT, no jointly decoder */
+ { ZD_CR31, 0x60 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x08 },
+ { ZD_CR34, 0x06 }, { ZD_CR35, 0x0a }, { ZD_CR36, 0x00 },
+ { ZD_CR37, 0x00 }, { ZD_CR38, 0x38 }, { ZD_CR39, 0x0c },
+ { ZD_CR40, 0x84 }, { ZD_CR41, 0x2a }, { ZD_CR42, 0x80 },
+ { ZD_CR43, 0x10 }, { ZD_CR44, 0x33 }, { ZD_CR46, 0xff },
+ { ZD_CR47, 0x1E }, { ZD_CR48, 0x26 }, { ZD_CR49, 0x5b },
+ { ZD_CR64, 0xd0 }, { ZD_CR65, 0x04 }, { ZD_CR66, 0x58 },
+ { ZD_CR67, 0xc9 }, { ZD_CR68, 0x88 }, { ZD_CR69, 0x41 },
+ { ZD_CR70, 0x23 }, { ZD_CR71, 0x10 }, { ZD_CR72, 0xff },
+ { ZD_CR73, 0x32 }, { ZD_CR74, 0x30 }, { ZD_CR75, 0x65 },
+ { ZD_CR76, 0x41 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x30 },
+ { ZD_CR79, 0xf0 }, { ZD_CR80, 0x64 }, { ZD_CR81, 0x64 },
+ { ZD_CR82, 0x00 }, { ZD_CR83, 0x24 }, { ZD_CR84, 0x04 },
+ { ZD_CR85, 0x00 }, { ZD_CR86, 0x0c }, { ZD_CR87, 0x12 },
+ { ZD_CR88, 0x0c }, { ZD_CR89, 0x00 }, { ZD_CR90, 0x58 },
+ { ZD_CR91, 0x04 }, { ZD_CR92, 0x00 }, { ZD_CR93, 0x00 },
+ { ZD_CR94, 0x01 },
+ { ZD_CR95, 0x20 }, /* ZD1211B */
+ { ZD_CR96, 0x50 }, { ZD_CR97, 0x37 }, { ZD_CR98, 0x35 },
+ { ZD_CR99, 0x00 }, { ZD_CR100, 0x01 }, { ZD_CR101, 0x13 },
+ { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 }, { ZD_CR104, 0x18 },
+ { ZD_CR105, 0x12 }, { ZD_CR106, 0x04 }, { ZD_CR107, 0x00 },
+ { ZD_CR108, 0x0a }, { ZD_CR109, 0x27 }, { ZD_CR110, 0x27 },
+ { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x27 }, { ZD_CR115, 0x26 }, { ZD_CR116, 0x24 },
+ { ZD_CR117, 0xfc }, { ZD_CR118, 0xfa }, { ZD_CR119, 0x1e },
+ { ZD_CR125, 0x90 }, { ZD_CR126, 0x00 }, { ZD_CR127, 0x00 },
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ { ZD_CR131, 0x0c }, { ZD_CR136, 0xdf }, { ZD_CR137, 0xa0 },
+ { ZD_CR138, 0xa8 }, { ZD_CR139, 0xb4 }, { ZD_CR140, 0x98 },
+ { ZD_CR141, 0x82 }, { ZD_CR142, 0x53 }, { ZD_CR143, 0x1c },
+ { ZD_CR144, 0x6c }, { ZD_CR147, 0x07 }, { ZD_CR148, 0x40 },
+ { ZD_CR149, 0x40 }, /* Org:0x50 ComTrend:RalLink AP */
+ { ZD_CR150, 0x14 }, /* Org:0x0E ComTrend:RalLink AP */
+ { ZD_CR151, 0x18 }, { ZD_CR159, 0x70 }, { ZD_CR160, 0xfe },
+ { ZD_CR161, 0xee }, { ZD_CR162, 0xaa }, { ZD_CR163, 0xfa },
+ { ZD_CR164, 0xfa }, { ZD_CR165, 0xea }, { ZD_CR166, 0xbe },
+ { ZD_CR167, 0xbe }, { ZD_CR168, 0x6a }, { ZD_CR169, 0xba },
+ { ZD_CR170, 0xba }, { ZD_CR171, 0xba },
+ /* Note: ZD_CR204 must lead the ZD_CR203 */
+ { ZD_CR204, 0x7d },
+ {},
+ { ZD_CR203, 0x30 },
+ };
+
+ int r, t;
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ goto out;
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ t = zd_chip_unlock_phy_regs(chip);
+ if (t && !r)
+ r = t;
+out:
+ return r;
+}
+
+static int hw_reset_phy(struct zd_chip *chip)
+{
+ return zd_chip_is_zd1211b(chip) ? zd1211b_hw_reset_phy(chip) :
+ zd1211_hw_reset_phy(chip);
+}
+
+static int zd1211_hw_init_hmac(struct zd_chip *chip)
+{
+ static const struct zd_ioreq32 ioreqs[] = {
+ { CR_ZD1211_RETRY_MAX, ZD1211_RETRY_COUNT },
+ { CR_RX_THRESHOLD, 0x000c0640 },
+ };
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211b_hw_init_hmac(struct zd_chip *chip)
+{
+ static const struct zd_ioreq32 ioreqs[] = {
+ { CR_ZD1211B_RETRY_MAX, ZD1211B_RETRY_COUNT },
+ { CR_ZD1211B_CWIN_MAX_MIN_AC0, 0x007f003f },
+ { CR_ZD1211B_CWIN_MAX_MIN_AC1, 0x007f003f },
+ { CR_ZD1211B_CWIN_MAX_MIN_AC2, 0x003f001f },
+ { CR_ZD1211B_CWIN_MAX_MIN_AC3, 0x001f000f },
+ { CR_ZD1211B_AIFS_CTL1, 0x00280028 },
+ { CR_ZD1211B_AIFS_CTL2, 0x008C003C },
+ { CR_ZD1211B_TXOP, 0x01800824 },
+ { CR_RX_THRESHOLD, 0x000c0eff, },
+ };
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int hw_init_hmac(struct zd_chip *chip)
+{
+ int r;
+ static const struct zd_ioreq32 ioreqs[] = {
+ { CR_ACK_TIMEOUT_EXT, 0x20 },
+ { CR_ADDA_MBIAS_WARMTIME, 0x30000808 },
+ { CR_SNIFFER_ON, 0 },
+ { CR_RX_FILTER, STA_RX_FILTER },
+ { CR_GROUP_HASH_P1, 0x00 },
+ { CR_GROUP_HASH_P2, 0x80000000 },
+ { CR_REG1, 0xa4 },
+ { CR_ADDA_PWR_DWN, 0x7f },
+ { CR_BCN_PLCP_CFG, 0x00f00401 },
+ { CR_PHY_DELAY, 0x00 },
+ { CR_ACK_TIMEOUT_EXT, 0x80 },
+ { CR_ADDA_PWR_DWN, 0x00 },
+ { CR_ACK_TIME_80211, 0x100 },
+ { CR_RX_PE_DELAY, 0x70 },
+ { CR_PS_CTRL, 0x10000000 },
+ { CR_RTS_CTS_RATE, 0x02030203 },
+ { CR_AFTER_PNP, 0x1 },
+ { CR_WEP_PROTECT, 0x114 },
+ { CR_IFS_VALUE, IFS_VALUE_DEFAULT },
+ { CR_CAM_MODE, MODE_AP_WDS},
+ };
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_iowrite32a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ return zd_chip_is_zd1211b(chip) ?
+ zd1211b_hw_init_hmac(chip) : zd1211_hw_init_hmac(chip);
+}
+
+struct aw_pt_bi {
+ u32 atim_wnd_period;
+ u32 pre_tbtt;
+ u32 beacon_interval;
+};
+
+static int get_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
+{
+ int r;
+ static const zd_addr_t aw_pt_bi_addr[] =
+ { CR_ATIM_WND_PERIOD, CR_PRE_TBTT, CR_BCN_INTERVAL };
+ u32 values[3];
+
+ r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
+ ARRAY_SIZE(aw_pt_bi_addr));
+ if (r) {
+ memset(s, 0, sizeof(*s));
+ return r;
+ }
+
+ s->atim_wnd_period = values[0];
+ s->pre_tbtt = values[1];
+ s->beacon_interval = values[2];
+ return 0;
+}
+
+static int set_aw_pt_bi(struct zd_chip *chip, struct aw_pt_bi *s)
+{
+ struct zd_ioreq32 reqs[3];
+ u16 b_interval = s->beacon_interval & 0xffff;
+
+ if (b_interval <= 5)
+ b_interval = 5;
+ if (s->pre_tbtt < 4 || s->pre_tbtt >= b_interval)
+ s->pre_tbtt = b_interval - 1;
+ if (s->atim_wnd_period >= s->pre_tbtt)
+ s->atim_wnd_period = s->pre_tbtt - 1;
+
+ reqs[0].addr = CR_ATIM_WND_PERIOD;
+ reqs[0].value = s->atim_wnd_period;
+ reqs[1].addr = CR_PRE_TBTT;
+ reqs[1].value = s->pre_tbtt;
+ reqs[2].addr = CR_BCN_INTERVAL;
+ reqs[2].value = (s->beacon_interval & ~0xffff) | b_interval;
+
+ return zd_iowrite32a_locked(chip, reqs, ARRAY_SIZE(reqs));
+}
+
+
+static int set_beacon_interval(struct zd_chip *chip, u16 interval,
+ u8 dtim_period, int type)
+{
+ int r;
+ struct aw_pt_bi s;
+ u32 b_interval, mode_flag;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+
+ if (interval > 0) {
+ switch (type) {
+ case NL80211_IFTYPE_ADHOC:
+ case NL80211_IFTYPE_MESH_POINT:
+ mode_flag = BCN_MODE_IBSS;
+ break;
+ case NL80211_IFTYPE_AP:
+ mode_flag = BCN_MODE_AP;
+ break;
+ default:
+ mode_flag = 0;
+ break;
+ }
+ } else {
+ dtim_period = 0;
+ mode_flag = 0;
+ }
+
+ b_interval = mode_flag | (dtim_period << 16) | interval;
+
+ r = zd_iowrite32_locked(chip, b_interval, CR_BCN_INTERVAL);
+ if (r)
+ return r;
+ r = get_aw_pt_bi(chip, &s);
+ if (r)
+ return r;
+ return set_aw_pt_bi(chip, &s);
+}
+
+int zd_set_beacon_interval(struct zd_chip *chip, u16 interval, u8 dtim_period,
+ int type)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = set_beacon_interval(chip, interval, dtim_period, type);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static int hw_init(struct zd_chip *chip)
+{
+ int r;
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = hw_reset_phy(chip);
+ if (r)
+ return r;
+
+ r = hw_init_hmac(chip);
+ if (r)
+ return r;
+
+ return set_beacon_interval(chip, 100, 0, NL80211_IFTYPE_UNSPECIFIED);
+}
+
+static zd_addr_t fw_reg_addr(struct zd_chip *chip, u16 offset)
+{
+ return (zd_addr_t)((u16)chip->fw_regs_base + offset);
+}
+
+#ifdef DEBUG
+static int dump_cr(struct zd_chip *chip, const zd_addr_t addr,
+ const char *addr_string)
+{
+ int r;
+ u32 value;
+
+ r = zd_ioread32_locked(chip, &value, addr);
+ if (r) {
+ dev_dbg_f(zd_chip_dev(chip),
+ "error reading %s. Error number %d\n", addr_string, r);
+ return r;
+ }
+
+ dev_dbg_f(zd_chip_dev(chip), "%s %#010x\n",
+ addr_string, (unsigned int)value);
+ return 0;
+}
+
+static int test_init(struct zd_chip *chip)
+{
+ int r;
+
+ r = dump_cr(chip, CR_AFTER_PNP, "CR_AFTER_PNP");
+ if (r)
+ return r;
+ r = dump_cr(chip, CR_GPI_EN, "CR_GPI_EN");
+ if (r)
+ return r;
+ return dump_cr(chip, CR_INTERRUPT, "CR_INTERRUPT");
+}
+
+static void dump_fw_registers(struct zd_chip *chip)
+{
+ const zd_addr_t addr[4] = {
+ fw_reg_addr(chip, FW_REG_FIRMWARE_VER),
+ fw_reg_addr(chip, FW_REG_USB_SPEED),
+ fw_reg_addr(chip, FW_REG_FIX_TX_RATE),
+ fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
+ };
+
+ int r;
+ u16 values[4];
+
+ r = zd_ioread16v_locked(chip, values, (const zd_addr_t*)addr,
+ ARRAY_SIZE(addr));
+ if (r) {
+ dev_dbg_f(zd_chip_dev(chip), "error %d zd_ioread16v_locked\n",
+ r);
+ return;
+ }
+
+ dev_dbg_f(zd_chip_dev(chip), "FW_FIRMWARE_VER %#06hx\n", values[0]);
+ dev_dbg_f(zd_chip_dev(chip), "FW_USB_SPEED %#06hx\n", values[1]);
+ dev_dbg_f(zd_chip_dev(chip), "FW_FIX_TX_RATE %#06hx\n", values[2]);
+ dev_dbg_f(zd_chip_dev(chip), "FW_LINK_STATUS %#06hx\n", values[3]);
+}
+#endif /* DEBUG */
+
+static int print_fw_version(struct zd_chip *chip)
+{
+ struct wiphy *wiphy = zd_chip_to_mac(chip)->hw->wiphy;
+ int r;
+ u16 version;
+
+ r = zd_ioread16_locked(chip, &version,
+ fw_reg_addr(chip, FW_REG_FIRMWARE_VER));
+ if (r)
+ return r;
+
+ dev_info(zd_chip_dev(chip),"firmware version %04hx\n", version);
+
+ snprintf(wiphy->fw_version, sizeof(wiphy->fw_version),
+ "%04hx", version);
+
+ return 0;
+}
+
+static int set_mandatory_rates(struct zd_chip *chip, int gmode)
+{
+ u32 rates;
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ /* This sets the mandatory rates, which only depend from the standard
+ * that the device is supporting. Until further notice we should try
+ * to support 802.11g also for full speed USB.
+ */
+ if (!gmode)
+ rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M;
+ else
+ rates = CR_RATE_1M|CR_RATE_2M|CR_RATE_5_5M|CR_RATE_11M|
+ CR_RATE_6M|CR_RATE_12M|CR_RATE_24M;
+
+ return zd_iowrite32_locked(chip, rates, CR_MANDATORY_RATE_TBL);
+}
+
+int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip,
+ int preamble)
+{
+ u32 value = 0;
+
+ dev_dbg_f(zd_chip_dev(chip), "preamble=%x\n", preamble);
+ value |= preamble << RTSCTS_SH_RTS_PMB_TYPE;
+ value |= preamble << RTSCTS_SH_CTS_PMB_TYPE;
+
+ /* We always send 11M RTS/self-CTS messages, like the vendor driver. */
+ value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_RTS_RATE;
+ value |= ZD_RX_CCK << RTSCTS_SH_RTS_MOD_TYPE;
+ value |= ZD_PURE_RATE(ZD_CCK_RATE_11M) << RTSCTS_SH_CTS_RATE;
+ value |= ZD_RX_CCK << RTSCTS_SH_CTS_MOD_TYPE;
+
+ return zd_iowrite32_locked(chip, value, CR_RTS_CTS_RATE);
+}
+
+int zd_chip_enable_hwint(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite32_locked(chip, HWINT_ENABLED, CR_INTERRUPT);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static int disable_hwint(struct zd_chip *chip)
+{
+ return zd_iowrite32_locked(chip, HWINT_DISABLED, CR_INTERRUPT);
+}
+
+int zd_chip_disable_hwint(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = disable_hwint(chip);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static int read_fw_regs_offset(struct zd_chip *chip)
+{
+ int r;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_ioread16_locked(chip, (u16*)&chip->fw_regs_base,
+ FWRAW_REGS_ADDR);
+ if (r)
+ return r;
+ dev_dbg_f(zd_chip_dev(chip), "fw_regs_base: %#06hx\n",
+ (u16)chip->fw_regs_base);
+
+ return 0;
+}
+
+/* Read mac address using pre-firmware interface */
+int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr)
+{
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+ return zd_usb_read_fw(&chip->usb, E2P_MAC_ADDR_P1, addr,
+ ETH_ALEN);
+}
+
+int zd_chip_init_hw(struct zd_chip *chip)
+{
+ int r;
+ u8 rf_type;
+
+ dev_dbg_f(zd_chip_dev(chip), "\n");
+
+ mutex_lock(&chip->mutex);
+
+#ifdef DEBUG
+ r = test_init(chip);
+ if (r)
+ goto out;
+#endif
+ r = zd_iowrite32_locked(chip, 1, CR_AFTER_PNP);
+ if (r)
+ goto out;
+
+ r = read_fw_regs_offset(chip);
+ if (r)
+ goto out;
+
+ /* GPI is always disabled, also in the other driver.
+ */
+ r = zd_iowrite32_locked(chip, 0, CR_GPI_EN);
+ if (r)
+ goto out;
+ r = zd_iowrite32_locked(chip, CWIN_SIZE, CR_CWMIN_CWMAX);
+ if (r)
+ goto out;
+ /* Currently we support IEEE 802.11g for full and high speed USB.
+ * It might be discussed, whether we should support pure b mode for
+ * full speed USB.
+ */
+ r = set_mandatory_rates(chip, 1);
+ if (r)
+ goto out;
+ /* Disabling interrupts is certainly a smart thing here.
+ */
+ r = disable_hwint(chip);
+ if (r)
+ goto out;
+ r = read_pod(chip, &rf_type);
+ if (r)
+ goto out;
+ r = hw_init(chip);
+ if (r)
+ goto out;
+ r = zd_rf_init_hw(&chip->rf, rf_type);
+ if (r)
+ goto out;
+
+ r = print_fw_version(chip);
+ if (r)
+ goto out;
+
+#ifdef DEBUG
+ dump_fw_registers(chip);
+ r = test_init(chip);
+ if (r)
+ goto out;
+#endif /* DEBUG */
+
+ r = read_cal_int_tables(chip);
+ if (r)
+ goto out;
+
+ print_id(chip);
+out:
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static int update_pwr_int(struct zd_chip *chip, u8 channel)
+{
+ u8 value = chip->pwr_int_values[channel - 1];
+ return zd_iowrite16_locked(chip, value, ZD_CR31);
+}
+
+static int update_pwr_cal(struct zd_chip *chip, u8 channel)
+{
+ u8 value = chip->pwr_cal_values[channel-1];
+ return zd_iowrite16_locked(chip, value, ZD_CR68);
+}
+
+static int update_ofdm_cal(struct zd_chip *chip, u8 channel)
+{
+ struct zd_ioreq16 ioreqs[3];
+
+ ioreqs[0].addr = ZD_CR67;
+ ioreqs[0].value = chip->ofdm_cal_values[OFDM_36M_INDEX][channel-1];
+ ioreqs[1].addr = ZD_CR66;
+ ioreqs[1].value = chip->ofdm_cal_values[OFDM_48M_INDEX][channel-1];
+ ioreqs[2].addr = ZD_CR65;
+ ioreqs[2].value = chip->ofdm_cal_values[OFDM_54M_INDEX][channel-1];
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int update_channel_integration_and_calibration(struct zd_chip *chip,
+ u8 channel)
+{
+ int r;
+
+ if (!zd_rf_should_update_pwr_int(&chip->rf))
+ return 0;
+
+ r = update_pwr_int(chip, channel);
+ if (r)
+ return r;
+ if (zd_chip_is_zd1211b(chip)) {
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR69, 0x28 },
+ {},
+ { ZD_CR69, 0x2a },
+ };
+
+ r = update_ofdm_cal(chip, channel);
+ if (r)
+ return r;
+ r = update_pwr_cal(chip, channel);
+ if (r)
+ return r;
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+ }
+
+ return 0;
+}
+
+/* The CCK baseband gain can be optionally patched by the EEPROM */
+static int patch_cck_gain(struct zd_chip *chip)
+{
+ int r;
+ u32 value;
+
+ if (!chip->patch_cck_gain || !zd_rf_should_patch_cck_gain(&chip->rf))
+ return 0;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_ioread32_locked(chip, &value, E2P_PHY_REG);
+ if (r)
+ return r;
+ dev_dbg_f(zd_chip_dev(chip), "patching value %x\n", value & 0xff);
+ return zd_iowrite16_locked(chip, value & 0xff, ZD_CR47);
+}
+
+int zd_chip_set_channel(struct zd_chip *chip, u8 channel)
+{
+ int r, t;
+
+ mutex_lock(&chip->mutex);
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ goto out;
+ r = zd_rf_set_channel(&chip->rf, channel);
+ if (r)
+ goto unlock;
+ r = update_channel_integration_and_calibration(chip, channel);
+ if (r)
+ goto unlock;
+ r = patch_cck_gain(chip);
+ if (r)
+ goto unlock;
+ r = patch_6m_band_edge(chip, channel);
+ if (r)
+ goto unlock;
+ r = zd_iowrite32_locked(chip, 0, CR_CONFIG_PHILIPS);
+unlock:
+ t = zd_chip_unlock_phy_regs(chip);
+ if (t && !r)
+ r = t;
+out:
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+u8 zd_chip_get_channel(struct zd_chip *chip)
+{
+ u8 channel;
+
+ mutex_lock(&chip->mutex);
+ channel = chip->rf.channel;
+ mutex_unlock(&chip->mutex);
+ return channel;
+}
+
+int zd_chip_control_leds(struct zd_chip *chip, enum led_status status)
+{
+ const zd_addr_t a[] = {
+ fw_reg_addr(chip, FW_REG_LED_LINK_STATUS),
+ CR_LED,
+ };
+
+ int r;
+ u16 v[ARRAY_SIZE(a)];
+ struct zd_ioreq16 ioreqs[ARRAY_SIZE(a)] = {
+ [0] = { fw_reg_addr(chip, FW_REG_LED_LINK_STATUS) },
+ [1] = { CR_LED },
+ };
+ u16 other_led;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread16v_locked(chip, v, (const zd_addr_t *)a, ARRAY_SIZE(a));
+ if (r)
+ goto out;
+
+ other_led = chip->link_led == LED1 ? LED2 : LED1;
+
+ switch (status) {
+ case ZD_LED_OFF:
+ ioreqs[0].value = FW_LINK_OFF;
+ ioreqs[1].value = v[1] & ~(LED1|LED2);
+ break;
+ case ZD_LED_SCANNING:
+ ioreqs[0].value = FW_LINK_OFF;
+ ioreqs[1].value = v[1] & ~other_led;
+ if (get_seconds() % 3 == 0) {
+ ioreqs[1].value &= ~chip->link_led;
+ } else {
+ ioreqs[1].value |= chip->link_led;
+ }
+ break;
+ case ZD_LED_ASSOCIATED:
+ ioreqs[0].value = FW_LINK_TX;
+ ioreqs[1].value = v[1] & ~other_led;
+ ioreqs[1].value |= chip->link_led;
+ break;
+ default:
+ r = -EINVAL;
+ goto out;
+ }
+
+ if (v[0] != ioreqs[0].value || v[1] != ioreqs[1].value) {
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ goto out;
+ }
+ r = 0;
+out:
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates)
+{
+ int r;
+
+ if (cr_rates & ~(CR_RATES_80211B|CR_RATES_80211G))
+ return -EINVAL;
+
+ mutex_lock(&chip->mutex);
+ r = zd_iowrite32_locked(chip, cr_rates, CR_BASIC_RATE_TBL);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+static inline u8 zd_rate_from_ofdm_plcp_header(const void *rx_frame)
+{
+ return ZD_OFDM | zd_ofdm_plcp_header_rate(rx_frame);
+}
+
+/**
+ * zd_rx_rate - report zd-rate
+ * @rx_frame - received frame
+ * @rx_status - rx_status as given by the device
+ *
+ * This function converts the rate as encoded in the received packet to the
+ * zd-rate, we are using on other places in the driver.
+ */
+u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status)
+{
+ u8 zd_rate;
+ if (status->frame_status & ZD_RX_OFDM) {
+ zd_rate = zd_rate_from_ofdm_plcp_header(rx_frame);
+ } else {
+ switch (zd_cck_plcp_header_signal(rx_frame)) {
+ case ZD_CCK_PLCP_SIGNAL_1M:
+ zd_rate = ZD_CCK_RATE_1M;
+ break;
+ case ZD_CCK_PLCP_SIGNAL_2M:
+ zd_rate = ZD_CCK_RATE_2M;
+ break;
+ case ZD_CCK_PLCP_SIGNAL_5M5:
+ zd_rate = ZD_CCK_RATE_5_5M;
+ break;
+ case ZD_CCK_PLCP_SIGNAL_11M:
+ zd_rate = ZD_CCK_RATE_11M;
+ break;
+ default:
+ zd_rate = 0;
+ }
+ }
+
+ return zd_rate;
+}
+
+int zd_chip_switch_radio_on(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_switch_radio_on(&chip->rf);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_chip_switch_radio_off(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_switch_radio_off(&chip->rf);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+int zd_chip_enable_int(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ r = zd_usb_enable_int(&chip->usb);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+void zd_chip_disable_int(struct zd_chip *chip)
+{
+ mutex_lock(&chip->mutex);
+ zd_usb_disable_int(&chip->usb);
+ mutex_unlock(&chip->mutex);
+
+ /* cancel pending interrupt work */
+ cancel_work_sync(&zd_chip_to_mac(chip)->process_intr);
+}
+
+int zd_chip_enable_rxtx(struct zd_chip *chip)
+{
+ int r;
+
+ mutex_lock(&chip->mutex);
+ zd_usb_enable_tx(&chip->usb);
+ r = zd_usb_enable_rx(&chip->usb);
+ zd_tx_watchdog_enable(&chip->usb);
+ mutex_unlock(&chip->mutex);
+ return r;
+}
+
+void zd_chip_disable_rxtx(struct zd_chip *chip)
+{
+ mutex_lock(&chip->mutex);
+ zd_tx_watchdog_disable(&chip->usb);
+ zd_usb_disable_rx(&chip->usb);
+ zd_usb_disable_tx(&chip->usb);
+ mutex_unlock(&chip->mutex);
+}
+
+int zd_rfwritev_locked(struct zd_chip *chip,
+ const u32* values, unsigned int count, u8 bits)
+{
+ int r;
+ unsigned int i;
+
+ for (i = 0; i < count; i++) {
+ r = zd_rfwrite_locked(chip, values[i], bits);
+ if (r)
+ return r;
+ }
+
+ return 0;
+}
+
+/*
+ * We can optionally program the RF directly through CR regs, if supported by
+ * the hardware. This is much faster than the older method.
+ */
+int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value)
+{
+ const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR244, (value >> 16) & 0xff },
+ { ZD_CR243, (value >> 8) & 0xff },
+ { ZD_CR242, value & 0xff },
+ };
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+int zd_rfwritev_cr_locked(struct zd_chip *chip,
+ const u32 *values, unsigned int count)
+{
+ int r;
+ unsigned int i;
+
+ for (i = 0; i < count; i++) {
+ r = zd_rfwrite_cr_locked(chip, values[i]);
+ if (r)
+ return r;
+ }
+
+ return 0;
+}
+
+int zd_chip_set_multicast_hash(struct zd_chip *chip,
+ struct zd_mc_hash *hash)
+{
+ const struct zd_ioreq32 ioreqs[] = {
+ { CR_GROUP_HASH_P1, hash->low },
+ { CR_GROUP_HASH_P2, hash->high },
+ };
+
+ return zd_iowrite32a(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+u64 zd_chip_get_tsf(struct zd_chip *chip)
+{
+ int r;
+ static const zd_addr_t aw_pt_bi_addr[] =
+ { CR_TSF_LOW_PART, CR_TSF_HIGH_PART };
+ u32 values[2];
+ u64 tsf;
+
+ mutex_lock(&chip->mutex);
+ r = zd_ioread32v_locked(chip, values, (const zd_addr_t *)aw_pt_bi_addr,
+ ARRAY_SIZE(aw_pt_bi_addr));
+ mutex_unlock(&chip->mutex);
+ if (r)
+ return 0;
+
+ tsf = values[1];
+ tsf = (tsf << 32) | values[0];
+
+ return tsf;
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ZD_CHIP_H
+#define _ZD_CHIP_H
+
+#include <net/mac80211.h>
+
+#include "zd_rf.h"
+#include "zd_usb.h"
+
+/* Header for the Media Access Controller (MAC) and the Baseband Processor
+ * (BBP). It appears that the ZD1211 wraps the old ZD1205 with USB glue and
+ * adds a processor for handling the USB protocol.
+ */
+
+/* Address space */
+enum {
+ /* CONTROL REGISTERS */
+ CR_START = 0x9000,
+
+
+ /* FIRMWARE */
+ FW_START = 0xee00,
+
+
+ /* EEPROM */
+ E2P_START = 0xf800,
+ E2P_LEN = 0x800,
+
+ /* EEPROM layout */
+ E2P_LOAD_CODE_LEN = 0xe, /* base 0xf800 */
+ E2P_LOAD_VECT_LEN = 0x9, /* base 0xf80e */
+ /* E2P_DATA indexes into this */
+ E2P_DATA_LEN = 0x7e, /* base 0xf817 */
+ E2P_BOOT_CODE_LEN = 0x760, /* base 0xf895 */
+ E2P_INTR_VECT_LEN = 0xb, /* base 0xfff5 */
+
+ /* Some precomputed offsets into the EEPROM */
+ E2P_DATA_OFFSET = E2P_LOAD_CODE_LEN + E2P_LOAD_VECT_LEN,
+ E2P_BOOT_CODE_OFFSET = E2P_DATA_OFFSET + E2P_DATA_LEN,
+};
+
+#define CTL_REG(offset) ((zd_addr_t)(CR_START + (offset)))
+#define E2P_DATA(offset) ((zd_addr_t)(E2P_START + E2P_DATA_OFFSET + (offset)))
+#define FWRAW_DATA(offset) ((zd_addr_t)(FW_START + (offset)))
+
+/* 8-bit hardware registers */
+#define ZD_CR0 CTL_REG(0x0000)
+#define ZD_CR1 CTL_REG(0x0004)
+#define ZD_CR2 CTL_REG(0x0008)
+#define ZD_CR3 CTL_REG(0x000C)
+
+#define ZD_CR5 CTL_REG(0x0010)
+/* bit 5: if set short preamble used
+ * bit 6: filter band - Japan channel 14 on, else off
+ */
+#define ZD_CR6 CTL_REG(0x0014)
+#define ZD_CR7 CTL_REG(0x0018)
+#define ZD_CR8 CTL_REG(0x001C)
+
+#define ZD_CR4 CTL_REG(0x0020)
+
+#define ZD_CR9 CTL_REG(0x0024)
+/* bit 2: antenna switch (together with ZD_CR10) */
+#define ZD_CR10 CTL_REG(0x0028)
+/* bit 1: antenna switch (together with ZD_CR9)
+ * RF2959 controls with ZD_CR11 radion on and off
+ */
+#define ZD_CR11 CTL_REG(0x002C)
+/* bit 6: TX power control for OFDM
+ * RF2959 controls with ZD_CR10 radio on and off
+ */
+#define ZD_CR12 CTL_REG(0x0030)
+#define ZD_CR13 CTL_REG(0x0034)
+#define ZD_CR14 CTL_REG(0x0038)
+#define ZD_CR15 CTL_REG(0x003C)
+#define ZD_CR16 CTL_REG(0x0040)
+#define ZD_CR17 CTL_REG(0x0044)
+#define ZD_CR18 CTL_REG(0x0048)
+#define ZD_CR19 CTL_REG(0x004C)
+#define ZD_CR20 CTL_REG(0x0050)
+#define ZD_CR21 CTL_REG(0x0054)
+#define ZD_CR22 CTL_REG(0x0058)
+#define ZD_CR23 CTL_REG(0x005C)
+#define ZD_CR24 CTL_REG(0x0060) /* CCA threshold */
+#define ZD_CR25 CTL_REG(0x0064)
+#define ZD_CR26 CTL_REG(0x0068)
+#define ZD_CR27 CTL_REG(0x006C)
+#define ZD_CR28 CTL_REG(0x0070)
+#define ZD_CR29 CTL_REG(0x0074)
+#define ZD_CR30 CTL_REG(0x0078)
+#define ZD_CR31 CTL_REG(0x007C) /* TX power control for RF in
+ * CCK mode
+ */
+#define ZD_CR32 CTL_REG(0x0080)
+#define ZD_CR33 CTL_REG(0x0084)
+#define ZD_CR34 CTL_REG(0x0088)
+#define ZD_CR35 CTL_REG(0x008C)
+#define ZD_CR36 CTL_REG(0x0090)
+#define ZD_CR37 CTL_REG(0x0094)
+#define ZD_CR38 CTL_REG(0x0098)
+#define ZD_CR39 CTL_REG(0x009C)
+#define ZD_CR40 CTL_REG(0x00A0)
+#define ZD_CR41 CTL_REG(0x00A4)
+#define ZD_CR42 CTL_REG(0x00A8)
+#define ZD_CR43 CTL_REG(0x00AC)
+#define ZD_CR44 CTL_REG(0x00B0)
+#define ZD_CR45 CTL_REG(0x00B4)
+#define ZD_CR46 CTL_REG(0x00B8)
+#define ZD_CR47 CTL_REG(0x00BC) /* CCK baseband gain
+ * (patch value might be in EEPROM)
+ */
+#define ZD_CR48 CTL_REG(0x00C0)
+#define ZD_CR49 CTL_REG(0x00C4)
+#define ZD_CR50 CTL_REG(0x00C8)
+#define ZD_CR51 CTL_REG(0x00CC) /* TX power control for RF in
+ * 6-36M modes
+ */
+#define ZD_CR52 CTL_REG(0x00D0) /* TX power control for RF in
+ * 48M mode
+ */
+#define ZD_CR53 CTL_REG(0x00D4) /* TX power control for RF in
+ * 54M mode
+ */
+#define ZD_CR54 CTL_REG(0x00D8)
+#define ZD_CR55 CTL_REG(0x00DC)
+#define ZD_CR56 CTL_REG(0x00E0)
+#define ZD_CR57 CTL_REG(0x00E4)
+#define ZD_CR58 CTL_REG(0x00E8)
+#define ZD_CR59 CTL_REG(0x00EC)
+#define ZD_CR60 CTL_REG(0x00F0)
+#define ZD_CR61 CTL_REG(0x00F4)
+#define ZD_CR62 CTL_REG(0x00F8)
+#define ZD_CR63 CTL_REG(0x00FC)
+#define ZD_CR64 CTL_REG(0x0100)
+#define ZD_CR65 CTL_REG(0x0104) /* OFDM 54M calibration */
+#define ZD_CR66 CTL_REG(0x0108) /* OFDM 48M calibration */
+#define ZD_CR67 CTL_REG(0x010C) /* OFDM 36M calibration */
+#define ZD_CR68 CTL_REG(0x0110) /* CCK calibration */
+#define ZD_CR69 CTL_REG(0x0114)
+#define ZD_CR70 CTL_REG(0x0118)
+#define ZD_CR71 CTL_REG(0x011C)
+#define ZD_CR72 CTL_REG(0x0120)
+#define ZD_CR73 CTL_REG(0x0124)
+#define ZD_CR74 CTL_REG(0x0128)
+#define ZD_CR75 CTL_REG(0x012C)
+#define ZD_CR76 CTL_REG(0x0130)
+#define ZD_CR77 CTL_REG(0x0134)
+#define ZD_CR78 CTL_REG(0x0138)
+#define ZD_CR79 CTL_REG(0x013C)
+#define ZD_CR80 CTL_REG(0x0140)
+#define ZD_CR81 CTL_REG(0x0144)
+#define ZD_CR82 CTL_REG(0x0148)
+#define ZD_CR83 CTL_REG(0x014C)
+#define ZD_CR84 CTL_REG(0x0150)
+#define ZD_CR85 CTL_REG(0x0154)
+#define ZD_CR86 CTL_REG(0x0158)
+#define ZD_CR87 CTL_REG(0x015C)
+#define ZD_CR88 CTL_REG(0x0160)
+#define ZD_CR89 CTL_REG(0x0164)
+#define ZD_CR90 CTL_REG(0x0168)
+#define ZD_CR91 CTL_REG(0x016C)
+#define ZD_CR92 CTL_REG(0x0170)
+#define ZD_CR93 CTL_REG(0x0174)
+#define ZD_CR94 CTL_REG(0x0178)
+#define ZD_CR95 CTL_REG(0x017C)
+#define ZD_CR96 CTL_REG(0x0180)
+#define ZD_CR97 CTL_REG(0x0184)
+#define ZD_CR98 CTL_REG(0x0188)
+#define ZD_CR99 CTL_REG(0x018C)
+#define ZD_CR100 CTL_REG(0x0190)
+#define ZD_CR101 CTL_REG(0x0194)
+#define ZD_CR102 CTL_REG(0x0198)
+#define ZD_CR103 CTL_REG(0x019C)
+#define ZD_CR104 CTL_REG(0x01A0)
+#define ZD_CR105 CTL_REG(0x01A4)
+#define ZD_CR106 CTL_REG(0x01A8)
+#define ZD_CR107 CTL_REG(0x01AC)
+#define ZD_CR108 CTL_REG(0x01B0)
+#define ZD_CR109 CTL_REG(0x01B4)
+#define ZD_CR110 CTL_REG(0x01B8)
+#define ZD_CR111 CTL_REG(0x01BC)
+#define ZD_CR112 CTL_REG(0x01C0)
+#define ZD_CR113 CTL_REG(0x01C4)
+#define ZD_CR114 CTL_REG(0x01C8)
+#define ZD_CR115 CTL_REG(0x01CC)
+#define ZD_CR116 CTL_REG(0x01D0)
+#define ZD_CR117 CTL_REG(0x01D4)
+#define ZD_CR118 CTL_REG(0x01D8)
+#define ZD_CR119 CTL_REG(0x01DC)
+#define ZD_CR120 CTL_REG(0x01E0)
+#define ZD_CR121 CTL_REG(0x01E4)
+#define ZD_CR122 CTL_REG(0x01E8)
+#define ZD_CR123 CTL_REG(0x01EC)
+#define ZD_CR124 CTL_REG(0x01F0)
+#define ZD_CR125 CTL_REG(0x01F4)
+#define ZD_CR126 CTL_REG(0x01F8)
+#define ZD_CR127 CTL_REG(0x01FC)
+#define ZD_CR128 CTL_REG(0x0200)
+#define ZD_CR129 CTL_REG(0x0204)
+#define ZD_CR130 CTL_REG(0x0208)
+#define ZD_CR131 CTL_REG(0x020C)
+#define ZD_CR132 CTL_REG(0x0210)
+#define ZD_CR133 CTL_REG(0x0214)
+#define ZD_CR134 CTL_REG(0x0218)
+#define ZD_CR135 CTL_REG(0x021C)
+#define ZD_CR136 CTL_REG(0x0220)
+#define ZD_CR137 CTL_REG(0x0224)
+#define ZD_CR138 CTL_REG(0x0228)
+#define ZD_CR139 CTL_REG(0x022C)
+#define ZD_CR140 CTL_REG(0x0230)
+#define ZD_CR141 CTL_REG(0x0234)
+#define ZD_CR142 CTL_REG(0x0238)
+#define ZD_CR143 CTL_REG(0x023C)
+#define ZD_CR144 CTL_REG(0x0240)
+#define ZD_CR145 CTL_REG(0x0244)
+#define ZD_CR146 CTL_REG(0x0248)
+#define ZD_CR147 CTL_REG(0x024C)
+#define ZD_CR148 CTL_REG(0x0250)
+#define ZD_CR149 CTL_REG(0x0254)
+#define ZD_CR150 CTL_REG(0x0258)
+#define ZD_CR151 CTL_REG(0x025C)
+#define ZD_CR152 CTL_REG(0x0260)
+#define ZD_CR153 CTL_REG(0x0264)
+#define ZD_CR154 CTL_REG(0x0268)
+#define ZD_CR155 CTL_REG(0x026C)
+#define ZD_CR156 CTL_REG(0x0270)
+#define ZD_CR157 CTL_REG(0x0274)
+#define ZD_CR158 CTL_REG(0x0278)
+#define ZD_CR159 CTL_REG(0x027C)
+#define ZD_CR160 CTL_REG(0x0280)
+#define ZD_CR161 CTL_REG(0x0284)
+#define ZD_CR162 CTL_REG(0x0288)
+#define ZD_CR163 CTL_REG(0x028C)
+#define ZD_CR164 CTL_REG(0x0290)
+#define ZD_CR165 CTL_REG(0x0294)
+#define ZD_CR166 CTL_REG(0x0298)
+#define ZD_CR167 CTL_REG(0x029C)
+#define ZD_CR168 CTL_REG(0x02A0)
+#define ZD_CR169 CTL_REG(0x02A4)
+#define ZD_CR170 CTL_REG(0x02A8)
+#define ZD_CR171 CTL_REG(0x02AC)
+#define ZD_CR172 CTL_REG(0x02B0)
+#define ZD_CR173 CTL_REG(0x02B4)
+#define ZD_CR174 CTL_REG(0x02B8)
+#define ZD_CR175 CTL_REG(0x02BC)
+#define ZD_CR176 CTL_REG(0x02C0)
+#define ZD_CR177 CTL_REG(0x02C4)
+#define ZD_CR178 CTL_REG(0x02C8)
+#define ZD_CR179 CTL_REG(0x02CC)
+#define ZD_CR180 CTL_REG(0x02D0)
+#define ZD_CR181 CTL_REG(0x02D4)
+#define ZD_CR182 CTL_REG(0x02D8)
+#define ZD_CR183 CTL_REG(0x02DC)
+#define ZD_CR184 CTL_REG(0x02E0)
+#define ZD_CR185 CTL_REG(0x02E4)
+#define ZD_CR186 CTL_REG(0x02E8)
+#define ZD_CR187 CTL_REG(0x02EC)
+#define ZD_CR188 CTL_REG(0x02F0)
+#define ZD_CR189 CTL_REG(0x02F4)
+#define ZD_CR190 CTL_REG(0x02F8)
+#define ZD_CR191 CTL_REG(0x02FC)
+#define ZD_CR192 CTL_REG(0x0300)
+#define ZD_CR193 CTL_REG(0x0304)
+#define ZD_CR194 CTL_REG(0x0308)
+#define ZD_CR195 CTL_REG(0x030C)
+#define ZD_CR196 CTL_REG(0x0310)
+#define ZD_CR197 CTL_REG(0x0314)
+#define ZD_CR198 CTL_REG(0x0318)
+#define ZD_CR199 CTL_REG(0x031C)
+#define ZD_CR200 CTL_REG(0x0320)
+#define ZD_CR201 CTL_REG(0x0324)
+#define ZD_CR202 CTL_REG(0x0328)
+#define ZD_CR203 CTL_REG(0x032C) /* I2C bus template value & flash
+ * control
+ */
+#define ZD_CR204 CTL_REG(0x0330)
+#define ZD_CR205 CTL_REG(0x0334)
+#define ZD_CR206 CTL_REG(0x0338)
+#define ZD_CR207 CTL_REG(0x033C)
+#define ZD_CR208 CTL_REG(0x0340)
+#define ZD_CR209 CTL_REG(0x0344)
+#define ZD_CR210 CTL_REG(0x0348)
+#define ZD_CR211 CTL_REG(0x034C)
+#define ZD_CR212 CTL_REG(0x0350)
+#define ZD_CR213 CTL_REG(0x0354)
+#define ZD_CR214 CTL_REG(0x0358)
+#define ZD_CR215 CTL_REG(0x035C)
+#define ZD_CR216 CTL_REG(0x0360)
+#define ZD_CR217 CTL_REG(0x0364)
+#define ZD_CR218 CTL_REG(0x0368)
+#define ZD_CR219 CTL_REG(0x036C)
+#define ZD_CR220 CTL_REG(0x0370)
+#define ZD_CR221 CTL_REG(0x0374)
+#define ZD_CR222 CTL_REG(0x0378)
+#define ZD_CR223 CTL_REG(0x037C)
+#define ZD_CR224 CTL_REG(0x0380)
+#define ZD_CR225 CTL_REG(0x0384)
+#define ZD_CR226 CTL_REG(0x0388)
+#define ZD_CR227 CTL_REG(0x038C)
+#define ZD_CR228 CTL_REG(0x0390)
+#define ZD_CR229 CTL_REG(0x0394)
+#define ZD_CR230 CTL_REG(0x0398)
+#define ZD_CR231 CTL_REG(0x039C)
+#define ZD_CR232 CTL_REG(0x03A0)
+#define ZD_CR233 CTL_REG(0x03A4)
+#define ZD_CR234 CTL_REG(0x03A8)
+#define ZD_CR235 CTL_REG(0x03AC)
+#define ZD_CR236 CTL_REG(0x03B0)
+
+#define ZD_CR240 CTL_REG(0x03C0)
+/* bit 7: host-controlled RF register writes
+ * ZD_CR241-ZD_CR245: for hardware controlled writing of RF bits, not needed for
+ * USB
+ */
+#define ZD_CR241 CTL_REG(0x03C4)
+#define ZD_CR242 CTL_REG(0x03C8)
+#define ZD_CR243 CTL_REG(0x03CC)
+#define ZD_CR244 CTL_REG(0x03D0)
+#define ZD_CR245 CTL_REG(0x03D4)
+
+#define ZD_CR251 CTL_REG(0x03EC) /* only used for activation and
+ * deactivation of Airoha RFs AL2230
+ * and AL7230B
+ */
+#define ZD_CR252 CTL_REG(0x03F0)
+#define ZD_CR253 CTL_REG(0x03F4)
+#define ZD_CR254 CTL_REG(0x03F8)
+#define ZD_CR255 CTL_REG(0x03FC)
+
+#define CR_MAX_PHY_REG 255
+
+/* Taken from the ZYDAS driver, not all of them are relevant for the ZD1211
+ * driver.
+ */
+
+#define CR_RF_IF_CLK CTL_REG(0x0400)
+#define CR_RF_IF_DATA CTL_REG(0x0404)
+#define CR_PE1_PE2 CTL_REG(0x0408)
+#define CR_PE2_DLY CTL_REG(0x040C)
+#define CR_LE1 CTL_REG(0x0410)
+#define CR_LE2 CTL_REG(0x0414)
+/* Seems to enable/disable GPI (General Purpose IO?) */
+#define CR_GPI_EN CTL_REG(0x0418)
+#define CR_RADIO_PD CTL_REG(0x042C)
+#define CR_RF2948_PD CTL_REG(0x042C)
+#define CR_ENABLE_PS_MANUAL_AGC CTL_REG(0x043C)
+#define CR_CONFIG_PHILIPS CTL_REG(0x0440)
+#define CR_SA2400_SER_AP CTL_REG(0x0444)
+#define CR_I2C_WRITE CTL_REG(0x0444)
+#define CR_SA2400_SER_RP CTL_REG(0x0448)
+#define CR_RADIO_PE CTL_REG(0x0458)
+#define CR_RST_BUS_MASTER CTL_REG(0x045C)
+#define CR_RFCFG CTL_REG(0x0464)
+#define CR_HSTSCHG CTL_REG(0x046C)
+#define CR_PHY_ON CTL_REG(0x0474)
+#define CR_RX_DELAY CTL_REG(0x0478)
+#define CR_RX_PE_DELAY CTL_REG(0x047C)
+#define CR_GPIO_1 CTL_REG(0x0490)
+#define CR_GPIO_2 CTL_REG(0x0494)
+#define CR_EncryBufMux CTL_REG(0x04A8)
+#define CR_PS_CTRL CTL_REG(0x0500)
+#define CR_ADDA_PWR_DWN CTL_REG(0x0504)
+#define CR_ADDA_MBIAS_WARMTIME CTL_REG(0x0508)
+#define CR_MAC_PS_STATE CTL_REG(0x050C)
+
+#define CR_INTERRUPT CTL_REG(0x0510)
+#define INT_TX_COMPLETE (1 << 0)
+#define INT_RX_COMPLETE (1 << 1)
+#define INT_RETRY_FAIL (1 << 2)
+#define INT_WAKEUP (1 << 3)
+#define INT_DTIM_NOTIFY (1 << 5)
+#define INT_CFG_NEXT_BCN (1 << 6)
+#define INT_BUS_ABORT (1 << 7)
+#define INT_TX_FIFO_READY (1 << 8)
+#define INT_UART (1 << 9)
+#define INT_TX_COMPLETE_EN (1 << 16)
+#define INT_RX_COMPLETE_EN (1 << 17)
+#define INT_RETRY_FAIL_EN (1 << 18)
+#define INT_WAKEUP_EN (1 << 19)
+#define INT_DTIM_NOTIFY_EN (1 << 21)
+#define INT_CFG_NEXT_BCN_EN (1 << 22)
+#define INT_BUS_ABORT_EN (1 << 23)
+#define INT_TX_FIFO_READY_EN (1 << 24)
+#define INT_UART_EN (1 << 25)
+
+#define CR_TSF_LOW_PART CTL_REG(0x0514)
+#define CR_TSF_HIGH_PART CTL_REG(0x0518)
+
+/* Following three values are in time units (1024us)
+ * Following condition must be met:
+ * atim < tbtt < bcn
+ */
+#define CR_ATIM_WND_PERIOD CTL_REG(0x051C)
+#define CR_BCN_INTERVAL CTL_REG(0x0520)
+#define CR_PRE_TBTT CTL_REG(0x0524)
+/* in units of TU(1024us) */
+
+/* for UART support */
+#define CR_UART_RBR_THR_DLL CTL_REG(0x0540)
+#define CR_UART_DLM_IER CTL_REG(0x0544)
+#define CR_UART_IIR_FCR CTL_REG(0x0548)
+#define CR_UART_LCR CTL_REG(0x054c)
+#define CR_UART_MCR CTL_REG(0x0550)
+#define CR_UART_LSR CTL_REG(0x0554)
+#define CR_UART_MSR CTL_REG(0x0558)
+#define CR_UART_ECR CTL_REG(0x055c)
+#define CR_UART_STATUS CTL_REG(0x0560)
+
+#define CR_PCI_TX_ADDR_P1 CTL_REG(0x0600)
+#define CR_PCI_TX_AddR_P2 CTL_REG(0x0604)
+#define CR_PCI_RX_AddR_P1 CTL_REG(0x0608)
+#define CR_PCI_RX_AddR_P2 CTL_REG(0x060C)
+
+/* must be overwritten if custom MAC address will be used */
+#define CR_MAC_ADDR_P1 CTL_REG(0x0610)
+#define CR_MAC_ADDR_P2 CTL_REG(0x0614)
+#define CR_BSSID_P1 CTL_REG(0x0618)
+#define CR_BSSID_P2 CTL_REG(0x061C)
+#define CR_BCN_PLCP_CFG CTL_REG(0x0620)
+
+/* Group hash table for filtering incoming packets.
+ *
+ * The group hash table is 64 bit large and split over two parts. The first
+ * part is the lower part. The upper 6 bits of the last byte of the target
+ * address are used as index. Packets are received if the hash table bit is
+ * set. This is used for multicast handling, but for broadcasts (address
+ * ff:ff:ff:ff:ff:ff) the highest bit in the second table must also be set.
+ */
+#define CR_GROUP_HASH_P1 CTL_REG(0x0624)
+#define CR_GROUP_HASH_P2 CTL_REG(0x0628)
+
+#define CR_RX_TIMEOUT CTL_REG(0x062C)
+
+/* Basic rates supported by the BSS. When producing ACK or CTS messages, the
+ * device will use a rate in this table that is less than or equal to the rate
+ * of the incoming frame which prompted the response. */
+#define CR_BASIC_RATE_TBL CTL_REG(0x0630)
+#define CR_RATE_1M (1 << 0) /* 802.11b */
+#define CR_RATE_2M (1 << 1) /* 802.11b */
+#define CR_RATE_5_5M (1 << 2) /* 802.11b */
+#define CR_RATE_11M (1 << 3) /* 802.11b */
+#define CR_RATE_6M (1 << 8) /* 802.11g */
+#define CR_RATE_9M (1 << 9) /* 802.11g */
+#define CR_RATE_12M (1 << 10) /* 802.11g */
+#define CR_RATE_18M (1 << 11) /* 802.11g */
+#define CR_RATE_24M (1 << 12) /* 802.11g */
+#define CR_RATE_36M (1 << 13) /* 802.11g */
+#define CR_RATE_48M (1 << 14) /* 802.11g */
+#define CR_RATE_54M (1 << 15) /* 802.11g */
+#define CR_RATES_80211G 0xff00
+#define CR_RATES_80211B 0x000f
+
+/* Mandatory rates required in the BSS. When producing ACK or CTS messages, if
+ * the device could not find an appropriate rate in CR_BASIC_RATE_TBL, it will
+ * look for a rate in this table that is less than or equal to the rate of
+ * the incoming frame. */
+#define CR_MANDATORY_RATE_TBL CTL_REG(0x0634)
+#define CR_RTS_CTS_RATE CTL_REG(0x0638)
+
+/* These are all bit indexes in CR_RTS_CTS_RATE, so remember to shift. */
+#define RTSCTS_SH_RTS_RATE 0
+#define RTSCTS_SH_EXP_CTS_RATE 4
+#define RTSCTS_SH_RTS_MOD_TYPE 8
+#define RTSCTS_SH_RTS_PMB_TYPE 9
+#define RTSCTS_SH_CTS_RATE 16
+#define RTSCTS_SH_CTS_MOD_TYPE 24
+#define RTSCTS_SH_CTS_PMB_TYPE 25
+
+#define CR_WEP_PROTECT CTL_REG(0x063C)
+#define CR_RX_THRESHOLD CTL_REG(0x0640)
+
+/* register for controlling the LEDS */
+#define CR_LED CTL_REG(0x0644)
+/* masks for controlling LEDs */
+#define LED1 (1 << 8)
+#define LED2 (1 << 9)
+#define LED_SW (1 << 10)
+
+/* Seems to indicate that the configuration is over.
+ */
+#define CR_AFTER_PNP CTL_REG(0x0648)
+#define CR_ACK_TIME_80211 CTL_REG(0x0658)
+
+#define CR_RX_OFFSET CTL_REG(0x065c)
+
+#define CR_BCN_LENGTH CTL_REG(0x0664)
+#define CR_PHY_DELAY CTL_REG(0x066C)
+#define CR_BCN_FIFO CTL_REG(0x0670)
+#define CR_SNIFFER_ON CTL_REG(0x0674)
+
+#define CR_ENCRYPTION_TYPE CTL_REG(0x0678)
+#define NO_WEP 0
+#define WEP64 1
+#define WEP128 5
+#define WEP256 6
+#define ENC_SNIFFER 8
+
+#define CR_ZD1211_RETRY_MAX CTL_REG(0x067C)
+
+#define CR_REG1 CTL_REG(0x0680)
+/* Setting the bit UNLOCK_PHY_REGS disallows the write access to physical
+ * registers, so one could argue it is a LOCK bit. But calling it
+ * LOCK_PHY_REGS makes it confusing.
+ */
+#define UNLOCK_PHY_REGS (1 << 7)
+
+#define CR_DEVICE_STATE CTL_REG(0x0684)
+#define CR_UNDERRUN_CNT CTL_REG(0x0688)
+
+#define CR_RX_FILTER CTL_REG(0x068c)
+#define RX_FILTER_ASSOC_REQUEST (1 << 0)
+#define RX_FILTER_ASSOC_RESPONSE (1 << 1)
+#define RX_FILTER_REASSOC_REQUEST (1 << 2)
+#define RX_FILTER_REASSOC_RESPONSE (1 << 3)
+#define RX_FILTER_PROBE_REQUEST (1 << 4)
+#define RX_FILTER_PROBE_RESPONSE (1 << 5)
+/* bits 6 and 7 reserved */
+#define RX_FILTER_BEACON (1 << 8)
+#define RX_FILTER_ATIM (1 << 9)
+#define RX_FILTER_DISASSOC (1 << 10)
+#define RX_FILTER_AUTH (1 << 11)
+#define RX_FILTER_DEAUTH (1 << 12)
+#define RX_FILTER_PSPOLL (1 << 26)
+#define RX_FILTER_RTS (1 << 27)
+#define RX_FILTER_CTS (1 << 28)
+#define RX_FILTER_ACK (1 << 29)
+#define RX_FILTER_CFEND (1 << 30)
+#define RX_FILTER_CFACK (1 << 31)
+
+/* Enable bits for all frames you are interested in. */
+#define STA_RX_FILTER (RX_FILTER_ASSOC_REQUEST | RX_FILTER_ASSOC_RESPONSE | \
+ RX_FILTER_REASSOC_REQUEST | RX_FILTER_REASSOC_RESPONSE | \
+ RX_FILTER_PROBE_REQUEST | RX_FILTER_PROBE_RESPONSE | \
+ (0x3 << 6) /* vendor driver sets these reserved bits */ | \
+ RX_FILTER_BEACON | RX_FILTER_ATIM | RX_FILTER_DISASSOC | \
+ RX_FILTER_AUTH | RX_FILTER_DEAUTH | \
+ (0x7 << 13) /* vendor driver sets these reserved bits */ | \
+ RX_FILTER_PSPOLL | RX_FILTER_ACK) /* 0x2400ffff */
+
+#define RX_FILTER_CTRL (RX_FILTER_RTS | RX_FILTER_CTS | \
+ RX_FILTER_CFEND | RX_FILTER_CFACK)
+
+#define BCN_MODE_AP 0x1000000
+#define BCN_MODE_IBSS 0x2000000
+
+/* Monitor mode sets filter to 0xfffff */
+
+#define CR_ACK_TIMEOUT_EXT CTL_REG(0x0690)
+#define CR_BCN_FIFO_SEMAPHORE CTL_REG(0x0694)
+
+#define CR_IFS_VALUE CTL_REG(0x0698)
+#define IFS_VALUE_DIFS_SH 0
+#define IFS_VALUE_EIFS_SH 12
+#define IFS_VALUE_SIFS_SH 24
+#define IFS_VALUE_DEFAULT (( 50 << IFS_VALUE_DIFS_SH) | \
+ (1148 << IFS_VALUE_EIFS_SH) | \
+ ( 10 << IFS_VALUE_SIFS_SH))
+
+#define CR_RX_TIME_OUT CTL_REG(0x069C)
+#define CR_TOTAL_RX_FRM CTL_REG(0x06A0)
+#define CR_CRC32_CNT CTL_REG(0x06A4)
+#define CR_CRC16_CNT CTL_REG(0x06A8)
+#define CR_DECRYPTION_ERR_UNI CTL_REG(0x06AC)
+#define CR_RX_FIFO_OVERRUN CTL_REG(0x06B0)
+
+#define CR_DECRYPTION_ERR_MUL CTL_REG(0x06BC)
+
+#define CR_NAV_CNT CTL_REG(0x06C4)
+#define CR_NAV_CCA CTL_REG(0x06C8)
+#define CR_RETRY_CNT CTL_REG(0x06CC)
+
+#define CR_READ_TCB_ADDR CTL_REG(0x06E8)
+#define CR_READ_RFD_ADDR CTL_REG(0x06EC)
+#define CR_CWMIN_CWMAX CTL_REG(0x06F0)
+#define CR_TOTAL_TX_FRM CTL_REG(0x06F4)
+
+/* CAM: Continuous Access Mode (power management) */
+#define CR_CAM_MODE CTL_REG(0x0700)
+#define MODE_IBSS 0x0
+#define MODE_AP 0x1
+#define MODE_STA 0x2
+#define MODE_AP_WDS 0x3
+
+#define CR_CAM_ROLL_TB_LOW CTL_REG(0x0704)
+#define CR_CAM_ROLL_TB_HIGH CTL_REG(0x0708)
+#define CR_CAM_ADDRESS CTL_REG(0x070C)
+#define CR_CAM_DATA CTL_REG(0x0710)
+
+#define CR_ROMDIR CTL_REG(0x0714)
+
+#define CR_DECRY_ERR_FLG_LOW CTL_REG(0x0714)
+#define CR_DECRY_ERR_FLG_HIGH CTL_REG(0x0718)
+
+#define CR_WEPKEY0 CTL_REG(0x0720)
+#define CR_WEPKEY1 CTL_REG(0x0724)
+#define CR_WEPKEY2 CTL_REG(0x0728)
+#define CR_WEPKEY3 CTL_REG(0x072C)
+#define CR_WEPKEY4 CTL_REG(0x0730)
+#define CR_WEPKEY5 CTL_REG(0x0734)
+#define CR_WEPKEY6 CTL_REG(0x0738)
+#define CR_WEPKEY7 CTL_REG(0x073C)
+#define CR_WEPKEY8 CTL_REG(0x0740)
+#define CR_WEPKEY9 CTL_REG(0x0744)
+#define CR_WEPKEY10 CTL_REG(0x0748)
+#define CR_WEPKEY11 CTL_REG(0x074C)
+#define CR_WEPKEY12 CTL_REG(0x0750)
+#define CR_WEPKEY13 CTL_REG(0x0754)
+#define CR_WEPKEY14 CTL_REG(0x0758)
+#define CR_WEPKEY15 CTL_REG(0x075c)
+#define CR_TKIP_MODE CTL_REG(0x0760)
+
+#define CR_EEPROM_PROTECT0 CTL_REG(0x0758)
+#define CR_EEPROM_PROTECT1 CTL_REG(0x075C)
+
+#define CR_DBG_FIFO_RD CTL_REG(0x0800)
+#define CR_DBG_SELECT CTL_REG(0x0804)
+#define CR_FIFO_Length CTL_REG(0x0808)
+
+
+#define CR_RSSI_MGC CTL_REG(0x0810)
+
+#define CR_PON CTL_REG(0x0818)
+#define CR_RX_ON CTL_REG(0x081C)
+#define CR_TX_ON CTL_REG(0x0820)
+#define CR_CHIP_EN CTL_REG(0x0824)
+#define CR_LO_SW CTL_REG(0x0828)
+#define CR_TXRX_SW CTL_REG(0x082C)
+#define CR_S_MD CTL_REG(0x0830)
+
+#define CR_USB_DEBUG_PORT CTL_REG(0x0888)
+#define CR_ZD1211B_CWIN_MAX_MIN_AC0 CTL_REG(0x0b00)
+#define CR_ZD1211B_CWIN_MAX_MIN_AC1 CTL_REG(0x0b04)
+#define CR_ZD1211B_CWIN_MAX_MIN_AC2 CTL_REG(0x0b08)
+#define CR_ZD1211B_CWIN_MAX_MIN_AC3 CTL_REG(0x0b0c)
+#define CR_ZD1211B_AIFS_CTL1 CTL_REG(0x0b10)
+#define CR_ZD1211B_AIFS_CTL2 CTL_REG(0x0b14)
+#define CR_ZD1211B_TXOP CTL_REG(0x0b20)
+#define CR_ZD1211B_RETRY_MAX CTL_REG(0x0b28)
+
+/* Value for CR_ZD1211_RETRY_MAX & CR_ZD1211B_RETRY_MAX. Vendor driver uses 2,
+ * we use 0. The first rate is tried (count+2), then all next rates are tried
+ * twice, until 1 Mbits is tried. */
+#define ZD1211_RETRY_COUNT 0
+#define ZD1211B_RETRY_COUNT \
+ (ZD1211_RETRY_COUNT << 0)| \
+ (ZD1211_RETRY_COUNT << 8)| \
+ (ZD1211_RETRY_COUNT << 16)| \
+ (ZD1211_RETRY_COUNT << 24)
+
+/* Used to detect PLL lock */
+#define UW2453_INTR_REG ((zd_addr_t)0x85c1)
+
+#define CWIN_SIZE 0x007f043f
+
+
+#define HWINT_ENABLED \
+ (INT_TX_COMPLETE_EN| \
+ INT_RX_COMPLETE_EN| \
+ INT_RETRY_FAIL_EN| \
+ INT_WAKEUP_EN| \
+ INT_CFG_NEXT_BCN_EN)
+
+#define HWINT_DISABLED 0
+
+#define E2P_PWR_INT_GUARD 8
+#define E2P_CHANNEL_COUNT 14
+
+/* If you compare this addresses with the ZYDAS orignal driver, please notify
+ * that we use word mapping for the EEPROM.
+ */
+
+/*
+ * Upper 16 bit contains the regulatory domain.
+ */
+#define E2P_SUBID E2P_DATA(0x00)
+#define E2P_POD E2P_DATA(0x02)
+#define E2P_MAC_ADDR_P1 E2P_DATA(0x04)
+#define E2P_MAC_ADDR_P2 E2P_DATA(0x06)
+#define E2P_PWR_CAL_VALUE1 E2P_DATA(0x08)
+#define E2P_PWR_CAL_VALUE2 E2P_DATA(0x0a)
+#define E2P_PWR_CAL_VALUE3 E2P_DATA(0x0c)
+#define E2P_PWR_CAL_VALUE4 E2P_DATA(0x0e)
+#define E2P_PWR_INT_VALUE1 E2P_DATA(0x10)
+#define E2P_PWR_INT_VALUE2 E2P_DATA(0x12)
+#define E2P_PWR_INT_VALUE3 E2P_DATA(0x14)
+#define E2P_PWR_INT_VALUE4 E2P_DATA(0x16)
+
+/* Contains a bit for each allowed channel. It gives for Europe (ETSI 0x30)
+ * also only 11 channels. */
+#define E2P_ALLOWED_CHANNEL E2P_DATA(0x18)
+
+#define E2P_DEVICE_VER E2P_DATA(0x20)
+#define E2P_PHY_REG E2P_DATA(0x25)
+#define E2P_36M_CAL_VALUE1 E2P_DATA(0x28)
+#define E2P_36M_CAL_VALUE2 E2P_DATA(0x2a)
+#define E2P_36M_CAL_VALUE3 E2P_DATA(0x2c)
+#define E2P_36M_CAL_VALUE4 E2P_DATA(0x2e)
+#define E2P_11A_INT_VALUE1 E2P_DATA(0x30)
+#define E2P_11A_INT_VALUE2 E2P_DATA(0x32)
+#define E2P_11A_INT_VALUE3 E2P_DATA(0x34)
+#define E2P_11A_INT_VALUE4 E2P_DATA(0x36)
+#define E2P_48M_CAL_VALUE1 E2P_DATA(0x38)
+#define E2P_48M_CAL_VALUE2 E2P_DATA(0x3a)
+#define E2P_48M_CAL_VALUE3 E2P_DATA(0x3c)
+#define E2P_48M_CAL_VALUE4 E2P_DATA(0x3e)
+#define E2P_48M_INT_VALUE1 E2P_DATA(0x40)
+#define E2P_48M_INT_VALUE2 E2P_DATA(0x42)
+#define E2P_48M_INT_VALUE3 E2P_DATA(0x44)
+#define E2P_48M_INT_VALUE4 E2P_DATA(0x46)
+#define E2P_54M_CAL_VALUE1 E2P_DATA(0x48) /* ??? */
+#define E2P_54M_CAL_VALUE2 E2P_DATA(0x4a)
+#define E2P_54M_CAL_VALUE3 E2P_DATA(0x4c)
+#define E2P_54M_CAL_VALUE4 E2P_DATA(0x4e)
+#define E2P_54M_INT_VALUE1 E2P_DATA(0x50)
+#define E2P_54M_INT_VALUE2 E2P_DATA(0x52)
+#define E2P_54M_INT_VALUE3 E2P_DATA(0x54)
+#define E2P_54M_INT_VALUE4 E2P_DATA(0x56)
+
+/* This word contains the base address of the FW_REG_ registers below */
+#define FWRAW_REGS_ADDR FWRAW_DATA(0x1d)
+
+/* All 16 bit values, offset from the address in FWRAW_REGS_ADDR */
+enum {
+ FW_REG_FIRMWARE_VER = 0,
+ /* non-zero if USB high speed connection */
+ FW_REG_USB_SPEED = 1,
+ FW_REG_FIX_TX_RATE = 2,
+ /* Seems to be able to control LEDs over the firmware */
+ FW_REG_LED_LINK_STATUS = 3,
+ FW_REG_SOFT_RESET = 4,
+ FW_REG_FLASH_CHK = 5,
+};
+
+/* Values for FW_LINK_STATUS */
+#define FW_LINK_OFF 0x0
+#define FW_LINK_TX 0x1
+/* 0x2 - link led on? */
+
+enum {
+ /* indices for ofdm_cal_values */
+ OFDM_36M_INDEX = 0,
+ OFDM_48M_INDEX = 1,
+ OFDM_54M_INDEX = 2,
+};
+
+struct zd_chip {
+ struct zd_usb usb;
+ struct zd_rf rf;
+ struct mutex mutex;
+ /* Base address of FW_REG_ registers */
+ zd_addr_t fw_regs_base;
+ /* EepSetPoint in the vendor driver */
+ u8 pwr_cal_values[E2P_CHANNEL_COUNT];
+ /* integration values in the vendor driver */
+ u8 pwr_int_values[E2P_CHANNEL_COUNT];
+ /* SetPointOFDM in the vendor driver */
+ u8 ofdm_cal_values[3][E2P_CHANNEL_COUNT];
+ u16 link_led;
+ unsigned int pa_type:4,
+ patch_cck_gain:1, patch_cr157:1, patch_6m_band_edge:1,
+ new_phy_layout:1, al2230s_bit:1,
+ supports_tx_led:1;
+};
+
+static inline struct zd_chip *zd_usb_to_chip(struct zd_usb *usb)
+{
+ return container_of(usb, struct zd_chip, usb);
+}
+
+static inline struct zd_chip *zd_rf_to_chip(struct zd_rf *rf)
+{
+ return container_of(rf, struct zd_chip, rf);
+}
+
+#define zd_chip_dev(chip) (&(chip)->usb.intf->dev)
+
+void zd_chip_init(struct zd_chip *chip,
+ struct ieee80211_hw *hw,
+ struct usb_interface *intf);
+void zd_chip_clear(struct zd_chip *chip);
+int zd_chip_read_mac_addr_fw(struct zd_chip *chip, u8 *addr);
+int zd_chip_init_hw(struct zd_chip *chip);
+int zd_chip_reset(struct zd_chip *chip);
+
+static inline int zd_chip_is_zd1211b(struct zd_chip *chip)
+{
+ return chip->usb.is_zd1211b;
+}
+
+static inline int zd_ioread16v_locked(struct zd_chip *chip, u16 *values,
+ const zd_addr_t *addresses,
+ unsigned int count)
+{
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_usb_ioread16v(&chip->usb, values, addresses, count);
+}
+
+static inline int zd_ioread16_locked(struct zd_chip *chip, u16 *value,
+ const zd_addr_t addr)
+{
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_usb_ioread16(&chip->usb, value, addr);
+}
+
+int zd_ioread32v_locked(struct zd_chip *chip, u32 *values,
+ const zd_addr_t *addresses, unsigned int count);
+
+static inline int zd_ioread32_locked(struct zd_chip *chip, u32 *value,
+ const zd_addr_t addr)
+{
+ return zd_ioread32v_locked(chip, value, &addr, 1);
+}
+
+static inline int zd_iowrite16_locked(struct zd_chip *chip, u16 value,
+ zd_addr_t addr)
+{
+ struct zd_ioreq16 ioreq;
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ ioreq.addr = addr;
+ ioreq.value = value;
+
+ return zd_usb_iowrite16v(&chip->usb, &ioreq, 1);
+}
+
+int zd_iowrite16a_locked(struct zd_chip *chip,
+ const struct zd_ioreq16 *ioreqs, unsigned int count);
+
+int _zd_iowrite32v_locked(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
+ unsigned int count);
+
+static inline int zd_iowrite32_locked(struct zd_chip *chip, u32 value,
+ zd_addr_t addr)
+{
+ struct zd_ioreq32 ioreq;
+
+ ioreq.addr = addr;
+ ioreq.value = value;
+
+ return _zd_iowrite32v_locked(chip, &ioreq, 1);
+}
+
+int zd_iowrite32a_locked(struct zd_chip *chip,
+ const struct zd_ioreq32 *ioreqs, unsigned int count);
+
+static inline int zd_rfwrite_locked(struct zd_chip *chip, u32 value, u8 bits)
+{
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ return zd_usb_rfwrite(&chip->usb, value, bits);
+}
+
+int zd_rfwrite_cr_locked(struct zd_chip *chip, u32 value);
+
+int zd_rfwritev_locked(struct zd_chip *chip,
+ const u32* values, unsigned int count, u8 bits);
+int zd_rfwritev_cr_locked(struct zd_chip *chip,
+ const u32* values, unsigned int count);
+
+/* Locking functions for reading and writing registers.
+ * The different parameters are intentional.
+ */
+int zd_ioread16(struct zd_chip *chip, zd_addr_t addr, u16 *value);
+int zd_iowrite16(struct zd_chip *chip, zd_addr_t addr, u16 value);
+int zd_ioread32(struct zd_chip *chip, zd_addr_t addr, u32 *value);
+int zd_iowrite32(struct zd_chip *chip, zd_addr_t addr, u32 value);
+int zd_ioread32v(struct zd_chip *chip, const zd_addr_t *addresses,
+ u32 *values, unsigned int count);
+int zd_iowrite32a(struct zd_chip *chip, const struct zd_ioreq32 *ioreqs,
+ unsigned int count);
+
+int zd_chip_set_channel(struct zd_chip *chip, u8 channel);
+static inline u8 _zd_chip_get_channel(struct zd_chip *chip)
+{
+ return chip->rf.channel;
+}
+u8 zd_chip_get_channel(struct zd_chip *chip);
+int zd_read_regdomain(struct zd_chip *chip, u8 *regdomain);
+int zd_write_mac_addr(struct zd_chip *chip, const u8 *mac_addr);
+int zd_write_bssid(struct zd_chip *chip, const u8 *bssid);
+int zd_chip_switch_radio_on(struct zd_chip *chip);
+int zd_chip_switch_radio_off(struct zd_chip *chip);
+int zd_chip_enable_int(struct zd_chip *chip);
+void zd_chip_disable_int(struct zd_chip *chip);
+int zd_chip_enable_rxtx(struct zd_chip *chip);
+void zd_chip_disable_rxtx(struct zd_chip *chip);
+int zd_chip_enable_hwint(struct zd_chip *chip);
+int zd_chip_disable_hwint(struct zd_chip *chip);
+int zd_chip_generic_patch_6m_band(struct zd_chip *chip, int channel);
+int zd_chip_set_rts_cts_rate_locked(struct zd_chip *chip, int preamble);
+
+static inline int zd_get_encryption_type(struct zd_chip *chip, u32 *type)
+{
+ return zd_ioread32(chip, CR_ENCRYPTION_TYPE, type);
+}
+
+static inline int zd_set_encryption_type(struct zd_chip *chip, u32 type)
+{
+ return zd_iowrite32(chip, CR_ENCRYPTION_TYPE, type);
+}
+
+static inline int zd_chip_get_basic_rates(struct zd_chip *chip, u16 *cr_rates)
+{
+ return zd_ioread16(chip, CR_BASIC_RATE_TBL, cr_rates);
+}
+
+int zd_chip_set_basic_rates(struct zd_chip *chip, u16 cr_rates);
+
+int zd_chip_lock_phy_regs(struct zd_chip *chip);
+int zd_chip_unlock_phy_regs(struct zd_chip *chip);
+
+enum led_status {
+ ZD_LED_OFF = 0,
+ ZD_LED_SCANNING = 1,
+ ZD_LED_ASSOCIATED = 2,
+};
+
+int zd_chip_control_leds(struct zd_chip *chip, enum led_status status);
+
+int zd_set_beacon_interval(struct zd_chip *chip, u16 interval, u8 dtim_period,
+ int type);
+
+static inline int zd_get_beacon_interval(struct zd_chip *chip, u32 *interval)
+{
+ return zd_ioread32(chip, CR_BCN_INTERVAL, interval);
+}
+
+struct rx_status;
+
+u8 zd_rx_rate(const void *rx_frame, const struct rx_status *status);
+
+struct zd_mc_hash {
+ u32 low;
+ u32 high;
+};
+
+static inline void zd_mc_clear(struct zd_mc_hash *hash)
+{
+ hash->low = 0;
+ /* The interfaces must always received broadcasts.
+ * The hash of the broadcast address ff:ff:ff:ff:ff:ff is 63.
+ */
+ hash->high = 0x80000000;
+}
+
+static inline void zd_mc_add_all(struct zd_mc_hash *hash)
+{
+ hash->low = hash->high = 0xffffffff;
+}
+
+static inline void zd_mc_add_addr(struct zd_mc_hash *hash, u8 *addr)
+{
+ unsigned int i = addr[5] >> 2;
+ if (i < 32) {
+ hash->low |= 1 << i;
+ } else {
+ hash->high |= 1 << (i-32);
+ }
+}
+
+int zd_chip_set_multicast_hash(struct zd_chip *chip,
+ struct zd_mc_hash *hash);
+
+u64 zd_chip_get_tsf(struct zd_chip *chip);
+
+#endif /* _ZD_CHIP_H */
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ZD_DEF_H
+#define _ZD_DEF_H
+
+#include <linux/kernel.h>
+#include <linux/stringify.h>
+#include <linux/device.h>
+
+typedef u16 __nocast zd_addr_t;
+
+#define dev_printk_f(level, dev, fmt, args...) \
+ dev_printk(level, dev, "%s() " fmt, __func__, ##args)
+
+#ifdef DEBUG
+# define dev_dbg_f(dev, fmt, args...) \
+ dev_printk_f(KERN_DEBUG, dev, fmt, ## args)
+# define dev_dbg_f_limit(dev, fmt, args...) do { \
+ if (net_ratelimit()) \
+ dev_printk_f(KERN_DEBUG, dev, fmt, ## args); \
+} while (0)
+# define dev_dbg_f_cond(dev, cond, fmt, args...) ({ \
+ bool __cond = !!(cond); \
+ if (unlikely(__cond)) \
+ dev_printk_f(KERN_DEBUG, dev, fmt, ## args); \
+})
+#else
+# define dev_dbg_f(dev, fmt, args...) do { (void)(dev); } while (0)
+# define dev_dbg_f_limit(dev, fmt, args...) do { (void)(dev); } while (0)
+# define dev_dbg_f_cond(dev, cond, fmt, args...) do { (void)(dev); } while (0)
+#endif /* DEBUG */
+
+#ifdef DEBUG
+# define ZD_ASSERT(x) \
+do { \
+ if (unlikely(!(x))) { \
+ pr_debug("%s:%d ASSERT %s VIOLATED!\n", \
+ __FILE__, __LINE__, __stringify(x)); \
+ dump_stack(); \
+ } \
+} while (0)
+#else
+# define ZD_ASSERT(x) do { } while (0)
+#endif
+
+#ifdef DEBUG
+# define ZD_MEMCLEAR(pointer, size) memset((pointer), 0xff, (size))
+#else
+# define ZD_MEMCLEAR(pointer, size) do { } while (0)
+#endif
+
+#endif /* _ZD_DEF_H */
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
+ * Copyright (C) 2007-2008 Luis R. Rodriguez <mcgrof@winlab.rutgers.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/jiffies.h>
+#include <net/ieee80211_radiotap.h>
+
+#include "zd_def.h"
+#include "zd_chip.h"
+#include "zd_mac.h"
+#include "zd_rf.h"
+
+struct zd_reg_alpha2_map {
+ u32 reg;
+ char alpha2[2];
+};
+
+static struct zd_reg_alpha2_map reg_alpha2_map[] = {
+ { ZD_REGDOMAIN_FCC, "US" },
+ { ZD_REGDOMAIN_IC, "CA" },
+ { ZD_REGDOMAIN_ETSI, "DE" }, /* Generic ETSI, use most restrictive */
+ { ZD_REGDOMAIN_JAPAN, "JP" },
+ { ZD_REGDOMAIN_JAPAN_2, "JP" },
+ { ZD_REGDOMAIN_JAPAN_3, "JP" },
+ { ZD_REGDOMAIN_SPAIN, "ES" },
+ { ZD_REGDOMAIN_FRANCE, "FR" },
+};
+
+/* This table contains the hardware specific values for the modulation rates. */
+static const struct ieee80211_rate zd_rates[] = {
+ { .bitrate = 10,
+ .hw_value = ZD_CCK_RATE_1M, },
+ { .bitrate = 20,
+ .hw_value = ZD_CCK_RATE_2M,
+ .hw_value_short = ZD_CCK_RATE_2M | ZD_CCK_PREA_SHORT,
+ .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+ { .bitrate = 55,
+ .hw_value = ZD_CCK_RATE_5_5M,
+ .hw_value_short = ZD_CCK_RATE_5_5M | ZD_CCK_PREA_SHORT,
+ .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+ { .bitrate = 110,
+ .hw_value = ZD_CCK_RATE_11M,
+ .hw_value_short = ZD_CCK_RATE_11M | ZD_CCK_PREA_SHORT,
+ .flags = IEEE80211_RATE_SHORT_PREAMBLE },
+ { .bitrate = 60,
+ .hw_value = ZD_OFDM_RATE_6M,
+ .flags = 0 },
+ { .bitrate = 90,
+ .hw_value = ZD_OFDM_RATE_9M,
+ .flags = 0 },
+ { .bitrate = 120,
+ .hw_value = ZD_OFDM_RATE_12M,
+ .flags = 0 },
+ { .bitrate = 180,
+ .hw_value = ZD_OFDM_RATE_18M,
+ .flags = 0 },
+ { .bitrate = 240,
+ .hw_value = ZD_OFDM_RATE_24M,
+ .flags = 0 },
+ { .bitrate = 360,
+ .hw_value = ZD_OFDM_RATE_36M,
+ .flags = 0 },
+ { .bitrate = 480,
+ .hw_value = ZD_OFDM_RATE_48M,
+ .flags = 0 },
+ { .bitrate = 540,
+ .hw_value = ZD_OFDM_RATE_54M,
+ .flags = 0 },
+};
+
+/*
+ * Zydas retry rates table. Each line is listed in the same order as
+ * in zd_rates[] and contains all the rate used when a packet is sent
+ * starting with a given rates. Let's consider an example :
+ *
+ * "11 Mbits : 4, 3, 2, 1, 0" means :
+ * - packet is sent using 4 different rates
+ * - 1st rate is index 3 (ie 11 Mbits)
+ * - 2nd rate is index 2 (ie 5.5 Mbits)
+ * - 3rd rate is index 1 (ie 2 Mbits)
+ * - 4th rate is index 0 (ie 1 Mbits)
+ */
+
+static const struct tx_retry_rate zd_retry_rates[] = {
+ { /* 1 Mbits */ 1, { 0 }},
+ { /* 2 Mbits */ 2, { 1, 0 }},
+ { /* 5.5 Mbits */ 3, { 2, 1, 0 }},
+ { /* 11 Mbits */ 4, { 3, 2, 1, 0 }},
+ { /* 6 Mbits */ 5, { 4, 3, 2, 1, 0 }},
+ { /* 9 Mbits */ 6, { 5, 4, 3, 2, 1, 0}},
+ { /* 12 Mbits */ 5, { 6, 3, 2, 1, 0 }},
+ { /* 18 Mbits */ 6, { 7, 6, 3, 2, 1, 0 }},
+ { /* 24 Mbits */ 6, { 8, 6, 3, 2, 1, 0 }},
+ { /* 36 Mbits */ 7, { 9, 8, 6, 3, 2, 1, 0 }},
+ { /* 48 Mbits */ 8, {10, 9, 8, 6, 3, 2, 1, 0 }},
+ { /* 54 Mbits */ 9, {11, 10, 9, 8, 6, 3, 2, 1, 0 }}
+};
+
+static const struct ieee80211_channel zd_channels[] = {
+ { .center_freq = 2412, .hw_value = 1 },
+ { .center_freq = 2417, .hw_value = 2 },
+ { .center_freq = 2422, .hw_value = 3 },
+ { .center_freq = 2427, .hw_value = 4 },
+ { .center_freq = 2432, .hw_value = 5 },
+ { .center_freq = 2437, .hw_value = 6 },
+ { .center_freq = 2442, .hw_value = 7 },
+ { .center_freq = 2447, .hw_value = 8 },
+ { .center_freq = 2452, .hw_value = 9 },
+ { .center_freq = 2457, .hw_value = 10 },
+ { .center_freq = 2462, .hw_value = 11 },
+ { .center_freq = 2467, .hw_value = 12 },
+ { .center_freq = 2472, .hw_value = 13 },
+ { .center_freq = 2484, .hw_value = 14 },
+};
+
+static void housekeeping_init(struct zd_mac *mac);
+static void housekeeping_enable(struct zd_mac *mac);
+static void housekeeping_disable(struct zd_mac *mac);
+static void beacon_init(struct zd_mac *mac);
+static void beacon_enable(struct zd_mac *mac);
+static void beacon_disable(struct zd_mac *mac);
+static void set_rts_cts(struct zd_mac *mac, unsigned int short_preamble);
+static int zd_mac_config_beacon(struct ieee80211_hw *hw,
+ struct sk_buff *beacon, bool in_intr);
+
+static int zd_reg2alpha2(u8 regdomain, char *alpha2)
+{
+ unsigned int i;
+ struct zd_reg_alpha2_map *reg_map;
+ for (i = 0; i < ARRAY_SIZE(reg_alpha2_map); i++) {
+ reg_map = ®_alpha2_map[i];
+ if (regdomain == reg_map->reg) {
+ alpha2[0] = reg_map->alpha2[0];
+ alpha2[1] = reg_map->alpha2[1];
+ return 0;
+ }
+ }
+ return 1;
+}
+
+static int zd_check_signal(struct ieee80211_hw *hw, int signal)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+
+ dev_dbg_f_cond(zd_mac_dev(mac), signal < 0 || signal > 100,
+ "%s: signal value from device not in range 0..100, "
+ "but %d.\n", __func__, signal);
+
+ if (signal < 0)
+ signal = 0;
+ else if (signal > 100)
+ signal = 100;
+
+ return signal;
+}
+
+int zd_mac_preinit_hw(struct ieee80211_hw *hw)
+{
+ int r;
+ u8 addr[ETH_ALEN];
+ struct zd_mac *mac = zd_hw_mac(hw);
+
+ r = zd_chip_read_mac_addr_fw(&mac->chip, addr);
+ if (r)
+ return r;
+
+ SET_IEEE80211_PERM_ADDR(hw, addr);
+
+ return 0;
+}
+
+int zd_mac_init_hw(struct ieee80211_hw *hw)
+{
+ int r;
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct zd_chip *chip = &mac->chip;
+ char alpha2[2];
+ u8 default_regdomain;
+
+ r = zd_chip_enable_int(chip);
+ if (r)
+ goto out;
+ r = zd_chip_init_hw(chip);
+ if (r)
+ goto disable_int;
+
+ ZD_ASSERT(!irqs_disabled());
+
+ r = zd_read_regdomain(chip, &default_regdomain);
+ if (r)
+ goto disable_int;
+ spin_lock_irq(&mac->lock);
+ mac->regdomain = mac->default_regdomain = default_regdomain;
+ spin_unlock_irq(&mac->lock);
+
+ /* We must inform the device that we are doing encryption/decryption in
+ * software at the moment. */
+ r = zd_set_encryption_type(chip, ENC_SNIFFER);
+ if (r)
+ goto disable_int;
+
+ r = zd_reg2alpha2(mac->regdomain, alpha2);
+ if (r)
+ goto disable_int;
+
+ r = regulatory_hint(hw->wiphy, alpha2);
+disable_int:
+ zd_chip_disable_int(chip);
+out:
+ return r;
+}
+
+void zd_mac_clear(struct zd_mac *mac)
+{
+ flush_workqueue(zd_workqueue);
+ zd_chip_clear(&mac->chip);
+ ZD_ASSERT(!spin_is_locked(&mac->lock));
+ ZD_MEMCLEAR(mac, sizeof(struct zd_mac));
+}
+
+static int set_rx_filter(struct zd_mac *mac)
+{
+ unsigned long flags;
+ u32 filter = STA_RX_FILTER;
+
+ spin_lock_irqsave(&mac->lock, flags);
+ if (mac->pass_ctrl)
+ filter |= RX_FILTER_CTRL;
+ spin_unlock_irqrestore(&mac->lock, flags);
+
+ return zd_iowrite32(&mac->chip, CR_RX_FILTER, filter);
+}
+
+static int set_mac_and_bssid(struct zd_mac *mac)
+{
+ int r;
+
+ if (!mac->vif)
+ return -1;
+
+ r = zd_write_mac_addr(&mac->chip, mac->vif->addr);
+ if (r)
+ return r;
+
+ /* Vendor driver after setting MAC either sets BSSID for AP or
+ * filter for other modes.
+ */
+ if (mac->type != NL80211_IFTYPE_AP)
+ return set_rx_filter(mac);
+ else
+ return zd_write_bssid(&mac->chip, mac->vif->addr);
+}
+
+static int set_mc_hash(struct zd_mac *mac)
+{
+ struct zd_mc_hash hash;
+ zd_mc_clear(&hash);
+ return zd_chip_set_multicast_hash(&mac->chip, &hash);
+}
+
+int zd_op_start(struct ieee80211_hw *hw)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct zd_chip *chip = &mac->chip;
+ struct zd_usb *usb = &chip->usb;
+ int r;
+
+ if (!usb->initialized) {
+ r = zd_usb_init_hw(usb);
+ if (r)
+ goto out;
+ }
+
+ r = zd_chip_enable_int(chip);
+ if (r < 0)
+ goto out;
+
+ r = zd_chip_set_basic_rates(chip, CR_RATES_80211B | CR_RATES_80211G);
+ if (r < 0)
+ goto disable_int;
+ r = set_rx_filter(mac);
+ if (r)
+ goto disable_int;
+ r = set_mc_hash(mac);
+ if (r)
+ goto disable_int;
+
+ /* Wait after setting the multicast hash table and powering on
+ * the radio otherwise interface bring up will fail. This matches
+ * what the vendor driver did.
+ */
+ msleep(10);
+
+ r = zd_chip_switch_radio_on(chip);
+ if (r < 0) {
+ dev_err(zd_chip_dev(chip),
+ "%s: failed to set radio on\n", __func__);
+ goto disable_int;
+ }
+ r = zd_chip_enable_rxtx(chip);
+ if (r < 0)
+ goto disable_radio;
+ r = zd_chip_enable_hwint(chip);
+ if (r < 0)
+ goto disable_rxtx;
+
+ housekeeping_enable(mac);
+ beacon_enable(mac);
+ set_bit(ZD_DEVICE_RUNNING, &mac->flags);
+ return 0;
+disable_rxtx:
+ zd_chip_disable_rxtx(chip);
+disable_radio:
+ zd_chip_switch_radio_off(chip);
+disable_int:
+ zd_chip_disable_int(chip);
+out:
+ return r;
+}
+
+void zd_op_stop(struct ieee80211_hw *hw)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct zd_chip *chip = &mac->chip;
+ struct sk_buff *skb;
+ struct sk_buff_head *ack_wait_queue = &mac->ack_wait_queue;
+
+ clear_bit(ZD_DEVICE_RUNNING, &mac->flags);
+
+ /* The order here deliberately is a little different from the open()
+ * method, since we need to make sure there is no opportunity for RX
+ * frames to be processed by mac80211 after we have stopped it.
+ */
+
+ zd_chip_disable_rxtx(chip);
+ beacon_disable(mac);
+ housekeeping_disable(mac);
+ flush_workqueue(zd_workqueue);
+
+ zd_chip_disable_hwint(chip);
+ zd_chip_switch_radio_off(chip);
+ zd_chip_disable_int(chip);
+
+
+ while ((skb = skb_dequeue(ack_wait_queue)))
+ dev_kfree_skb_any(skb);
+}
+
+int zd_restore_settings(struct zd_mac *mac)
+{
+ struct sk_buff *beacon;
+ struct zd_mc_hash multicast_hash;
+ unsigned int short_preamble;
+ int r, beacon_interval, beacon_period;
+ u8 channel;
+
+ dev_dbg_f(zd_mac_dev(mac), "\n");
+
+ spin_lock_irq(&mac->lock);
+ multicast_hash = mac->multicast_hash;
+ short_preamble = mac->short_preamble;
+ beacon_interval = mac->beacon.interval;
+ beacon_period = mac->beacon.period;
+ channel = mac->channel;
+ spin_unlock_irq(&mac->lock);
+
+ r = set_mac_and_bssid(mac);
+ if (r < 0) {
+ dev_dbg_f(zd_mac_dev(mac), "set_mac_and_bssid failed, %d\n", r);
+ return r;
+ }
+
+ r = zd_chip_set_channel(&mac->chip, channel);
+ if (r < 0) {
+ dev_dbg_f(zd_mac_dev(mac), "zd_chip_set_channel failed, %d\n",
+ r);
+ return r;
+ }
+
+ set_rts_cts(mac, short_preamble);
+
+ r = zd_chip_set_multicast_hash(&mac->chip, &multicast_hash);
+ if (r < 0) {
+ dev_dbg_f(zd_mac_dev(mac),
+ "zd_chip_set_multicast_hash failed, %d\n", r);
+ return r;
+ }
+
+ if (mac->type == NL80211_IFTYPE_MESH_POINT ||
+ mac->type == NL80211_IFTYPE_ADHOC ||
+ mac->type == NL80211_IFTYPE_AP) {
+ if (mac->vif != NULL) {
+ beacon = ieee80211_beacon_get(mac->hw, mac->vif);
+ if (beacon)
+ zd_mac_config_beacon(mac->hw, beacon, false);
+ }
+
+ zd_set_beacon_interval(&mac->chip, beacon_interval,
+ beacon_period, mac->type);
+
+ spin_lock_irq(&mac->lock);
+ mac->beacon.last_update = jiffies;
+ spin_unlock_irq(&mac->lock);
+ }
+
+ return 0;
+}
+
+/**
+ * zd_mac_tx_status - reports tx status of a packet if required
+ * @hw - a &struct ieee80211_hw pointer
+ * @skb - a sk-buffer
+ * @flags: extra flags to set in the TX status info
+ * @ackssi: ACK signal strength
+ * @success - True for successful transmission of the frame
+ *
+ * This information calls ieee80211_tx_status_irqsafe() if required by the
+ * control information. It copies the control information into the status
+ * information.
+ *
+ * If no status information has been requested, the skb is freed.
+ */
+static void zd_mac_tx_status(struct ieee80211_hw *hw, struct sk_buff *skb,
+ int ackssi, struct tx_status *tx_status)
+{
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ int i;
+ int success = 1, retry = 1;
+ int first_idx;
+ const struct tx_retry_rate *retries;
+
+ ieee80211_tx_info_clear_status(info);
+
+ if (tx_status) {
+ success = !tx_status->failure;
+ retry = tx_status->retry + success;
+ }
+
+ if (success) {
+ /* success */
+ info->flags |= IEEE80211_TX_STAT_ACK;
+ } else {
+ /* failure */
+ info->flags &= ~IEEE80211_TX_STAT_ACK;
+ }
+
+ first_idx = info->status.rates[0].idx;
+ ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
+ retries = &zd_retry_rates[first_idx];
+ ZD_ASSERT(1 <= retry && retry <= retries->count);
+
+ info->status.rates[0].idx = retries->rate[0];
+ info->status.rates[0].count = 1; // (retry > 1 ? 2 : 1);
+
+ for (i=1; i<IEEE80211_TX_MAX_RATES-1 && i<retry; i++) {
+ info->status.rates[i].idx = retries->rate[i];
+ info->status.rates[i].count = 1; // ((i==retry-1) && success ? 1:2);
+ }
+ for (; i<IEEE80211_TX_MAX_RATES && i<retry; i++) {
+ info->status.rates[i].idx = retries->rate[retry - 1];
+ info->status.rates[i].count = 1; // (success ? 1:2);
+ }
+ if (i<IEEE80211_TX_MAX_RATES)
+ info->status.rates[i].idx = -1; /* terminate */
+
+ info->status.ack_signal = zd_check_signal(hw, ackssi);
+ ieee80211_tx_status_irqsafe(hw, skb);
+}
+
+/**
+ * zd_mac_tx_failed - callback for failed frames
+ * @dev: the mac80211 wireless device
+ *
+ * This function is called if a frame couldn't be successfully
+ * transferred. The first frame from the tx queue, will be selected and
+ * reported as error to the upper layers.
+ */
+void zd_mac_tx_failed(struct urb *urb)
+{
+ struct ieee80211_hw * hw = zd_usb_to_hw(urb->context);
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct sk_buff_head *q = &mac->ack_wait_queue;
+ struct sk_buff *skb;
+ struct tx_status *tx_status = (struct tx_status *)urb->transfer_buffer;
+ unsigned long flags;
+ int success = !tx_status->failure;
+ int retry = tx_status->retry + success;
+ int found = 0;
+ int i, position = 0;
+
+ q = &mac->ack_wait_queue;
+ spin_lock_irqsave(&q->lock, flags);
+
+ skb_queue_walk(q, skb) {
+ struct ieee80211_hdr *tx_hdr;
+ struct ieee80211_tx_info *info;
+ int first_idx, final_idx;
+ const struct tx_retry_rate *retries;
+ u8 final_rate;
+
+ position ++;
+
+ /* if the hardware reports a failure and we had a 802.11 ACK
+ * pending, then we skip the first skb when searching for a
+ * matching frame */
+ if (tx_status->failure && mac->ack_pending &&
+ skb_queue_is_first(q, skb)) {
+ continue;
+ }
+
+ tx_hdr = (struct ieee80211_hdr *)skb->data;
+
+ /* we skip all frames not matching the reported destination */
+ if (unlikely(!ether_addr_equal(tx_hdr->addr1, tx_status->mac)))
+ continue;
+
+ /* we skip all frames not matching the reported final rate */
+
+ info = IEEE80211_SKB_CB(skb);
+ first_idx = info->status.rates[0].idx;
+ ZD_ASSERT(0<=first_idx && first_idx<ARRAY_SIZE(zd_retry_rates));
+ retries = &zd_retry_rates[first_idx];
+ if (retry <= 0 || retry > retries->count)
+ continue;
+
+ final_idx = retries->rate[retry - 1];
+ final_rate = zd_rates[final_idx].hw_value;
+
+ if (final_rate != tx_status->rate) {
+ continue;
+ }
+
+ found = 1;
+ break;
+ }
+
+ if (found) {
+ for (i=1; i<=position; i++) {
+ skb = __skb_dequeue(q);
+ zd_mac_tx_status(hw, skb,
+ mac->ack_pending ? mac->ack_signal : 0,
+ i == position ? tx_status : NULL);
+ mac->ack_pending = 0;
+ }
+ }
+
+ spin_unlock_irqrestore(&q->lock, flags);
+}
+
+/**
+ * zd_mac_tx_to_dev - callback for USB layer
+ * @skb: a &sk_buff pointer
+ * @error: error value, 0 if transmission successful
+ *
+ * Informs the MAC layer that the frame has successfully transferred to the
+ * device. If an ACK is required and the transfer to the device has been
+ * successful, the packets are put on the @ack_wait_queue with
+ * the control set removed.
+ */
+void zd_mac_tx_to_dev(struct sk_buff *skb, int error)
+{
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ struct ieee80211_hw *hw = info->rate_driver_data[0];
+ struct zd_mac *mac = zd_hw_mac(hw);
+
+ ieee80211_tx_info_clear_status(info);
+
+ skb_pull(skb, sizeof(struct zd_ctrlset));
+ if (unlikely(error ||
+ (info->flags & IEEE80211_TX_CTL_NO_ACK))) {
+ /*
+ * FIXME : do we need to fill in anything ?
+ */
+ ieee80211_tx_status_irqsafe(hw, skb);
+ } else {
+ struct sk_buff_head *q = &mac->ack_wait_queue;
+
+ skb_queue_tail(q, skb);
+ while (skb_queue_len(q) > ZD_MAC_MAX_ACK_WAITERS) {
+ zd_mac_tx_status(hw, skb_dequeue(q),
+ mac->ack_pending ? mac->ack_signal : 0,
+ NULL);
+ mac->ack_pending = 0;
+ }
+ }
+}
+
+static int zd_calc_tx_length_us(u8 *service, u8 zd_rate, u16 tx_length)
+{
+ /* ZD_PURE_RATE() must be used to remove the modulation type flag of
+ * the zd-rate values.
+ */
+ static const u8 rate_divisor[] = {
+ [ZD_PURE_RATE(ZD_CCK_RATE_1M)] = 1,
+ [ZD_PURE_RATE(ZD_CCK_RATE_2M)] = 2,
+ /* Bits must be doubled. */
+ [ZD_PURE_RATE(ZD_CCK_RATE_5_5M)] = 11,
+ [ZD_PURE_RATE(ZD_CCK_RATE_11M)] = 11,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_6M)] = 6,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_9M)] = 9,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_12M)] = 12,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_18M)] = 18,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_24M)] = 24,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_36M)] = 36,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_48M)] = 48,
+ [ZD_PURE_RATE(ZD_OFDM_RATE_54M)] = 54,
+ };
+
+ u32 bits = (u32)tx_length * 8;
+ u32 divisor;
+
+ divisor = rate_divisor[ZD_PURE_RATE(zd_rate)];
+ if (divisor == 0)
+ return -EINVAL;
+
+ switch (zd_rate) {
+ case ZD_CCK_RATE_5_5M:
+ bits = (2*bits) + 10; /* round up to the next integer */
+ break;
+ case ZD_CCK_RATE_11M:
+ if (service) {
+ u32 t = bits % 11;
+ *service &= ~ZD_PLCP_SERVICE_LENGTH_EXTENSION;
+ if (0 < t && t <= 3) {
+ *service |= ZD_PLCP_SERVICE_LENGTH_EXTENSION;
+ }
+ }
+ bits += 10; /* round up to the next integer */
+ break;
+ }
+
+ return bits/divisor;
+}
+
+static void cs_set_control(struct zd_mac *mac, struct zd_ctrlset *cs,
+ struct ieee80211_hdr *header,
+ struct ieee80211_tx_info *info)
+{
+ /*
+ * CONTROL TODO:
+ * - if backoff needed, enable bit 0
+ * - if burst (backoff not needed) disable bit 0
+ */
+
+ cs->control = 0;
+
+ /* First fragment */
+ if (info->flags & IEEE80211_TX_CTL_FIRST_FRAGMENT)
+ cs->control |= ZD_CS_NEED_RANDOM_BACKOFF;
+
+ /* No ACK expected (multicast, etc.) */
+ if (info->flags & IEEE80211_TX_CTL_NO_ACK)
+ cs->control |= ZD_CS_NO_ACK;
+
+ /* PS-POLL */
+ if (ieee80211_is_pspoll(header->frame_control))
+ cs->control |= ZD_CS_PS_POLL_FRAME;
+
+ if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS)
+ cs->control |= ZD_CS_RTS;
+
+ if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT)
+ cs->control |= ZD_CS_SELF_CTS;
+
+ /* FIXME: Management frame? */
+}
+
+static bool zd_mac_match_cur_beacon(struct zd_mac *mac, struct sk_buff *beacon)
+{
+ if (!mac->beacon.cur_beacon)
+ return false;
+
+ if (mac->beacon.cur_beacon->len != beacon->len)
+ return false;
+
+ return !memcmp(beacon->data, mac->beacon.cur_beacon->data, beacon->len);
+}
+
+static void zd_mac_free_cur_beacon_locked(struct zd_mac *mac)
+{
+ ZD_ASSERT(mutex_is_locked(&mac->chip.mutex));
+
+ kfree_skb(mac->beacon.cur_beacon);
+ mac->beacon.cur_beacon = NULL;
+}
+
+static void zd_mac_free_cur_beacon(struct zd_mac *mac)
+{
+ mutex_lock(&mac->chip.mutex);
+ zd_mac_free_cur_beacon_locked(mac);
+ mutex_unlock(&mac->chip.mutex);
+}
+
+static int zd_mac_config_beacon(struct ieee80211_hw *hw, struct sk_buff *beacon,
+ bool in_intr)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ int r, ret, num_cmds, req_pos = 0;
+ u32 tmp, j = 0;
+ /* 4 more bytes for tail CRC */
+ u32 full_len = beacon->len + 4;
+ unsigned long end_jiffies, message_jiffies;
+ struct zd_ioreq32 *ioreqs;
+
+ mutex_lock(&mac->chip.mutex);
+
+ /* Check if hw already has this beacon. */
+ if (zd_mac_match_cur_beacon(mac, beacon)) {
+ r = 0;
+ goto out_nofree;
+ }
+
+ /* Alloc memory for full beacon write at once. */
+ num_cmds = 1 + zd_chip_is_zd1211b(&mac->chip) + full_len;
+ ioreqs = kmalloc(num_cmds * sizeof(struct zd_ioreq32), GFP_KERNEL);
+ if (!ioreqs) {
+ r = -ENOMEM;
+ goto out_nofree;
+ }
+
+ r = zd_iowrite32_locked(&mac->chip, 0, CR_BCN_FIFO_SEMAPHORE);
+ if (r < 0)
+ goto out;
+ r = zd_ioread32_locked(&mac->chip, &tmp, CR_BCN_FIFO_SEMAPHORE);
+ if (r < 0)
+ goto release_sema;
+ if (in_intr && tmp & 0x2) {
+ r = -EBUSY;
+ goto release_sema;
+ }
+
+ end_jiffies = jiffies + HZ / 2; /*~500ms*/
+ message_jiffies = jiffies + HZ / 10; /*~100ms*/
+ while (tmp & 0x2) {
+ r = zd_ioread32_locked(&mac->chip, &tmp, CR_BCN_FIFO_SEMAPHORE);
+ if (r < 0)
+ goto release_sema;
+ if (time_is_before_eq_jiffies(message_jiffies)) {
+ message_jiffies = jiffies + HZ / 10;
+ dev_err(zd_mac_dev(mac),
+ "CR_BCN_FIFO_SEMAPHORE not ready\n");
+ if (time_is_before_eq_jiffies(end_jiffies)) {
+ dev_err(zd_mac_dev(mac),
+ "Giving up beacon config.\n");
+ r = -ETIMEDOUT;
+ goto reset_device;
+ }
+ }
+ msleep(20);
+ }
+
+ ioreqs[req_pos].addr = CR_BCN_FIFO;
+ ioreqs[req_pos].value = full_len - 1;
+ req_pos++;
+ if (zd_chip_is_zd1211b(&mac->chip)) {
+ ioreqs[req_pos].addr = CR_BCN_LENGTH;
+ ioreqs[req_pos].value = full_len - 1;
+ req_pos++;
+ }
+
+ for (j = 0 ; j < beacon->len; j++) {
+ ioreqs[req_pos].addr = CR_BCN_FIFO;
+ ioreqs[req_pos].value = *((u8 *)(beacon->data + j));
+ req_pos++;
+ }
+
+ for (j = 0; j < 4; j++) {
+ ioreqs[req_pos].addr = CR_BCN_FIFO;
+ ioreqs[req_pos].value = 0x0;
+ req_pos++;
+ }
+
+ BUG_ON(req_pos != num_cmds);
+
+ r = zd_iowrite32a_locked(&mac->chip, ioreqs, num_cmds);
+
+release_sema:
+ /*
+ * Try very hard to release device beacon semaphore, as otherwise
+ * device/driver can be left in unusable state.
+ */
+ end_jiffies = jiffies + HZ / 2; /*~500ms*/
+ ret = zd_iowrite32_locked(&mac->chip, 1, CR_BCN_FIFO_SEMAPHORE);
+ while (ret < 0) {
+ if (in_intr || time_is_before_eq_jiffies(end_jiffies)) {
+ ret = -ETIMEDOUT;
+ break;
+ }
+
+ msleep(20);
+ ret = zd_iowrite32_locked(&mac->chip, 1, CR_BCN_FIFO_SEMAPHORE);
+ }
+
+ if (ret < 0)
+ dev_err(zd_mac_dev(mac), "Could not release "
+ "CR_BCN_FIFO_SEMAPHORE!\n");
+ if (r < 0 || ret < 0) {
+ if (r >= 0)
+ r = ret;
+
+ /* We don't know if beacon was written successfully or not,
+ * so clear current. */
+ zd_mac_free_cur_beacon_locked(mac);
+
+ goto out;
+ }
+
+ /* Beacon has now been written successfully, update current. */
+ zd_mac_free_cur_beacon_locked(mac);
+ mac->beacon.cur_beacon = beacon;
+ beacon = NULL;
+
+ /* 802.11b/g 2.4G CCK 1Mb
+ * 802.11a, not yet implemented, uses different values (see GPL vendor
+ * driver)
+ */
+ r = zd_iowrite32_locked(&mac->chip, 0x00000400 | (full_len << 19),
+ CR_BCN_PLCP_CFG);
+out:
+ kfree(ioreqs);
+out_nofree:
+ kfree_skb(beacon);
+ mutex_unlock(&mac->chip.mutex);
+
+ return r;
+
+reset_device:
+ zd_mac_free_cur_beacon_locked(mac);
+ kfree_skb(beacon);
+
+ mutex_unlock(&mac->chip.mutex);
+ kfree(ioreqs);
+
+ /* semaphore stuck, reset device to avoid fw freeze later */
+ dev_warn(zd_mac_dev(mac), "CR_BCN_FIFO_SEMAPHORE stuck, "
+ "resetting device...");
+ usb_queue_reset_device(mac->chip.usb.intf);
+
+ return r;
+}
+
+static int fill_ctrlset(struct zd_mac *mac,
+ struct sk_buff *skb)
+{
+ int r;
+ struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
+ unsigned int frag_len = skb->len + FCS_LEN;
+ unsigned int packet_length;
+ struct ieee80211_rate *txrate;
+ struct zd_ctrlset *cs = (struct zd_ctrlset *)
+ skb_push(skb, sizeof(struct zd_ctrlset));
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+
+ ZD_ASSERT(frag_len <= 0xffff);
+
+ /*
+ * Firmware computes the duration itself (for all frames except PSPoll)
+ * and needs the field set to 0 at input, otherwise firmware messes up
+ * duration_id and sets bits 14 and 15 on.
+ */
+ if (!ieee80211_is_pspoll(hdr->frame_control))
+ hdr->duration_id = 0;
+
+ txrate = ieee80211_get_tx_rate(mac->hw, info);
+
+ cs->modulation = txrate->hw_value;
+ if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_SHORT_PREAMBLE)
+ cs->modulation = txrate->hw_value_short;
+
+ cs->tx_length = cpu_to_le16(frag_len);
+
+ cs_set_control(mac, cs, hdr, info);
+
+ packet_length = frag_len + sizeof(struct zd_ctrlset) + 10;
+ ZD_ASSERT(packet_length <= 0xffff);
+ /* ZD1211B: Computing the length difference this way, gives us
+ * flexibility to compute the packet length.
+ */
+ cs->packet_length = cpu_to_le16(zd_chip_is_zd1211b(&mac->chip) ?
+ packet_length - frag_len : packet_length);
+
+ /*
+ * CURRENT LENGTH:
+ * - transmit frame length in microseconds
+ * - seems to be derived from frame length
+ * - see Cal_Us_Service() in zdinlinef.h
+ * - if macp->bTxBurstEnable is enabled, then multiply by 4
+ * - bTxBurstEnable is never set in the vendor driver
+ *
+ * SERVICE:
+ * - "for PLCP configuration"
+ * - always 0 except in some situations at 802.11b 11M
+ * - see line 53 of zdinlinef.h
+ */
+ cs->service = 0;
+ r = zd_calc_tx_length_us(&cs->service, ZD_RATE(cs->modulation),
+ le16_to_cpu(cs->tx_length));
+ if (r < 0)
+ return r;
+ cs->current_length = cpu_to_le16(r);
+ cs->next_frame_length = 0;
+
+ return 0;
+}
+
+/**
+ * zd_op_tx - transmits a network frame to the device
+ *
+ * @dev: mac80211 hardware device
+ * @skb: socket buffer
+ * @control: the control structure
+ *
+ * This function transmit an IEEE 802.11 network frame to the device. The
+ * control block of the skbuff will be initialized. If necessary the incoming
+ * mac80211 queues will be stopped.
+ */
+static void zd_op_tx(struct ieee80211_hw *hw,
+ struct ieee80211_tx_control *control,
+ struct sk_buff *skb)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ int r;
+
+ r = fill_ctrlset(mac, skb);
+ if (r)
+ goto fail;
+
+ info->rate_driver_data[0] = hw;
+
+ r = zd_usb_tx(&mac->chip.usb, skb);
+ if (r)
+ goto fail;
+ return;
+
+fail:
+ dev_kfree_skb(skb);
+}
+
+/**
+ * filter_ack - filters incoming packets for acknowledgements
+ * @dev: the mac80211 device
+ * @rx_hdr: received header
+ * @stats: the status for the received packet
+ *
+ * This functions looks for ACK packets and tries to match them with the
+ * frames in the tx queue. If a match is found the frame will be dequeued and
+ * the upper layers is informed about the successful transmission. If
+ * mac80211 queues have been stopped and the number of frames still to be
+ * transmitted is low the queues will be opened again.
+ *
+ * Returns 1 if the frame was an ACK, 0 if it was ignored.
+ */
+static int filter_ack(struct ieee80211_hw *hw, struct ieee80211_hdr *rx_hdr,
+ struct ieee80211_rx_status *stats)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct sk_buff *skb;
+ struct sk_buff_head *q;
+ unsigned long flags;
+ int found = 0;
+ int i, position = 0;
+
+ if (!ieee80211_is_ack(rx_hdr->frame_control))
+ return 0;
+
+ q = &mac->ack_wait_queue;
+ spin_lock_irqsave(&q->lock, flags);
+ skb_queue_walk(q, skb) {
+ struct ieee80211_hdr *tx_hdr;
+
+ position ++;
+
+ if (mac->ack_pending && skb_queue_is_first(q, skb))
+ continue;
+
+ tx_hdr = (struct ieee80211_hdr *)skb->data;
+ if (likely(ether_addr_equal(tx_hdr->addr2, rx_hdr->addr1)))
+ {
+ found = 1;
+ break;
+ }
+ }
+
+ if (found) {
+ for (i=1; i<position; i++) {
+ skb = __skb_dequeue(q);
+ zd_mac_tx_status(hw, skb,
+ mac->ack_pending ? mac->ack_signal : 0,
+ NULL);
+ mac->ack_pending = 0;
+ }
+
+ mac->ack_pending = 1;
+ mac->ack_signal = stats->signal;
+
+ /* Prevent pending tx-packet on AP-mode */
+ if (mac->type == NL80211_IFTYPE_AP) {
+ skb = __skb_dequeue(q);
+ zd_mac_tx_status(hw, skb, mac->ack_signal, NULL);
+ mac->ack_pending = 0;
+ }
+ }
+
+ spin_unlock_irqrestore(&q->lock, flags);
+ return 1;
+}
+
+int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct ieee80211_rx_status stats;
+ const struct rx_status *status;
+ struct sk_buff *skb;
+ int bad_frame = 0;
+ __le16 fc;
+ int need_padding;
+ int i;
+ u8 rate;
+
+ if (length < ZD_PLCP_HEADER_SIZE + 10 /* IEEE80211_1ADDR_LEN */ +
+ FCS_LEN + sizeof(struct rx_status))
+ return -EINVAL;
+
+ memset(&stats, 0, sizeof(stats));
+
+ /* Note about pass_failed_fcs and pass_ctrl access below:
+ * mac locking intentionally omitted here, as this is the only unlocked
+ * reader and the only writer is configure_filter. Plus, if there were
+ * any races accessing these variables, it wouldn't really matter.
+ * If mac80211 ever provides a way for us to access filter flags
+ * from outside configure_filter, we could improve on this. Also, this
+ * situation may change once we implement some kind of DMA-into-skb
+ * RX path. */
+
+ /* Caller has to ensure that length >= sizeof(struct rx_status). */
+ status = (struct rx_status *)
+ (buffer + (length - sizeof(struct rx_status)));
+ if (status->frame_status & ZD_RX_ERROR) {
+ if (mac->pass_failed_fcs &&
+ (status->frame_status & ZD_RX_CRC32_ERROR)) {
+ stats.flag |= RX_FLAG_FAILED_FCS_CRC;
+ bad_frame = 1;
+ } else {
+ return -EINVAL;
+ }
+ }
+
+ stats.freq = zd_channels[_zd_chip_get_channel(&mac->chip) - 1].center_freq;
+ stats.band = IEEE80211_BAND_2GHZ;
+ stats.signal = zd_check_signal(hw, status->signal_strength);
+
+ rate = zd_rx_rate(buffer, status);
+
+ /* todo: return index in the big switches in zd_rx_rate instead */
+ for (i = 0; i < mac->band.n_bitrates; i++)
+ if (rate == mac->band.bitrates[i].hw_value)
+ stats.rate_idx = i;
+
+ length -= ZD_PLCP_HEADER_SIZE + sizeof(struct rx_status);
+ buffer += ZD_PLCP_HEADER_SIZE;
+
+ /* Except for bad frames, filter each frame to see if it is an ACK, in
+ * which case our internal TX tracking is updated. Normally we then
+ * bail here as there's no need to pass ACKs on up to the stack, but
+ * there is also the case where the stack has requested us to pass
+ * control frames on up (pass_ctrl) which we must consider. */
+ if (!bad_frame &&
+ filter_ack(hw, (struct ieee80211_hdr *)buffer, &stats)
+ && !mac->pass_ctrl)
+ return 0;
+
+ fc = get_unaligned((__le16*)buffer);
+ need_padding = ieee80211_is_data_qos(fc) ^ ieee80211_has_a4(fc);
+
+ skb = dev_alloc_skb(length + (need_padding ? 2 : 0));
+ if (skb == NULL)
+ return -ENOMEM;
+ if (need_padding) {
+ /* Make sure the payload data is 4 byte aligned. */
+ skb_reserve(skb, 2);
+ }
+
+ /* FIXME : could we avoid this big memcpy ? */
+ memcpy(skb_put(skb, length), buffer, length);
+
+ memcpy(IEEE80211_SKB_RXCB(skb), &stats, sizeof(stats));
+ ieee80211_rx_irqsafe(hw, skb);
+ return 0;
+}
+
+static int zd_op_add_interface(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+
+ /* using NL80211_IFTYPE_UNSPECIFIED to indicate no mode selected */
+ if (mac->type != NL80211_IFTYPE_UNSPECIFIED)
+ return -EOPNOTSUPP;
+
+ switch (vif->type) {
+ case NL80211_IFTYPE_MONITOR:
+ case NL80211_IFTYPE_MESH_POINT:
+ case NL80211_IFTYPE_STATION:
+ case NL80211_IFTYPE_ADHOC:
+ case NL80211_IFTYPE_AP:
+ mac->type = vif->type;
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ mac->vif = vif;
+
+ return set_mac_and_bssid(mac);
+}
+
+static void zd_op_remove_interface(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ mac->type = NL80211_IFTYPE_UNSPECIFIED;
+ mac->vif = NULL;
+ zd_set_beacon_interval(&mac->chip, 0, 0, NL80211_IFTYPE_UNSPECIFIED);
+ zd_write_mac_addr(&mac->chip, NULL);
+
+ zd_mac_free_cur_beacon(mac);
+}
+
+static int zd_op_config(struct ieee80211_hw *hw, u32 changed)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct ieee80211_conf *conf = &hw->conf;
+
+ spin_lock_irq(&mac->lock);
+ mac->channel = conf->chandef.chan->hw_value;
+ spin_unlock_irq(&mac->lock);
+
+ return zd_chip_set_channel(&mac->chip, conf->chandef.chan->hw_value);
+}
+
+static void zd_beacon_done(struct zd_mac *mac)
+{
+ struct sk_buff *skb, *beacon;
+
+ if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
+ return;
+ if (!mac->vif || mac->vif->type != NL80211_IFTYPE_AP)
+ return;
+
+ /*
+ * Send out buffered broad- and multicast frames.
+ */
+ while (!ieee80211_queue_stopped(mac->hw, 0)) {
+ skb = ieee80211_get_buffered_bc(mac->hw, mac->vif);
+ if (!skb)
+ break;
+ zd_op_tx(mac->hw, NULL, skb);
+ }
+
+ /*
+ * Fetch next beacon so that tim_count is updated.
+ */
+ beacon = ieee80211_beacon_get(mac->hw, mac->vif);
+ if (beacon)
+ zd_mac_config_beacon(mac->hw, beacon, true);
+
+ spin_lock_irq(&mac->lock);
+ mac->beacon.last_update = jiffies;
+ spin_unlock_irq(&mac->lock);
+}
+
+static void zd_process_intr(struct work_struct *work)
+{
+ u16 int_status;
+ unsigned long flags;
+ struct zd_mac *mac = container_of(work, struct zd_mac, process_intr);
+
+ spin_lock_irqsave(&mac->lock, flags);
+ int_status = le16_to_cpu(*(__le16 *)(mac->intr_buffer + 4));
+ spin_unlock_irqrestore(&mac->lock, flags);
+
+ if (int_status & INT_CFG_NEXT_BCN) {
+ /*dev_dbg_f_limit(zd_mac_dev(mac), "INT_CFG_NEXT_BCN\n");*/
+ zd_beacon_done(mac);
+ } else {
+ dev_dbg_f(zd_mac_dev(mac), "Unsupported interrupt\n");
+ }
+
+ zd_chip_enable_hwint(&mac->chip);
+}
+
+
+static u64 zd_op_prepare_multicast(struct ieee80211_hw *hw,
+ struct netdev_hw_addr_list *mc_list)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ struct zd_mc_hash hash;
+ struct netdev_hw_addr *ha;
+
+ zd_mc_clear(&hash);
+
+ netdev_hw_addr_list_for_each(ha, mc_list) {
+ dev_dbg_f(zd_mac_dev(mac), "mc addr %pM\n", ha->addr);
+ zd_mc_add_addr(&hash, ha->addr);
+ }
+
+ return hash.low | ((u64)hash.high << 32);
+}
+
+#define SUPPORTED_FIF_FLAGS \
+ (FIF_ALLMULTI | FIF_FCSFAIL | FIF_CONTROL | \
+ FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)
+static void zd_op_configure_filter(struct ieee80211_hw *hw,
+ unsigned int changed_flags,
+ unsigned int *new_flags,
+ u64 multicast)
+{
+ struct zd_mc_hash hash = {
+ .low = multicast,
+ .high = multicast >> 32,
+ };
+ struct zd_mac *mac = zd_hw_mac(hw);
+ unsigned long flags;
+ int r;
+
+ /* Only deal with supported flags */
+ changed_flags &= SUPPORTED_FIF_FLAGS;
+ *new_flags &= SUPPORTED_FIF_FLAGS;
+
+ /*
+ * If multicast parameter (as returned by zd_op_prepare_multicast)
+ * has changed, no bit in changed_flags is set. To handle this
+ * situation, we do not return if changed_flags is 0. If we do so,
+ * we will have some issue with IPv6 which uses multicast for link
+ * layer address resolution.
+ */
+ if (*new_flags & FIF_ALLMULTI)
+ zd_mc_add_all(&hash);
+
+ spin_lock_irqsave(&mac->lock, flags);
+ mac->pass_failed_fcs = !!(*new_flags & FIF_FCSFAIL);
+ mac->pass_ctrl = !!(*new_flags & FIF_CONTROL);
+ mac->multicast_hash = hash;
+ spin_unlock_irqrestore(&mac->lock, flags);
+
+ zd_chip_set_multicast_hash(&mac->chip, &hash);
+
+ if (changed_flags & FIF_CONTROL) {
+ r = set_rx_filter(mac);
+ if (r)
+ dev_err(zd_mac_dev(mac), "set_rx_filter error %d\n", r);
+ }
+
+ /* no handling required for FIF_OTHER_BSS as we don't currently
+ * do BSSID filtering */
+ /* FIXME: in future it would be nice to enable the probe response
+ * filter (so that the driver doesn't see them) until
+ * FIF_BCN_PRBRESP_PROMISC is set. however due to atomicity here, we'd
+ * have to schedule work to enable prbresp reception, which might
+ * happen too late. For now we'll just listen and forward them all the
+ * time. */
+}
+
+static void set_rts_cts(struct zd_mac *mac, unsigned int short_preamble)
+{
+ mutex_lock(&mac->chip.mutex);
+ zd_chip_set_rts_cts_rate_locked(&mac->chip, short_preamble);
+ mutex_unlock(&mac->chip.mutex);
+}
+
+static void zd_op_bss_info_changed(struct ieee80211_hw *hw,
+ struct ieee80211_vif *vif,
+ struct ieee80211_bss_conf *bss_conf,
+ u32 changes)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ int associated;
+
+ dev_dbg_f(zd_mac_dev(mac), "changes: %x\n", changes);
+
+ if (mac->type == NL80211_IFTYPE_MESH_POINT ||
+ mac->type == NL80211_IFTYPE_ADHOC ||
+ mac->type == NL80211_IFTYPE_AP) {
+ associated = true;
+ if (changes & BSS_CHANGED_BEACON) {
+ struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
+
+ if (beacon) {
+ zd_chip_disable_hwint(&mac->chip);
+ zd_mac_config_beacon(hw, beacon, false);
+ zd_chip_enable_hwint(&mac->chip);
+ }
+ }
+
+ if (changes & BSS_CHANGED_BEACON_ENABLED) {
+ u16 interval = 0;
+ u8 period = 0;
+
+ if (bss_conf->enable_beacon) {
+ period = bss_conf->dtim_period;
+ interval = bss_conf->beacon_int;
+ }
+
+ spin_lock_irq(&mac->lock);
+ mac->beacon.period = period;
+ mac->beacon.interval = interval;
+ mac->beacon.last_update = jiffies;
+ spin_unlock_irq(&mac->lock);
+
+ zd_set_beacon_interval(&mac->chip, interval, period,
+ mac->type);
+ }
+ } else
+ associated = is_valid_ether_addr(bss_conf->bssid);
+
+ spin_lock_irq(&mac->lock);
+ mac->associated = associated;
+ spin_unlock_irq(&mac->lock);
+
+ /* TODO: do hardware bssid filtering */
+
+ if (changes & BSS_CHANGED_ERP_PREAMBLE) {
+ spin_lock_irq(&mac->lock);
+ mac->short_preamble = bss_conf->use_short_preamble;
+ spin_unlock_irq(&mac->lock);
+
+ set_rts_cts(mac, bss_conf->use_short_preamble);
+ }
+}
+
+static u64 zd_op_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
+{
+ struct zd_mac *mac = zd_hw_mac(hw);
+ return zd_chip_get_tsf(&mac->chip);
+}
+
+static const struct ieee80211_ops zd_ops = {
+ .tx = zd_op_tx,
+ .start = zd_op_start,
+ .stop = zd_op_stop,
+ .add_interface = zd_op_add_interface,
+ .remove_interface = zd_op_remove_interface,
+ .config = zd_op_config,
+ .prepare_multicast = zd_op_prepare_multicast,
+ .configure_filter = zd_op_configure_filter,
+ .bss_info_changed = zd_op_bss_info_changed,
+ .get_tsf = zd_op_get_tsf,
+};
+
+struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf)
+{
+ struct zd_mac *mac;
+ struct ieee80211_hw *hw;
+
+ hw = ieee80211_alloc_hw(sizeof(struct zd_mac), &zd_ops);
+ if (!hw) {
+ dev_dbg_f(&intf->dev, "out of memory\n");
+ return NULL;
+ }
+
+ mac = zd_hw_mac(hw);
+
+ memset(mac, 0, sizeof(*mac));
+ spin_lock_init(&mac->lock);
+ mac->hw = hw;
+
+ mac->type = NL80211_IFTYPE_UNSPECIFIED;
+
+ memcpy(mac->channels, zd_channels, sizeof(zd_channels));
+ memcpy(mac->rates, zd_rates, sizeof(zd_rates));
+ mac->band.n_bitrates = ARRAY_SIZE(zd_rates);
+ mac->band.bitrates = mac->rates;
+ mac->band.n_channels = ARRAY_SIZE(zd_channels);
+ mac->band.channels = mac->channels;
+
+ hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &mac->band;
+
+ ieee80211_hw_set(hw, MFP_CAPABLE);
+ ieee80211_hw_set(hw, HOST_BROADCAST_PS_BUFFERING);
+ ieee80211_hw_set(hw, RX_INCLUDES_FCS);
+ ieee80211_hw_set(hw, SIGNAL_UNSPEC);
+
+ hw->wiphy->interface_modes =
+ BIT(NL80211_IFTYPE_MESH_POINT) |
+ BIT(NL80211_IFTYPE_STATION) |
+ BIT(NL80211_IFTYPE_ADHOC) |
+ BIT(NL80211_IFTYPE_AP);
+
+ hw->max_signal = 100;
+ hw->queues = 1;
+ hw->extra_tx_headroom = sizeof(struct zd_ctrlset);
+
+ /*
+ * Tell mac80211 that we support multi rate retries
+ */
+ hw->max_rates = IEEE80211_TX_MAX_RATES;
+ hw->max_rate_tries = 18; /* 9 rates * 2 retries/rate */
+
+ skb_queue_head_init(&mac->ack_wait_queue);
+ mac->ack_pending = 0;
+
+ zd_chip_init(&mac->chip, hw, intf);
+ housekeeping_init(mac);
+ beacon_init(mac);
+ INIT_WORK(&mac->process_intr, zd_process_intr);
+
+ SET_IEEE80211_DEV(hw, &intf->dev);
+ return hw;
+}
+
+#define BEACON_WATCHDOG_DELAY round_jiffies_relative(HZ)
+
+static void beacon_watchdog_handler(struct work_struct *work)
+{
+ struct zd_mac *mac =
+ container_of(work, struct zd_mac, beacon.watchdog_work.work);
+ struct sk_buff *beacon;
+ unsigned long timeout;
+ int interval, period;
+
+ if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
+ goto rearm;
+ if (mac->type != NL80211_IFTYPE_AP || !mac->vif)
+ goto rearm;
+
+ spin_lock_irq(&mac->lock);
+ interval = mac->beacon.interval;
+ period = mac->beacon.period;
+ timeout = mac->beacon.last_update +
+ msecs_to_jiffies(interval * 1024 / 1000) * 3;
+ spin_unlock_irq(&mac->lock);
+
+ if (interval > 0 && time_is_before_jiffies(timeout)) {
+ dev_dbg_f(zd_mac_dev(mac), "beacon interrupt stalled, "
+ "restarting. "
+ "(interval: %d, dtim: %d)\n",
+ interval, period);
+
+ zd_chip_disable_hwint(&mac->chip);
+
+ beacon = ieee80211_beacon_get(mac->hw, mac->vif);
+ if (beacon) {
+ zd_mac_free_cur_beacon(mac);
+
+ zd_mac_config_beacon(mac->hw, beacon, false);
+ }
+
+ zd_set_beacon_interval(&mac->chip, interval, period, mac->type);
+
+ zd_chip_enable_hwint(&mac->chip);
+
+ spin_lock_irq(&mac->lock);
+ mac->beacon.last_update = jiffies;
+ spin_unlock_irq(&mac->lock);
+ }
+
+rearm:
+ queue_delayed_work(zd_workqueue, &mac->beacon.watchdog_work,
+ BEACON_WATCHDOG_DELAY);
+}
+
+static void beacon_init(struct zd_mac *mac)
+{
+ INIT_DELAYED_WORK(&mac->beacon.watchdog_work, beacon_watchdog_handler);
+}
+
+static void beacon_enable(struct zd_mac *mac)
+{
+ dev_dbg_f(zd_mac_dev(mac), "\n");
+
+ mac->beacon.last_update = jiffies;
+ queue_delayed_work(zd_workqueue, &mac->beacon.watchdog_work,
+ BEACON_WATCHDOG_DELAY);
+}
+
+static void beacon_disable(struct zd_mac *mac)
+{
+ dev_dbg_f(zd_mac_dev(mac), "\n");
+ cancel_delayed_work_sync(&mac->beacon.watchdog_work);
+
+ zd_mac_free_cur_beacon(mac);
+}
+
+#define LINK_LED_WORK_DELAY HZ
+
+static void link_led_handler(struct work_struct *work)
+{
+ struct zd_mac *mac =
+ container_of(work, struct zd_mac, housekeeping.link_led_work.work);
+ struct zd_chip *chip = &mac->chip;
+ int is_associated;
+ int r;
+
+ if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
+ goto requeue;
+
+ spin_lock_irq(&mac->lock);
+ is_associated = mac->associated;
+ spin_unlock_irq(&mac->lock);
+
+ r = zd_chip_control_leds(chip,
+ is_associated ? ZD_LED_ASSOCIATED : ZD_LED_SCANNING);
+ if (r)
+ dev_dbg_f(zd_mac_dev(mac), "zd_chip_control_leds error %d\n", r);
+
+requeue:
+ queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
+ LINK_LED_WORK_DELAY);
+}
+
+static void housekeeping_init(struct zd_mac *mac)
+{
+ INIT_DELAYED_WORK(&mac->housekeeping.link_led_work, link_led_handler);
+}
+
+static void housekeeping_enable(struct zd_mac *mac)
+{
+ dev_dbg_f(zd_mac_dev(mac), "\n");
+ queue_delayed_work(zd_workqueue, &mac->housekeeping.link_led_work,
+ 0);
+}
+
+static void housekeeping_disable(struct zd_mac *mac)
+{
+ dev_dbg_f(zd_mac_dev(mac), "\n");
+ cancel_delayed_work_sync(&mac->housekeeping.link_led_work);
+ zd_chip_control_leds(&mac->chip, ZD_LED_OFF);
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ZD_MAC_H
+#define _ZD_MAC_H
+
+#include <linux/kernel.h>
+#include <net/mac80211.h>
+
+#include "zd_chip.h"
+
+struct zd_ctrlset {
+ u8 modulation;
+ __le16 tx_length;
+ u8 control;
+ /* stores only the difference to tx_length on ZD1211B */
+ __le16 packet_length;
+ __le16 current_length;
+ u8 service;
+ __le16 next_frame_length;
+} __packed;
+
+#define ZD_CS_RESERVED_SIZE 25
+
+/* The field modulation of struct zd_ctrlset controls the bit rate, the use
+ * of short or long preambles in 802.11b (CCK mode) or the use of 802.11a or
+ * 802.11g in OFDM mode.
+ *
+ * The term zd-rate is used for the combination of the modulation type flag
+ * and the "pure" rate value.
+ */
+#define ZD_PURE_RATE_MASK 0x0f
+#define ZD_MODULATION_TYPE_MASK 0x10
+#define ZD_RATE_MASK (ZD_PURE_RATE_MASK|ZD_MODULATION_TYPE_MASK)
+#define ZD_PURE_RATE(modulation) ((modulation) & ZD_PURE_RATE_MASK)
+#define ZD_MODULATION_TYPE(modulation) ((modulation) & ZD_MODULATION_TYPE_MASK)
+#define ZD_RATE(modulation) ((modulation) & ZD_RATE_MASK)
+
+/* The two possible modulation types. Notify that 802.11b doesn't use the CCK
+ * codeing for the 1 and 2 MBit/s rate. We stay with the term here to remain
+ * consistent with uses the term at other places.
+ */
+#define ZD_CCK 0x00
+#define ZD_OFDM 0x10
+
+/* The ZD1211 firmware uses proprietary encodings of the 802.11b (CCK) rates.
+ * For OFDM the PLCP rate encodings are used. We combine these "pure" rates
+ * with the modulation type flag and call the resulting values zd-rates.
+ */
+#define ZD_CCK_RATE_1M (ZD_CCK|0x00)
+#define ZD_CCK_RATE_2M (ZD_CCK|0x01)
+#define ZD_CCK_RATE_5_5M (ZD_CCK|0x02)
+#define ZD_CCK_RATE_11M (ZD_CCK|0x03)
+#define ZD_OFDM_RATE_6M (ZD_OFDM|ZD_OFDM_PLCP_RATE_6M)
+#define ZD_OFDM_RATE_9M (ZD_OFDM|ZD_OFDM_PLCP_RATE_9M)
+#define ZD_OFDM_RATE_12M (ZD_OFDM|ZD_OFDM_PLCP_RATE_12M)
+#define ZD_OFDM_RATE_18M (ZD_OFDM|ZD_OFDM_PLCP_RATE_18M)
+#define ZD_OFDM_RATE_24M (ZD_OFDM|ZD_OFDM_PLCP_RATE_24M)
+#define ZD_OFDM_RATE_36M (ZD_OFDM|ZD_OFDM_PLCP_RATE_36M)
+#define ZD_OFDM_RATE_48M (ZD_OFDM|ZD_OFDM_PLCP_RATE_48M)
+#define ZD_OFDM_RATE_54M (ZD_OFDM|ZD_OFDM_PLCP_RATE_54M)
+
+/* The bit 5 of the zd_ctrlset modulation field controls the preamble in CCK
+ * mode or the 802.11a/802.11g selection in OFDM mode.
+ */
+#define ZD_CCK_PREA_LONG 0x00
+#define ZD_CCK_PREA_SHORT 0x20
+#define ZD_OFDM_MODE_11G 0x00
+#define ZD_OFDM_MODE_11A 0x20
+
+/* zd_ctrlset control field */
+#define ZD_CS_NEED_RANDOM_BACKOFF 0x01
+#define ZD_CS_NO_ACK 0x02
+
+#define ZD_CS_FRAME_TYPE_MASK 0x0c
+#define ZD_CS_DATA_FRAME 0x00
+#define ZD_CS_PS_POLL_FRAME 0x04
+#define ZD_CS_MANAGEMENT_FRAME 0x08
+#define ZD_CS_NO_SEQUENCE_CTL_FRAME 0x0c
+
+#define ZD_CS_WAKE_DESTINATION 0x10
+#define ZD_CS_RTS 0x20
+#define ZD_CS_ENCRYPT 0x40
+#define ZD_CS_SELF_CTS 0x80
+
+/* Incoming frames are prepended by a PLCP header */
+#define ZD_PLCP_HEADER_SIZE 5
+
+struct rx_length_info {
+ __le16 length[3];
+ __le16 tag;
+} __packed;
+
+#define RX_LENGTH_INFO_TAG 0x697e
+
+struct rx_status {
+ u8 signal_quality_cck;
+ /* rssi */
+ u8 signal_strength;
+ u8 signal_quality_ofdm;
+ u8 decryption_type;
+ u8 frame_status;
+} __packed;
+
+/* rx_status field decryption_type */
+#define ZD_RX_NO_WEP 0
+#define ZD_RX_WEP64 1
+#define ZD_RX_TKIP 2
+#define ZD_RX_AES 4
+#define ZD_RX_WEP128 5
+#define ZD_RX_WEP256 6
+
+/* rx_status field frame_status */
+#define ZD_RX_FRAME_MODULATION_MASK 0x01
+#define ZD_RX_CCK 0x00
+#define ZD_RX_OFDM 0x01
+
+#define ZD_RX_TIMEOUT_ERROR 0x02
+#define ZD_RX_FIFO_OVERRUN_ERROR 0x04
+#define ZD_RX_DECRYPTION_ERROR 0x08
+#define ZD_RX_CRC32_ERROR 0x10
+#define ZD_RX_NO_ADDR1_MATCH_ERROR 0x20
+#define ZD_RX_CRC16_ERROR 0x40
+#define ZD_RX_ERROR 0x80
+
+struct tx_retry_rate {
+ int count; /* number of valid element in rate[] array */
+ int rate[10]; /* retry rates, described by an index in zd_rates[] */
+};
+
+struct tx_status {
+ u8 type; /* must always be 0x01 : USB_INT_TYPE */
+ u8 id; /* must always be 0xa0 : USB_INT_ID_RETRY_FAILED */
+ u8 rate;
+ u8 pad;
+ u8 mac[ETH_ALEN];
+ u8 retry;
+ u8 failure;
+} __packed;
+
+enum mac_flags {
+ MAC_FIXED_CHANNEL = 0x01,
+};
+
+struct housekeeping {
+ struct delayed_work link_led_work;
+};
+
+struct beacon {
+ struct delayed_work watchdog_work;
+ struct sk_buff *cur_beacon;
+ unsigned long last_update;
+ u16 interval;
+ u8 period;
+};
+
+enum zd_device_flags {
+ ZD_DEVICE_RUNNING,
+};
+
+#define ZD_MAC_STATS_BUFFER_SIZE 16
+
+#define ZD_MAC_MAX_ACK_WAITERS 50
+
+struct zd_mac {
+ struct zd_chip chip;
+ spinlock_t lock;
+ spinlock_t intr_lock;
+ struct ieee80211_hw *hw;
+ struct ieee80211_vif *vif;
+ struct housekeeping housekeeping;
+ struct beacon beacon;
+ struct work_struct set_rts_cts_work;
+ struct work_struct process_intr;
+ struct zd_mc_hash multicast_hash;
+ u8 intr_buffer[USB_MAX_EP_INT_BUFFER];
+ u8 regdomain;
+ u8 default_regdomain;
+ u8 channel;
+ int type;
+ int associated;
+ unsigned long flags;
+ struct sk_buff_head ack_wait_queue;
+ struct ieee80211_channel channels[14];
+ struct ieee80211_rate rates[12];
+ struct ieee80211_supported_band band;
+
+ /* Short preamble (used for RTS/CTS) */
+ unsigned int short_preamble:1;
+
+ /* whether to pass frames with CRC errors to stack */
+ unsigned int pass_failed_fcs:1;
+
+ /* whether to pass control frames to stack */
+ unsigned int pass_ctrl:1;
+
+ /* whether we have received a 802.11 ACK that is pending */
+ unsigned int ack_pending:1;
+
+ /* signal strength of the last 802.11 ACK received */
+ int ack_signal;
+};
+
+#define ZD_REGDOMAIN_FCC 0x10
+#define ZD_REGDOMAIN_IC 0x20
+#define ZD_REGDOMAIN_ETSI 0x30
+#define ZD_REGDOMAIN_SPAIN 0x31
+#define ZD_REGDOMAIN_FRANCE 0x32
+#define ZD_REGDOMAIN_JAPAN_2 0x40
+#define ZD_REGDOMAIN_JAPAN 0x41
+#define ZD_REGDOMAIN_JAPAN_3 0x49
+
+enum {
+ MIN_CHANNEL24 = 1,
+ MAX_CHANNEL24 = 14,
+};
+
+#define ZD_PLCP_SERVICE_LENGTH_EXTENSION 0x80
+
+struct ofdm_plcp_header {
+ u8 prefix[3];
+ __le16 service;
+} __packed;
+
+static inline u8 zd_ofdm_plcp_header_rate(const struct ofdm_plcp_header *header)
+{
+ return header->prefix[0] & 0xf;
+}
+
+/* The following defines give the encoding of the 4-bit rate field in the
+ * OFDM (802.11a/802.11g) PLCP header. Notify that these values are used to
+ * define the zd-rate values for OFDM.
+ *
+ * See the struct zd_ctrlset definition in zd_mac.h.
+ */
+#define ZD_OFDM_PLCP_RATE_6M 0xb
+#define ZD_OFDM_PLCP_RATE_9M 0xf
+#define ZD_OFDM_PLCP_RATE_12M 0xa
+#define ZD_OFDM_PLCP_RATE_18M 0xe
+#define ZD_OFDM_PLCP_RATE_24M 0x9
+#define ZD_OFDM_PLCP_RATE_36M 0xd
+#define ZD_OFDM_PLCP_RATE_48M 0x8
+#define ZD_OFDM_PLCP_RATE_54M 0xc
+
+struct cck_plcp_header {
+ u8 signal;
+ u8 service;
+ __le16 length;
+ __le16 crc16;
+} __packed;
+
+static inline u8 zd_cck_plcp_header_signal(const struct cck_plcp_header *header)
+{
+ return header->signal;
+}
+
+/* These defines give the encodings of the signal field in the 802.11b PLCP
+ * header. The signal field gives the bit rate of the following packet. Even
+ * if technically wrong we use CCK here also for the 1 MBit/s and 2 MBit/s
+ * rate to stay consistent with Zydas and our use of the term.
+ *
+ * Notify that these values are *not* used in the zd-rates.
+ */
+#define ZD_CCK_PLCP_SIGNAL_1M 0x0a
+#define ZD_CCK_PLCP_SIGNAL_2M 0x14
+#define ZD_CCK_PLCP_SIGNAL_5M5 0x37
+#define ZD_CCK_PLCP_SIGNAL_11M 0x6e
+
+static inline struct zd_mac *zd_hw_mac(struct ieee80211_hw *hw)
+{
+ return hw->priv;
+}
+
+static inline struct zd_mac *zd_chip_to_mac(struct zd_chip *chip)
+{
+ return container_of(chip, struct zd_mac, chip);
+}
+
+static inline struct zd_mac *zd_usb_to_mac(struct zd_usb *usb)
+{
+ return zd_chip_to_mac(zd_usb_to_chip(usb));
+}
+
+static inline u8 *zd_mac_get_perm_addr(struct zd_mac *mac)
+{
+ return mac->hw->wiphy->perm_addr;
+}
+
+#define zd_mac_dev(mac) (zd_chip_dev(&(mac)->chip))
+
+struct ieee80211_hw *zd_mac_alloc_hw(struct usb_interface *intf);
+void zd_mac_clear(struct zd_mac *mac);
+
+int zd_mac_preinit_hw(struct ieee80211_hw *hw);
+int zd_mac_init_hw(struct ieee80211_hw *hw);
+
+int zd_mac_rx(struct ieee80211_hw *hw, const u8 *buffer, unsigned int length);
+void zd_mac_tx_failed(struct urb *urb);
+void zd_mac_tx_to_dev(struct sk_buff *skb, int error);
+
+int zd_op_start(struct ieee80211_hw *hw);
+void zd_op_stop(struct ieee80211_hw *hw);
+int zd_restore_settings(struct zd_mac *mac);
+
+#ifdef DEBUG
+void zd_dump_rx_status(const struct rx_status *status);
+#else
+#define zd_dump_rx_status(status)
+#endif /* DEBUG */
+
+#endif /* _ZD_MAC_H */
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/errno.h>
+#include <linux/string.h>
+
+#include "zd_def.h"
+#include "zd_rf.h"
+#include "zd_mac.h"
+#include "zd_chip.h"
+
+static const char * const rfs[] = {
+ [0] = "unknown RF0",
+ [1] = "unknown RF1",
+ [UW2451_RF] = "UW2451_RF",
+ [UCHIP_RF] = "UCHIP_RF",
+ [AL2230_RF] = "AL2230_RF",
+ [AL7230B_RF] = "AL7230B_RF",
+ [THETA_RF] = "THETA_RF",
+ [AL2210_RF] = "AL2210_RF",
+ [MAXIM_NEW_RF] = "MAXIM_NEW_RF",
+ [UW2453_RF] = "UW2453_RF",
+ [AL2230S_RF] = "AL2230S_RF",
+ [RALINK_RF] = "RALINK_RF",
+ [INTERSIL_RF] = "INTERSIL_RF",
+ [RF2959_RF] = "RF2959_RF",
+ [MAXIM_NEW2_RF] = "MAXIM_NEW2_RF",
+ [PHILIPS_RF] = "PHILIPS_RF",
+};
+
+const char *zd_rf_name(u8 type)
+{
+ if (type & 0xf0)
+ type = 0;
+ return rfs[type];
+}
+
+void zd_rf_init(struct zd_rf *rf)
+{
+ memset(rf, 0, sizeof(*rf));
+
+ /* default to update channel integration, as almost all RF's do want
+ * this */
+ rf->update_channel_int = 1;
+}
+
+void zd_rf_clear(struct zd_rf *rf)
+{
+ if (rf->clear)
+ rf->clear(rf);
+ ZD_MEMCLEAR(rf, sizeof(*rf));
+}
+
+int zd_rf_init_hw(struct zd_rf *rf, u8 type)
+{
+ int r = 0;
+ int t;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ switch (type) {
+ case RF2959_RF:
+ r = zd_rf_init_rf2959(rf);
+ break;
+ case AL2230_RF:
+ case AL2230S_RF:
+ r = zd_rf_init_al2230(rf);
+ break;
+ case AL7230B_RF:
+ r = zd_rf_init_al7230b(rf);
+ break;
+ case MAXIM_NEW_RF:
+ case UW2453_RF:
+ r = zd_rf_init_uw2453(rf);
+ break;
+ default:
+ dev_err(zd_chip_dev(chip),
+ "RF %s %#x is not supported\n", zd_rf_name(type), type);
+ rf->type = 0;
+ return -ENODEV;
+ }
+
+ if (r)
+ return r;
+
+ rf->type = type;
+
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ return r;
+ t = rf->init_hw(rf);
+ r = zd_chip_unlock_phy_regs(chip);
+ if (t)
+ r = t;
+ return r;
+}
+
+int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size)
+{
+ return scnprintf(buffer, size, "%s", zd_rf_name(rf->type));
+}
+
+int zd_rf_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+
+ ZD_ASSERT(mutex_is_locked(&zd_rf_to_chip(rf)->mutex));
+ if (channel < MIN_CHANNEL24)
+ return -EINVAL;
+ if (channel > MAX_CHANNEL24)
+ return -EINVAL;
+ dev_dbg_f(zd_chip_dev(zd_rf_to_chip(rf)), "channel: %d\n", channel);
+
+ r = rf->set_channel(rf, channel);
+ if (r >= 0)
+ rf->channel = channel;
+ return r;
+}
+
+int zd_switch_radio_on(struct zd_rf *rf)
+{
+ int r, t;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ return r;
+ t = rf->switch_radio_on(rf);
+ r = zd_chip_unlock_phy_regs(chip);
+ if (t)
+ r = t;
+ return r;
+}
+
+int zd_switch_radio_off(struct zd_rf *rf)
+{
+ int r, t;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ /* TODO: move phy regs handling to zd_chip */
+ ZD_ASSERT(mutex_is_locked(&chip->mutex));
+ r = zd_chip_lock_phy_regs(chip);
+ if (r)
+ return r;
+ t = rf->switch_radio_off(rf);
+ r = zd_chip_unlock_phy_regs(chip);
+ if (t)
+ r = t;
+ return r;
+}
+
+int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel)
+{
+ if (!rf->patch_6m_band_edge)
+ return 0;
+
+ return rf->patch_6m_band_edge(rf, channel);
+}
+
+int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel)
+{
+ return zd_chip_generic_patch_6m_band(zd_rf_to_chip(rf), channel);
+}
+
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ZD_RF_H
+#define _ZD_RF_H
+
+#define UW2451_RF 0x2
+#define UCHIP_RF 0x3
+#define AL2230_RF 0x4
+#define AL7230B_RF 0x5 /* a,b,g */
+#define THETA_RF 0x6
+#define AL2210_RF 0x7
+#define MAXIM_NEW_RF 0x8
+#define UW2453_RF 0x9
+#define AL2230S_RF 0xa
+#define RALINK_RF 0xb
+#define INTERSIL_RF 0xc
+#define RF2959_RF 0xd
+#define MAXIM_NEW2_RF 0xe
+#define PHILIPS_RF 0xf
+
+#define RF_CHANNEL(ch) [(ch)-1]
+
+/* Provides functions of the RF transceiver. */
+
+enum {
+ RF_REG_BITS = 6,
+ RF_VALUE_BITS = 18,
+ RF_RV_BITS = RF_REG_BITS + RF_VALUE_BITS,
+};
+
+struct zd_rf {
+ u8 type;
+
+ u8 channel;
+
+ /* whether channel integration and calibration should be updated
+ * defaults to 1 (yes) */
+ u8 update_channel_int:1;
+
+ /* whether ZD_CR47 should be patched from the EEPROM, if the appropriate
+ * flag is set in the POD. The vendor driver suggests that this should
+ * be done for all RF's, but a bug in their code prevents but their
+ * HW_OverWritePhyRegFromE2P() routine from ever taking effect. */
+ u8 patch_cck_gain:1;
+
+ /* private RF driver data */
+ void *priv;
+
+ /* RF-specific functions */
+ int (*init_hw)(struct zd_rf *rf);
+ int (*set_channel)(struct zd_rf *rf, u8 channel);
+ int (*switch_radio_on)(struct zd_rf *rf);
+ int (*switch_radio_off)(struct zd_rf *rf);
+ int (*patch_6m_band_edge)(struct zd_rf *rf, u8 channel);
+ void (*clear)(struct zd_rf *rf);
+};
+
+const char *zd_rf_name(u8 type);
+void zd_rf_init(struct zd_rf *rf);
+void zd_rf_clear(struct zd_rf *rf);
+int zd_rf_init_hw(struct zd_rf *rf, u8 type);
+
+int zd_rf_scnprint_id(struct zd_rf *rf, char *buffer, size_t size);
+
+int zd_rf_set_channel(struct zd_rf *rf, u8 channel);
+
+int zd_switch_radio_on(struct zd_rf *rf);
+int zd_switch_radio_off(struct zd_rf *rf);
+
+int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel);
+int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel);
+
+static inline int zd_rf_should_update_pwr_int(struct zd_rf *rf)
+{
+ return rf->update_channel_int;
+}
+
+static inline int zd_rf_should_patch_cck_gain(struct zd_rf *rf)
+{
+ return rf->patch_cck_gain;
+}
+
+int zd_rf_patch_6m_band_edge(struct zd_rf *rf, u8 channel);
+int zd_rf_generic_patch_6m(struct zd_rf *rf, u8 channel);
+
+/* Functions for individual RF chips */
+
+int zd_rf_init_rf2959(struct zd_rf *rf);
+int zd_rf_init_al2230(struct zd_rf *rf);
+int zd_rf_init_al7230b(struct zd_rf *rf);
+int zd_rf_init_uw2453(struct zd_rf *rf);
+
+#endif /* _ZD_RF_H */
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+
+#include "zd_rf.h"
+#include "zd_usb.h"
+#include "zd_chip.h"
+
+#define IS_AL2230S(chip) ((chip)->al2230s_bit || (chip)->rf.type == AL2230S_RF)
+
+static const u32 zd1211_al2230_table[][3] = {
+ RF_CHANNEL( 1) = { 0x03f790, 0x033331, 0x00000d, },
+ RF_CHANNEL( 2) = { 0x03f790, 0x0b3331, 0x00000d, },
+ RF_CHANNEL( 3) = { 0x03e790, 0x033331, 0x00000d, },
+ RF_CHANNEL( 4) = { 0x03e790, 0x0b3331, 0x00000d, },
+ RF_CHANNEL( 5) = { 0x03f7a0, 0x033331, 0x00000d, },
+ RF_CHANNEL( 6) = { 0x03f7a0, 0x0b3331, 0x00000d, },
+ RF_CHANNEL( 7) = { 0x03e7a0, 0x033331, 0x00000d, },
+ RF_CHANNEL( 8) = { 0x03e7a0, 0x0b3331, 0x00000d, },
+ RF_CHANNEL( 9) = { 0x03f7b0, 0x033331, 0x00000d, },
+ RF_CHANNEL(10) = { 0x03f7b0, 0x0b3331, 0x00000d, },
+ RF_CHANNEL(11) = { 0x03e7b0, 0x033331, 0x00000d, },
+ RF_CHANNEL(12) = { 0x03e7b0, 0x0b3331, 0x00000d, },
+ RF_CHANNEL(13) = { 0x03f7c0, 0x033331, 0x00000d, },
+ RF_CHANNEL(14) = { 0x03e7c0, 0x066661, 0x00000d, },
+};
+
+static const u32 zd1211b_al2230_table[][3] = {
+ RF_CHANNEL( 1) = { 0x09efc0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL( 2) = { 0x09efc0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL( 3) = { 0x09e7c0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL( 4) = { 0x09e7c0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL( 5) = { 0x05efc0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL( 6) = { 0x05efc0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL( 7) = { 0x05e7c0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL( 8) = { 0x05e7c0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL( 9) = { 0x0defc0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL(10) = { 0x0defc0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL(11) = { 0x0de7c0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL(12) = { 0x0de7c0, 0x8cccd0, 0xb00000, },
+ RF_CHANNEL(13) = { 0x03efc0, 0x8cccc0, 0xb00000, },
+ RF_CHANNEL(14) = { 0x03e7c0, 0x866660, 0xb00000, },
+};
+
+static const struct zd_ioreq16 zd1211b_ioreqs_shared_1[] = {
+ { ZD_CR240, 0x57 }, { ZD_CR9, 0xe0 },
+};
+
+static const struct zd_ioreq16 ioreqs_init_al2230s[] = {
+ { ZD_CR47, 0x1e }, /* MARK_002 */
+ { ZD_CR106, 0x22 },
+ { ZD_CR107, 0x2a }, /* MARK_002 */
+ { ZD_CR109, 0x13 }, /* MARK_002 */
+ { ZD_CR118, 0xf8 }, /* MARK_002 */
+ { ZD_CR119, 0x12 }, { ZD_CR122, 0xe0 },
+ { ZD_CR128, 0x10 }, /* MARK_001 from 0xe->0x10 */
+ { ZD_CR129, 0x0e }, /* MARK_001 from 0xd->0x0e */
+ { ZD_CR130, 0x10 }, /* MARK_001 from 0xb->0x0d */
+};
+
+static int zd1211b_al2230_finalize_rf(struct zd_chip *chip)
+{
+ int r;
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
+ { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
+ { ZD_CR203, 0x06 },
+ { },
+
+ { ZD_CR240, 0x80 },
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ /* related to antenna selection? */
+ if (chip->new_phy_layout) {
+ r = zd_iowrite16_locked(chip, 0xe1, ZD_CR9);
+ if (r)
+ return r;
+ }
+
+ return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
+}
+
+static int zd1211_al2230_init_hw(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs_init[] = {
+ { ZD_CR15, 0x20 }, { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 },
+ { ZD_CR26, 0x11 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
+ { ZD_CR44, 0x33 }, { ZD_CR106, 0x2a }, { ZD_CR107, 0x1a },
+ { ZD_CR109, 0x09 }, { ZD_CR110, 0x27 }, { ZD_CR111, 0x2b },
+ { ZD_CR112, 0x2b }, { ZD_CR119, 0x0a }, { ZD_CR10, 0x89 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR17, 0x28 },
+ { ZD_CR26, 0x93 }, { ZD_CR34, 0x30 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR35, 0x3e },
+ { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR46, 0x96 },
+ { ZD_CR47, 0x1e }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
+ { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
+ { ZD_CR92, 0x0a }, { ZD_CR99, 0x28 }, { ZD_CR100, 0x00 },
+ { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 }, { ZD_CR106, 0x24 },
+ { ZD_CR107, 0x2a }, { ZD_CR109, 0x09 }, { ZD_CR110, 0x13 },
+ { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x27 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR115, 0x24 },
+ { ZD_CR116, 0x24 }, { ZD_CR117, 0xf4 }, { ZD_CR118, 0xfc },
+ { ZD_CR119, 0x10 }, { ZD_CR120, 0x4f }, { ZD_CR121, 0x77 },
+ { ZD_CR122, 0xe0 }, { ZD_CR137, 0x88 }, { ZD_CR252, 0xff },
+ { ZD_CR253, 0xff },
+ };
+
+ static const struct zd_ioreq16 ioreqs_pll[] = {
+ /* shdnb(PLL_ON)=0 */
+ { ZD_CR251, 0x2f },
+ /* shdnb(PLL_ON)=1 */
+ { ZD_CR251, 0x3f },
+ { ZD_CR138, 0x28 }, { ZD_CR203, 0x06 },
+ };
+
+ static const u32 rv1[] = {
+ /* Channel 1 */
+ 0x03f790,
+ 0x033331,
+ 0x00000d,
+
+ 0x0b3331,
+ 0x03b812,
+ 0x00fff3,
+ };
+
+ static const u32 rv2[] = {
+ 0x000da4,
+ 0x0f4dc5, /* fix freq shift, 0x04edc5 */
+ 0x0805b6,
+ 0x011687,
+ 0x000688,
+ 0x0403b9, /* external control TX power (ZD_CR31) */
+ 0x00dbba,
+ 0x00099b,
+ 0x0bdffc,
+ 0x00000d,
+ 0x00500f,
+ };
+
+ static const u32 rv3[] = {
+ 0x00d00f,
+ 0x004c0f,
+ 0x00540f,
+ 0x00700f,
+ 0x00500f,
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs_init, ARRAY_SIZE(ioreqs_init));
+ if (r)
+ return r;
+
+ if (IS_AL2230S(chip)) {
+ r = zd_iowrite16a_locked(chip, ioreqs_init_al2230s,
+ ARRAY_SIZE(ioreqs_init_al2230s));
+ if (r)
+ return r;
+ }
+
+ r = zd_rfwritev_locked(chip, rv1, ARRAY_SIZE(rv1), RF_RV_BITS);
+ if (r)
+ return r;
+
+ /* improve band edge for AL2230S */
+ if (IS_AL2230S(chip))
+ r = zd_rfwrite_locked(chip, 0x000824, RF_RV_BITS);
+ else
+ r = zd_rfwrite_locked(chip, 0x0005a4, RF_RV_BITS);
+ if (r)
+ return r;
+
+ r = zd_rfwritev_locked(chip, rv2, ARRAY_SIZE(rv2), RF_RV_BITS);
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_pll, ARRAY_SIZE(ioreqs_pll));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_locked(chip, rv3, ARRAY_SIZE(rv3), RF_RV_BITS);
+ if (r)
+ return r;
+
+ return 0;
+}
+
+static int zd1211b_al2230_init_hw(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs1[] = {
+ { ZD_CR10, 0x89 }, { ZD_CR15, 0x20 },
+ { ZD_CR17, 0x2B }, /* for newest(3rd cut) AL2230 */
+ { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
+ { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
+ { ZD_CR33, 0x28 }, /* 5621 */
+ { ZD_CR34, 0x30 },
+ { ZD_CR35, 0x3e }, /* for newest(3rd cut) AL2230 */
+ { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
+ { ZD_CR46, 0x99 }, /* for newest(3rd cut) AL2230 */
+ { ZD_CR47, 0x1e },
+
+ /* ZD1211B 05.06.10 */
+ { ZD_CR48, 0x06 }, { ZD_CR49, 0xf9 }, { ZD_CR51, 0x01 },
+ { ZD_CR52, 0x80 }, { ZD_CR53, 0x7e }, { ZD_CR65, 0x00 },
+ { ZD_CR66, 0x00 }, { ZD_CR67, 0x00 }, { ZD_CR68, 0x00 },
+ { ZD_CR69, 0x28 },
+
+ { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
+ { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
+ { ZD_CR91, 0x00 }, /* 5621 */
+ { ZD_CR92, 0x0a },
+ { ZD_CR98, 0x8d }, /* 4804, for 1212 new algorithm */
+ { ZD_CR99, 0x00 }, /* 5621 */
+ { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 },
+ { ZD_CR106, 0x24 }, /* for newest(3rd cut) AL2230 */
+ { ZD_CR107, 0x2a },
+ { ZD_CR109, 0x13 }, /* 4804, for 1212 new algorithm */
+ { ZD_CR110, 0x1f }, /* 4804, for 1212 new algorithm */
+ { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x27 },
+ { ZD_CR115, 0x26 }, /* 24->26 at 4902 for newest(3rd cut)
+ * AL2230
+ */
+ { ZD_CR116, 0x24 },
+ { ZD_CR117, 0xfa }, /* for 1211b */
+ { ZD_CR118, 0xfa }, /* for 1211b */
+ { ZD_CR119, 0x10 },
+ { ZD_CR120, 0x4f },
+ { ZD_CR121, 0x6c }, /* for 1211b */
+ { ZD_CR122, 0xfc }, /* E0->FC at 4902 */
+ { ZD_CR123, 0x57 }, /* 5623 */
+ { ZD_CR125, 0xad }, /* 4804, for 1212 new algorithm */
+ { ZD_CR126, 0x6c }, /* 5614 */
+ { ZD_CR127, 0x03 }, /* 4804, for 1212 new algorithm */
+ { ZD_CR137, 0x50 }, /* 5614 */
+ { ZD_CR138, 0xa8 },
+ { ZD_CR144, 0xac }, /* 5621 */
+ { ZD_CR150, 0x0d }, { ZD_CR252, 0x34 }, { ZD_CR253, 0x34 },
+ };
+
+ static const u32 rv1[] = {
+ 0x8cccd0,
+ 0x481dc0,
+ 0xcfff00,
+ 0x25a000,
+ };
+
+ static const u32 rv2[] = {
+ /* To improve AL2230 yield, improve phase noise, 4713 */
+ 0x25a000,
+ 0xa3b2f0,
+
+ 0x6da010, /* Reg6 update for MP versio */
+ 0xe36280, /* Modified by jxiao for Bor-Chin on 2004/08/02 */
+ 0x116000,
+ 0x9dc020, /* External control TX power (ZD_CR31) */
+ 0x5ddb00, /* RegA update for MP version */
+ 0xd99000, /* RegB update for MP version */
+ 0x3ffbd0, /* RegC update for MP version */
+ 0xb00000, /* RegD update for MP version */
+
+ /* improve phase noise and remove phase calibration,4713 */
+ 0xf01a00,
+ };
+
+ static const struct zd_ioreq16 ioreqs2[] = {
+ { ZD_CR251, 0x2f }, /* shdnb(PLL_ON)=0 */
+ { ZD_CR251, 0x7f }, /* shdnb(PLL_ON)=1 */
+ };
+
+ static const u32 rv3[] = {
+ /* To improve AL2230 yield, 4713 */
+ 0xf01b00,
+ 0xf01e00,
+ 0xf01a00,
+ };
+
+ static const struct zd_ioreq16 ioreqs3[] = {
+ /* related to 6M band edge patching, happens unconditionally */
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ };
+
+ r = zd_iowrite16a_locked(chip, zd1211b_ioreqs_shared_1,
+ ARRAY_SIZE(zd1211b_ioreqs_shared_1));
+ if (r)
+ return r;
+ r = zd_iowrite16a_locked(chip, ioreqs1, ARRAY_SIZE(ioreqs1));
+ if (r)
+ return r;
+
+ if (IS_AL2230S(chip)) {
+ r = zd_iowrite16a_locked(chip, ioreqs_init_al2230s,
+ ARRAY_SIZE(ioreqs_init_al2230s));
+ if (r)
+ return r;
+ }
+
+ r = zd_rfwritev_cr_locked(chip, zd1211b_al2230_table[0], 3);
+ if (r)
+ return r;
+ r = zd_rfwritev_cr_locked(chip, rv1, ARRAY_SIZE(rv1));
+ if (r)
+ return r;
+
+ if (IS_AL2230S(chip))
+ r = zd_rfwrite_locked(chip, 0x241000, RF_RV_BITS);
+ else
+ r = zd_rfwrite_locked(chip, 0x25a000, RF_RV_BITS);
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv2, ARRAY_SIZE(rv2));
+ if (r)
+ return r;
+ r = zd_iowrite16a_locked(chip, ioreqs2, ARRAY_SIZE(ioreqs2));
+ if (r)
+ return r;
+ r = zd_rfwritev_cr_locked(chip, rv3, ARRAY_SIZE(rv3));
+ if (r)
+ return r;
+ r = zd_iowrite16a_locked(chip, ioreqs3, ARRAY_SIZE(ioreqs3));
+ if (r)
+ return r;
+ return zd1211b_al2230_finalize_rf(chip);
+}
+
+static int zd1211_al2230_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+ const u32 *rv = zd1211_al2230_table[channel-1];
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR138, 0x28 },
+ { ZD_CR203, 0x06 },
+ };
+
+ r = zd_rfwritev_locked(chip, rv, 3, RF_RV_BITS);
+ if (r)
+ return r;
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211b_al2230_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+ const u32 *rv = zd1211b_al2230_table[channel-1];
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ r = zd_iowrite16a_locked(chip, zd1211b_ioreqs_shared_1,
+ ARRAY_SIZE(zd1211b_ioreqs_shared_1));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv, 3);
+ if (r)
+ return r;
+
+ return zd1211b_al2230_finalize_rf(chip);
+}
+
+static int zd1211_al2230_switch_radio_on(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x00 },
+ { ZD_CR251, 0x3f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211b_al2230_switch_radio_on(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x00 },
+ { ZD_CR251, 0x7f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int al2230_switch_radio_off(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x04 },
+ { ZD_CR251, 0x2f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+int zd_rf_init_al2230(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ rf->switch_radio_off = al2230_switch_radio_off;
+ if (zd_chip_is_zd1211b(chip)) {
+ rf->init_hw = zd1211b_al2230_init_hw;
+ rf->set_channel = zd1211b_al2230_set_channel;
+ rf->switch_radio_on = zd1211b_al2230_switch_radio_on;
+ } else {
+ rf->init_hw = zd1211_al2230_init_hw;
+ rf->set_channel = zd1211_al2230_set_channel;
+ rf->switch_radio_on = zd1211_al2230_switch_radio_on;
+ }
+ rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
+ rf->patch_cck_gain = 1;
+ return 0;
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+
+#include "zd_rf.h"
+#include "zd_usb.h"
+#include "zd_chip.h"
+
+static const u32 chan_rv[][2] = {
+ RF_CHANNEL( 1) = { 0x09ec00, 0x8cccc8 },
+ RF_CHANNEL( 2) = { 0x09ec00, 0x8cccd8 },
+ RF_CHANNEL( 3) = { 0x09ec00, 0x8cccc0 },
+ RF_CHANNEL( 4) = { 0x09ec00, 0x8cccd0 },
+ RF_CHANNEL( 5) = { 0x05ec00, 0x8cccc8 },
+ RF_CHANNEL( 6) = { 0x05ec00, 0x8cccd8 },
+ RF_CHANNEL( 7) = { 0x05ec00, 0x8cccc0 },
+ RF_CHANNEL( 8) = { 0x05ec00, 0x8cccd0 },
+ RF_CHANNEL( 9) = { 0x0dec00, 0x8cccc8 },
+ RF_CHANNEL(10) = { 0x0dec00, 0x8cccd8 },
+ RF_CHANNEL(11) = { 0x0dec00, 0x8cccc0 },
+ RF_CHANNEL(12) = { 0x0dec00, 0x8cccd0 },
+ RF_CHANNEL(13) = { 0x03ec00, 0x8cccc8 },
+ RF_CHANNEL(14) = { 0x03ec00, 0x866660 },
+};
+
+static const u32 std_rv[] = {
+ 0x4ff821,
+ 0xc5fbfc,
+ 0x21ebfe,
+ 0xafd401, /* freq shift 0xaad401 */
+ 0x6cf56a,
+ 0xe04073,
+ 0x193d76,
+ 0x9dd844,
+ 0x500007,
+ 0xd8c010,
+};
+
+static const u32 rv_init1[] = {
+ 0x3c9000,
+ 0xbfffff,
+ 0x700000,
+ 0xf15d58,
+};
+
+static const u32 rv_init2[] = {
+ 0xf15d59,
+ 0xf15d5c,
+ 0xf15d58,
+};
+
+static const struct zd_ioreq16 ioreqs_sw[] = {
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
+};
+
+static int zd1211b_al7230b_finalize(struct zd_chip *chip)
+{
+ int r;
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
+ { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
+ { ZD_CR203, 0x04 },
+ { },
+ { ZD_CR240, 0x80 },
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ if (chip->new_phy_layout) {
+ /* antenna selection? */
+ r = zd_iowrite16_locked(chip, 0xe5, ZD_CR9);
+ if (r)
+ return r;
+ }
+
+ return zd_iowrite16_locked(chip, 0x04, ZD_CR203);
+}
+
+static int zd1211_al7230b_init_hw(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ /* All of these writes are identical to AL2230 unless otherwise
+ * specified */
+ static const struct zd_ioreq16 ioreqs_1[] = {
+ /* This one is 7230-specific, and happens before the rest */
+ { ZD_CR240, 0x57 },
+ { },
+
+ { ZD_CR15, 0x20 }, { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 },
+ { ZD_CR26, 0x11 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
+ { ZD_CR44, 0x33 },
+ /* This value is different for 7230 (was: 0x2a) */
+ { ZD_CR106, 0x22 },
+ { ZD_CR107, 0x1a }, { ZD_CR109, 0x09 }, { ZD_CR110, 0x27 },
+ { ZD_CR111, 0x2b }, { ZD_CR112, 0x2b }, { ZD_CR119, 0x0a },
+ /* This happened further down in AL2230,
+ * and the value changed (was: 0xe0) */
+ { ZD_CR122, 0xfc },
+ { ZD_CR10, 0x89 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR17, 0x28 },
+ { ZD_CR26, 0x93 }, { ZD_CR34, 0x30 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR35, 0x3e },
+ { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR46, 0x96 },
+ { ZD_CR47, 0x1e }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
+ { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
+ { ZD_CR92, 0x0a }, { ZD_CR99, 0x28 },
+ /* This value is different for 7230 (was: 0x00) */
+ { ZD_CR100, 0x02 },
+ { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 },
+ /* This value is different for 7230 (was: 0x24) */
+ { ZD_CR106, 0x22 },
+ /* This value is different for 7230 (was: 0x2a) */
+ { ZD_CR107, 0x3f },
+ { ZD_CR109, 0x09 },
+ /* This value is different for 7230 (was: 0x13) */
+ { ZD_CR110, 0x1f },
+ { ZD_CR111, 0x1f }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x27 },
+ /* for newest (3rd cut) AL2300 */
+ { ZD_CR115, 0x24 },
+ /* This value is different for 7230 (was: 0x24) */
+ { ZD_CR116, 0x3f },
+ /* This value is different for 7230 (was: 0xf4) */
+ { ZD_CR117, 0xfa },
+ { ZD_CR118, 0xfc }, { ZD_CR119, 0x10 }, { ZD_CR120, 0x4f },
+ { ZD_CR121, 0x77 }, { ZD_CR137, 0x88 },
+ /* This one is 7230-specific */
+ { ZD_CR138, 0xa8 },
+ /* This value is different for 7230 (was: 0xff) */
+ { ZD_CR252, 0x34 },
+ /* This value is different for 7230 (was: 0xff) */
+ { ZD_CR253, 0x34 },
+
+ /* PLL_OFF */
+ { ZD_CR251, 0x2f },
+ };
+
+ static const struct zd_ioreq16 ioreqs_2[] = {
+ { ZD_CR251, 0x3f }, /* PLL_ON */
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
+ if (r)
+ return r;
+
+ r = zd_iowrite16_locked(chip, 0x06, ZD_CR203);
+ if (r)
+ return r;
+ r = zd_iowrite16_locked(chip, 0x80, ZD_CR240);
+ if (r)
+ return r;
+
+ return 0;
+}
+
+static int zd1211b_al7230b_init_hw(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs_1[] = {
+ { ZD_CR240, 0x57 }, { ZD_CR9, 0x9 },
+ { },
+ { ZD_CR10, 0x8b }, { ZD_CR15, 0x20 },
+ { ZD_CR17, 0x2B }, /* for newest (3rd cut) AL2230 */
+ { ZD_CR20, 0x10 }, /* 4N25->Stone Request */
+ { ZD_CR23, 0x40 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
+ { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
+ { ZD_CR33, 0x28 }, /* 5613 */
+ { ZD_CR34, 0x30 },
+ { ZD_CR35, 0x3e }, /* for newest (3rd cut) AL2230 */
+ { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
+ { ZD_CR46, 0x99 }, /* for newest (3rd cut) AL2230 */
+ { ZD_CR47, 0x1e },
+
+ /* ZD1215 5610 */
+ { ZD_CR48, 0x00 }, { ZD_CR49, 0x00 }, { ZD_CR51, 0x01 },
+ { ZD_CR52, 0x80 }, { ZD_CR53, 0x7e }, { ZD_CR65, 0x00 },
+ { ZD_CR66, 0x00 }, { ZD_CR67, 0x00 }, { ZD_CR68, 0x00 },
+ { ZD_CR69, 0x28 },
+
+ { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
+ { ZD_CR87, 0x0A }, { ZD_CR89, 0x04 },
+ { ZD_CR90, 0x58 }, /* 5112 */
+ { ZD_CR91, 0x00 }, /* 5613 */
+ { ZD_CR92, 0x0a },
+ { ZD_CR98, 0x8d }, /* 4804, for 1212 new algorithm */
+ { ZD_CR99, 0x00 }, { ZD_CR100, 0x02 }, { ZD_CR101, 0x13 },
+ { ZD_CR102, 0x27 },
+ { ZD_CR106, 0x20 }, /* change to 0x24 for AL7230B */
+ { ZD_CR109, 0x13 }, /* 4804, for 1212 new algorithm */
+ { ZD_CR112, 0x1f },
+ };
+
+ static const struct zd_ioreq16 ioreqs_new_phy[] = {
+ { ZD_CR107, 0x28 },
+ { ZD_CR110, 0x1f }, /* 5127, 0x13->0x1f */
+ { ZD_CR111, 0x1f }, /* 0x13 to 0x1f for AL7230B */
+ { ZD_CR116, 0x2a }, { ZD_CR118, 0xfa }, { ZD_CR119, 0x12 },
+ { ZD_CR121, 0x6c }, /* 5613 */
+ };
+
+ static const struct zd_ioreq16 ioreqs_old_phy[] = {
+ { ZD_CR107, 0x24 },
+ { ZD_CR110, 0x13 }, /* 5127, 0x13->0x1f */
+ { ZD_CR111, 0x13 }, /* 0x13 to 0x1f for AL7230B */
+ { ZD_CR116, 0x24 }, { ZD_CR118, 0xfc }, { ZD_CR119, 0x11 },
+ { ZD_CR121, 0x6a }, /* 5613 */
+ };
+
+ static const struct zd_ioreq16 ioreqs_2[] = {
+ { ZD_CR113, 0x27 }, { ZD_CR114, 0x27 }, { ZD_CR115, 0x24 },
+ { ZD_CR117, 0xfa }, { ZD_CR120, 0x4f },
+ { ZD_CR122, 0xfc }, /* E0->FCh at 4901 */
+ { ZD_CR123, 0x57 }, /* 5613 */
+ { ZD_CR125, 0xad }, /* 4804, for 1212 new algorithm */
+ { ZD_CR126, 0x6c }, /* 5613 */
+ { ZD_CR127, 0x03 }, /* 4804, for 1212 new algorithm */
+ { ZD_CR130, 0x10 },
+ { ZD_CR131, 0x00 }, /* 5112 */
+ { ZD_CR137, 0x50 }, /* 5613 */
+ { ZD_CR138, 0xa8 }, /* 5112 */
+ { ZD_CR144, 0xac }, /* 5613 */
+ { ZD_CR148, 0x40 }, /* 5112 */
+ { ZD_CR149, 0x40 }, /* 4O07, 50->40 */
+ { ZD_CR150, 0x1a }, /* 5112, 0C->1A */
+ { ZD_CR252, 0x34 }, { ZD_CR253, 0x34 },
+ { ZD_CR251, 0x2f }, /* PLL_OFF */
+ };
+
+ static const struct zd_ioreq16 ioreqs_3[] = {
+ { ZD_CR251, 0x7f }, /* PLL_ON */
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 }, { ZD_CR130, 0x10 },
+ { ZD_CR38, 0x38 }, { ZD_CR136, 0xdf },
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs_1, ARRAY_SIZE(ioreqs_1));
+ if (r)
+ return r;
+
+ if (chip->new_phy_layout)
+ r = zd_iowrite16a_locked(chip, ioreqs_new_phy,
+ ARRAY_SIZE(ioreqs_new_phy));
+ else
+ r = zd_iowrite16a_locked(chip, ioreqs_old_phy,
+ ARRAY_SIZE(ioreqs_old_phy));
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_2, ARRAY_SIZE(ioreqs_2));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, chan_rv[0], ARRAY_SIZE(chan_rv[0]));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv_init1, ARRAY_SIZE(rv_init1));
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_3, ARRAY_SIZE(ioreqs_3));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv_init2, ARRAY_SIZE(rv_init2));
+ if (r)
+ return r;
+
+ return zd1211b_al7230b_finalize(chip);
+}
+
+static int zd1211_al7230b_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+ const u32 *rv = chan_rv[channel-1];
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs[] = {
+ /* PLL_ON */
+ { ZD_CR251, 0x3f },
+ { ZD_CR203, 0x06 }, { ZD_CR240, 0x08 },
+ };
+
+ r = zd_iowrite16_locked(chip, 0x57, ZD_CR240);
+ if (r)
+ return r;
+
+ /* PLL_OFF */
+ r = zd_iowrite16_locked(chip, 0x2f, ZD_CR251);
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
+ if (r)
+ return r;
+
+ r = zd_rfwrite_cr_locked(chip, 0x3c9000);
+ if (r)
+ return r;
+ r = zd_rfwrite_cr_locked(chip, 0xf15d58);
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv, 2);
+ if (r)
+ return r;
+
+ r = zd_rfwrite_cr_locked(chip, 0x3c9000);
+ if (r)
+ return r;
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211b_al7230b_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+ const u32 *rv = chan_rv[channel-1];
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ r = zd_iowrite16_locked(chip, 0x57, ZD_CR240);
+ if (r)
+ return r;
+ r = zd_iowrite16_locked(chip, 0xe4, ZD_CR9);
+ if (r)
+ return r;
+
+ /* PLL_OFF */
+ r = zd_iowrite16_locked(chip, 0x2f, ZD_CR251);
+ if (r)
+ return r;
+ r = zd_rfwritev_cr_locked(chip, std_rv, ARRAY_SIZE(std_rv));
+ if (r)
+ return r;
+
+ r = zd_rfwrite_cr_locked(chip, 0x3c9000);
+ if (r)
+ return r;
+ r = zd_rfwrite_cr_locked(chip, 0xf15d58);
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs_sw, ARRAY_SIZE(ioreqs_sw));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_cr_locked(chip, rv, 2);
+ if (r)
+ return r;
+
+ r = zd_rfwrite_cr_locked(chip, 0x3c9000);
+ if (r)
+ return r;
+
+ r = zd_iowrite16_locked(chip, 0x7f, ZD_CR251);
+ if (r)
+ return r;
+
+ return zd1211b_al7230b_finalize(chip);
+}
+
+static int zd1211_al7230b_switch_radio_on(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x00 },
+ { ZD_CR251, 0x3f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int zd1211b_al7230b_switch_radio_on(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x00 },
+ { ZD_CR251, 0x7f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int al7230b_switch_radio_off(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x04 },
+ { ZD_CR251, 0x2f },
+ };
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+/* ZD1211B+AL7230B 6m band edge patching differs slightly from other
+ * configurations */
+static int zd1211b_al7230b_patch_6m(struct zd_rf *rf, u8 channel)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR128, 0x14 }, { ZD_CR129, 0x12 },
+ };
+
+ /* FIXME: Channel 11 is not the edge for all regulatory domains. */
+ if (channel == 1) {
+ ioreqs[0].value = 0x0e;
+ ioreqs[1].value = 0x10;
+ } else if (channel == 11) {
+ ioreqs[0].value = 0x10;
+ ioreqs[1].value = 0x10;
+ }
+
+ dev_dbg_f(zd_chip_dev(chip), "patching for channel %d\n", channel);
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+int zd_rf_init_al7230b(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ if (zd_chip_is_zd1211b(chip)) {
+ rf->init_hw = zd1211b_al7230b_init_hw;
+ rf->switch_radio_on = zd1211b_al7230b_switch_radio_on;
+ rf->set_channel = zd1211b_al7230b_set_channel;
+ rf->patch_6m_band_edge = zd1211b_al7230b_patch_6m;
+ } else {
+ rf->init_hw = zd1211_al7230b_init_hw;
+ rf->switch_radio_on = zd1211_al7230b_switch_radio_on;
+ rf->set_channel = zd1211_al7230b_set_channel;
+ rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
+ rf->patch_cck_gain = 1;
+ }
+
+ rf->switch_radio_off = al7230b_switch_radio_off;
+
+ return 0;
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+
+#include "zd_rf.h"
+#include "zd_usb.h"
+#include "zd_chip.h"
+
+static const u32 rf2959_table[][2] = {
+ RF_CHANNEL( 1) = { 0x181979, 0x1e6666 },
+ RF_CHANNEL( 2) = { 0x181989, 0x1e6666 },
+ RF_CHANNEL( 3) = { 0x181999, 0x1e6666 },
+ RF_CHANNEL( 4) = { 0x1819a9, 0x1e6666 },
+ RF_CHANNEL( 5) = { 0x1819b9, 0x1e6666 },
+ RF_CHANNEL( 6) = { 0x1819c9, 0x1e6666 },
+ RF_CHANNEL( 7) = { 0x1819d9, 0x1e6666 },
+ RF_CHANNEL( 8) = { 0x1819e9, 0x1e6666 },
+ RF_CHANNEL( 9) = { 0x1819f9, 0x1e6666 },
+ RF_CHANNEL(10) = { 0x181a09, 0x1e6666 },
+ RF_CHANNEL(11) = { 0x181a19, 0x1e6666 },
+ RF_CHANNEL(12) = { 0x181a29, 0x1e6666 },
+ RF_CHANNEL(13) = { 0x181a39, 0x1e6666 },
+ RF_CHANNEL(14) = { 0x181a60, 0x1c0000 },
+};
+
+#if 0
+static int bits(u32 rw, int from, int to)
+{
+ rw &= ~(0xffffffffU << (to+1));
+ rw >>= from;
+ return rw;
+}
+
+static int bit(u32 rw, int bit)
+{
+ return bits(rw, bit, bit);
+}
+
+static void dump_regwrite(u32 rw)
+{
+ int reg = bits(rw, 18, 22);
+ int rw_flag = bits(rw, 23, 23);
+ PDEBUG("rf2959 %#010x reg %d rw %d", rw, reg, rw_flag);
+
+ switch (reg) {
+ case 0:
+ PDEBUG("reg0 CFG1 ref_sel %d hybernate %d rf_vco_reg_en %d"
+ " if_vco_reg_en %d if_vga_en %d",
+ bits(rw, 14, 15), bit(rw, 3), bit(rw, 2), bit(rw, 1),
+ bit(rw, 0));
+ break;
+ case 1:
+ PDEBUG("reg1 IFPLL1 pll_en1 %d kv_en1 %d vtc_en1 %d lpf1 %d"
+ " cpl1 %d pdp1 %d autocal_en1 %d ld_en1 %d ifloopr %d"
+ " ifloopc %d dac1 %d",
+ bit(rw, 17), bit(rw, 16), bit(rw, 15), bit(rw, 14),
+ bit(rw, 13), bit(rw, 12), bit(rw, 11), bit(rw, 10),
+ bits(rw, 7, 9), bits(rw, 4, 6), bits(rw, 0, 3));
+ break;
+ case 2:
+ PDEBUG("reg2 IFPLL2 n1 %d num1 %d",
+ bits(rw, 6, 17), bits(rw, 0, 5));
+ break;
+ case 3:
+ PDEBUG("reg3 IFPLL3 num %d", bits(rw, 0, 17));
+ break;
+ case 4:
+ PDEBUG("reg4 IFPLL4 dn1 %#04x ct_def1 %d kv_def1 %d",
+ bits(rw, 8, 16), bits(rw, 4, 7), bits(rw, 0, 3));
+ break;
+ case 5:
+ PDEBUG("reg5 RFPLL1 pll_en %d kv_en %d vtc_en %d lpf %d cpl %d"
+ " pdp %d autocal_en %d ld_en %d rfloopr %d rfloopc %d"
+ " dac %d",
+ bit(rw, 17), bit(rw, 16), bit(rw, 15), bit(rw, 14),
+ bit(rw, 13), bit(rw, 12), bit(rw, 11), bit(rw, 10),
+ bits(rw, 7, 9), bits(rw, 4, 6), bits(rw, 0,3));
+ break;
+ case 6:
+ PDEBUG("reg6 RFPLL2 n %d num %d",
+ bits(rw, 6, 17), bits(rw, 0, 5));
+ break;
+ case 7:
+ PDEBUG("reg7 RFPLL3 num2 %d", bits(rw, 0, 17));
+ break;
+ case 8:
+ PDEBUG("reg8 RFPLL4 dn %#06x ct_def %d kv_def %d",
+ bits(rw, 8, 16), bits(rw, 4, 7), bits(rw, 0, 3));
+ break;
+ case 9:
+ PDEBUG("reg9 CAL1 tvco %d tlock %d m_ct_value %d ld_window %d",
+ bits(rw, 13, 17), bits(rw, 8, 12), bits(rw, 3, 7),
+ bits(rw, 0, 2));
+ break;
+ case 10:
+ PDEBUG("reg10 TXRX1 rxdcfbbyps %d pcontrol %d txvgc %d"
+ " rxlpfbw %d txlpfbw %d txdiffmode %d txenmode %d"
+ " intbiasen %d tybypass %d",
+ bit(rw, 17), bits(rw, 15, 16), bits(rw, 10, 14),
+ bits(rw, 7, 9), bits(rw, 4, 6), bit(rw, 3), bit(rw, 2),
+ bit(rw, 1), bit(rw, 0));
+ break;
+ case 11:
+ PDEBUG("reg11 PCNT1 mid_bias %d p_desired %d pc_offset %d"
+ " tx_delay %d",
+ bits(rw, 15, 17), bits(rw, 9, 14), bits(rw, 3, 8),
+ bits(rw, 0, 2));
+ break;
+ case 12:
+ PDEBUG("reg12 PCNT2 max_power %d mid_power %d min_power %d",
+ bits(rw, 12, 17), bits(rw, 6, 11), bits(rw, 0, 5));
+ break;
+ case 13:
+ PDEBUG("reg13 VCOT1 rfpll vco comp %d ifpll vco comp %d"
+ " lobias %d if_biasbuf %d if_biasvco %d rf_biasbuf %d"
+ " rf_biasvco %d",
+ bit(rw, 17), bit(rw, 16), bit(rw, 15),
+ bits(rw, 8, 9), bits(rw, 5, 7), bits(rw, 3, 4),
+ bits(rw, 0, 2));
+ break;
+ case 14:
+ PDEBUG("reg14 IQCAL rx_acal %d rx_pcal %d"
+ " tx_acal %d tx_pcal %d",
+ bits(rw, 13, 17), bits(rw, 9, 12), bits(rw, 4, 8),
+ bits(rw, 0, 3));
+ break;
+ }
+}
+#endif /* 0 */
+
+static int rf2959_init_hw(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR2, 0x1E }, { ZD_CR9, 0x20 }, { ZD_CR10, 0x89 },
+ { ZD_CR11, 0x00 }, { ZD_CR15, 0xD0 }, { ZD_CR17, 0x68 },
+ { ZD_CR19, 0x4a }, { ZD_CR20, 0x0c }, { ZD_CR21, 0x0E },
+ { ZD_CR23, 0x48 },
+ /* normal size for cca threshold */
+ { ZD_CR24, 0x14 },
+ /* { ZD_CR24, 0x20 }, */
+ { ZD_CR26, 0x90 }, { ZD_CR27, 0x30 }, { ZD_CR29, 0x20 },
+ { ZD_CR31, 0xb2 }, { ZD_CR32, 0x43 }, { ZD_CR33, 0x28 },
+ { ZD_CR38, 0x30 }, { ZD_CR34, 0x0f }, { ZD_CR35, 0xF0 },
+ { ZD_CR41, 0x2a }, { ZD_CR46, 0x7F }, { ZD_CR47, 0x1E },
+ { ZD_CR51, 0xc5 }, { ZD_CR52, 0xc5 }, { ZD_CR53, 0xc5 },
+ { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 },
+ { ZD_CR82, 0x00 }, { ZD_CR83, 0x24 }, { ZD_CR84, 0x04 },
+ { ZD_CR85, 0x00 }, { ZD_CR86, 0x10 }, { ZD_CR87, 0x2A },
+ { ZD_CR88, 0x10 }, { ZD_CR89, 0x24 }, { ZD_CR90, 0x18 },
+ /* { ZD_CR91, 0x18 }, */
+ /* should solve continuous CTS frame problems */
+ { ZD_CR91, 0x00 },
+ { ZD_CR92, 0x0a }, { ZD_CR93, 0x00 }, { ZD_CR94, 0x01 },
+ { ZD_CR95, 0x00 }, { ZD_CR96, 0x40 }, { ZD_CR97, 0x37 },
+ { ZD_CR98, 0x05 }, { ZD_CR99, 0x28 }, { ZD_CR100, 0x00 },
+ { ZD_CR101, 0x13 }, { ZD_CR102, 0x27 }, { ZD_CR103, 0x27 },
+ { ZD_CR104, 0x18 }, { ZD_CR105, 0x12 },
+ /* normal size */
+ { ZD_CR106, 0x1a },
+ /* { ZD_CR106, 0x22 }, */
+ { ZD_CR107, 0x24 }, { ZD_CR108, 0x0a }, { ZD_CR109, 0x13 },
+ { ZD_CR110, 0x2F }, { ZD_CR111, 0x27 }, { ZD_CR112, 0x27 },
+ { ZD_CR113, 0x27 }, { ZD_CR114, 0x27 }, { ZD_CR115, 0x40 },
+ { ZD_CR116, 0x40 }, { ZD_CR117, 0xF0 }, { ZD_CR118, 0xF0 },
+ { ZD_CR119, 0x16 },
+ /* no TX continuation */
+ { ZD_CR122, 0x00 },
+ /* { ZD_CR122, 0xff }, */
+ { ZD_CR127, 0x03 }, { ZD_CR131, 0x08 }, { ZD_CR138, 0x28 },
+ { ZD_CR148, 0x44 }, { ZD_CR150, 0x10 }, { ZD_CR169, 0xBB },
+ { ZD_CR170, 0xBB },
+ };
+
+ static const u32 rv[] = {
+ 0x000007, /* REG0(CFG1) */
+ 0x07dd43, /* REG1(IFPLL1) */
+ 0x080959, /* REG2(IFPLL2) */
+ 0x0e6666,
+ 0x116a57, /* REG4 */
+ 0x17dd43, /* REG5 */
+ 0x1819f9, /* REG6 */
+ 0x1e6666,
+ 0x214554,
+ 0x25e7fa,
+ 0x27fffa,
+ /* The Zydas driver somehow forgets to set this value. It's
+ * only set for Japan. We are using internal power control
+ * for now.
+ */
+ 0x294128, /* internal power */
+ /* 0x28252c, */ /* External control TX power */
+ /* ZD_CR31_CCK, ZD_CR51_6-36M, ZD_CR52_48M, ZD_CR53_54M */
+ 0x2c0000,
+ 0x300000,
+ 0x340000, /* REG13(0xD) */
+ 0x381e0f, /* REG14(0xE) */
+ /* Bogus, RF2959's data sheet doesn't know register 27, which is
+ * actually referenced here. The commented 0x11 is 17.
+ */
+ 0x6c180f, /* REG27(0x11) */
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ return zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
+}
+
+static int rf2959_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int i, r;
+ const u32 *rv = rf2959_table[channel-1];
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ for (i = 0; i < 2; i++) {
+ r = zd_rfwrite_locked(chip, rv[i], RF_RV_BITS);
+ if (r)
+ return r;
+ }
+ return 0;
+}
+
+static int rf2959_switch_radio_on(struct zd_rf *rf)
+{
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR10, 0x89 },
+ { ZD_CR11, 0x00 },
+ };
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int rf2959_switch_radio_off(struct zd_rf *rf)
+{
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR10, 0x15 },
+ { ZD_CR11, 0x81 },
+ };
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+int zd_rf_init_rf2959(struct zd_rf *rf)
+{
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ if (zd_chip_is_zd1211b(chip)) {
+ dev_err(zd_chip_dev(chip),
+ "RF2959 is currently not supported for ZD1211B"
+ " devices\n");
+ return -ENODEV;
+ }
+ rf->init_hw = rf2959_init_hw;
+ rf->set_channel = rf2959_set_channel;
+ rf->switch_radio_on = rf2959_switch_radio_on;
+ rf->switch_radio_off = rf2959_switch_radio_off;
+ return 0;
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+#include <linux/slab.h>
+
+#include "zd_rf.h"
+#include "zd_usb.h"
+#include "zd_chip.h"
+
+/* This RF programming code is based upon the code found in v2.16.0.0 of the
+ * ZyDAS vendor driver. Unlike other RF's, Ubec publish full technical specs
+ * for this RF on their website, so we're able to understand more than
+ * usual as to what is going on. Thumbs up for Ubec for doing that. */
+
+/* The 3-wire serial interface provides access to 8 write-only registers.
+ * The data format is a 4 bit register address followed by a 20 bit value. */
+#define UW2453_REGWRITE(reg, val) ((((reg) & 0xf) << 20) | ((val) & 0xfffff))
+
+/* For channel tuning, we have to configure registers 1 (synthesizer), 2 (synth
+ * fractional divide ratio) and 3 (VCO config).
+ *
+ * We configure the RF to produce an interrupt when the PLL is locked onto
+ * the configured frequency. During initialization, we run through a variety
+ * of different VCO configurations on channel 1 until we detect a PLL lock.
+ * When this happens, we remember which VCO configuration produced the lock
+ * and use it later. Actually, we use the configuration *after* the one that
+ * produced the lock, which seems odd, but it works.
+ *
+ * If we do not see a PLL lock on any standard VCO config, we fall back on an
+ * autocal configuration, which has a fixed (as opposed to per-channel) VCO
+ * config and different synth values from the standard set (divide ratio
+ * is still shared with the standard set). */
+
+/* The per-channel synth values for all standard VCO configurations. These get
+ * written to register 1. */
+static const u8 uw2453_std_synth[] = {
+ RF_CHANNEL( 1) = 0x47,
+ RF_CHANNEL( 2) = 0x47,
+ RF_CHANNEL( 3) = 0x67,
+ RF_CHANNEL( 4) = 0x67,
+ RF_CHANNEL( 5) = 0x67,
+ RF_CHANNEL( 6) = 0x67,
+ RF_CHANNEL( 7) = 0x57,
+ RF_CHANNEL( 8) = 0x57,
+ RF_CHANNEL( 9) = 0x57,
+ RF_CHANNEL(10) = 0x57,
+ RF_CHANNEL(11) = 0x77,
+ RF_CHANNEL(12) = 0x77,
+ RF_CHANNEL(13) = 0x77,
+ RF_CHANNEL(14) = 0x4f,
+};
+
+/* This table stores the synthesizer fractional divide ratio for *all* VCO
+ * configurations (both standard and autocal). These get written to register 2.
+ */
+static const u16 uw2453_synth_divide[] = {
+ RF_CHANNEL( 1) = 0x999,
+ RF_CHANNEL( 2) = 0x99b,
+ RF_CHANNEL( 3) = 0x998,
+ RF_CHANNEL( 4) = 0x99a,
+ RF_CHANNEL( 5) = 0x999,
+ RF_CHANNEL( 6) = 0x99b,
+ RF_CHANNEL( 7) = 0x998,
+ RF_CHANNEL( 8) = 0x99a,
+ RF_CHANNEL( 9) = 0x999,
+ RF_CHANNEL(10) = 0x99b,
+ RF_CHANNEL(11) = 0x998,
+ RF_CHANNEL(12) = 0x99a,
+ RF_CHANNEL(13) = 0x999,
+ RF_CHANNEL(14) = 0xccc,
+};
+
+/* Here is the data for all the standard VCO configurations. We shrink our
+ * table a little by observing that both channels in a consecutive pair share
+ * the same value. We also observe that the high 4 bits ([0:3] in the specs)
+ * are all 'Reserved' and are always set to 0x4 - we chop them off in the data
+ * below. */
+#define CHAN_TO_PAIRIDX(a) ((a - 1) / 2)
+#define RF_CHANPAIR(a,b) [CHAN_TO_PAIRIDX(a)]
+static const u16 uw2453_std_vco_cfg[][7] = {
+ { /* table 1 */
+ RF_CHANPAIR( 1, 2) = 0x664d,
+ RF_CHANPAIR( 3, 4) = 0x604d,
+ RF_CHANPAIR( 5, 6) = 0x6675,
+ RF_CHANPAIR( 7, 8) = 0x6475,
+ RF_CHANPAIR( 9, 10) = 0x6655,
+ RF_CHANPAIR(11, 12) = 0x6455,
+ RF_CHANPAIR(13, 14) = 0x6665,
+ },
+ { /* table 2 */
+ RF_CHANPAIR( 1, 2) = 0x666d,
+ RF_CHANPAIR( 3, 4) = 0x606d,
+ RF_CHANPAIR( 5, 6) = 0x664d,
+ RF_CHANPAIR( 7, 8) = 0x644d,
+ RF_CHANPAIR( 9, 10) = 0x6675,
+ RF_CHANPAIR(11, 12) = 0x6475,
+ RF_CHANPAIR(13, 14) = 0x6655,
+ },
+ { /* table 3 */
+ RF_CHANPAIR( 1, 2) = 0x665d,
+ RF_CHANPAIR( 3, 4) = 0x605d,
+ RF_CHANPAIR( 5, 6) = 0x666d,
+ RF_CHANPAIR( 7, 8) = 0x646d,
+ RF_CHANPAIR( 9, 10) = 0x664d,
+ RF_CHANPAIR(11, 12) = 0x644d,
+ RF_CHANPAIR(13, 14) = 0x6675,
+ },
+ { /* table 4 */
+ RF_CHANPAIR( 1, 2) = 0x667d,
+ RF_CHANPAIR( 3, 4) = 0x607d,
+ RF_CHANPAIR( 5, 6) = 0x665d,
+ RF_CHANPAIR( 7, 8) = 0x645d,
+ RF_CHANPAIR( 9, 10) = 0x666d,
+ RF_CHANPAIR(11, 12) = 0x646d,
+ RF_CHANPAIR(13, 14) = 0x664d,
+ },
+ { /* table 5 */
+ RF_CHANPAIR( 1, 2) = 0x6643,
+ RF_CHANPAIR( 3, 4) = 0x6043,
+ RF_CHANPAIR( 5, 6) = 0x667d,
+ RF_CHANPAIR( 7, 8) = 0x647d,
+ RF_CHANPAIR( 9, 10) = 0x665d,
+ RF_CHANPAIR(11, 12) = 0x645d,
+ RF_CHANPAIR(13, 14) = 0x666d,
+ },
+ { /* table 6 */
+ RF_CHANPAIR( 1, 2) = 0x6663,
+ RF_CHANPAIR( 3, 4) = 0x6063,
+ RF_CHANPAIR( 5, 6) = 0x6643,
+ RF_CHANPAIR( 7, 8) = 0x6443,
+ RF_CHANPAIR( 9, 10) = 0x667d,
+ RF_CHANPAIR(11, 12) = 0x647d,
+ RF_CHANPAIR(13, 14) = 0x665d,
+ },
+ { /* table 7 */
+ RF_CHANPAIR( 1, 2) = 0x6653,
+ RF_CHANPAIR( 3, 4) = 0x6053,
+ RF_CHANPAIR( 5, 6) = 0x6663,
+ RF_CHANPAIR( 7, 8) = 0x6463,
+ RF_CHANPAIR( 9, 10) = 0x6643,
+ RF_CHANPAIR(11, 12) = 0x6443,
+ RF_CHANPAIR(13, 14) = 0x667d,
+ },
+ { /* table 8 */
+ RF_CHANPAIR( 1, 2) = 0x6673,
+ RF_CHANPAIR( 3, 4) = 0x6073,
+ RF_CHANPAIR( 5, 6) = 0x6653,
+ RF_CHANPAIR( 7, 8) = 0x6453,
+ RF_CHANPAIR( 9, 10) = 0x6663,
+ RF_CHANPAIR(11, 12) = 0x6463,
+ RF_CHANPAIR(13, 14) = 0x6643,
+ },
+ { /* table 9 */
+ RF_CHANPAIR( 1, 2) = 0x664b,
+ RF_CHANPAIR( 3, 4) = 0x604b,
+ RF_CHANPAIR( 5, 6) = 0x6673,
+ RF_CHANPAIR( 7, 8) = 0x6473,
+ RF_CHANPAIR( 9, 10) = 0x6653,
+ RF_CHANPAIR(11, 12) = 0x6453,
+ RF_CHANPAIR(13, 14) = 0x6663,
+ },
+ { /* table 10 */
+ RF_CHANPAIR( 1, 2) = 0x666b,
+ RF_CHANPAIR( 3, 4) = 0x606b,
+ RF_CHANPAIR( 5, 6) = 0x664b,
+ RF_CHANPAIR( 7, 8) = 0x644b,
+ RF_CHANPAIR( 9, 10) = 0x6673,
+ RF_CHANPAIR(11, 12) = 0x6473,
+ RF_CHANPAIR(13, 14) = 0x6653,
+ },
+ { /* table 11 */
+ RF_CHANPAIR( 1, 2) = 0x665b,
+ RF_CHANPAIR( 3, 4) = 0x605b,
+ RF_CHANPAIR( 5, 6) = 0x666b,
+ RF_CHANPAIR( 7, 8) = 0x646b,
+ RF_CHANPAIR( 9, 10) = 0x664b,
+ RF_CHANPAIR(11, 12) = 0x644b,
+ RF_CHANPAIR(13, 14) = 0x6673,
+ },
+
+};
+
+/* The per-channel synth values for autocal. These get written to register 1. */
+static const u16 uw2453_autocal_synth[] = {
+ RF_CHANNEL( 1) = 0x6847,
+ RF_CHANNEL( 2) = 0x6847,
+ RF_CHANNEL( 3) = 0x6867,
+ RF_CHANNEL( 4) = 0x6867,
+ RF_CHANNEL( 5) = 0x6867,
+ RF_CHANNEL( 6) = 0x6867,
+ RF_CHANNEL( 7) = 0x6857,
+ RF_CHANNEL( 8) = 0x6857,
+ RF_CHANNEL( 9) = 0x6857,
+ RF_CHANNEL(10) = 0x6857,
+ RF_CHANNEL(11) = 0x6877,
+ RF_CHANNEL(12) = 0x6877,
+ RF_CHANNEL(13) = 0x6877,
+ RF_CHANNEL(14) = 0x684f,
+};
+
+/* The VCO configuration for autocal (all channels) */
+static const u16 UW2453_AUTOCAL_VCO_CFG = 0x6662;
+
+/* TX gain settings. The array index corresponds to the TX power integration
+ * values found in the EEPROM. The values get written to register 7. */
+static u32 uw2453_txgain[] = {
+ [0x00] = 0x0e313,
+ [0x01] = 0x0fb13,
+ [0x02] = 0x0e093,
+ [0x03] = 0x0f893,
+ [0x04] = 0x0ea93,
+ [0x05] = 0x1f093,
+ [0x06] = 0x1f493,
+ [0x07] = 0x1f693,
+ [0x08] = 0x1f393,
+ [0x09] = 0x1f35b,
+ [0x0a] = 0x1e6db,
+ [0x0b] = 0x1ff3f,
+ [0x0c] = 0x1ffff,
+ [0x0d] = 0x361d7,
+ [0x0e] = 0x37fbf,
+ [0x0f] = 0x3ff8b,
+ [0x10] = 0x3ff33,
+ [0x11] = 0x3fb3f,
+ [0x12] = 0x3ffff,
+};
+
+/* RF-specific structure */
+struct uw2453_priv {
+ /* index into synth/VCO config tables where PLL lock was found
+ * -1 means autocal */
+ int config;
+};
+
+#define UW2453_PRIV(rf) ((struct uw2453_priv *) (rf)->priv)
+
+static int uw2453_synth_set_channel(struct zd_chip *chip, int channel,
+ bool autocal)
+{
+ int r;
+ int idx = channel - 1;
+ u32 val;
+
+ if (autocal)
+ val = UW2453_REGWRITE(1, uw2453_autocal_synth[idx]);
+ else
+ val = UW2453_REGWRITE(1, uw2453_std_synth[idx]);
+
+ r = zd_rfwrite_locked(chip, val, RF_RV_BITS);
+ if (r)
+ return r;
+
+ return zd_rfwrite_locked(chip,
+ UW2453_REGWRITE(2, uw2453_synth_divide[idx]), RF_RV_BITS);
+}
+
+static int uw2453_write_vco_cfg(struct zd_chip *chip, u16 value)
+{
+ /* vendor driver always sets these upper bits even though the specs say
+ * they are reserved */
+ u32 val = 0x40000 | value;
+ return zd_rfwrite_locked(chip, UW2453_REGWRITE(3, val), RF_RV_BITS);
+}
+
+static int uw2453_init_mode(struct zd_chip *chip)
+{
+ static const u32 rv[] = {
+ UW2453_REGWRITE(0, 0x25f98), /* enter IDLE mode */
+ UW2453_REGWRITE(0, 0x25f9a), /* enter CAL_VCO mode */
+ UW2453_REGWRITE(0, 0x25f94), /* enter RX/TX mode */
+ UW2453_REGWRITE(0, 0x27fd4), /* power down RSSI circuit */
+ };
+
+ return zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
+}
+
+static int uw2453_set_tx_gain_level(struct zd_chip *chip, int channel)
+{
+ u8 int_value = chip->pwr_int_values[channel - 1];
+
+ if (int_value >= ARRAY_SIZE(uw2453_txgain)) {
+ dev_dbg_f(zd_chip_dev(chip), "can't configure TX gain for "
+ "int value %x on channel %d\n", int_value, channel);
+ return 0;
+ }
+
+ return zd_rfwrite_locked(chip,
+ UW2453_REGWRITE(7, uw2453_txgain[int_value]), RF_RV_BITS);
+}
+
+static int uw2453_init_hw(struct zd_rf *rf)
+{
+ int i, r;
+ int found_config = -1;
+ u16 intr_status;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR10, 0x89 }, { ZD_CR15, 0x20 },
+ { ZD_CR17, 0x28 }, /* 6112 no change */
+ { ZD_CR23, 0x38 }, { ZD_CR24, 0x20 }, { ZD_CR26, 0x93 },
+ { ZD_CR27, 0x15 }, { ZD_CR28, 0x3e }, { ZD_CR29, 0x00 },
+ { ZD_CR33, 0x28 }, { ZD_CR34, 0x30 },
+ { ZD_CR35, 0x43 }, /* 6112 3e->43 */
+ { ZD_CR41, 0x24 }, { ZD_CR44, 0x32 },
+ { ZD_CR46, 0x92 }, /* 6112 96->92 */
+ { ZD_CR47, 0x1e },
+ { ZD_CR48, 0x04 }, /* 5602 Roger */
+ { ZD_CR49, 0xfa }, { ZD_CR79, 0x58 }, { ZD_CR80, 0x30 },
+ { ZD_CR81, 0x30 }, { ZD_CR87, 0x0a }, { ZD_CR89, 0x04 },
+ { ZD_CR91, 0x00 }, { ZD_CR92, 0x0a }, { ZD_CR98, 0x8d },
+ { ZD_CR99, 0x28 }, { ZD_CR100, 0x02 },
+ { ZD_CR101, 0x09 }, /* 6112 13->1f 6220 1f->13 6407 13->9 */
+ { ZD_CR102, 0x27 },
+ { ZD_CR106, 0x1c }, /* 5d07 5112 1f->1c 6220 1c->1f
+ * 6221 1f->1c
+ */
+ { ZD_CR107, 0x1c }, /* 6220 1c->1a 5221 1a->1c */
+ { ZD_CR109, 0x13 },
+ { ZD_CR110, 0x1f }, /* 6112 13->1f 6221 1f->13 6407 13->0x09 */
+ { ZD_CR111, 0x13 }, { ZD_CR112, 0x1f }, { ZD_CR113, 0x27 },
+ { ZD_CR114, 0x23 }, /* 6221 27->23 */
+ { ZD_CR115, 0x24 }, /* 6112 24->1c 6220 1c->24 */
+ { ZD_CR116, 0x24 }, /* 6220 1c->24 */
+ { ZD_CR117, 0xfa }, /* 6112 fa->f8 6220 f8->f4 6220 f4->fa */
+ { ZD_CR118, 0xf0 }, /* 5d07 6112 f0->f2 6220 f2->f0 */
+ { ZD_CR119, 0x1a }, /* 6112 1a->10 6220 10->14 6220 14->1a */
+ { ZD_CR120, 0x4f },
+ { ZD_CR121, 0x1f }, /* 6220 4f->1f */
+ { ZD_CR122, 0xf0 }, { ZD_CR123, 0x57 }, { ZD_CR125, 0xad },
+ { ZD_CR126, 0x6c }, { ZD_CR127, 0x03 },
+ { ZD_CR128, 0x14 }, /* 6302 12->11 */
+ { ZD_CR129, 0x12 }, /* 6301 10->0f */
+ { ZD_CR130, 0x10 }, { ZD_CR137, 0x50 }, { ZD_CR138, 0xa8 },
+ { ZD_CR144, 0xac }, { ZD_CR146, 0x20 }, { ZD_CR252, 0xff },
+ { ZD_CR253, 0xff },
+ };
+
+ static const u32 rv[] = {
+ UW2453_REGWRITE(4, 0x2b), /* configure receiver gain */
+ UW2453_REGWRITE(5, 0x19e4f), /* configure transmitter gain */
+ UW2453_REGWRITE(6, 0xf81ad), /* enable RX/TX filter tuning */
+ UW2453_REGWRITE(7, 0x3fffe), /* disable TX gain in test mode */
+
+ /* enter CAL_FIL mode, TX gain set by registers, RX gain set by pins,
+ * RSSI circuit powered down, reduced RSSI range */
+ UW2453_REGWRITE(0, 0x25f9c), /* 5d01 cal_fil */
+
+ /* synthesizer configuration for channel 1 */
+ UW2453_REGWRITE(1, 0x47),
+ UW2453_REGWRITE(2, 0x999),
+
+ /* disable manual VCO band selection */
+ UW2453_REGWRITE(3, 0x7602),
+
+ /* enable manual VCO band selection, configure current level */
+ UW2453_REGWRITE(3, 0x46063),
+ };
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ r = zd_rfwritev_locked(chip, rv, ARRAY_SIZE(rv), RF_RV_BITS);
+ if (r)
+ return r;
+
+ r = uw2453_init_mode(chip);
+ if (r)
+ return r;
+
+ /* Try all standard VCO configuration settings on channel 1 */
+ for (i = 0; i < ARRAY_SIZE(uw2453_std_vco_cfg) - 1; i++) {
+ /* Configure synthesizer for channel 1 */
+ r = uw2453_synth_set_channel(chip, 1, false);
+ if (r)
+ return r;
+
+ /* Write VCO config */
+ r = uw2453_write_vco_cfg(chip, uw2453_std_vco_cfg[i][0]);
+ if (r)
+ return r;
+
+ /* ack interrupt event */
+ r = zd_iowrite16_locked(chip, 0x0f, UW2453_INTR_REG);
+ if (r)
+ return r;
+
+ /* check interrupt status */
+ r = zd_ioread16_locked(chip, &intr_status, UW2453_INTR_REG);
+ if (r)
+ return r;
+
+ if (!(intr_status & 0xf)) {
+ dev_dbg_f(zd_chip_dev(chip),
+ "PLL locked on configuration %d\n", i);
+ found_config = i;
+ break;
+ }
+ }
+
+ if (found_config == -1) {
+ /* autocal */
+ dev_dbg_f(zd_chip_dev(chip),
+ "PLL did not lock, using autocal\n");
+
+ r = uw2453_synth_set_channel(chip, 1, true);
+ if (r)
+ return r;
+
+ r = uw2453_write_vco_cfg(chip, UW2453_AUTOCAL_VCO_CFG);
+ if (r)
+ return r;
+ }
+
+ /* To match the vendor driver behaviour, we use the configuration after
+ * the one that produced a lock. */
+ UW2453_PRIV(rf)->config = found_config + 1;
+
+ return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
+}
+
+static int uw2453_set_channel(struct zd_rf *rf, u8 channel)
+{
+ int r;
+ u16 vco_cfg;
+ int config = UW2453_PRIV(rf)->config;
+ bool autocal = (config == -1);
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR80, 0x30 }, { ZD_CR81, 0x30 }, { ZD_CR79, 0x58 },
+ { ZD_CR12, 0xf0 }, { ZD_CR77, 0x1b }, { ZD_CR78, 0x58 },
+ };
+
+ r = uw2453_synth_set_channel(chip, channel, autocal);
+ if (r)
+ return r;
+
+ if (autocal)
+ vco_cfg = UW2453_AUTOCAL_VCO_CFG;
+ else
+ vco_cfg = uw2453_std_vco_cfg[config][CHAN_TO_PAIRIDX(channel)];
+
+ r = uw2453_write_vco_cfg(chip, vco_cfg);
+ if (r)
+ return r;
+
+ r = uw2453_init_mode(chip);
+ if (r)
+ return r;
+
+ r = zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+ if (r)
+ return r;
+
+ r = uw2453_set_tx_gain_level(chip, channel);
+ if (r)
+ return r;
+
+ return zd_iowrite16_locked(chip, 0x06, ZD_CR203);
+}
+
+static int uw2453_switch_radio_on(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x00 }, { ZD_CR251, 0x3f },
+ };
+
+ /* enter RXTX mode */
+ r = zd_rfwrite_locked(chip, UW2453_REGWRITE(0, 0x25f94), RF_RV_BITS);
+ if (r)
+ return r;
+
+ if (zd_chip_is_zd1211b(chip))
+ ioreqs[1].value = 0x7f;
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static int uw2453_switch_radio_off(struct zd_rf *rf)
+{
+ int r;
+ struct zd_chip *chip = zd_rf_to_chip(rf);
+ static const struct zd_ioreq16 ioreqs[] = {
+ { ZD_CR11, 0x04 }, { ZD_CR251, 0x2f },
+ };
+
+ /* enter IDLE mode */
+ /* FIXME: shouldn't we go to SLEEP? sent email to zydas */
+ r = zd_rfwrite_locked(chip, UW2453_REGWRITE(0, 0x25f90), RF_RV_BITS);
+ if (r)
+ return r;
+
+ return zd_iowrite16a_locked(chip, ioreqs, ARRAY_SIZE(ioreqs));
+}
+
+static void uw2453_clear(struct zd_rf *rf)
+{
+ kfree(rf->priv);
+}
+
+int zd_rf_init_uw2453(struct zd_rf *rf)
+{
+ rf->init_hw = uw2453_init_hw;
+ rf->set_channel = uw2453_set_channel;
+ rf->switch_radio_on = uw2453_switch_radio_on;
+ rf->switch_radio_off = uw2453_switch_radio_off;
+ rf->patch_6m_band_edge = zd_rf_generic_patch_6m;
+ rf->clear = uw2453_clear;
+ /* we have our own TX integration code */
+ rf->update_channel_int = 0;
+
+ rf->priv = kmalloc(sizeof(struct uw2453_priv), GFP_KERNEL);
+ if (rf->priv == NULL)
+ return -ENOMEM;
+
+ return 0;
+}
+
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright (C) 2006-2007 Michael Wu <flamingice@sourmilk.net>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/firmware.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/skbuff.h>
+#include <linux/usb.h>
+#include <linux/workqueue.h>
+#include <linux/module.h>
+#include <net/mac80211.h>
+#include <asm/unaligned.h>
+
+#include "zd_def.h"
+#include "zd_mac.h"
+#include "zd_usb.h"
+
+static struct usb_device_id usb_ids[] = {
+ /* ZD1211 */
+ { USB_DEVICE(0x0105, 0x145f), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0586, 0x3401), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0586, 0x3402), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0586, 0x3407), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0586, 0x3409), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x079b, 0x004a), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0ace, 0x1211), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0ace, 0xa211), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0b05, 0x170c), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0b3b, 0x1630), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0b3b, 0x5630), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0df6, 0x9071), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x0df6, 0x9075), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x126f, 0xa006), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x129b, 0x1666), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x13b1, 0x001e), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x1435, 0x0711), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x14ea, 0xab10), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x14ea, 0xab13), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x157e, 0x300a), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x157e, 0x300b), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x157e, 0x3204), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x157e, 0x3207), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x1740, 0x2000), .driver_info = DEVICE_ZD1211 },
+ { USB_DEVICE(0x6891, 0xa727), .driver_info = DEVICE_ZD1211 },
+ /* ZD1211B */
+ { USB_DEVICE(0x0053, 0x5301), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0409, 0x0248), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0411, 0x00da), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0471, 0x1236), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0471, 0x1237), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x050d, 0x705c), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x054c, 0x0257), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0586, 0x340a), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0586, 0x340f), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0586, 0x3410), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0586, 0x3412), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0586, 0x3413), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x079b, 0x0062), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x07b8, 0x6001), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x07fa, 0x1196), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x083a, 0x4505), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x083a, 0xe501), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x083a, 0xe503), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x083a, 0xe506), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0ace, 0x1215), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0ace, 0xb215), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0b05, 0x171b), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0baf, 0x0121), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0cde, 0x001a), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x0df6, 0x0036), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x129b, 0x1667), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x13b1, 0x0024), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x157e, 0x300d), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x1582, 0x6003), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x2019, 0x5303), .driver_info = DEVICE_ZD1211B },
+ { USB_DEVICE(0x2019, 0xed01), .driver_info = DEVICE_ZD1211B },
+ /* "Driverless" devices that need ejecting */
+ { USB_DEVICE(0x0ace, 0x2011), .driver_info = DEVICE_INSTALLER },
+ { USB_DEVICE(0x0ace, 0x20ff), .driver_info = DEVICE_INSTALLER },
+ {}
+};
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("USB driver for devices with the ZD1211 chip.");
+MODULE_AUTHOR("Ulrich Kunitz");
+MODULE_AUTHOR("Daniel Drake");
+MODULE_VERSION("1.0");
+MODULE_DEVICE_TABLE(usb, usb_ids);
+
+#define FW_ZD1211_PREFIX "zd1211/zd1211_"
+#define FW_ZD1211B_PREFIX "zd1211/zd1211b_"
+
+static bool check_read_regs(struct zd_usb *usb, struct usb_req_read_regs *req,
+ unsigned int count);
+
+/* USB device initialization */
+static void int_urb_complete(struct urb *urb);
+
+static int request_fw_file(
+ const struct firmware **fw, const char *name, struct device *device)
+{
+ int r;
+
+ dev_dbg_f(device, "fw name %s\n", name);
+
+ r = request_firmware(fw, name, device);
+ if (r)
+ dev_err(device,
+ "Could not load firmware file %s. Error number %d\n",
+ name, r);
+ return r;
+}
+
+static inline u16 get_bcdDevice(const struct usb_device *udev)
+{
+ return le16_to_cpu(udev->descriptor.bcdDevice);
+}
+
+enum upload_code_flags {
+ REBOOT = 1,
+};
+
+/* Ensures that MAX_TRANSFER_SIZE is even. */
+#define MAX_TRANSFER_SIZE (USB_MAX_TRANSFER_SIZE & ~1)
+
+static int upload_code(struct usb_device *udev,
+ const u8 *data, size_t size, u16 code_offset, int flags)
+{
+ u8 *p;
+ int r;
+
+ /* USB request blocks need "kmalloced" buffers.
+ */
+ p = kmalloc(MAX_TRANSFER_SIZE, GFP_KERNEL);
+ if (!p) {
+ r = -ENOMEM;
+ goto error;
+ }
+
+ size &= ~1;
+ while (size > 0) {
+ size_t transfer_size = size <= MAX_TRANSFER_SIZE ?
+ size : MAX_TRANSFER_SIZE;
+
+ dev_dbg_f(&udev->dev, "transfer size %zu\n", transfer_size);
+
+ memcpy(p, data, transfer_size);
+ r = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+ USB_REQ_FIRMWARE_DOWNLOAD,
+ USB_DIR_OUT | USB_TYPE_VENDOR,
+ code_offset, 0, p, transfer_size, 1000 /* ms */);
+ if (r < 0) {
+ dev_err(&udev->dev,
+ "USB control request for firmware upload"
+ " failed. Error number %d\n", r);
+ goto error;
+ }
+ transfer_size = r & ~1;
+
+ size -= transfer_size;
+ data += transfer_size;
+ code_offset += transfer_size/sizeof(u16);
+ }
+
+ if (flags & REBOOT) {
+ u8 ret;
+
+ /* Use "DMA-aware" buffer. */
+ r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ USB_REQ_FIRMWARE_CONFIRM,
+ USB_DIR_IN | USB_TYPE_VENDOR,
+ 0, 0, p, sizeof(ret), 5000 /* ms */);
+ if (r != sizeof(ret)) {
+ dev_err(&udev->dev,
+ "control request firmeware confirmation failed."
+ " Return value %d\n", r);
+ if (r >= 0)
+ r = -ENODEV;
+ goto error;
+ }
+ ret = p[0];
+ if (ret & 0x80) {
+ dev_err(&udev->dev,
+ "Internal error while downloading."
+ " Firmware confirm return value %#04x\n",
+ (unsigned int)ret);
+ r = -ENODEV;
+ goto error;
+ }
+ dev_dbg_f(&udev->dev, "firmware confirm return value %#04x\n",
+ (unsigned int)ret);
+ }
+
+ r = 0;
+error:
+ kfree(p);
+ return r;
+}
+
+static u16 get_word(const void *data, u16 offset)
+{
+ const __le16 *p = data;
+ return le16_to_cpu(p[offset]);
+}
+
+static char *get_fw_name(struct zd_usb *usb, char *buffer, size_t size,
+ const char* postfix)
+{
+ scnprintf(buffer, size, "%s%s",
+ usb->is_zd1211b ?
+ FW_ZD1211B_PREFIX : FW_ZD1211_PREFIX,
+ postfix);
+ return buffer;
+}
+
+static int handle_version_mismatch(struct zd_usb *usb,
+ const struct firmware *ub_fw)
+{
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ const struct firmware *ur_fw = NULL;
+ int offset;
+ int r = 0;
+ char fw_name[128];
+
+ r = request_fw_file(&ur_fw,
+ get_fw_name(usb, fw_name, sizeof(fw_name), "ur"),
+ &udev->dev);
+ if (r)
+ goto error;
+
+ r = upload_code(udev, ur_fw->data, ur_fw->size, FW_START, REBOOT);
+ if (r)
+ goto error;
+
+ offset = (E2P_BOOT_CODE_OFFSET * sizeof(u16));
+ r = upload_code(udev, ub_fw->data + offset, ub_fw->size - offset,
+ E2P_START + E2P_BOOT_CODE_OFFSET, REBOOT);
+
+ /* At this point, the vendor driver downloads the whole firmware
+ * image, hacks around with version IDs, and uploads it again,
+ * completely overwriting the boot code. We do not do this here as
+ * it is not required on any tested devices, and it is suspected to
+ * cause problems. */
+error:
+ release_firmware(ur_fw);
+ return r;
+}
+
+static int upload_firmware(struct zd_usb *usb)
+{
+ int r;
+ u16 fw_bcdDevice;
+ u16 bcdDevice;
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ const struct firmware *ub_fw = NULL;
+ const struct firmware *uph_fw = NULL;
+ char fw_name[128];
+
+ bcdDevice = get_bcdDevice(udev);
+
+ r = request_fw_file(&ub_fw,
+ get_fw_name(usb, fw_name, sizeof(fw_name), "ub"),
+ &udev->dev);
+ if (r)
+ goto error;
+
+ fw_bcdDevice = get_word(ub_fw->data, E2P_DATA_OFFSET);
+
+ if (fw_bcdDevice != bcdDevice) {
+ dev_info(&udev->dev,
+ "firmware version %#06x and device bootcode version "
+ "%#06x differ\n", fw_bcdDevice, bcdDevice);
+ if (bcdDevice <= 0x4313)
+ dev_warn(&udev->dev, "device has old bootcode, please "
+ "report success or failure\n");
+
+ r = handle_version_mismatch(usb, ub_fw);
+ if (r)
+ goto error;
+ } else {
+ dev_dbg_f(&udev->dev,
+ "firmware device id %#06x is equal to the "
+ "actual device id\n", fw_bcdDevice);
+ }
+
+
+ r = request_fw_file(&uph_fw,
+ get_fw_name(usb, fw_name, sizeof(fw_name), "uphr"),
+ &udev->dev);
+ if (r)
+ goto error;
+
+ r = upload_code(udev, uph_fw->data, uph_fw->size, FW_START, REBOOT);
+ if (r) {
+ dev_err(&udev->dev,
+ "Could not upload firmware code uph. Error number %d\n",
+ r);
+ }
+
+ /* FALL-THROUGH */
+error:
+ release_firmware(ub_fw);
+ release_firmware(uph_fw);
+ return r;
+}
+
+MODULE_FIRMWARE(FW_ZD1211B_PREFIX "ur");
+MODULE_FIRMWARE(FW_ZD1211_PREFIX "ur");
+MODULE_FIRMWARE(FW_ZD1211B_PREFIX "ub");
+MODULE_FIRMWARE(FW_ZD1211_PREFIX "ub");
+MODULE_FIRMWARE(FW_ZD1211B_PREFIX "uphr");
+MODULE_FIRMWARE(FW_ZD1211_PREFIX "uphr");
+
+/* Read data from device address space using "firmware interface" which does
+ * not require firmware to be loaded. */
+int zd_usb_read_fw(struct zd_usb *usb, zd_addr_t addr, u8 *data, u16 len)
+{
+ int r;
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ u8 *buf;
+
+ /* Use "DMA-aware" buffer. */
+ buf = kmalloc(len, GFP_KERNEL);
+ if (!buf)
+ return -ENOMEM;
+ r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+ USB_REQ_FIRMWARE_READ_DATA, USB_DIR_IN | 0x40, addr, 0,
+ buf, len, 5000);
+ if (r < 0) {
+ dev_err(&udev->dev,
+ "read over firmware interface failed: %d\n", r);
+ goto exit;
+ } else if (r != len) {
+ dev_err(&udev->dev,
+ "incomplete read over firmware interface: %d/%d\n",
+ r, len);
+ r = -EIO;
+ goto exit;
+ }
+ r = 0;
+ memcpy(data, buf, len);
+exit:
+ kfree(buf);
+ return r;
+}
+
+#define urb_dev(urb) (&(urb)->dev->dev)
+
+static inline void handle_regs_int_override(struct urb *urb)
+{
+ struct zd_usb *usb = urb->context;
+ struct zd_usb_interrupt *intr = &usb->intr;
+
+ spin_lock(&intr->lock);
+ if (atomic_read(&intr->read_regs_enabled)) {
+ atomic_set(&intr->read_regs_enabled, 0);
+ intr->read_regs_int_overridden = 1;
+ complete(&intr->read_regs.completion);
+ }
+ spin_unlock(&intr->lock);
+}
+
+static inline void handle_regs_int(struct urb *urb)
+{
+ struct zd_usb *usb = urb->context;
+ struct zd_usb_interrupt *intr = &usb->intr;
+ int len;
+ u16 int_num;
+
+ ZD_ASSERT(in_interrupt());
+ spin_lock(&intr->lock);
+
+ int_num = le16_to_cpu(*(__le16 *)(urb->transfer_buffer+2));
+ if (int_num == CR_INTERRUPT) {
+ struct zd_mac *mac = zd_hw_mac(zd_usb_to_hw(urb->context));
+ spin_lock(&mac->lock);
+ memcpy(&mac->intr_buffer, urb->transfer_buffer,
+ USB_MAX_EP_INT_BUFFER);
+ spin_unlock(&mac->lock);
+ schedule_work(&mac->process_intr);
+ } else if (atomic_read(&intr->read_regs_enabled)) {
+ len = urb->actual_length;
+ intr->read_regs.length = urb->actual_length;
+ if (len > sizeof(intr->read_regs.buffer))
+ len = sizeof(intr->read_regs.buffer);
+
+ memcpy(intr->read_regs.buffer, urb->transfer_buffer, len);
+
+ /* Sometimes USB_INT_ID_REGS is not overridden, but comes after
+ * USB_INT_ID_RETRY_FAILED. Read-reg retry then gets this
+ * delayed USB_INT_ID_REGS, but leaves USB_INT_ID_REGS of
+ * retry unhandled. Next read-reg command then might catch
+ * this wrong USB_INT_ID_REGS. Fix by ignoring wrong reads.
+ */
+ if (!check_read_regs(usb, intr->read_regs.req,
+ intr->read_regs.req_count))
+ goto out;
+
+ atomic_set(&intr->read_regs_enabled, 0);
+ intr->read_regs_int_overridden = 0;
+ complete(&intr->read_regs.completion);
+
+ goto out;
+ }
+
+out:
+ spin_unlock(&intr->lock);
+
+ /* CR_INTERRUPT might override read_reg too. */
+ if (int_num == CR_INTERRUPT && atomic_read(&intr->read_regs_enabled))
+ handle_regs_int_override(urb);
+}
+
+static void int_urb_complete(struct urb *urb)
+{
+ int r;
+ struct usb_int_header *hdr;
+ struct zd_usb *usb;
+ struct zd_usb_interrupt *intr;
+
+ switch (urb->status) {
+ case 0:
+ break;
+ case -ESHUTDOWN:
+ case -EINVAL:
+ case -ENODEV:
+ case -ENOENT:
+ case -ECONNRESET:
+ case -EPIPE:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ return;
+ default:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ goto resubmit;
+ }
+
+ if (urb->actual_length < sizeof(hdr)) {
+ dev_dbg_f(urb_dev(urb), "error: urb %p to small\n", urb);
+ goto resubmit;
+ }
+
+ hdr = urb->transfer_buffer;
+ if (hdr->type != USB_INT_TYPE) {
+ dev_dbg_f(urb_dev(urb), "error: urb %p wrong type\n", urb);
+ goto resubmit;
+ }
+
+ /* USB_INT_ID_RETRY_FAILED triggered by tx-urb submit can override
+ * pending USB_INT_ID_REGS causing read command timeout.
+ */
+ usb = urb->context;
+ intr = &usb->intr;
+ if (hdr->id != USB_INT_ID_REGS && atomic_read(&intr->read_regs_enabled))
+ handle_regs_int_override(urb);
+
+ switch (hdr->id) {
+ case USB_INT_ID_REGS:
+ handle_regs_int(urb);
+ break;
+ case USB_INT_ID_RETRY_FAILED:
+ zd_mac_tx_failed(urb);
+ break;
+ default:
+ dev_dbg_f(urb_dev(urb), "error: urb %p unknown id %x\n", urb,
+ (unsigned int)hdr->id);
+ goto resubmit;
+ }
+
+resubmit:
+ r = usb_submit_urb(urb, GFP_ATOMIC);
+ if (r) {
+ dev_dbg_f(urb_dev(urb), "error: resubmit urb %p err code %d\n",
+ urb, r);
+ /* TODO: add worker to reset intr->urb */
+ }
+ return;
+}
+
+static inline int int_urb_interval(struct usb_device *udev)
+{
+ switch (udev->speed) {
+ case USB_SPEED_HIGH:
+ return 4;
+ case USB_SPEED_LOW:
+ return 10;
+ case USB_SPEED_FULL:
+ default:
+ return 1;
+ }
+}
+
+static inline int usb_int_enabled(struct zd_usb *usb)
+{
+ unsigned long flags;
+ struct zd_usb_interrupt *intr = &usb->intr;
+ struct urb *urb;
+
+ spin_lock_irqsave(&intr->lock, flags);
+ urb = intr->urb;
+ spin_unlock_irqrestore(&intr->lock, flags);
+ return urb != NULL;
+}
+
+int zd_usb_enable_int(struct zd_usb *usb)
+{
+ int r;
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ struct zd_usb_interrupt *intr = &usb->intr;
+ struct urb *urb;
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!urb) {
+ r = -ENOMEM;
+ goto out;
+ }
+
+ ZD_ASSERT(!irqs_disabled());
+ spin_lock_irq(&intr->lock);
+ if (intr->urb) {
+ spin_unlock_irq(&intr->lock);
+ r = 0;
+ goto error_free_urb;
+ }
+ intr->urb = urb;
+ spin_unlock_irq(&intr->lock);
+
+ r = -ENOMEM;
+ intr->buffer = usb_alloc_coherent(udev, USB_MAX_EP_INT_BUFFER,
+ GFP_KERNEL, &intr->buffer_dma);
+ if (!intr->buffer) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "couldn't allocate transfer_buffer\n");
+ goto error_set_urb_null;
+ }
+
+ usb_fill_int_urb(urb, udev, usb_rcvintpipe(udev, EP_INT_IN),
+ intr->buffer, USB_MAX_EP_INT_BUFFER,
+ int_urb_complete, usb,
+ intr->interval);
+ urb->transfer_dma = intr->buffer_dma;
+ urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+ dev_dbg_f(zd_usb_dev(usb), "submit urb %p\n", intr->urb);
+ r = usb_submit_urb(urb, GFP_KERNEL);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "Couldn't submit urb. Error number %d\n", r);
+ goto error;
+ }
+
+ return 0;
+error:
+ usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
+ intr->buffer, intr->buffer_dma);
+error_set_urb_null:
+ spin_lock_irq(&intr->lock);
+ intr->urb = NULL;
+ spin_unlock_irq(&intr->lock);
+error_free_urb:
+ usb_free_urb(urb);
+out:
+ return r;
+}
+
+void zd_usb_disable_int(struct zd_usb *usb)
+{
+ unsigned long flags;
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ struct zd_usb_interrupt *intr = &usb->intr;
+ struct urb *urb;
+ void *buffer;
+ dma_addr_t buffer_dma;
+
+ spin_lock_irqsave(&intr->lock, flags);
+ urb = intr->urb;
+ if (!urb) {
+ spin_unlock_irqrestore(&intr->lock, flags);
+ return;
+ }
+ intr->urb = NULL;
+ buffer = intr->buffer;
+ buffer_dma = intr->buffer_dma;
+ intr->buffer = NULL;
+ spin_unlock_irqrestore(&intr->lock, flags);
+
+ usb_kill_urb(urb);
+ dev_dbg_f(zd_usb_dev(usb), "urb %p killed\n", urb);
+ usb_free_urb(urb);
+
+ if (buffer)
+ usb_free_coherent(udev, USB_MAX_EP_INT_BUFFER,
+ buffer, buffer_dma);
+}
+
+static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
+ unsigned int length)
+{
+ int i;
+ const struct rx_length_info *length_info;
+
+ if (length < sizeof(struct rx_length_info)) {
+ /* It's not a complete packet anyhow. */
+ dev_dbg_f(zd_usb_dev(usb), "invalid, small RX packet : %d\n",
+ length);
+ return;
+ }
+ length_info = (struct rx_length_info *)
+ (buffer + length - sizeof(struct rx_length_info));
+
+ /* It might be that three frames are merged into a single URB
+ * transaction. We have to check for the length info tag.
+ *
+ * While testing we discovered that length_info might be unaligned,
+ * because if USB transactions are merged, the last packet will not
+ * be padded. Unaligned access might also happen if the length_info
+ * structure is not present.
+ */
+ if (get_unaligned_le16(&length_info->tag) == RX_LENGTH_INFO_TAG)
+ {
+ unsigned int l, k, n;
+ for (i = 0, l = 0;; i++) {
+ k = get_unaligned_le16(&length_info->length[i]);
+ if (k == 0)
+ return;
+ n = l+k;
+ if (n > length)
+ return;
+ zd_mac_rx(zd_usb_to_hw(usb), buffer+l, k);
+ if (i >= 2)
+ return;
+ l = (n+3) & ~3;
+ }
+ } else {
+ zd_mac_rx(zd_usb_to_hw(usb), buffer, length);
+ }
+}
+
+static void rx_urb_complete(struct urb *urb)
+{
+ int r;
+ struct zd_usb *usb;
+ struct zd_usb_rx *rx;
+ const u8 *buffer;
+ unsigned int length;
+
+ switch (urb->status) {
+ case 0:
+ break;
+ case -ESHUTDOWN:
+ case -EINVAL:
+ case -ENODEV:
+ case -ENOENT:
+ case -ECONNRESET:
+ case -EPIPE:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ return;
+ default:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ goto resubmit;
+ }
+
+ buffer = urb->transfer_buffer;
+ length = urb->actual_length;
+ usb = urb->context;
+ rx = &usb->rx;
+
+ tasklet_schedule(&rx->reset_timer_tasklet);
+
+ if (length%rx->usb_packet_size > rx->usb_packet_size-4) {
+ /* If there is an old first fragment, we don't care. */
+ dev_dbg_f(urb_dev(urb), "*** first fragment ***\n");
+ ZD_ASSERT(length <= ARRAY_SIZE(rx->fragment));
+ spin_lock(&rx->lock);
+ memcpy(rx->fragment, buffer, length);
+ rx->fragment_length = length;
+ spin_unlock(&rx->lock);
+ goto resubmit;
+ }
+
+ spin_lock(&rx->lock);
+ if (rx->fragment_length > 0) {
+ /* We are on a second fragment, we believe */
+ ZD_ASSERT(length + rx->fragment_length <=
+ ARRAY_SIZE(rx->fragment));
+ dev_dbg_f(urb_dev(urb), "*** second fragment ***\n");
+ memcpy(rx->fragment+rx->fragment_length, buffer, length);
+ handle_rx_packet(usb, rx->fragment,
+ rx->fragment_length + length);
+ rx->fragment_length = 0;
+ spin_unlock(&rx->lock);
+ } else {
+ spin_unlock(&rx->lock);
+ handle_rx_packet(usb, buffer, length);
+ }
+
+resubmit:
+ r = usb_submit_urb(urb, GFP_ATOMIC);
+ if (r)
+ dev_dbg_f(urb_dev(urb), "urb %p resubmit error %d\n", urb, r);
+}
+
+static struct urb *alloc_rx_urb(struct zd_usb *usb)
+{
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ struct urb *urb;
+ void *buffer;
+
+ urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!urb)
+ return NULL;
+ buffer = usb_alloc_coherent(udev, USB_MAX_RX_SIZE, GFP_KERNEL,
+ &urb->transfer_dma);
+ if (!buffer) {
+ usb_free_urb(urb);
+ return NULL;
+ }
+
+ usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN),
+ buffer, USB_MAX_RX_SIZE,
+ rx_urb_complete, usb);
+ urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+ return urb;
+}
+
+static void free_rx_urb(struct urb *urb)
+{
+ if (!urb)
+ return;
+ usb_free_coherent(urb->dev, urb->transfer_buffer_length,
+ urb->transfer_buffer, urb->transfer_dma);
+ usb_free_urb(urb);
+}
+
+static int __zd_usb_enable_rx(struct zd_usb *usb)
+{
+ int i, r;
+ struct zd_usb_rx *rx = &usb->rx;
+ struct urb **urbs;
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ r = -ENOMEM;
+ urbs = kcalloc(RX_URBS_COUNT, sizeof(struct urb *), GFP_KERNEL);
+ if (!urbs)
+ goto error;
+ for (i = 0; i < RX_URBS_COUNT; i++) {
+ urbs[i] = alloc_rx_urb(usb);
+ if (!urbs[i])
+ goto error;
+ }
+
+ ZD_ASSERT(!irqs_disabled());
+ spin_lock_irq(&rx->lock);
+ if (rx->urbs) {
+ spin_unlock_irq(&rx->lock);
+ r = 0;
+ goto error;
+ }
+ rx->urbs = urbs;
+ rx->urbs_count = RX_URBS_COUNT;
+ spin_unlock_irq(&rx->lock);
+
+ for (i = 0; i < RX_URBS_COUNT; i++) {
+ r = usb_submit_urb(urbs[i], GFP_KERNEL);
+ if (r)
+ goto error_submit;
+ }
+
+ return 0;
+error_submit:
+ for (i = 0; i < RX_URBS_COUNT; i++) {
+ usb_kill_urb(urbs[i]);
+ }
+ spin_lock_irq(&rx->lock);
+ rx->urbs = NULL;
+ rx->urbs_count = 0;
+ spin_unlock_irq(&rx->lock);
+error:
+ if (urbs) {
+ for (i = 0; i < RX_URBS_COUNT; i++)
+ free_rx_urb(urbs[i]);
+ }
+ return r;
+}
+
+int zd_usb_enable_rx(struct zd_usb *usb)
+{
+ int r;
+ struct zd_usb_rx *rx = &usb->rx;
+
+ mutex_lock(&rx->setup_mutex);
+ r = __zd_usb_enable_rx(usb);
+ mutex_unlock(&rx->setup_mutex);
+
+ zd_usb_reset_rx_idle_timer(usb);
+
+ return r;
+}
+
+static void __zd_usb_disable_rx(struct zd_usb *usb)
+{
+ int i;
+ unsigned long flags;
+ struct urb **urbs;
+ unsigned int count;
+ struct zd_usb_rx *rx = &usb->rx;
+
+ spin_lock_irqsave(&rx->lock, flags);
+ urbs = rx->urbs;
+ count = rx->urbs_count;
+ spin_unlock_irqrestore(&rx->lock, flags);
+ if (!urbs)
+ return;
+
+ for (i = 0; i < count; i++) {
+ usb_kill_urb(urbs[i]);
+ free_rx_urb(urbs[i]);
+ }
+ kfree(urbs);
+
+ spin_lock_irqsave(&rx->lock, flags);
+ rx->urbs = NULL;
+ rx->urbs_count = 0;
+ spin_unlock_irqrestore(&rx->lock, flags);
+}
+
+void zd_usb_disable_rx(struct zd_usb *usb)
+{
+ struct zd_usb_rx *rx = &usb->rx;
+
+ mutex_lock(&rx->setup_mutex);
+ __zd_usb_disable_rx(usb);
+ mutex_unlock(&rx->setup_mutex);
+
+ tasklet_kill(&rx->reset_timer_tasklet);
+ cancel_delayed_work_sync(&rx->idle_work);
+}
+
+static void zd_usb_reset_rx(struct zd_usb *usb)
+{
+ bool do_reset;
+ struct zd_usb_rx *rx = &usb->rx;
+ unsigned long flags;
+
+ mutex_lock(&rx->setup_mutex);
+
+ spin_lock_irqsave(&rx->lock, flags);
+ do_reset = rx->urbs != NULL;
+ spin_unlock_irqrestore(&rx->lock, flags);
+
+ if (do_reset) {
+ __zd_usb_disable_rx(usb);
+ __zd_usb_enable_rx(usb);
+ }
+
+ mutex_unlock(&rx->setup_mutex);
+
+ if (do_reset)
+ zd_usb_reset_rx_idle_timer(usb);
+}
+
+/**
+ * zd_usb_disable_tx - disable transmission
+ * @usb: the zd1211rw-private USB structure
+ *
+ * Frees all URBs in the free list and marks the transmission as disabled.
+ */
+void zd_usb_disable_tx(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+ unsigned long flags;
+
+ atomic_set(&tx->enabled, 0);
+
+ /* kill all submitted tx-urbs */
+ usb_kill_anchored_urbs(&tx->submitted);
+
+ spin_lock_irqsave(&tx->lock, flags);
+ WARN_ON(!skb_queue_empty(&tx->submitted_skbs));
+ WARN_ON(tx->submitted_urbs != 0);
+ tx->submitted_urbs = 0;
+ spin_unlock_irqrestore(&tx->lock, flags);
+
+ /* The stopped state is ignored, relying on ieee80211_wake_queues()
+ * in a potentionally following zd_usb_enable_tx().
+ */
+}
+
+/**
+ * zd_usb_enable_tx - enables transmission
+ * @usb: a &struct zd_usb pointer
+ *
+ * This function enables transmission and prepares the &zd_usb_tx data
+ * structure.
+ */
+void zd_usb_enable_tx(struct zd_usb *usb)
+{
+ unsigned long flags;
+ struct zd_usb_tx *tx = &usb->tx;
+
+ spin_lock_irqsave(&tx->lock, flags);
+ atomic_set(&tx->enabled, 1);
+ tx->submitted_urbs = 0;
+ ieee80211_wake_queues(zd_usb_to_hw(usb));
+ tx->stopped = 0;
+ spin_unlock_irqrestore(&tx->lock, flags);
+}
+
+static void tx_dec_submitted_urbs(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+ unsigned long flags;
+
+ spin_lock_irqsave(&tx->lock, flags);
+ --tx->submitted_urbs;
+ if (tx->stopped && tx->submitted_urbs <= ZD_USB_TX_LOW) {
+ ieee80211_wake_queues(zd_usb_to_hw(usb));
+ tx->stopped = 0;
+ }
+ spin_unlock_irqrestore(&tx->lock, flags);
+}
+
+static void tx_inc_submitted_urbs(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+ unsigned long flags;
+
+ spin_lock_irqsave(&tx->lock, flags);
+ ++tx->submitted_urbs;
+ if (!tx->stopped && tx->submitted_urbs > ZD_USB_TX_HIGH) {
+ ieee80211_stop_queues(zd_usb_to_hw(usb));
+ tx->stopped = 1;
+ }
+ spin_unlock_irqrestore(&tx->lock, flags);
+}
+
+/**
+ * tx_urb_complete - completes the execution of an URB
+ * @urb: a URB
+ *
+ * This function is called if the URB has been transferred to a device or an
+ * error has happened.
+ */
+static void tx_urb_complete(struct urb *urb)
+{
+ int r;
+ struct sk_buff *skb;
+ struct ieee80211_tx_info *info;
+ struct zd_usb *usb;
+ struct zd_usb_tx *tx;
+
+ skb = (struct sk_buff *)urb->context;
+ info = IEEE80211_SKB_CB(skb);
+ /*
+ * grab 'usb' pointer before handing off the skb (since
+ * it might be freed by zd_mac_tx_to_dev or mac80211)
+ */
+ usb = &zd_hw_mac(info->rate_driver_data[0])->chip.usb;
+ tx = &usb->tx;
+
+ switch (urb->status) {
+ case 0:
+ break;
+ case -ESHUTDOWN:
+ case -EINVAL:
+ case -ENODEV:
+ case -ENOENT:
+ case -ECONNRESET:
+ case -EPIPE:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ break;
+ default:
+ dev_dbg_f(urb_dev(urb), "urb %p error %d\n", urb, urb->status);
+ goto resubmit;
+ }
+free_urb:
+ skb_unlink(skb, &usb->tx.submitted_skbs);
+ zd_mac_tx_to_dev(skb, urb->status);
+ usb_free_urb(urb);
+ tx_dec_submitted_urbs(usb);
+ return;
+resubmit:
+ usb_anchor_urb(urb, &tx->submitted);
+ r = usb_submit_urb(urb, GFP_ATOMIC);
+ if (r) {
+ usb_unanchor_urb(urb);
+ dev_dbg_f(urb_dev(urb), "error resubmit urb %p %d\n", urb, r);
+ goto free_urb;
+ }
+}
+
+/**
+ * zd_usb_tx: initiates transfer of a frame of the device
+ *
+ * @usb: the zd1211rw-private USB structure
+ * @skb: a &struct sk_buff pointer
+ *
+ * This function tranmits a frame to the device. It doesn't wait for
+ * completion. The frame must contain the control set and have all the
+ * control set information available.
+ *
+ * The function returns 0 if the transfer has been successfully initiated.
+ */
+int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb)
+{
+ int r;
+ struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+ struct usb_device *udev = zd_usb_to_usbdev(usb);
+ struct urb *urb;
+ struct zd_usb_tx *tx = &usb->tx;
+
+ if (!atomic_read(&tx->enabled)) {
+ r = -ENOENT;
+ goto out;
+ }
+
+ urb = usb_alloc_urb(0, GFP_ATOMIC);
+ if (!urb) {
+ r = -ENOMEM;
+ goto out;
+ }
+
+ usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_DATA_OUT),
+ skb->data, skb->len, tx_urb_complete, skb);
+
+ info->rate_driver_data[1] = (void *)jiffies;
+ skb_queue_tail(&tx->submitted_skbs, skb);
+ usb_anchor_urb(urb, &tx->submitted);
+
+ r = usb_submit_urb(urb, GFP_ATOMIC);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb), "error submit urb %p %d\n", urb, r);
+ usb_unanchor_urb(urb);
+ skb_unlink(skb, &tx->submitted_skbs);
+ goto error;
+ }
+ tx_inc_submitted_urbs(usb);
+ return 0;
+error:
+ usb_free_urb(urb);
+out:
+ return r;
+}
+
+static bool zd_tx_timeout(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+ struct sk_buff_head *q = &tx->submitted_skbs;
+ struct sk_buff *skb, *skbnext;
+ struct ieee80211_tx_info *info;
+ unsigned long flags, trans_start;
+ bool have_timedout = false;
+
+ spin_lock_irqsave(&q->lock, flags);
+ skb_queue_walk_safe(q, skb, skbnext) {
+ info = IEEE80211_SKB_CB(skb);
+ trans_start = (unsigned long)info->rate_driver_data[1];
+
+ if (time_is_before_jiffies(trans_start + ZD_TX_TIMEOUT)) {
+ have_timedout = true;
+ break;
+ }
+ }
+ spin_unlock_irqrestore(&q->lock, flags);
+
+ return have_timedout;
+}
+
+static void zd_tx_watchdog_handler(struct work_struct *work)
+{
+ struct zd_usb *usb =
+ container_of(work, struct zd_usb, tx.watchdog_work.work);
+ struct zd_usb_tx *tx = &usb->tx;
+
+ if (!atomic_read(&tx->enabled) || !tx->watchdog_enabled)
+ goto out;
+ if (!zd_tx_timeout(usb))
+ goto out;
+
+ /* TX halted, try reset */
+ dev_warn(zd_usb_dev(usb), "TX-stall detected, resetting device...");
+
+ usb_queue_reset_device(usb->intf);
+
+ /* reset will stop this worker, don't rearm */
+ return;
+out:
+ queue_delayed_work(zd_workqueue, &tx->watchdog_work,
+ ZD_TX_WATCHDOG_INTERVAL);
+}
+
+void zd_tx_watchdog_enable(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+
+ if (!tx->watchdog_enabled) {
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+ queue_delayed_work(zd_workqueue, &tx->watchdog_work,
+ ZD_TX_WATCHDOG_INTERVAL);
+ tx->watchdog_enabled = 1;
+ }
+}
+
+void zd_tx_watchdog_disable(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+
+ if (tx->watchdog_enabled) {
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+ tx->watchdog_enabled = 0;
+ cancel_delayed_work_sync(&tx->watchdog_work);
+ }
+}
+
+static void zd_rx_idle_timer_handler(struct work_struct *work)
+{
+ struct zd_usb *usb =
+ container_of(work, struct zd_usb, rx.idle_work.work);
+ struct zd_mac *mac = zd_usb_to_mac(usb);
+
+ if (!test_bit(ZD_DEVICE_RUNNING, &mac->flags))
+ return;
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ /* 30 seconds since last rx, reset rx */
+ zd_usb_reset_rx(usb);
+}
+
+static void zd_usb_reset_rx_idle_timer_tasklet(unsigned long param)
+{
+ struct zd_usb *usb = (struct zd_usb *)param;
+
+ zd_usb_reset_rx_idle_timer(usb);
+}
+
+void zd_usb_reset_rx_idle_timer(struct zd_usb *usb)
+{
+ struct zd_usb_rx *rx = &usb->rx;
+
+ mod_delayed_work(zd_workqueue, &rx->idle_work, ZD_RX_IDLE_INTERVAL);
+}
+
+static inline void init_usb_interrupt(struct zd_usb *usb)
+{
+ struct zd_usb_interrupt *intr = &usb->intr;
+
+ spin_lock_init(&intr->lock);
+ intr->interval = int_urb_interval(zd_usb_to_usbdev(usb));
+ init_completion(&intr->read_regs.completion);
+ atomic_set(&intr->read_regs_enabled, 0);
+ intr->read_regs.cr_int_addr = cpu_to_le16((u16)CR_INTERRUPT);
+}
+
+static inline void init_usb_rx(struct zd_usb *usb)
+{
+ struct zd_usb_rx *rx = &usb->rx;
+
+ spin_lock_init(&rx->lock);
+ mutex_init(&rx->setup_mutex);
+ if (interface_to_usbdev(usb->intf)->speed == USB_SPEED_HIGH) {
+ rx->usb_packet_size = 512;
+ } else {
+ rx->usb_packet_size = 64;
+ }
+ ZD_ASSERT(rx->fragment_length == 0);
+ INIT_DELAYED_WORK(&rx->idle_work, zd_rx_idle_timer_handler);
+ rx->reset_timer_tasklet.func = zd_usb_reset_rx_idle_timer_tasklet;
+ rx->reset_timer_tasklet.data = (unsigned long)usb;
+}
+
+static inline void init_usb_tx(struct zd_usb *usb)
+{
+ struct zd_usb_tx *tx = &usb->tx;
+
+ spin_lock_init(&tx->lock);
+ atomic_set(&tx->enabled, 0);
+ tx->stopped = 0;
+ skb_queue_head_init(&tx->submitted_skbs);
+ init_usb_anchor(&tx->submitted);
+ tx->submitted_urbs = 0;
+ tx->watchdog_enabled = 0;
+ INIT_DELAYED_WORK(&tx->watchdog_work, zd_tx_watchdog_handler);
+}
+
+void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
+ struct usb_interface *intf)
+{
+ memset(usb, 0, sizeof(*usb));
+ usb->intf = usb_get_intf(intf);
+ usb_set_intfdata(usb->intf, hw);
+ init_usb_anchor(&usb->submitted_cmds);
+ init_usb_interrupt(usb);
+ init_usb_tx(usb);
+ init_usb_rx(usb);
+}
+
+void zd_usb_clear(struct zd_usb *usb)
+{
+ usb_set_intfdata(usb->intf, NULL);
+ usb_put_intf(usb->intf);
+ ZD_MEMCLEAR(usb, sizeof(*usb));
+ /* FIXME: usb_interrupt, usb_tx, usb_rx? */
+}
+
+static const char *speed(enum usb_device_speed speed)
+{
+ switch (speed) {
+ case USB_SPEED_LOW:
+ return "low";
+ case USB_SPEED_FULL:
+ return "full";
+ case USB_SPEED_HIGH:
+ return "high";
+ default:
+ return "unknown speed";
+ }
+}
+
+static int scnprint_id(struct usb_device *udev, char *buffer, size_t size)
+{
+ return scnprintf(buffer, size, "%04hx:%04hx v%04hx %s",
+ le16_to_cpu(udev->descriptor.idVendor),
+ le16_to_cpu(udev->descriptor.idProduct),
+ get_bcdDevice(udev),
+ speed(udev->speed));
+}
+
+int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size)
+{
+ struct usb_device *udev = interface_to_usbdev(usb->intf);
+ return scnprint_id(udev, buffer, size);
+}
+
+#ifdef DEBUG
+static void print_id(struct usb_device *udev)
+{
+ char buffer[40];
+
+ scnprint_id(udev, buffer, sizeof(buffer));
+ buffer[sizeof(buffer)-1] = 0;
+ dev_dbg_f(&udev->dev, "%s\n", buffer);
+}
+#else
+#define print_id(udev) do { } while (0)
+#endif
+
+static int eject_installer(struct usb_interface *intf)
+{
+ struct usb_device *udev = interface_to_usbdev(intf);
+ struct usb_host_interface *iface_desc = &intf->altsetting[0];
+ struct usb_endpoint_descriptor *endpoint;
+ unsigned char *cmd;
+ u8 bulk_out_ep;
+ int r;
+
+ /* Find bulk out endpoint */
+ for (r = 1; r >= 0; r--) {
+ endpoint = &iface_desc->endpoint[r].desc;
+ if (usb_endpoint_dir_out(endpoint) &&
+ usb_endpoint_xfer_bulk(endpoint)) {
+ bulk_out_ep = endpoint->bEndpointAddress;
+ break;
+ }
+ }
+ if (r == -1) {
+ dev_err(&udev->dev,
+ "zd1211rw: Could not find bulk out endpoint\n");
+ return -ENODEV;
+ }
+
+ cmd = kzalloc(31, GFP_KERNEL);
+ if (cmd == NULL)
+ return -ENODEV;
+
+ /* USB bulk command block */
+ cmd[0] = 0x55; /* bulk command signature */
+ cmd[1] = 0x53; /* bulk command signature */
+ cmd[2] = 0x42; /* bulk command signature */
+ cmd[3] = 0x43; /* bulk command signature */
+ cmd[14] = 6; /* command length */
+
+ cmd[15] = 0x1b; /* SCSI command: START STOP UNIT */
+ cmd[19] = 0x2; /* eject disc */
+
+ dev_info(&udev->dev, "Ejecting virtual installer media...\n");
+ r = usb_bulk_msg(udev, usb_sndbulkpipe(udev, bulk_out_ep),
+ cmd, 31, NULL, 2000);
+ kfree(cmd);
+ if (r)
+ return r;
+
+ /* At this point, the device disconnects and reconnects with the real
+ * ID numbers. */
+
+ usb_set_intfdata(intf, NULL);
+ return 0;
+}
+
+int zd_usb_init_hw(struct zd_usb *usb)
+{
+ int r;
+ struct zd_mac *mac = zd_usb_to_mac(usb);
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ r = upload_firmware(usb);
+ if (r) {
+ dev_err(zd_usb_dev(usb),
+ "couldn't load firmware. Error number %d\n", r);
+ return r;
+ }
+
+ r = usb_reset_configuration(zd_usb_to_usbdev(usb));
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "couldn't reset configuration. Error number %d\n", r);
+ return r;
+ }
+
+ r = zd_mac_init_hw(mac->hw);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "couldn't initialize mac. Error number %d\n", r);
+ return r;
+ }
+
+ usb->initialized = 1;
+ return 0;
+}
+
+static int probe(struct usb_interface *intf, const struct usb_device_id *id)
+{
+ int r;
+ struct usb_device *udev = interface_to_usbdev(intf);
+ struct zd_usb *usb;
+ struct ieee80211_hw *hw = NULL;
+
+ print_id(udev);
+
+ if (id->driver_info & DEVICE_INSTALLER)
+ return eject_installer(intf);
+
+ switch (udev->speed) {
+ case USB_SPEED_LOW:
+ case USB_SPEED_FULL:
+ case USB_SPEED_HIGH:
+ break;
+ default:
+ dev_dbg_f(&intf->dev, "Unknown USB speed\n");
+ r = -ENODEV;
+ goto error;
+ }
+
+ r = usb_reset_device(udev);
+ if (r) {
+ dev_err(&intf->dev,
+ "couldn't reset usb device. Error number %d\n", r);
+ goto error;
+ }
+
+ hw = zd_mac_alloc_hw(intf);
+ if (hw == NULL) {
+ r = -ENOMEM;
+ goto error;
+ }
+
+ usb = &zd_hw_mac(hw)->chip.usb;
+ usb->is_zd1211b = (id->driver_info == DEVICE_ZD1211B) != 0;
+
+ r = zd_mac_preinit_hw(hw);
+ if (r) {
+ dev_dbg_f(&intf->dev,
+ "couldn't initialize mac. Error number %d\n", r);
+ goto error;
+ }
+
+ r = ieee80211_register_hw(hw);
+ if (r) {
+ dev_dbg_f(&intf->dev,
+ "couldn't register device. Error number %d\n", r);
+ goto error;
+ }
+
+ dev_dbg_f(&intf->dev, "successful\n");
+ dev_info(&intf->dev, "%s\n", wiphy_name(hw->wiphy));
+ return 0;
+error:
+ usb_reset_device(interface_to_usbdev(intf));
+ if (hw) {
+ zd_mac_clear(zd_hw_mac(hw));
+ ieee80211_free_hw(hw);
+ }
+ return r;
+}
+
+static void disconnect(struct usb_interface *intf)
+{
+ struct ieee80211_hw *hw = zd_intf_to_hw(intf);
+ struct zd_mac *mac;
+ struct zd_usb *usb;
+
+ /* Either something really bad happened, or we're just dealing with
+ * a DEVICE_INSTALLER. */
+ if (hw == NULL)
+ return;
+
+ mac = zd_hw_mac(hw);
+ usb = &mac->chip.usb;
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ ieee80211_unregister_hw(hw);
+
+ /* Just in case something has gone wrong! */
+ zd_usb_disable_tx(usb);
+ zd_usb_disable_rx(usb);
+ zd_usb_disable_int(usb);
+
+ /* If the disconnect has been caused by a removal of the
+ * driver module, the reset allows reloading of the driver. If the
+ * reset will not be executed here, the upload of the firmware in the
+ * probe function caused by the reloading of the driver will fail.
+ */
+ usb_reset_device(interface_to_usbdev(intf));
+
+ zd_mac_clear(mac);
+ ieee80211_free_hw(hw);
+ dev_dbg(&intf->dev, "disconnected\n");
+}
+
+static void zd_usb_resume(struct zd_usb *usb)
+{
+ struct zd_mac *mac = zd_usb_to_mac(usb);
+ int r;
+
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ r = zd_op_start(zd_usb_to_hw(usb));
+ if (r < 0) {
+ dev_warn(zd_usb_dev(usb), "Device resume failed "
+ "with error code %d. Retrying...\n", r);
+ if (usb->was_running)
+ set_bit(ZD_DEVICE_RUNNING, &mac->flags);
+ usb_queue_reset_device(usb->intf);
+ return;
+ }
+
+ if (mac->type != NL80211_IFTYPE_UNSPECIFIED) {
+ r = zd_restore_settings(mac);
+ if (r < 0) {
+ dev_dbg(zd_usb_dev(usb),
+ "failed to restore settings, %d\n", r);
+ return;
+ }
+ }
+}
+
+static void zd_usb_stop(struct zd_usb *usb)
+{
+ dev_dbg_f(zd_usb_dev(usb), "\n");
+
+ zd_op_stop(zd_usb_to_hw(usb));
+
+ zd_usb_disable_tx(usb);
+ zd_usb_disable_rx(usb);
+ zd_usb_disable_int(usb);
+
+ usb->initialized = 0;
+}
+
+static int pre_reset(struct usb_interface *intf)
+{
+ struct ieee80211_hw *hw = usb_get_intfdata(intf);
+ struct zd_mac *mac;
+ struct zd_usb *usb;
+
+ if (!hw || intf->condition != USB_INTERFACE_BOUND)
+ return 0;
+
+ mac = zd_hw_mac(hw);
+ usb = &mac->chip.usb;
+
+ usb->was_running = test_bit(ZD_DEVICE_RUNNING, &mac->flags);
+
+ zd_usb_stop(usb);
+
+ mutex_lock(&mac->chip.mutex);
+ return 0;
+}
+
+static int post_reset(struct usb_interface *intf)
+{
+ struct ieee80211_hw *hw = usb_get_intfdata(intf);
+ struct zd_mac *mac;
+ struct zd_usb *usb;
+
+ if (!hw || intf->condition != USB_INTERFACE_BOUND)
+ return 0;
+
+ mac = zd_hw_mac(hw);
+ usb = &mac->chip.usb;
+
+ mutex_unlock(&mac->chip.mutex);
+
+ if (usb->was_running)
+ zd_usb_resume(usb);
+ return 0;
+}
+
+static struct usb_driver driver = {
+ .name = KBUILD_MODNAME,
+ .id_table = usb_ids,
+ .probe = probe,
+ .disconnect = disconnect,
+ .pre_reset = pre_reset,
+ .post_reset = post_reset,
+ .disable_hub_initiated_lpm = 1,
+};
+
+struct workqueue_struct *zd_workqueue;
+
+static int __init usb_init(void)
+{
+ int r;
+
+ pr_debug("%s usb_init()\n", driver.name);
+
+ zd_workqueue = create_singlethread_workqueue(driver.name);
+ if (zd_workqueue == NULL) {
+ printk(KERN_ERR "%s couldn't create workqueue\n", driver.name);
+ return -ENOMEM;
+ }
+
+ r = usb_register(&driver);
+ if (r) {
+ destroy_workqueue(zd_workqueue);
+ printk(KERN_ERR "%s usb_register() failed. Error number %d\n",
+ driver.name, r);
+ return r;
+ }
+
+ pr_debug("%s initialized\n", driver.name);
+ return 0;
+}
+
+static void __exit usb_exit(void)
+{
+ pr_debug("%s usb_exit()\n", driver.name);
+ usb_deregister(&driver);
+ destroy_workqueue(zd_workqueue);
+}
+
+module_init(usb_init);
+module_exit(usb_exit);
+
+static int zd_ep_regs_out_msg(struct usb_device *udev, void *data, int len,
+ int *actual_length, int timeout)
+{
+ /* In USB 2.0 mode EP_REGS_OUT endpoint is interrupt type. However in
+ * USB 1.1 mode endpoint is bulk. Select correct type URB by endpoint
+ * descriptor.
+ */
+ struct usb_host_endpoint *ep;
+ unsigned int pipe;
+
+ pipe = usb_sndintpipe(udev, EP_REGS_OUT);
+ ep = usb_pipe_endpoint(udev, pipe);
+ if (!ep)
+ return -EINVAL;
+
+ if (usb_endpoint_xfer_int(&ep->desc)) {
+ return usb_interrupt_msg(udev, pipe, data, len,
+ actual_length, timeout);
+ } else {
+ pipe = usb_sndbulkpipe(udev, EP_REGS_OUT);
+ return usb_bulk_msg(udev, pipe, data, len, actual_length,
+ timeout);
+ }
+}
+
+static int usb_int_regs_length(unsigned int count)
+{
+ return sizeof(struct usb_int_regs) + count * sizeof(struct reg_data);
+}
+
+static void prepare_read_regs_int(struct zd_usb *usb,
+ struct usb_req_read_regs *req,
+ unsigned int count)
+{
+ struct zd_usb_interrupt *intr = &usb->intr;
+
+ spin_lock_irq(&intr->lock);
+ atomic_set(&intr->read_regs_enabled, 1);
+ intr->read_regs.req = req;
+ intr->read_regs.req_count = count;
+ reinit_completion(&intr->read_regs.completion);
+ spin_unlock_irq(&intr->lock);
+}
+
+static void disable_read_regs_int(struct zd_usb *usb)
+{
+ struct zd_usb_interrupt *intr = &usb->intr;
+
+ spin_lock_irq(&intr->lock);
+ atomic_set(&intr->read_regs_enabled, 0);
+ spin_unlock_irq(&intr->lock);
+}
+
+static bool check_read_regs(struct zd_usb *usb, struct usb_req_read_regs *req,
+ unsigned int count)
+{
+ int i;
+ struct zd_usb_interrupt *intr = &usb->intr;
+ struct read_regs_int *rr = &intr->read_regs;
+ struct usb_int_regs *regs = (struct usb_int_regs *)rr->buffer;
+
+ /* The created block size seems to be larger than expected.
+ * However results appear to be correct.
+ */
+ if (rr->length < usb_int_regs_length(count)) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: actual length %d less than expected %d\n",
+ rr->length, usb_int_regs_length(count));
+ return false;
+ }
+
+ if (rr->length > sizeof(rr->buffer)) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: actual length %d exceeds buffer size %zu\n",
+ rr->length, sizeof(rr->buffer));
+ return false;
+ }
+
+ for (i = 0; i < count; i++) {
+ struct reg_data *rd = ®s->regs[i];
+ if (rd->addr != req->addr[i]) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "rd[%d] addr %#06hx expected %#06hx\n", i,
+ le16_to_cpu(rd->addr),
+ le16_to_cpu(req->addr[i]));
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static int get_results(struct zd_usb *usb, u16 *values,
+ struct usb_req_read_regs *req, unsigned int count,
+ bool *retry)
+{
+ int r;
+ int i;
+ struct zd_usb_interrupt *intr = &usb->intr;
+ struct read_regs_int *rr = &intr->read_regs;
+ struct usb_int_regs *regs = (struct usb_int_regs *)rr->buffer;
+
+ spin_lock_irq(&intr->lock);
+
+ r = -EIO;
+
+ /* Read failed because firmware bug? */
+ *retry = !!intr->read_regs_int_overridden;
+ if (*retry)
+ goto error_unlock;
+
+ if (!check_read_regs(usb, req, count)) {
+ dev_dbg_f(zd_usb_dev(usb), "error: invalid read regs\n");
+ goto error_unlock;
+ }
+
+ for (i = 0; i < count; i++) {
+ struct reg_data *rd = ®s->regs[i];
+ values[i] = le16_to_cpu(rd->value);
+ }
+
+ r = 0;
+error_unlock:
+ spin_unlock_irq(&intr->lock);
+ return r;
+}
+
+int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
+ const zd_addr_t *addresses, unsigned int count)
+{
+ int r, i, req_len, actual_req_len, try_count = 0;
+ struct usb_device *udev;
+ struct usb_req_read_regs *req = NULL;
+ unsigned long timeout;
+ bool retry = false;
+
+ if (count < 1) {
+ dev_dbg_f(zd_usb_dev(usb), "error: count is zero\n");
+ return -EINVAL;
+ }
+ if (count > USB_MAX_IOREAD16_COUNT) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: count %u exceeds possible max %u\n",
+ count, USB_MAX_IOREAD16_COUNT);
+ return -EINVAL;
+ }
+ if (in_atomic()) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: io in atomic context not supported\n");
+ return -EWOULDBLOCK;
+ }
+ if (!usb_int_enabled(usb)) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: usb interrupt not enabled\n");
+ return -EWOULDBLOCK;
+ }
+
+ ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
+ BUILD_BUG_ON(sizeof(struct usb_req_read_regs) + USB_MAX_IOREAD16_COUNT *
+ sizeof(__le16) > sizeof(usb->req_buf));
+ BUG_ON(sizeof(struct usb_req_read_regs) + count * sizeof(__le16) >
+ sizeof(usb->req_buf));
+
+ req_len = sizeof(struct usb_req_read_regs) + count * sizeof(__le16);
+ req = (void *)usb->req_buf;
+
+ req->id = cpu_to_le16(USB_REQ_READ_REGS);
+ for (i = 0; i < count; i++)
+ req->addr[i] = cpu_to_le16((u16)addresses[i]);
+
+retry_read:
+ try_count++;
+ udev = zd_usb_to_usbdev(usb);
+ prepare_read_regs_int(usb, req, count);
+ r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error in zd_ep_regs_out_msg(). Error number %d\n", r);
+ goto error;
+ }
+ if (req_len != actual_req_len) {
+ dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()\n"
+ " req_len %d != actual_req_len %d\n",
+ req_len, actual_req_len);
+ r = -EIO;
+ goto error;
+ }
+
+ timeout = wait_for_completion_timeout(&usb->intr.read_regs.completion,
+ msecs_to_jiffies(50));
+ if (!timeout) {
+ disable_read_regs_int(usb);
+ dev_dbg_f(zd_usb_dev(usb), "read timed out\n");
+ r = -ETIMEDOUT;
+ goto error;
+ }
+
+ r = get_results(usb, values, req, count, &retry);
+ if (retry && try_count < 20) {
+ dev_dbg_f(zd_usb_dev(usb), "read retry, tries so far: %d\n",
+ try_count);
+ goto retry_read;
+ }
+error:
+ return r;
+}
+
+static void iowrite16v_urb_complete(struct urb *urb)
+{
+ struct zd_usb *usb = urb->context;
+
+ if (urb->status && !usb->cmd_error)
+ usb->cmd_error = urb->status;
+
+ if (!usb->cmd_error &&
+ urb->actual_length != urb->transfer_buffer_length)
+ usb->cmd_error = -EIO;
+}
+
+static int zd_submit_waiting_urb(struct zd_usb *usb, bool last)
+{
+ int r = 0;
+ struct urb *urb = usb->urb_async_waiting;
+
+ if (!urb)
+ return 0;
+
+ usb->urb_async_waiting = NULL;
+
+ if (!last)
+ urb->transfer_flags |= URB_NO_INTERRUPT;
+
+ usb_anchor_urb(urb, &usb->submitted_cmds);
+ r = usb_submit_urb(urb, GFP_KERNEL);
+ if (r) {
+ usb_unanchor_urb(urb);
+ dev_dbg_f(zd_usb_dev(usb),
+ "error in usb_submit_urb(). Error number %d\n", r);
+ goto error;
+ }
+
+ /* fall-through with r == 0 */
+error:
+ usb_free_urb(urb);
+ return r;
+}
+
+void zd_usb_iowrite16v_async_start(struct zd_usb *usb)
+{
+ ZD_ASSERT(usb_anchor_empty(&usb->submitted_cmds));
+ ZD_ASSERT(usb->urb_async_waiting == NULL);
+ ZD_ASSERT(!usb->in_async);
+
+ ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
+
+ usb->in_async = 1;
+ usb->cmd_error = 0;
+ usb->urb_async_waiting = NULL;
+}
+
+int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout)
+{
+ int r;
+
+ ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
+ ZD_ASSERT(usb->in_async);
+
+ /* Submit last iowrite16v URB */
+ r = zd_submit_waiting_urb(usb, true);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error in zd_submit_waiting_usb(). "
+ "Error number %d\n", r);
+
+ usb_kill_anchored_urbs(&usb->submitted_cmds);
+ goto error;
+ }
+
+ if (timeout)
+ timeout = usb_wait_anchor_empty_timeout(&usb->submitted_cmds,
+ timeout);
+ if (!timeout) {
+ usb_kill_anchored_urbs(&usb->submitted_cmds);
+ if (usb->cmd_error == -ENOENT) {
+ dev_dbg_f(zd_usb_dev(usb), "timed out");
+ r = -ETIMEDOUT;
+ goto error;
+ }
+ }
+
+ r = usb->cmd_error;
+error:
+ usb->in_async = 0;
+ return r;
+}
+
+int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
+ unsigned int count)
+{
+ int r;
+ struct usb_device *udev;
+ struct usb_req_write_regs *req = NULL;
+ int i, req_len;
+ struct urb *urb;
+ struct usb_host_endpoint *ep;
+
+ ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
+ ZD_ASSERT(usb->in_async);
+
+ if (count == 0)
+ return 0;
+ if (count > USB_MAX_IOWRITE16_COUNT) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: count %u exceeds possible max %u\n",
+ count, USB_MAX_IOWRITE16_COUNT);
+ return -EINVAL;
+ }
+ if (in_atomic()) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: io in atomic context not supported\n");
+ return -EWOULDBLOCK;
+ }
+
+ udev = zd_usb_to_usbdev(usb);
+
+ ep = usb_pipe_endpoint(udev, usb_sndintpipe(udev, EP_REGS_OUT));
+ if (!ep)
+ return -ENOENT;
+
+ urb = usb_alloc_urb(0, GFP_KERNEL);
+ if (!urb)
+ return -ENOMEM;
+
+ req_len = sizeof(struct usb_req_write_regs) +
+ count * sizeof(struct reg_data);
+ req = kmalloc(req_len, GFP_KERNEL);
+ if (!req) {
+ r = -ENOMEM;
+ goto error;
+ }
+
+ req->id = cpu_to_le16(USB_REQ_WRITE_REGS);
+ for (i = 0; i < count; i++) {
+ struct reg_data *rw = &req->reg_writes[i];
+ rw->addr = cpu_to_le16((u16)ioreqs[i].addr);
+ rw->value = cpu_to_le16(ioreqs[i].value);
+ }
+
+ /* In USB 2.0 mode endpoint is interrupt type. However in USB 1.1 mode
+ * endpoint is bulk. Select correct type URB by endpoint descriptor.
+ */
+ if (usb_endpoint_xfer_int(&ep->desc))
+ usb_fill_int_urb(urb, udev, usb_sndintpipe(udev, EP_REGS_OUT),
+ req, req_len, iowrite16v_urb_complete, usb,
+ ep->desc.bInterval);
+ else
+ usb_fill_bulk_urb(urb, udev, usb_sndbulkpipe(udev, EP_REGS_OUT),
+ req, req_len, iowrite16v_urb_complete, usb);
+
+ urb->transfer_flags |= URB_FREE_BUFFER;
+
+ /* Submit previous URB */
+ r = zd_submit_waiting_urb(usb, false);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error in zd_submit_waiting_usb(). "
+ "Error number %d\n", r);
+ goto error;
+ }
+
+ /* Delay submit so that URB_NO_INTERRUPT flag can be set for all URBs
+ * of currect batch except for very last.
+ */
+ usb->urb_async_waiting = urb;
+ return 0;
+error:
+ usb_free_urb(urb);
+ return r;
+}
+
+int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
+ unsigned int count)
+{
+ int r;
+
+ zd_usb_iowrite16v_async_start(usb);
+ r = zd_usb_iowrite16v_async(usb, ioreqs, count);
+ if (r) {
+ zd_usb_iowrite16v_async_end(usb, 0);
+ return r;
+ }
+ return zd_usb_iowrite16v_async_end(usb, 50 /* ms */);
+}
+
+int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits)
+{
+ int r;
+ struct usb_device *udev;
+ struct usb_req_rfwrite *req = NULL;
+ int i, req_len, actual_req_len;
+ u16 bit_value_template;
+
+ if (in_atomic()) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: io in atomic context not supported\n");
+ return -EWOULDBLOCK;
+ }
+ if (bits < USB_MIN_RFWRITE_BIT_COUNT) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: bits %d are smaller than"
+ " USB_MIN_RFWRITE_BIT_COUNT %d\n",
+ bits, USB_MIN_RFWRITE_BIT_COUNT);
+ return -EINVAL;
+ }
+ if (bits > USB_MAX_RFWRITE_BIT_COUNT) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: bits %d exceed USB_MAX_RFWRITE_BIT_COUNT %d\n",
+ bits, USB_MAX_RFWRITE_BIT_COUNT);
+ return -EINVAL;
+ }
+#ifdef DEBUG
+ if (value & (~0UL << bits)) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error: value %#09x has bits >= %d set\n",
+ value, bits);
+ return -EINVAL;
+ }
+#endif /* DEBUG */
+
+ dev_dbg_f(zd_usb_dev(usb), "value %#09x bits %d\n", value, bits);
+
+ r = zd_usb_ioread16(usb, &bit_value_template, ZD_CR203);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error %d: Couldn't read ZD_CR203\n", r);
+ return r;
+ }
+ bit_value_template &= ~(RF_IF_LE|RF_CLK|RF_DATA);
+
+ ZD_ASSERT(mutex_is_locked(&zd_usb_to_chip(usb)->mutex));
+ BUILD_BUG_ON(sizeof(struct usb_req_rfwrite) +
+ USB_MAX_RFWRITE_BIT_COUNT * sizeof(__le16) >
+ sizeof(usb->req_buf));
+ BUG_ON(sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16) >
+ sizeof(usb->req_buf));
+
+ req_len = sizeof(struct usb_req_rfwrite) + bits * sizeof(__le16);
+ req = (void *)usb->req_buf;
+
+ req->id = cpu_to_le16(USB_REQ_WRITE_RF);
+ /* 1: 3683a, but not used in ZYDAS driver */
+ req->value = cpu_to_le16(2);
+ req->bits = cpu_to_le16(bits);
+
+ for (i = 0; i < bits; i++) {
+ u16 bv = bit_value_template;
+ if (value & (1 << (bits-1-i)))
+ bv |= RF_DATA;
+ req->bit_values[i] = cpu_to_le16(bv);
+ }
+
+ udev = zd_usb_to_usbdev(usb);
+ r = zd_ep_regs_out_msg(udev, req, req_len, &actual_req_len, 50 /*ms*/);
+ if (r) {
+ dev_dbg_f(zd_usb_dev(usb),
+ "error in zd_ep_regs_out_msg(). Error number %d\n", r);
+ goto out;
+ }
+ if (req_len != actual_req_len) {
+ dev_dbg_f(zd_usb_dev(usb), "error in zd_ep_regs_out_msg()"
+ " req_len %d != actual_req_len %d\n",
+ req_len, actual_req_len);
+ r = -EIO;
+ goto out;
+ }
+
+ /* FALL-THROUGH with r == 0 */
+out:
+ return r;
+}
--- /dev/null
+/* ZD1211 USB-WLAN driver for Linux
+ *
+ * Copyright (C) 2005-2007 Ulrich Kunitz <kune@deine-taler.de>
+ * Copyright (C) 2006-2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _ZD_USB_H
+#define _ZD_USB_H
+
+#include <linux/completion.h>
+#include <linux/netdevice.h>
+#include <linux/spinlock.h>
+#include <linux/skbuff.h>
+#include <linux/usb.h>
+
+#include "zd_def.h"
+
+#define ZD_USB_TX_HIGH 5
+#define ZD_USB_TX_LOW 2
+
+#define ZD_TX_TIMEOUT (HZ * 5)
+#define ZD_TX_WATCHDOG_INTERVAL round_jiffies_relative(HZ)
+#define ZD_RX_IDLE_INTERVAL round_jiffies_relative(30 * HZ)
+
+enum devicetype {
+ DEVICE_ZD1211 = 0,
+ DEVICE_ZD1211B = 1,
+ DEVICE_INSTALLER = 2,
+};
+
+enum endpoints {
+ EP_CTRL = 0,
+ EP_DATA_OUT = 1,
+ EP_DATA_IN = 2,
+ EP_INT_IN = 3,
+ EP_REGS_OUT = 4,
+};
+
+enum {
+ USB_MAX_TRANSFER_SIZE = 4096, /* bytes */
+ /* FIXME: The original driver uses this value. We have to check,
+ * whether the MAX_TRANSFER_SIZE is sufficient and this needs only be
+ * used if one combined frame is split over two USB transactions.
+ */
+ USB_MAX_RX_SIZE = 4800, /* bytes */
+ USB_MAX_IOWRITE16_COUNT = 15,
+ USB_MAX_IOWRITE32_COUNT = USB_MAX_IOWRITE16_COUNT/2,
+ USB_MAX_IOREAD16_COUNT = 15,
+ USB_MAX_IOREAD32_COUNT = USB_MAX_IOREAD16_COUNT/2,
+ USB_MIN_RFWRITE_BIT_COUNT = 16,
+ USB_MAX_RFWRITE_BIT_COUNT = 28,
+ USB_MAX_EP_INT_BUFFER = 64,
+ USB_ZD1211B_BCD_DEVICE = 0x4810,
+};
+
+enum control_requests {
+ USB_REQ_WRITE_REGS = 0x21,
+ USB_REQ_READ_REGS = 0x22,
+ USB_REQ_WRITE_RF = 0x23,
+ USB_REQ_PROG_FLASH = 0x24,
+ USB_REQ_EEPROM_START = 0x0128, /* ? request is a byte */
+ USB_REQ_EEPROM_MID = 0x28,
+ USB_REQ_EEPROM_END = 0x0228, /* ? request is a byte */
+ USB_REQ_FIRMWARE_DOWNLOAD = 0x30,
+ USB_REQ_FIRMWARE_CONFIRM = 0x31,
+ USB_REQ_FIRMWARE_READ_DATA = 0x32,
+};
+
+struct usb_req_read_regs {
+ __le16 id;
+ __le16 addr[0];
+} __packed;
+
+struct reg_data {
+ __le16 addr;
+ __le16 value;
+} __packed;
+
+struct usb_req_write_regs {
+ __le16 id;
+ struct reg_data reg_writes[0];
+} __packed;
+
+enum {
+ RF_IF_LE = 0x02,
+ RF_CLK = 0x04,
+ RF_DATA = 0x08,
+};
+
+struct usb_req_rfwrite {
+ __le16 id;
+ __le16 value;
+ /* 1: 3683a */
+ /* 2: other (default) */
+ __le16 bits;
+ /* RF2595: 24 */
+ __le16 bit_values[0];
+ /* (ZD_CR203 & ~(RF_IF_LE | RF_CLK | RF_DATA)) | (bit ? RF_DATA : 0) */
+} __packed;
+
+/* USB interrupt */
+
+enum usb_int_id {
+ USB_INT_TYPE = 0x01,
+ USB_INT_ID_REGS = 0x90,
+ USB_INT_ID_RETRY_FAILED = 0xa0,
+};
+
+enum usb_int_flags {
+ USB_INT_READ_REGS_EN = 0x01,
+};
+
+struct usb_int_header {
+ u8 type; /* must always be 1 */
+ u8 id;
+} __packed;
+
+struct usb_int_regs {
+ struct usb_int_header hdr;
+ struct reg_data regs[0];
+} __packed;
+
+struct usb_int_retry_fail {
+ struct usb_int_header hdr;
+ u8 new_rate;
+ u8 _dummy;
+ u8 addr[ETH_ALEN];
+ u8 ibss_wakeup_dest;
+} __packed;
+
+struct read_regs_int {
+ struct completion completion;
+ struct usb_req_read_regs *req;
+ unsigned int req_count;
+ /* Stores the USB int structure and contains the USB address of the
+ * first requested register before request.
+ */
+ u8 buffer[USB_MAX_EP_INT_BUFFER];
+ int length;
+ __le16 cr_int_addr;
+};
+
+struct zd_ioreq16 {
+ zd_addr_t addr;
+ u16 value;
+};
+
+struct zd_ioreq32 {
+ zd_addr_t addr;
+ u32 value;
+};
+
+struct zd_usb_interrupt {
+ struct read_regs_int read_regs;
+ spinlock_t lock;
+ struct urb *urb;
+ void *buffer;
+ dma_addr_t buffer_dma;
+ int interval;
+ atomic_t read_regs_enabled;
+ u8 read_regs_int_overridden:1;
+};
+
+static inline struct usb_int_regs *get_read_regs(struct zd_usb_interrupt *intr)
+{
+ return (struct usb_int_regs *)intr->read_regs.buffer;
+}
+
+#define RX_URBS_COUNT 5
+
+struct zd_usb_rx {
+ spinlock_t lock;
+ struct mutex setup_mutex;
+ struct delayed_work idle_work;
+ struct tasklet_struct reset_timer_tasklet;
+ u8 fragment[2 * USB_MAX_RX_SIZE];
+ unsigned int fragment_length;
+ unsigned int usb_packet_size;
+ struct urb **urbs;
+ int urbs_count;
+};
+
+/**
+ * struct zd_usb_tx - structure used for transmitting frames
+ * @enabled: atomic enabled flag, indicates whether tx is enabled
+ * @lock: lock for transmission
+ * @submitted: anchor for URBs sent to device
+ * @submitted_urbs: atomic integer that counts the URBs having sent to the
+ * device, which haven't been completed
+ * @stopped: indicates whether higher level tx queues are stopped
+ */
+struct zd_usb_tx {
+ atomic_t enabled;
+ spinlock_t lock;
+ struct delayed_work watchdog_work;
+ struct sk_buff_head submitted_skbs;
+ struct usb_anchor submitted;
+ int submitted_urbs;
+ u8 stopped:1, watchdog_enabled:1;
+};
+
+/* Contains the usb parts. The structure doesn't require a lock because intf
+ * will not be changed after initialization.
+ */
+struct zd_usb {
+ struct zd_usb_interrupt intr;
+ struct zd_usb_rx rx;
+ struct zd_usb_tx tx;
+ struct usb_interface *intf;
+ struct usb_anchor submitted_cmds;
+ struct urb *urb_async_waiting;
+ int cmd_error;
+ u8 req_buf[64]; /* zd_usb_iowrite16v needs 62 bytes */
+ u8 is_zd1211b:1, initialized:1, was_running:1, in_async:1;
+};
+
+#define zd_usb_dev(usb) (&usb->intf->dev)
+
+static inline struct usb_device *zd_usb_to_usbdev(struct zd_usb *usb)
+{
+ return interface_to_usbdev(usb->intf);
+}
+
+static inline struct ieee80211_hw *zd_intf_to_hw(struct usb_interface *intf)
+{
+ return usb_get_intfdata(intf);
+}
+
+static inline struct ieee80211_hw *zd_usb_to_hw(struct zd_usb *usb)
+{
+ return zd_intf_to_hw(usb->intf);
+}
+
+void zd_usb_init(struct zd_usb *usb, struct ieee80211_hw *hw,
+ struct usb_interface *intf);
+int zd_usb_init_hw(struct zd_usb *usb);
+void zd_usb_clear(struct zd_usb *usb);
+
+int zd_usb_scnprint_id(struct zd_usb *usb, char *buffer, size_t size);
+
+void zd_tx_watchdog_enable(struct zd_usb *usb);
+void zd_tx_watchdog_disable(struct zd_usb *usb);
+
+int zd_usb_enable_int(struct zd_usb *usb);
+void zd_usb_disable_int(struct zd_usb *usb);
+
+int zd_usb_enable_rx(struct zd_usb *usb);
+void zd_usb_disable_rx(struct zd_usb *usb);
+
+void zd_usb_reset_rx_idle_timer(struct zd_usb *usb);
+
+void zd_usb_enable_tx(struct zd_usb *usb);
+void zd_usb_disable_tx(struct zd_usb *usb);
+
+int zd_usb_tx(struct zd_usb *usb, struct sk_buff *skb);
+
+int zd_usb_ioread16v(struct zd_usb *usb, u16 *values,
+ const zd_addr_t *addresses, unsigned int count);
+
+static inline int zd_usb_ioread16(struct zd_usb *usb, u16 *value,
+ const zd_addr_t addr)
+{
+ return zd_usb_ioread16v(usb, value, &addr, 1);
+}
+
+void zd_usb_iowrite16v_async_start(struct zd_usb *usb);
+int zd_usb_iowrite16v_async_end(struct zd_usb *usb, unsigned int timeout);
+int zd_usb_iowrite16v_async(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
+ unsigned int count);
+int zd_usb_iowrite16v(struct zd_usb *usb, const struct zd_ioreq16 *ioreqs,
+ unsigned int count);
+
+int zd_usb_rfwrite(struct zd_usb *usb, u32 value, u8 bits);
+
+int zd_usb_read_fw(struct zd_usb *usb, zd_addr_t addr, u8 *data, u16 len);
+
+extern struct workqueue_struct *zd_workqueue;
+
+#endif /* _ZD_USB_H */
projects / openwrt / staging / blogic.git / commitdiff