2007-09-26 00:57:13 +00:00
|
|
|
/*
|
2008-02-03 14:42:53 +00:00
|
|
|
Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
|
2007-09-26 00:57:13 +00:00
|
|
|
<http://rt2x00.serialmonkey.com>
|
|
|
|
|
|
|
|
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, write to the
|
|
|
|
Free Software Foundation, Inc.,
|
|
|
|
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
Module: rt2400pci
|
|
|
|
Abstract: rt2400pci device specific routines.
|
|
|
|
Supported chipsets: RT2460.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/eeprom_93cx6.h>
|
|
|
|
|
|
|
|
#include "rt2x00.h"
|
|
|
|
#include "rt2x00pci.h"
|
|
|
|
#include "rt2400pci.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Register access.
|
|
|
|
* All access to the CSR registers will go through the methods
|
|
|
|
* rt2x00pci_register_read and rt2x00pci_register_write.
|
|
|
|
* BBP and RF register require indirect register access,
|
|
|
|
* and use the CSR registers BBPCSR and RFCSR to achieve this.
|
|
|
|
* These indirect registers work with busy bits,
|
|
|
|
* and we will try maximal REGISTER_BUSY_COUNT times to access
|
|
|
|
* the register while taking a REGISTER_BUSY_DELAY us delay
|
|
|
|
* between each attampt. When the busy bit is still set at that time,
|
|
|
|
* the access attempt is considered to have failed,
|
|
|
|
* and we will print an error.
|
|
|
|
*/
|
2007-10-27 11:41:25 +00:00
|
|
|
static u32 rt2400pci_bbp_check(struct rt2x00_dev *rt2x00dev)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
|
|
|
|
rt2x00pci_register_read(rt2x00dev, BBPCSR, ®);
|
|
|
|
if (!rt2x00_get_field32(reg, BBPCSR_BUSY))
|
|
|
|
break;
|
|
|
|
udelay(REGISTER_BUSY_DELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reg;
|
|
|
|
}
|
|
|
|
|
2007-10-27 11:41:25 +00:00
|
|
|
static void rt2400pci_bbp_write(struct rt2x00_dev *rt2x00dev,
|
2007-09-26 00:57:13 +00:00
|
|
|
const unsigned int word, const u8 value)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait until the BBP becomes ready.
|
|
|
|
*/
|
|
|
|
reg = rt2400pci_bbp_check(rt2x00dev);
|
|
|
|
if (rt2x00_get_field32(reg, BBPCSR_BUSY)) {
|
|
|
|
ERROR(rt2x00dev, "BBPCSR register busy. Write failed.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write the data into the BBP.
|
|
|
|
*/
|
|
|
|
reg = 0;
|
|
|
|
rt2x00_set_field32(®, BBPCSR_VALUE, value);
|
|
|
|
rt2x00_set_field32(®, BBPCSR_REGNUM, word);
|
|
|
|
rt2x00_set_field32(®, BBPCSR_BUSY, 1);
|
|
|
|
rt2x00_set_field32(®, BBPCSR_WRITE_CONTROL, 1);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, BBPCSR, reg);
|
|
|
|
}
|
|
|
|
|
2007-10-27 11:41:25 +00:00
|
|
|
static void rt2400pci_bbp_read(struct rt2x00_dev *rt2x00dev,
|
2007-09-26 00:57:13 +00:00
|
|
|
const unsigned int word, u8 *value)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait until the BBP becomes ready.
|
|
|
|
*/
|
|
|
|
reg = rt2400pci_bbp_check(rt2x00dev);
|
|
|
|
if (rt2x00_get_field32(reg, BBPCSR_BUSY)) {
|
|
|
|
ERROR(rt2x00dev, "BBPCSR register busy. Read failed.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write the request into the BBP.
|
|
|
|
*/
|
|
|
|
reg = 0;
|
|
|
|
rt2x00_set_field32(®, BBPCSR_REGNUM, word);
|
|
|
|
rt2x00_set_field32(®, BBPCSR_BUSY, 1);
|
|
|
|
rt2x00_set_field32(®, BBPCSR_WRITE_CONTROL, 0);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, BBPCSR, reg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait until the BBP becomes ready.
|
|
|
|
*/
|
|
|
|
reg = rt2400pci_bbp_check(rt2x00dev);
|
|
|
|
if (rt2x00_get_field32(reg, BBPCSR_BUSY)) {
|
|
|
|
ERROR(rt2x00dev, "BBPCSR register busy. Read failed.\n");
|
|
|
|
*value = 0xff;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*value = rt2x00_get_field32(reg, BBPCSR_VALUE);
|
|
|
|
}
|
|
|
|
|
2007-10-27 11:41:25 +00:00
|
|
|
static void rt2400pci_rf_write(struct rt2x00_dev *rt2x00dev,
|
2007-09-26 00:57:13 +00:00
|
|
|
const unsigned int word, const u32 value)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
if (!word)
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RFCSR, ®);
|
|
|
|
if (!rt2x00_get_field32(reg, RFCSR_BUSY))
|
|
|
|
goto rf_write;
|
|
|
|
udelay(REGISTER_BUSY_DELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
ERROR(rt2x00dev, "RFCSR register busy. Write failed.\n");
|
|
|
|
return;
|
|
|
|
|
|
|
|
rf_write:
|
|
|
|
reg = 0;
|
|
|
|
rt2x00_set_field32(®, RFCSR_VALUE, value);
|
|
|
|
rt2x00_set_field32(®, RFCSR_NUMBER_OF_BITS, 20);
|
|
|
|
rt2x00_set_field32(®, RFCSR_IF_SELECT, 0);
|
|
|
|
rt2x00_set_field32(®, RFCSR_BUSY, 1);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, RFCSR, reg);
|
|
|
|
rt2x00_rf_write(rt2x00dev, word, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_eepromregister_read(struct eeprom_93cx6 *eeprom)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = eeprom->data;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR21, ®);
|
|
|
|
|
|
|
|
eeprom->reg_data_in = !!rt2x00_get_field32(reg, CSR21_EEPROM_DATA_IN);
|
|
|
|
eeprom->reg_data_out = !!rt2x00_get_field32(reg, CSR21_EEPROM_DATA_OUT);
|
|
|
|
eeprom->reg_data_clock =
|
|
|
|
!!rt2x00_get_field32(reg, CSR21_EEPROM_DATA_CLOCK);
|
|
|
|
eeprom->reg_chip_select =
|
|
|
|
!!rt2x00_get_field32(reg, CSR21_EEPROM_CHIP_SELECT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_eepromregister_write(struct eeprom_93cx6 *eeprom)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = eeprom->data;
|
|
|
|
u32 reg = 0;
|
|
|
|
|
|
|
|
rt2x00_set_field32(®, CSR21_EEPROM_DATA_IN, !!eeprom->reg_data_in);
|
|
|
|
rt2x00_set_field32(®, CSR21_EEPROM_DATA_OUT, !!eeprom->reg_data_out);
|
|
|
|
rt2x00_set_field32(®, CSR21_EEPROM_DATA_CLOCK,
|
|
|
|
!!eeprom->reg_data_clock);
|
|
|
|
rt2x00_set_field32(®, CSR21_EEPROM_CHIP_SELECT,
|
|
|
|
!!eeprom->reg_chip_select);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR21, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT2X00_LIB_DEBUGFS
|
|
|
|
#define CSR_OFFSET(__word) ( CSR_REG_BASE + ((__word) * sizeof(u32)) )
|
|
|
|
|
2007-10-27 11:41:25 +00:00
|
|
|
static void rt2400pci_read_csr(struct rt2x00_dev *rt2x00dev,
|
2007-09-26 00:57:13 +00:00
|
|
|
const unsigned int word, u32 *data)
|
|
|
|
{
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR_OFFSET(word), data);
|
|
|
|
}
|
|
|
|
|
2007-10-27 11:41:25 +00:00
|
|
|
static void rt2400pci_write_csr(struct rt2x00_dev *rt2x00dev,
|
2007-09-26 00:57:13 +00:00
|
|
|
const unsigned int word, u32 data)
|
|
|
|
{
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR_OFFSET(word), data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct rt2x00debug rt2400pci_rt2x00debug = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.csr = {
|
|
|
|
.read = rt2400pci_read_csr,
|
|
|
|
.write = rt2400pci_write_csr,
|
|
|
|
.word_size = sizeof(u32),
|
|
|
|
.word_count = CSR_REG_SIZE / sizeof(u32),
|
|
|
|
},
|
|
|
|
.eeprom = {
|
|
|
|
.read = rt2x00_eeprom_read,
|
|
|
|
.write = rt2x00_eeprom_write,
|
|
|
|
.word_size = sizeof(u16),
|
|
|
|
.word_count = EEPROM_SIZE / sizeof(u16),
|
|
|
|
},
|
|
|
|
.bbp = {
|
|
|
|
.read = rt2400pci_bbp_read,
|
|
|
|
.write = rt2400pci_bbp_write,
|
|
|
|
.word_size = sizeof(u8),
|
|
|
|
.word_count = BBP_SIZE / sizeof(u8),
|
|
|
|
},
|
|
|
|
.rf = {
|
|
|
|
.read = rt2x00_rf_read,
|
|
|
|
.write = rt2400pci_rf_write,
|
|
|
|
.word_size = sizeof(u32),
|
|
|
|
.word_count = RF_SIZE / sizeof(u32),
|
|
|
|
},
|
|
|
|
};
|
|
|
|
#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT2400PCI_RFKILL
|
|
|
|
static int rt2400pci_rfkill_poll(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, GPIOCSR, ®);
|
|
|
|
return rt2x00_get_field32(reg, GPIOCSR_BIT0);
|
|
|
|
}
|
2007-10-06 12:14:06 +00:00
|
|
|
#else
|
|
|
|
#define rt2400pci_rfkill_poll NULL
|
2007-09-26 00:57:13 +00:00
|
|
|
#endif /* CONFIG_RT2400PCI_RFKILL */
|
|
|
|
|
2008-02-03 14:53:40 +00:00
|
|
|
#ifdef CONFIG_RT2400PCI_LEDS
|
2008-03-31 13:53:44 +00:00
|
|
|
static void rt2400pci_brightness_set(struct led_classdev *led_cdev,
|
2008-02-03 14:53:40 +00:00
|
|
|
enum led_brightness brightness)
|
|
|
|
{
|
|
|
|
struct rt2x00_led *led =
|
|
|
|
container_of(led_cdev, struct rt2x00_led, led_dev);
|
|
|
|
unsigned int enabled = brightness != LED_OFF;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(led->rt2x00dev, LEDCSR, ®);
|
|
|
|
|
2008-03-31 13:53:44 +00:00
|
|
|
if (led->type == LED_TYPE_RADIO || led->type == LED_TYPE_ASSOC)
|
2008-02-03 14:53:40 +00:00
|
|
|
rt2x00_set_field32(®, LEDCSR_LINK, enabled);
|
2008-03-31 13:53:44 +00:00
|
|
|
else if (led->type == LED_TYPE_ACTIVITY)
|
|
|
|
rt2x00_set_field32(®, LEDCSR_ACTIVITY, enabled);
|
2008-02-03 14:53:40 +00:00
|
|
|
|
|
|
|
rt2x00pci_register_write(led->rt2x00dev, LEDCSR, reg);
|
|
|
|
}
|
2008-03-31 13:53:44 +00:00
|
|
|
|
|
|
|
static int rt2400pci_blink_set(struct led_classdev *led_cdev,
|
|
|
|
unsigned long *delay_on,
|
|
|
|
unsigned long *delay_off)
|
|
|
|
{
|
|
|
|
struct rt2x00_led *led =
|
|
|
|
container_of(led_cdev, struct rt2x00_led, led_dev);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(led->rt2x00dev, LEDCSR, ®);
|
|
|
|
rt2x00_set_field32(®, LEDCSR_ON_PERIOD, *delay_on);
|
|
|
|
rt2x00_set_field32(®, LEDCSR_OFF_PERIOD, *delay_off);
|
|
|
|
rt2x00pci_register_write(led->rt2x00dev, LEDCSR, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-06-03 18:30:01 +00:00
|
|
|
|
|
|
|
static void rt2400pci_init_led(struct rt2x00_dev *rt2x00dev,
|
|
|
|
struct rt2x00_led *led,
|
|
|
|
enum led_type type)
|
|
|
|
{
|
|
|
|
led->rt2x00dev = rt2x00dev;
|
|
|
|
led->type = type;
|
|
|
|
led->led_dev.brightness_set = rt2400pci_brightness_set;
|
|
|
|
led->led_dev.blink_set = rt2400pci_blink_set;
|
|
|
|
led->flags = LED_INITIALIZED;
|
|
|
|
}
|
2008-02-03 14:53:40 +00:00
|
|
|
#endif /* CONFIG_RT2400PCI_LEDS */
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
/*
|
|
|
|
* Configuration handlers.
|
|
|
|
*/
|
2008-03-25 13:13:18 +00:00
|
|
|
static void rt2400pci_config_filter(struct rt2x00_dev *rt2x00dev,
|
|
|
|
const unsigned int filter_flags)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start configuration steps.
|
|
|
|
* Note that the version error will always be dropped
|
|
|
|
* since there is no filter for it at this time.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RXCSR0, ®);
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_CRC,
|
|
|
|
!(filter_flags & FIF_FCSFAIL));
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_PHYSICAL,
|
|
|
|
!(filter_flags & FIF_PLCPFAIL));
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_CONTROL,
|
|
|
|
!(filter_flags & FIF_CONTROL));
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_NOT_TO_ME,
|
|
|
|
!(filter_flags & FIF_PROMISC_IN_BSS));
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_TODS,
|
2008-03-31 13:24:53 +00:00
|
|
|
!(filter_flags & FIF_PROMISC_IN_BSS) &&
|
|
|
|
!rt2x00dev->intf_ap_count);
|
2008-03-25 13:13:18 +00:00
|
|
|
rt2x00_set_field32(®, RXCSR0_DROP_VERSION_ERROR, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
|
|
|
|
}
|
|
|
|
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
static void rt2400pci_config_intf(struct rt2x00_dev *rt2x00dev,
|
|
|
|
struct rt2x00_intf *intf,
|
|
|
|
struct rt2x00intf_conf *conf,
|
|
|
|
const unsigned int flags)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
unsigned int bcn_preload;
|
|
|
|
u32 reg;
|
2007-09-26 00:57:13 +00:00
|
|
|
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
if (flags & CONFIG_UPDATE_TYPE) {
|
|
|
|
/*
|
|
|
|
* Enable beacon config
|
|
|
|
*/
|
|
|
|
bcn_preload = PREAMBLE + get_duration(IEEE80211_HEADER, 20);
|
|
|
|
rt2x00pci_register_read(rt2x00dev, BCNCSR1, ®);
|
|
|
|
rt2x00_set_field32(®, BCNCSR1_PRELOAD, bcn_preload);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, BCNCSR1, reg);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
/*
|
|
|
|
* Enable synchronisation.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR14, ®);
|
2008-03-09 21:47:43 +00:00
|
|
|
rt2x00_set_field32(®, CSR14_TSF_COUNT, 1);
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
rt2x00_set_field32(®, CSR14_TSF_SYNC, conf->sync);
|
2008-03-09 21:47:43 +00:00
|
|
|
rt2x00_set_field32(®, CSR14_TBCN, 1);
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR14, reg);
|
|
|
|
}
|
2007-09-26 00:57:13 +00:00
|
|
|
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
if (flags & CONFIG_UPDATE_MAC)
|
|
|
|
rt2x00pci_register_multiwrite(rt2x00dev, CSR3,
|
|
|
|
conf->mac, sizeof(conf->mac));
|
2007-09-26 00:57:13 +00:00
|
|
|
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
if (flags & CONFIG_UPDATE_BSSID)
|
|
|
|
rt2x00pci_register_multiwrite(rt2x00dev, CSR5,
|
|
|
|
conf->bssid, sizeof(conf->bssid));
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
2008-03-25 13:13:18 +00:00
|
|
|
static void rt2400pci_config_erp(struct rt2x00_dev *rt2x00dev,
|
|
|
|
struct rt2x00lib_erp *erp)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2007-10-06 11:34:52 +00:00
|
|
|
int preamble_mask;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 reg;
|
|
|
|
|
2007-10-06 11:34:52 +00:00
|
|
|
/*
|
|
|
|
* When short preamble is enabled, we should set bit 0x08
|
|
|
|
*/
|
2008-03-09 21:46:18 +00:00
|
|
|
preamble_mask = erp->short_preamble << 3;
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR1, ®);
|
2008-03-09 21:46:18 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR1_ACK_TIMEOUT,
|
|
|
|
erp->ack_timeout);
|
|
|
|
rt2x00_set_field32(®, TXCSR1_ACK_CONSUME_TIME,
|
|
|
|
erp->ack_consume_time);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR1, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, ARCSR2, ®);
|
2008-04-21 17:00:17 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR2_SIGNAL, 0x00);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR2_SERVICE, 0x04);
|
|
|
|
rt2x00_set_field32(®, ARCSR2_LENGTH, get_duration(ACK_SIZE, 10));
|
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR2, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, ARCSR3, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR3_SIGNAL, 0x01 | preamble_mask);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR3_SERVICE, 0x04);
|
|
|
|
rt2x00_set_field32(®, ARCSR2_LENGTH, get_duration(ACK_SIZE, 20));
|
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR3, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, ARCSR4, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR4_SIGNAL, 0x02 | preamble_mask);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR4_SERVICE, 0x04);
|
|
|
|
rt2x00_set_field32(®, ARCSR2_LENGTH, get_duration(ACK_SIZE, 55));
|
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR4, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, ARCSR5, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR5_SIGNAL, 0x03 | preamble_mask);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(®, ARCSR5_SERVICE, 0x84);
|
|
|
|
rt2x00_set_field32(®, ARCSR2_LENGTH, get_duration(ACK_SIZE, 110));
|
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR5, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_phymode(struct rt2x00_dev *rt2x00dev,
|
2007-10-06 11:34:52 +00:00
|
|
|
const int basic_rate_mask)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR1, basic_rate_mask);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_channel(struct rt2x00_dev *rt2x00dev,
|
2007-10-06 11:34:52 +00:00
|
|
|
struct rf_channel *rf)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Switch on tuning bits.
|
|
|
|
*/
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(&rf->rf1, RF1_TUNER, 1);
|
|
|
|
rt2x00_set_field32(&rf->rf3, RF3_TUNER, 1);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 1, rf->rf1);
|
|
|
|
rt2400pci_rf_write(rt2x00dev, 2, rf->rf2);
|
|
|
|
rt2400pci_rf_write(rt2x00dev, 3, rf->rf3);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* RF2420 chipset don't need any additional actions.
|
|
|
|
*/
|
|
|
|
if (rt2x00_rf(&rt2x00dev->chip, RF2420))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For the RT2421 chipsets we need to write an invalid
|
|
|
|
* reference clock rate to activate auto_tune.
|
|
|
|
* After that we set the value back to the correct channel.
|
|
|
|
*/
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 1, rf->rf1);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 2, 0x000c2a32);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 3, rf->rf3);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 1, rf->rf1);
|
|
|
|
rt2400pci_rf_write(rt2x00dev, 2, rf->rf2);
|
|
|
|
rt2400pci_rf_write(rt2x00dev, 3, rf->rf3);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
msleep(1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Switch off tuning bits.
|
|
|
|
*/
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(&rf->rf1, RF1_TUNER, 0);
|
|
|
|
rt2x00_set_field32(&rf->rf3, RF3_TUNER, 0);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_rf_write(rt2x00dev, 1, rf->rf1);
|
|
|
|
rt2400pci_rf_write(rt2x00dev, 3, rf->rf3);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Clear false CRC during channel switch.
|
|
|
|
*/
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, CNT0, &rf->rf1);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_txpower(struct rt2x00_dev *rt2x00dev, int txpower)
|
|
|
|
{
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 3, TXPOWER_TO_DEV(txpower));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_antenna(struct rt2x00_dev *rt2x00dev,
|
2007-10-13 14:26:23 +00:00
|
|
|
struct antenna_setup *ant)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u8 r1;
|
|
|
|
u8 r4;
|
|
|
|
|
2008-03-09 21:45:21 +00:00
|
|
|
/*
|
|
|
|
* We should never come here because rt2x00lib is supposed
|
|
|
|
* to catch this and send us the correct antenna explicitely.
|
|
|
|
*/
|
|
|
|
BUG_ON(ant->rx == ANTENNA_SW_DIVERSITY ||
|
|
|
|
ant->tx == ANTENNA_SW_DIVERSITY);
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2400pci_bbp_read(rt2x00dev, 4, &r4);
|
|
|
|
rt2400pci_bbp_read(rt2x00dev, 1, &r1);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure the TX antenna.
|
|
|
|
*/
|
2007-10-13 14:26:23 +00:00
|
|
|
switch (ant->tx) {
|
2007-09-26 00:57:13 +00:00
|
|
|
case ANTENNA_HW_DIVERSITY:
|
|
|
|
rt2x00_set_field8(&r1, BBP_R1_TX_ANTENNA, 1);
|
|
|
|
break;
|
|
|
|
case ANTENNA_A:
|
|
|
|
rt2x00_set_field8(&r1, BBP_R1_TX_ANTENNA, 0);
|
|
|
|
break;
|
|
|
|
case ANTENNA_B:
|
2008-03-09 21:45:21 +00:00
|
|
|
default:
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field8(&r1, BBP_R1_TX_ANTENNA, 2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure the RX antenna.
|
|
|
|
*/
|
2007-10-13 14:26:23 +00:00
|
|
|
switch (ant->rx) {
|
2007-09-26 00:57:13 +00:00
|
|
|
case ANTENNA_HW_DIVERSITY:
|
|
|
|
rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA, 1);
|
|
|
|
break;
|
|
|
|
case ANTENNA_A:
|
|
|
|
rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA, 0);
|
|
|
|
break;
|
|
|
|
case ANTENNA_B:
|
2008-03-09 21:45:21 +00:00
|
|
|
default:
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field8(&r4, BBP_R4_RX_ANTENNA, 2);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 4, r4);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 1, r1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_duration(struct rt2x00_dev *rt2x00dev,
|
2007-10-06 11:34:52 +00:00
|
|
|
struct rt2x00lib_conf *libconf)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR11, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, CSR11_SLOT_TIME, libconf->slot_time);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR11, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR18, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, CSR18_SIFS, libconf->sifs);
|
|
|
|
rt2x00_set_field32(®, CSR18_PIFS, libconf->pifs);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR18, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR19, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, CSR19_DIFS, libconf->difs);
|
|
|
|
rt2x00_set_field32(®, CSR19_EIFS, libconf->eifs);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR19, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR1, ®);
|
|
|
|
rt2x00_set_field32(®, TXCSR1_TSF_OFFSET, IEEE80211_HEADER);
|
|
|
|
rt2x00_set_field32(®, TXCSR1_AUTORESPONDER, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR1, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR12, ®);
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2x00_set_field32(®, CSR12_BEACON_INTERVAL,
|
|
|
|
libconf->conf->beacon_int * 16);
|
|
|
|
rt2x00_set_field32(®, CSR12_CFP_MAX_DURATION,
|
|
|
|
libconf->conf->beacon_int * 16);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR12, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config(struct rt2x00_dev *rt2x00dev,
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
struct rt2x00lib_conf *libconf,
|
|
|
|
const unsigned int flags)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
if (flags & CONFIG_UPDATE_PHYMODE)
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_config_phymode(rt2x00dev, libconf->basic_rates);
|
2007-09-26 00:57:13 +00:00
|
|
|
if (flags & CONFIG_UPDATE_CHANNEL)
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_config_channel(rt2x00dev, &libconf->rf);
|
2007-09-26 00:57:13 +00:00
|
|
|
if (flags & CONFIG_UPDATE_TXPOWER)
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_config_txpower(rt2x00dev,
|
|
|
|
libconf->conf->power_level);
|
2007-09-26 00:57:13 +00:00
|
|
|
if (flags & CONFIG_UPDATE_ANTENNA)
|
2007-10-13 14:26:23 +00:00
|
|
|
rt2400pci_config_antenna(rt2x00dev, &libconf->ant);
|
2007-09-26 00:57:13 +00:00
|
|
|
if (flags & (CONFIG_UPDATE_SLOT_TIME | CONFIG_UPDATE_BEACON_INT))
|
2007-10-06 11:34:52 +00:00
|
|
|
rt2400pci_config_duration(rt2x00dev, libconf);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_config_cw(struct rt2x00_dev *rt2x00dev,
|
2008-02-05 21:42:23 +00:00
|
|
|
const int cw_min, const int cw_max)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR11, ®);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(®, CSR11_CWMIN, cw_min);
|
|
|
|
rt2x00_set_field32(®, CSR11_CWMAX, cw_max);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR11, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Link tuning
|
|
|
|
*/
|
2007-10-13 14:26:12 +00:00
|
|
|
static void rt2400pci_link_stats(struct rt2x00_dev *rt2x00dev,
|
|
|
|
struct link_qual *qual)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
u8 bbp;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update FCS error count from register.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CNT0, ®);
|
2007-10-13 14:26:12 +00:00
|
|
|
qual->rx_failed = rt2x00_get_field32(reg, CNT0_FCS_ERROR);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Update False CCA count from register.
|
|
|
|
*/
|
|
|
|
rt2400pci_bbp_read(rt2x00dev, 39, &bbp);
|
2007-10-13 14:26:12 +00:00
|
|
|
qual->false_cca = bbp;
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_reset_tuner(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 13, 0x08);
|
|
|
|
rt2x00dev->link.vgc_level = 0x08;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_link_tuner(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
u8 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The link tuner should not run longer then 60 seconds,
|
|
|
|
* and should run once every 2 seconds.
|
|
|
|
*/
|
|
|
|
if (rt2x00dev->link.count > 60 || !(rt2x00dev->link.count & 1))
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Base r13 link tuning on the false cca count.
|
|
|
|
*/
|
|
|
|
rt2400pci_bbp_read(rt2x00dev, 13, ®);
|
|
|
|
|
2007-10-13 14:26:12 +00:00
|
|
|
if (rt2x00dev->link.qual.false_cca > 512 && reg < 0x20) {
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2400pci_bbp_write(rt2x00dev, 13, ++reg);
|
|
|
|
rt2x00dev->link.vgc_level = reg;
|
2007-10-13 14:26:12 +00:00
|
|
|
} else if (rt2x00dev->link.qual.false_cca < 100 && reg > 0x08) {
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2400pci_bbp_write(rt2x00dev, 13, --reg);
|
|
|
|
rt2x00dev->link.vgc_level = reg;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialization functions.
|
|
|
|
*/
|
2008-01-06 22:41:45 +00:00
|
|
|
static void rt2400pci_init_rxentry(struct rt2x00_dev *rt2x00dev,
|
2008-02-05 21:42:23 +00:00
|
|
|
struct queue_entry *entry)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv = entry->priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 word;
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 2, &word);
|
2008-02-17 16:33:24 +00:00
|
|
|
rt2x00_set_field32(&word, RXD_W2_BUFFER_LENGTH,
|
|
|
|
entry->queue->data_size);
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_write(entry_priv->desc, 2, word);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 1, &word);
|
|
|
|
rt2x00_set_field32(&word, RXD_W1_BUFFER_ADDRESS, entry_priv->data_dma);
|
|
|
|
rt2x00_desc_write(entry_priv->desc, 1, word);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 0, &word);
|
2008-01-06 22:41:45 +00:00
|
|
|
rt2x00_set_field32(&word, RXD_W0_OWNER_NIC, 1);
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_write(entry_priv->desc, 0, word);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
2008-01-06 22:41:45 +00:00
|
|
|
static void rt2400pci_init_txentry(struct rt2x00_dev *rt2x00dev,
|
2008-02-05 21:42:23 +00:00
|
|
|
struct queue_entry *entry)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv = entry->priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 word;
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 0, &word);
|
2008-01-06 22:41:45 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W0_VALID, 0);
|
|
|
|
rt2x00_set_field32(&word, TXD_W0_OWNER_NIC, 0);
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_write(entry_priv->desc, 0, word);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
2008-02-05 21:42:23 +00:00
|
|
|
static int rt2400pci_init_queues(struct rt2x00_dev *rt2x00dev)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize registers.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR2, ®);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR2_TXD_SIZE, rt2x00dev->tx[0].desc_size);
|
|
|
|
rt2x00_set_field32(®, TXCSR2_NUM_TXD, rt2x00dev->tx[1].limit);
|
|
|
|
rt2x00_set_field32(®, TXCSR2_NUM_ATIM, rt2x00dev->bcn[1].limit);
|
|
|
|
rt2x00_set_field32(®, TXCSR2_NUM_PRIO, rt2x00dev->tx[0].limit);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR2, reg);
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = rt2x00dev->tx[1].entries[0].priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR3, ®);
|
2008-02-17 16:33:24 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR3_TX_RING_REGISTER,
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv->desc_dma);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR3, reg);
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = rt2x00dev->tx[0].entries[0].priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR5, ®);
|
2008-02-17 16:33:24 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR5_PRIO_RING_REGISTER,
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv->desc_dma);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR5, reg);
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = rt2x00dev->bcn[1].entries[0].priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR4, ®);
|
2008-02-17 16:33:24 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR4_ATIM_RING_REGISTER,
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv->desc_dma);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR4, reg);
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = rt2x00dev->bcn[0].entries[0].priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR6, ®);
|
2008-02-17 16:33:24 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR6_BEACON_RING_REGISTER,
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv->desc_dma);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR6, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RXCSR1, ®);
|
|
|
|
rt2x00_set_field32(®, RXCSR1_RXD_SIZE, rt2x00dev->rx->desc_size);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(®, RXCSR1_NUM_RXD, rt2x00dev->rx->limit);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, RXCSR1, reg);
|
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = rt2x00dev->rx->entries[0].priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, RXCSR2, ®);
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_set_field32(®, RXCSR2_RX_RING_REGISTER,
|
|
|
|
entry_priv->desc_dma);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, RXCSR2, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_init_registers(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PSCSR0, 0x00020002);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PSCSR1, 0x00000002);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PSCSR2, 0x00023f20);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PSCSR3, 0x00000002);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TIMECSR, ®);
|
|
|
|
rt2x00_set_field32(®, TIMECSR_US_COUNT, 33);
|
|
|
|
rt2x00_set_field32(®, TIMECSR_US_64_COUNT, 63);
|
|
|
|
rt2x00_set_field32(®, TIMECSR_BEACON_EXPECT, 0);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, TIMECSR, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR9, ®);
|
|
|
|
rt2x00_set_field32(®, CSR9_MAX_FRAME_UNIT,
|
|
|
|
(rt2x00dev->rx->data_size / 128));
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR9, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CNT3, 0x3f080000);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, ARCSR0, ®);
|
|
|
|
rt2x00_set_field32(®, ARCSR0_AR_BBP_DATA0, 133);
|
|
|
|
rt2x00_set_field32(®, ARCSR0_AR_BBP_ID0, 134);
|
|
|
|
rt2x00_set_field32(®, ARCSR0_AR_BBP_DATA1, 136);
|
|
|
|
rt2x00_set_field32(®, ARCSR0_AR_BBP_ID1, 135);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, ARCSR0, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RXCSR3, ®);
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID0, 3); /* Tx power.*/
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID0_VALID, 1);
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID1, 32); /* Signal */
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID1_VALID, 1);
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID2, 36); /* Rssi */
|
|
|
|
rt2x00_set_field32(®, RXCSR3_BBP_ID2_VALID, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, RXCSR3, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0x3f3b3100);
|
|
|
|
|
|
|
|
if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, MACCSR0, 0x00217223);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, MACCSR1, 0x00235518);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, MACCSR2, ®);
|
|
|
|
rt2x00_set_field32(®, MACCSR2_DELAY, 64);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, MACCSR2, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RALINKCSR, ®);
|
|
|
|
rt2x00_set_field32(®, RALINKCSR_AR_BBP_DATA0, 17);
|
|
|
|
rt2x00_set_field32(®, RALINKCSR_AR_BBP_ID0, 154);
|
|
|
|
rt2x00_set_field32(®, RALINKCSR_AR_BBP_DATA1, 0);
|
|
|
|
rt2x00_set_field32(®, RALINKCSR_AR_BBP_ID1, 154);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, RALINKCSR, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR1, ®);
|
|
|
|
rt2x00_set_field32(®, CSR1_SOFT_RESET, 1);
|
|
|
|
rt2x00_set_field32(®, CSR1_BBP_RESET, 0);
|
|
|
|
rt2x00_set_field32(®, CSR1_HOST_READY, 0);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR1, reg);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR1, ®);
|
|
|
|
rt2x00_set_field32(®, CSR1_SOFT_RESET, 0);
|
|
|
|
rt2x00_set_field32(®, CSR1_HOST_READY, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR1, reg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We must clear the FCS and FIFO error count.
|
|
|
|
* These registers are cleared on read,
|
|
|
|
* so we may pass a useless variable to store the value.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CNT0, ®);
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CNT4, ®);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-06-03 16:58:56 +00:00
|
|
|
static int rt2400pci_wait_bbp_ready(struct rt2x00_dev *rt2x00dev)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
u8 value;
|
|
|
|
|
|
|
|
for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
|
|
|
|
rt2400pci_bbp_read(rt2x00dev, 0, &value);
|
|
|
|
if ((value != 0xff) && (value != 0x00))
|
2008-06-03 16:58:56 +00:00
|
|
|
return 0;
|
2007-09-26 00:57:13 +00:00
|
|
|
udelay(REGISTER_BUSY_DELAY);
|
|
|
|
}
|
|
|
|
|
|
|
|
ERROR(rt2x00dev, "BBP register access failed, aborting.\n");
|
|
|
|
return -EACCES;
|
2008-06-03 16:58:56 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_init_bbp(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
u16 eeprom;
|
|
|
|
u8 reg_id;
|
|
|
|
u8 value;
|
|
|
|
|
|
|
|
if (unlikely(rt2400pci_wait_bbp_ready(rt2x00dev)))
|
|
|
|
return -EACCES;
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 1, 0x00);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 3, 0x27);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 4, 0x08);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 10, 0x0f);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 15, 0x72);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 16, 0x74);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 17, 0x20);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 18, 0x72);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 19, 0x0b);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 20, 0x00);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 28, 0x11);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 29, 0x04);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 30, 0x21);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, 31, 0x00);
|
|
|
|
|
|
|
|
for (i = 0; i < EEPROM_BBP_SIZE; i++) {
|
|
|
|
rt2x00_eeprom_read(rt2x00dev, EEPROM_BBP_START + i, &eeprom);
|
|
|
|
|
|
|
|
if (eeprom != 0xffff && eeprom != 0x0000) {
|
|
|
|
reg_id = rt2x00_get_field16(eeprom, EEPROM_BBP_REG_ID);
|
|
|
|
value = rt2x00_get_field16(eeprom, EEPROM_BBP_VALUE);
|
|
|
|
rt2400pci_bbp_write(rt2x00dev, reg_id, value);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device state switch handlers.
|
|
|
|
*/
|
|
|
|
static void rt2400pci_toggle_rx(struct rt2x00_dev *rt2x00dev,
|
|
|
|
enum dev_state state)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, RXCSR0, ®);
|
|
|
|
rt2x00_set_field32(®, RXCSR0_DISABLE_RX,
|
2008-06-03 16:58:56 +00:00
|
|
|
(state == STATE_RADIO_RX_OFF) ||
|
|
|
|
(state == STATE_RADIO_RX_OFF_LINK));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, RXCSR0, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_toggle_irq(struct rt2x00_dev *rt2x00dev,
|
|
|
|
enum dev_state state)
|
|
|
|
{
|
|
|
|
int mask = (state == STATE_RADIO_IRQ_OFF);
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* When interrupts are being enabled, the interrupt registers
|
|
|
|
* should clear the register to assure a clean state.
|
|
|
|
*/
|
|
|
|
if (state == STATE_RADIO_IRQ_ON) {
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR7, ®);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR7, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Only toggle the interrupts bits we are going to use.
|
|
|
|
* Non-checked interrupt bits are disabled by default.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR8, ®);
|
|
|
|
rt2x00_set_field32(®, CSR8_TBCN_EXPIRE, mask);
|
|
|
|
rt2x00_set_field32(®, CSR8_TXDONE_TXRING, mask);
|
|
|
|
rt2x00_set_field32(®, CSR8_TXDONE_ATIMRING, mask);
|
|
|
|
rt2x00_set_field32(®, CSR8_TXDONE_PRIORING, mask);
|
|
|
|
rt2x00_set_field32(®, CSR8_RXDONE, mask);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR8, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_enable_radio(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Initialize all registers.
|
|
|
|
*/
|
2008-06-03 16:58:56 +00:00
|
|
|
if (unlikely(rt2400pci_init_queues(rt2x00dev) ||
|
|
|
|
rt2400pci_init_registers(rt2x00dev) ||
|
|
|
|
rt2400pci_init_bbp(rt2x00dev)))
|
2007-09-26 00:57:13 +00:00
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void rt2400pci_disable_radio(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PWRCSR0, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable synchronisation.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR14, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Cancel RX and TX.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR0, ®);
|
|
|
|
rt2x00_set_field32(®, TXCSR0_ABORT, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_set_state(struct rt2x00_dev *rt2x00dev,
|
|
|
|
enum dev_state state)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
unsigned int i;
|
|
|
|
char put_to_sleep;
|
|
|
|
char bbp_state;
|
|
|
|
char rf_state;
|
|
|
|
|
|
|
|
put_to_sleep = (state != STATE_AWAKE);
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, PWRCSR1, ®);
|
|
|
|
rt2x00_set_field32(®, PWRCSR1_SET_STATE, 1);
|
|
|
|
rt2x00_set_field32(®, PWRCSR1_BBP_DESIRE_STATE, state);
|
|
|
|
rt2x00_set_field32(®, PWRCSR1_RF_DESIRE_STATE, state);
|
|
|
|
rt2x00_set_field32(®, PWRCSR1_PUT_TO_SLEEP, put_to_sleep);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, PWRCSR1, reg);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device is not guaranteed to be in the requested state yet.
|
|
|
|
* We must wait until the register indicates that the
|
|
|
|
* device has entered the correct state.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < REGISTER_BUSY_COUNT; i++) {
|
|
|
|
rt2x00pci_register_read(rt2x00dev, PWRCSR1, ®);
|
|
|
|
bbp_state = rt2x00_get_field32(reg, PWRCSR1_BBP_CURR_STATE);
|
|
|
|
rf_state = rt2x00_get_field32(reg, PWRCSR1_RF_CURR_STATE);
|
|
|
|
if (bbp_state == state && rf_state == state)
|
|
|
|
return 0;
|
|
|
|
msleep(10);
|
|
|
|
}
|
|
|
|
|
|
|
|
return -EBUSY;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_set_device_state(struct rt2x00_dev *rt2x00dev,
|
|
|
|
enum dev_state state)
|
|
|
|
{
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case STATE_RADIO_ON:
|
|
|
|
retval = rt2400pci_enable_radio(rt2x00dev);
|
|
|
|
break;
|
|
|
|
case STATE_RADIO_OFF:
|
|
|
|
rt2400pci_disable_radio(rt2x00dev);
|
|
|
|
break;
|
|
|
|
case STATE_RADIO_RX_ON:
|
2008-02-25 22:15:05 +00:00
|
|
|
case STATE_RADIO_RX_ON_LINK:
|
2007-09-26 00:57:13 +00:00
|
|
|
case STATE_RADIO_RX_OFF:
|
2008-02-25 22:15:05 +00:00
|
|
|
case STATE_RADIO_RX_OFF_LINK:
|
2008-06-03 16:58:56 +00:00
|
|
|
rt2400pci_toggle_rx(rt2x00dev, state);
|
|
|
|
break;
|
|
|
|
case STATE_RADIO_IRQ_ON:
|
|
|
|
case STATE_RADIO_IRQ_OFF:
|
|
|
|
rt2400pci_toggle_irq(rt2x00dev, state);
|
2007-09-26 00:57:13 +00:00
|
|
|
break;
|
|
|
|
case STATE_DEEP_SLEEP:
|
|
|
|
case STATE_SLEEP:
|
|
|
|
case STATE_STANDBY:
|
|
|
|
case STATE_AWAKE:
|
|
|
|
retval = rt2400pci_set_state(rt2x00dev, state);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
retval = -ENOTSUPP;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-06-03 16:58:56 +00:00
|
|
|
if (unlikely(retval))
|
|
|
|
ERROR(rt2x00dev, "Device failed to enter state %d (%d).\n",
|
|
|
|
state, retval);
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TX descriptor initialization
|
|
|
|
*/
|
|
|
|
static void rt2400pci_write_tx_desc(struct rt2x00_dev *rt2x00dev,
|
2008-01-06 22:41:10 +00:00
|
|
|
struct sk_buff *skb,
|
2008-05-10 11:42:31 +00:00
|
|
|
struct txentry_desc *txdesc)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-02-05 21:42:23 +00:00
|
|
|
struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv = skbdesc->entry->priv_data;
|
2008-01-06 22:41:10 +00:00
|
|
|
__le32 *txd = skbdesc->desc;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 word;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start writing the descriptor words.
|
|
|
|
*/
|
2008-05-10 11:44:14 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 1, &word);
|
|
|
|
rt2x00_set_field32(&word, TXD_W1_BUFFER_ADDRESS, entry_priv->data_dma);
|
|
|
|
rt2x00_desc_write(entry_priv->desc, 1, word);
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_desc_read(txd, 2, &word);
|
2008-06-06 20:54:08 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W2_BUFFER_LENGTH, skb->len);
|
|
|
|
rt2x00_set_field32(&word, TXD_W2_DATABYTE_COUNT, skb->len);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_desc_write(txd, 2, word);
|
|
|
|
|
|
|
|
rt2x00_desc_read(txd, 3, &word);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SIGNAL, txdesc->signal);
|
2007-11-27 20:47:56 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SIGNAL_REGNUM, 5);
|
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SIGNAL_BUSY, 1);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SERVICE, txdesc->service);
|
2007-11-27 20:47:56 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SERVICE_REGNUM, 6);
|
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_SERVICE_BUSY, 1);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_desc_write(txd, 3, word);
|
|
|
|
|
|
|
|
rt2x00_desc_read(txd, 4, &word);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W4_PLCP_LENGTH_LOW, txdesc->length_low);
|
2007-11-27 20:47:56 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_LENGTH_LOW_REGNUM, 8);
|
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_LENGTH_LOW_BUSY, 1);
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W4_PLCP_LENGTH_HIGH, txdesc->length_high);
|
2007-11-27 20:47:56 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_LENGTH_HIGH_REGNUM, 7);
|
|
|
|
rt2x00_set_field32(&word, TXD_W3_PLCP_LENGTH_HIGH_BUSY, 1);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_desc_write(txd, 4, word);
|
|
|
|
|
|
|
|
rt2x00_desc_read(txd, 0, &word);
|
|
|
|
rt2x00_set_field32(&word, TXD_W0_OWNER_NIC, 1);
|
|
|
|
rt2x00_set_field32(&word, TXD_W0_VALID, 1);
|
|
|
|
rt2x00_set_field32(&word, TXD_W0_MORE_FRAG,
|
2008-02-05 21:42:23 +00:00
|
|
|
test_bit(ENTRY_TXD_MORE_FRAG, &txdesc->flags));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W0_ACK,
|
2008-02-05 21:42:23 +00:00
|
|
|
test_bit(ENTRY_TXD_ACK, &txdesc->flags));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W0_TIMESTAMP,
|
2008-02-05 21:42:23 +00:00
|
|
|
test_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc->flags));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W0_RTS,
|
2008-02-05 21:42:23 +00:00
|
|
|
test_bit(ENTRY_TXD_RTS_FRAME, &txdesc->flags));
|
|
|
|
rt2x00_set_field32(&word, TXD_W0_IFS, txdesc->ifs);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(&word, TXD_W0_RETRY_MODE,
|
2008-05-10 11:45:58 +00:00
|
|
|
test_bit(ENTRY_TXD_RETRY_MODE, &txdesc->flags));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_desc_write(txd, 0, word);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* TX data initialization
|
|
|
|
*/
|
|
|
|
static void rt2400pci_kick_tx_queue(struct rt2x00_dev *rt2x00dev,
|
2008-04-21 17:00:47 +00:00
|
|
|
const enum data_queue_qid queue)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
|
2008-04-21 17:00:47 +00:00
|
|
|
if (queue == QID_BEACON) {
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR14, ®);
|
|
|
|
if (!rt2x00_get_field32(reg, CSR14_BEACON_GEN)) {
|
2008-03-09 21:42:59 +00:00
|
|
|
rt2x00_set_field32(®, CSR14_TSF_COUNT, 1);
|
|
|
|
rt2x00_set_field32(®, CSR14_TBCN, 1);
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_set_field32(®, CSR14_BEACON_GEN, 1);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR14, reg);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, TXCSR0, ®);
|
2008-04-21 17:00:47 +00:00
|
|
|
rt2x00_set_field32(®, TXCSR0_KICK_PRIO, (queue == QID_AC_BE));
|
|
|
|
rt2x00_set_field32(®, TXCSR0_KICK_TX, (queue == QID_AC_BK));
|
|
|
|
rt2x00_set_field32(®, TXCSR0_KICK_ATIM, (queue == QID_ATIM));
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00pci_register_write(rt2x00dev, TXCSR0, reg);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RX control handlers
|
|
|
|
*/
|
2008-02-05 21:42:23 +00:00
|
|
|
static void rt2400pci_fill_rxdone(struct queue_entry *entry,
|
|
|
|
struct rxdone_entry_desc *rxdesc)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv = entry->priv_data;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 word0;
|
|
|
|
u32 word2;
|
2008-03-09 21:49:04 +00:00
|
|
|
u32 word3;
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2008-05-10 11:46:03 +00:00
|
|
|
rt2x00_desc_read(entry_priv->desc, 0, &word0);
|
|
|
|
rt2x00_desc_read(entry_priv->desc, 2, &word2);
|
|
|
|
rt2x00_desc_read(entry_priv->desc, 3, &word3);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 05:29:23 +00:00
|
|
|
if (rt2x00_get_field32(word0, RXD_W0_CRC_ERROR))
|
2008-02-05 21:42:23 +00:00
|
|
|
rxdesc->flags |= RX_FLAG_FAILED_FCS_CRC;
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 05:29:23 +00:00
|
|
|
if (rt2x00_get_field32(word0, RXD_W0_PHYSICAL_ERROR))
|
2008-02-05 21:42:23 +00:00
|
|
|
rxdesc->flags |= RX_FLAG_FAILED_PLCP_CRC;
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Obtain the status about this packet.
|
2008-03-09 23:30:44 +00:00
|
|
|
* The signal is the PLCP value, and needs to be stripped
|
|
|
|
* of the preamble bit (0x08).
|
2007-09-26 00:57:13 +00:00
|
|
|
*/
|
2008-03-09 23:30:44 +00:00
|
|
|
rxdesc->signal = rt2x00_get_field32(word2, RXD_W2_SIGNAL) & ~0x08;
|
2008-03-09 21:49:04 +00:00
|
|
|
rxdesc->rssi = rt2x00_get_field32(word2, RXD_W3_RSSI) -
|
2008-02-05 21:42:23 +00:00
|
|
|
entry->queue->rt2x00dev->rssi_offset;
|
|
|
|
rxdesc->size = rt2x00_get_field32(word0, RXD_W0_DATABYTE_COUNT);
|
2008-03-15 20:38:07 +00:00
|
|
|
|
2008-05-10 11:46:08 +00:00
|
|
|
rxdesc->dev_flags |= RXDONE_SIGNAL_PLCP;
|
2008-03-15 20:38:07 +00:00
|
|
|
if (rt2x00_get_field32(word0, RXD_W0_MY_BSS))
|
|
|
|
rxdesc->dev_flags |= RXDONE_MY_BSS;
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Interrupt functions.
|
|
|
|
*/
|
2008-02-05 21:42:23 +00:00
|
|
|
static void rt2400pci_txdone(struct rt2x00_dev *rt2x00dev,
|
2008-04-21 17:00:47 +00:00
|
|
|
const enum data_queue_qid queue_idx)
|
2007-09-26 00:57:13 +00:00
|
|
|
{
|
2008-02-05 21:42:23 +00:00
|
|
|
struct data_queue *queue = rt2x00queue_get_queue(rt2x00dev, queue_idx);
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv;
|
2008-02-05 21:42:23 +00:00
|
|
|
struct queue_entry *entry;
|
|
|
|
struct txdone_entry_desc txdesc;
|
2007-09-26 00:57:13 +00:00
|
|
|
u32 word;
|
|
|
|
|
2008-02-05 21:42:23 +00:00
|
|
|
while (!rt2x00queue_empty(queue)) {
|
|
|
|
entry = rt2x00queue_get_entry(queue, Q_INDEX_DONE);
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = entry->priv_data;
|
|
|
|
rt2x00_desc_read(entry_priv->desc, 0, &word);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
if (rt2x00_get_field32(word, TXD_W0_OWNER_NIC) ||
|
|
|
|
!rt2x00_get_field32(word, TXD_W0_VALID))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Obtain the status about this packet.
|
|
|
|
*/
|
2008-05-10 11:42:06 +00:00
|
|
|
txdesc.flags = 0;
|
|
|
|
switch (rt2x00_get_field32(word, TXD_W0_RESULT)) {
|
|
|
|
case 0: /* Success */
|
|
|
|
case 1: /* Success with retry */
|
|
|
|
__set_bit(TXDONE_SUCCESS, &txdesc.flags);
|
|
|
|
break;
|
|
|
|
case 2: /* Failure, excessive retries */
|
|
|
|
__set_bit(TXDONE_EXCESSIVE_RETRY, &txdesc.flags);
|
|
|
|
/* Don't break, this is a failed frame! */
|
|
|
|
default: /* Failure */
|
|
|
|
__set_bit(TXDONE_FAILURE, &txdesc.flags);
|
|
|
|
}
|
2008-02-05 21:42:23 +00:00
|
|
|
txdesc.retry = rt2x00_get_field32(word, TXD_W0_RETRY_COUNT);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2x00pci_txdone(rt2x00dev, entry, &txdesc);
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static irqreturn_t rt2400pci_interrupt(int irq, void *dev_instance)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = dev_instance;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get the interrupt sources & saved to local variable.
|
|
|
|
* Write register value back to clear pending interrupts.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR7, ®);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR7, reg);
|
|
|
|
|
|
|
|
if (!reg)
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
|
|
|
if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle interrupts, walk through all bits
|
|
|
|
* and run the tasks, the bits are checked in order of
|
|
|
|
* priority.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 1 - Beacon timer expired interrupt.
|
|
|
|
*/
|
|
|
|
if (rt2x00_get_field32(reg, CSR7_TBCN_EXPIRE))
|
|
|
|
rt2x00lib_beacondone(rt2x00dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 2 - Rx ring done interrupt.
|
|
|
|
*/
|
|
|
|
if (rt2x00_get_field32(reg, CSR7_RXDONE))
|
|
|
|
rt2x00pci_rxdone(rt2x00dev);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 3 - Atim ring transmit done interrupt.
|
|
|
|
*/
|
|
|
|
if (rt2x00_get_field32(reg, CSR7_TXDONE_ATIMRING))
|
2008-04-21 17:00:47 +00:00
|
|
|
rt2400pci_txdone(rt2x00dev, QID_ATIM);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 4 - Priority ring transmit done interrupt.
|
|
|
|
*/
|
|
|
|
if (rt2x00_get_field32(reg, CSR7_TXDONE_PRIORING))
|
2008-04-21 17:00:47 +00:00
|
|
|
rt2400pci_txdone(rt2x00dev, QID_AC_BE);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 5 - Tx ring transmit done interrupt.
|
|
|
|
*/
|
|
|
|
if (rt2x00_get_field32(reg, CSR7_TXDONE_TXRING))
|
2008-04-21 17:00:47 +00:00
|
|
|
rt2400pci_txdone(rt2x00dev, QID_AC_BK);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Device probe functions.
|
|
|
|
*/
|
|
|
|
static int rt2400pci_validate_eeprom(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
struct eeprom_93cx6 eeprom;
|
|
|
|
u32 reg;
|
|
|
|
u16 word;
|
|
|
|
u8 *mac;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR21, ®);
|
|
|
|
|
|
|
|
eeprom.data = rt2x00dev;
|
|
|
|
eeprom.register_read = rt2400pci_eepromregister_read;
|
|
|
|
eeprom.register_write = rt2400pci_eepromregister_write;
|
|
|
|
eeprom.width = rt2x00_get_field32(reg, CSR21_TYPE_93C46) ?
|
|
|
|
PCI_EEPROM_WIDTH_93C46 : PCI_EEPROM_WIDTH_93C66;
|
|
|
|
eeprom.reg_data_in = 0;
|
|
|
|
eeprom.reg_data_out = 0;
|
|
|
|
eeprom.reg_data_clock = 0;
|
|
|
|
eeprom.reg_chip_select = 0;
|
|
|
|
|
|
|
|
eeprom_93cx6_multiread(&eeprom, EEPROM_BASE, rt2x00dev->eeprom,
|
|
|
|
EEPROM_SIZE / sizeof(u16));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Start validation of the data that has been read.
|
|
|
|
*/
|
|
|
|
mac = rt2x00_eeprom_addr(rt2x00dev, EEPROM_MAC_ADDR_0);
|
|
|
|
if (!is_valid_ether_addr(mac)) {
|
2007-10-04 00:59:30 +00:00
|
|
|
DECLARE_MAC_BUF(macbuf);
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
random_ether_addr(mac);
|
2007-10-04 00:59:30 +00:00
|
|
|
EEPROM(rt2x00dev, "MAC: %s\n", print_mac(macbuf, mac));
|
2007-09-26 00:57:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &word);
|
|
|
|
if (word == 0xffff) {
|
|
|
|
ERROR(rt2x00dev, "Invalid EEPROM data detected.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_init_eeprom(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
u32 reg;
|
|
|
|
u16 value;
|
|
|
|
u16 eeprom;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Read EEPROM word for configuration.
|
|
|
|
*/
|
|
|
|
rt2x00_eeprom_read(rt2x00dev, EEPROM_ANTENNA, &eeprom);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Identify RF chipset.
|
|
|
|
*/
|
|
|
|
value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RF_TYPE);
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR0, ®);
|
|
|
|
rt2x00_set_chip(rt2x00dev, RT2460, value, reg);
|
|
|
|
|
|
|
|
if (!rt2x00_rf(&rt2x00dev->chip, RF2420) &&
|
|
|
|
!rt2x00_rf(&rt2x00dev->chip, RF2421)) {
|
|
|
|
ERROR(rt2x00dev, "Invalid RF chipset detected.\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Identify default antenna configuration.
|
|
|
|
*/
|
2007-10-13 14:26:23 +00:00
|
|
|
rt2x00dev->default_ant.tx =
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_get_field16(eeprom, EEPROM_ANTENNA_TX_DEFAULT);
|
2007-10-13 14:26:23 +00:00
|
|
|
rt2x00dev->default_ant.rx =
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RX_DEFAULT);
|
|
|
|
|
2007-10-13 14:26:23 +00:00
|
|
|
/*
|
|
|
|
* When the eeprom indicates SW_DIVERSITY use HW_DIVERSITY instead.
|
|
|
|
* I am not 100% sure about this, but the legacy drivers do not
|
|
|
|
* indicate antenna swapping in software is required when
|
|
|
|
* diversity is enabled.
|
|
|
|
*/
|
|
|
|
if (rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
|
|
|
|
rt2x00dev->default_ant.tx = ANTENNA_HW_DIVERSITY;
|
|
|
|
if (rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
|
|
|
|
rt2x00dev->default_ant.rx = ANTENNA_HW_DIVERSITY;
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
/*
|
|
|
|
* Store led mode, for correct led behaviour.
|
|
|
|
*/
|
2008-02-03 14:53:40 +00:00
|
|
|
#ifdef CONFIG_RT2400PCI_LEDS
|
|
|
|
value = rt2x00_get_field16(eeprom, EEPROM_ANTENNA_LED_MODE);
|
|
|
|
|
2008-06-03 18:30:01 +00:00
|
|
|
rt2400pci_init_led(rt2x00dev, &rt2x00dev->led_radio, LED_TYPE_RADIO);
|
|
|
|
if (value == LED_MODE_TXRX_ACTIVITY)
|
|
|
|
rt2400pci_init_led(rt2x00dev, &rt2x00dev->led_qual,
|
|
|
|
LED_TYPE_ACTIVITY);
|
2008-02-03 14:53:40 +00:00
|
|
|
#endif /* CONFIG_RT2400PCI_LEDS */
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Detect if this device has an hardware controlled radio.
|
|
|
|
*/
|
2007-10-06 12:14:06 +00:00
|
|
|
#ifdef CONFIG_RT2400PCI_RFKILL
|
2007-09-26 00:57:13 +00:00
|
|
|
if (rt2x00_get_field16(eeprom, EEPROM_ANTENNA_HARDWARE_RADIO))
|
2007-09-25 18:55:39 +00:00
|
|
|
__set_bit(CONFIG_SUPPORT_HW_BUTTON, &rt2x00dev->flags);
|
2007-10-06 12:14:06 +00:00
|
|
|
#endif /* CONFIG_RT2400PCI_RFKILL */
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if the BBP tuning should be enabled.
|
|
|
|
*/
|
|
|
|
if (!rt2x00_get_field16(eeprom, EEPROM_ANTENNA_RX_AGCVGC_TUNING))
|
|
|
|
__set_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RF value list for RF2420 & RF2421
|
|
|
|
* Supports: 2.4 GHz
|
|
|
|
*/
|
|
|
|
static const struct rf_channel rf_vals_bg[] = {
|
|
|
|
{ 1, 0x00022058, 0x000c1fda, 0x00000101, 0 },
|
|
|
|
{ 2, 0x00022058, 0x000c1fee, 0x00000101, 0 },
|
|
|
|
{ 3, 0x00022058, 0x000c2002, 0x00000101, 0 },
|
|
|
|
{ 4, 0x00022058, 0x000c2016, 0x00000101, 0 },
|
|
|
|
{ 5, 0x00022058, 0x000c202a, 0x00000101, 0 },
|
|
|
|
{ 6, 0x00022058, 0x000c203e, 0x00000101, 0 },
|
|
|
|
{ 7, 0x00022058, 0x000c2052, 0x00000101, 0 },
|
|
|
|
{ 8, 0x00022058, 0x000c2066, 0x00000101, 0 },
|
|
|
|
{ 9, 0x00022058, 0x000c207a, 0x00000101, 0 },
|
|
|
|
{ 10, 0x00022058, 0x000c208e, 0x00000101, 0 },
|
|
|
|
{ 11, 0x00022058, 0x000c20a2, 0x00000101, 0 },
|
|
|
|
{ 12, 0x00022058, 0x000c20b6, 0x00000101, 0 },
|
|
|
|
{ 13, 0x00022058, 0x000c20ca, 0x00000101, 0 },
|
|
|
|
{ 14, 0x00022058, 0x000c20fa, 0x00000101, 0 },
|
|
|
|
};
|
|
|
|
|
|
|
|
static void rt2400pci_probe_hw_mode(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
struct hw_mode_spec *spec = &rt2x00dev->spec;
|
|
|
|
u8 *txpower;
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize all hw fields.
|
|
|
|
*/
|
2008-05-08 17:15:40 +00:00
|
|
|
rt2x00dev->hw->flags = IEEE80211_HW_HOST_BROADCAST_PS_BUFFERING |
|
|
|
|
IEEE80211_HW_SIGNAL_DBM;
|
2007-09-26 00:57:13 +00:00
|
|
|
rt2x00dev->hw->extra_tx_headroom = 0;
|
|
|
|
|
|
|
|
SET_IEEE80211_DEV(rt2x00dev->hw, &rt2x00dev_pci(rt2x00dev)->dev);
|
|
|
|
SET_IEEE80211_PERM_ADDR(rt2x00dev->hw,
|
|
|
|
rt2x00_eeprom_addr(rt2x00dev,
|
|
|
|
EEPROM_MAC_ADDR_0));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert tx_power array in eeprom.
|
|
|
|
*/
|
|
|
|
txpower = rt2x00_eeprom_addr(rt2x00dev, EEPROM_TXPOWER_START);
|
|
|
|
for (i = 0; i < 14; i++)
|
|
|
|
txpower[i] = TXPOWER_FROM_DEV(txpower[i]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize hw_mode information.
|
|
|
|
*/
|
2008-02-17 16:35:05 +00:00
|
|
|
spec->supported_bands = SUPPORT_BAND_2GHZ;
|
|
|
|
spec->supported_rates = SUPPORT_RATE_CCK;
|
2007-09-26 00:57:13 +00:00
|
|
|
spec->tx_power_a = NULL;
|
|
|
|
spec->tx_power_bg = txpower;
|
|
|
|
spec->tx_power_default = DEFAULT_TXPOWER;
|
|
|
|
|
|
|
|
spec->num_channels = ARRAY_SIZE(rf_vals_bg);
|
|
|
|
spec->channels = rf_vals_bg;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int rt2400pci_probe_hw(struct rt2x00_dev *rt2x00dev)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate eeprom data.
|
|
|
|
*/
|
|
|
|
retval = rt2400pci_validate_eeprom(rt2x00dev);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
retval = rt2400pci_init_eeprom(rt2x00dev);
|
|
|
|
if (retval)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize hw specifications.
|
|
|
|
*/
|
|
|
|
rt2400pci_probe_hw_mode(rt2x00dev);
|
|
|
|
|
|
|
|
/*
|
2008-02-05 21:42:23 +00:00
|
|
|
* This device requires the atim queue
|
2007-09-26 00:57:13 +00:00
|
|
|
*/
|
2008-02-05 21:42:23 +00:00
|
|
|
__set_bit(DRIVER_REQUIRE_ATIM_QUEUE, &rt2x00dev->flags);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the rssi offset.
|
|
|
|
*/
|
|
|
|
rt2x00dev->rssi_offset = DEFAULT_RSSI_OFFSET;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* IEEE80211 stack callback functions.
|
|
|
|
*/
|
|
|
|
static int rt2400pci_set_retry_limit(struct ieee80211_hw *hw,
|
|
|
|
u32 short_retry, u32 long_retry)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = hw->priv;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR11, ®);
|
|
|
|
rt2x00_set_field32(®, CSR11_LONG_RETRY, long_retry);
|
|
|
|
rt2x00_set_field32(®, CSR11_SHORT_RETRY, short_retry);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR11, reg);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 16:51:21 +00:00
|
|
|
static int rt2400pci_conf_tx(struct ieee80211_hw *hw, u16 queue,
|
2007-09-26 00:57:13 +00:00
|
|
|
const struct ieee80211_tx_queue_params *params)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = hw->priv;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't support variating cw_min and cw_max variables
|
|
|
|
* per queue. So by default we only configure the TX queue,
|
|
|
|
* and ignore all other configurations.
|
|
|
|
*/
|
2008-04-30 16:51:21 +00:00
|
|
|
if (queue != 0)
|
2007-09-26 00:57:13 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (rt2x00mac_conf_tx(hw, queue, params))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write configuration to register.
|
|
|
|
*/
|
2008-02-05 21:42:23 +00:00
|
|
|
rt2400pci_config_cw(rt2x00dev,
|
|
|
|
rt2x00dev->tx->cw_min, rt2x00dev->tx->cw_max);
|
2007-09-26 00:57:13 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static u64 rt2400pci_get_tsf(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = hw->priv;
|
|
|
|
u64 tsf;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR17, ®);
|
|
|
|
tsf = (u64) rt2x00_get_field32(reg, CSR17_HIGH_TSFTIMER) << 32;
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR16, ®);
|
|
|
|
tsf |= rt2x00_get_field32(reg, CSR16_LOW_TSFTIMER);
|
|
|
|
|
|
|
|
return tsf;
|
|
|
|
}
|
|
|
|
|
2008-05-15 10:55:29 +00:00
|
|
|
static int rt2400pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
|
2008-02-03 14:54:57 +00:00
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = hw->priv;
|
2008-05-15 10:55:29 +00:00
|
|
|
struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(skb);
|
|
|
|
struct rt2x00_intf *intf = vif_to_intf(tx_info->control.vif);
|
2008-05-10 11:46:03 +00:00
|
|
|
struct queue_entry_priv_pci *entry_priv;
|
2008-02-03 14:54:57 +00:00
|
|
|
struct skb_frame_desc *skbdesc;
|
2008-05-10 11:46:13 +00:00
|
|
|
struct txentry_desc txdesc;
|
2008-03-09 21:42:59 +00:00
|
|
|
u32 reg;
|
2008-02-03 14:54:57 +00:00
|
|
|
|
|
|
|
if (unlikely(!intf->beacon))
|
|
|
|
return -ENOBUFS;
|
2008-05-10 11:46:03 +00:00
|
|
|
entry_priv = intf->beacon->priv_data;
|
2008-02-03 14:54:57 +00:00
|
|
|
|
2008-05-10 11:46:13 +00:00
|
|
|
/*
|
|
|
|
* Copy all TX descriptor information into txdesc,
|
|
|
|
* after that we are free to use the skb->cb array
|
|
|
|
* for our information.
|
|
|
|
*/
|
|
|
|
intf->beacon->skb = skb;
|
2008-05-15 10:55:29 +00:00
|
|
|
rt2x00queue_create_tx_descriptor(intf->beacon, &txdesc);
|
2008-05-10 11:46:13 +00:00
|
|
|
|
2008-02-03 14:54:57 +00:00
|
|
|
/*
|
|
|
|
* Fill in skb descriptor
|
|
|
|
*/
|
|
|
|
skbdesc = get_skb_frame_desc(skb);
|
|
|
|
memset(skbdesc, 0, sizeof(*skbdesc));
|
2008-05-10 11:46:03 +00:00
|
|
|
skbdesc->desc = entry_priv->desc;
|
2008-02-03 14:54:57 +00:00
|
|
|
skbdesc->desc_len = intf->beacon->queue->desc_size;
|
|
|
|
skbdesc->entry = intf->beacon;
|
|
|
|
|
2008-03-09 21:42:59 +00:00
|
|
|
/*
|
|
|
|
* Disable beaconing while we are reloading the beacon data,
|
|
|
|
* otherwise we might be sending out invalid data.
|
|
|
|
*/
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR14, ®);
|
|
|
|
rt2x00_set_field32(®, CSR14_TSF_COUNT, 0);
|
|
|
|
rt2x00_set_field32(®, CSR14_TBCN, 0);
|
|
|
|
rt2x00_set_field32(®, CSR14_BEACON_GEN, 0);
|
|
|
|
rt2x00pci_register_write(rt2x00dev, CSR14, reg);
|
|
|
|
|
2008-02-03 14:54:57 +00:00
|
|
|
/*
|
|
|
|
* Enable beacon generation.
|
|
|
|
* Write entire beacon with descriptor to register,
|
|
|
|
* and kick the beacon generator.
|
|
|
|
*/
|
2008-05-10 11:46:03 +00:00
|
|
|
memcpy(entry_priv->data, skb->data, skb->len);
|
2008-05-10 11:46:13 +00:00
|
|
|
rt2x00queue_write_tx_descriptor(intf->beacon, &txdesc);
|
2008-04-21 17:00:47 +00:00
|
|
|
rt2x00dev->ops->lib->kick_tx_queue(rt2x00dev, QID_BEACON);
|
2008-02-03 14:54:57 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
static int rt2400pci_tx_last_beacon(struct ieee80211_hw *hw)
|
|
|
|
{
|
|
|
|
struct rt2x00_dev *rt2x00dev = hw->priv;
|
|
|
|
u32 reg;
|
|
|
|
|
|
|
|
rt2x00pci_register_read(rt2x00dev, CSR15, ®);
|
|
|
|
return rt2x00_get_field32(reg, CSR15_BEACON_SENT);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct ieee80211_ops rt2400pci_mac80211_ops = {
|
|
|
|
.tx = rt2x00mac_tx,
|
[PATCH] mac80211: revamp interface and filter configuration
Drivers are currently supposed to keep track of monitor
interfaces if they allow so-called "hard" monitor, and
they are also supposed to keep track of multicast etc.
This patch changes that, replaces the set_multicast_list()
callback with a new configure_filter() callback that takes
filter flags (FIF_*) instead of interface flags (IFF_*).
For a driver, this means it should open the filter as much
as necessary to get all frames requested by the filter flags.
Accordingly, the filter flags are named "positively", e.g.
FIF_ALLMULTI.
Multicast filtering is a bit special in that drivers that
have no multicast address filters need to allow multicast
frames through when either the FIF_ALLMULTI flag is set or
when the mc_count value is positive.
At the same time, drivers are no longer notified about
monitor interfaces at all, this means they now need to
implement the start() and stop() callbacks and the new
change_filter_flags() callback. Also, the start()/stop()
ordering changed, start() is now called *before* any
add_interface() as it really should be, and stop() after
any remove_interface().
The patch also changes the behaviour of setting the bssid
to multicast for scanning when IEEE80211_HW_NO_PROBE_FILTERING
is set; the IEEE80211_HW_NO_PROBE_FILTERING flag is removed
and the filter flag FIF_BCN_PRBRESP_PROMISC introduced.
This is a lot more efficient for hardware like b43 that
supports it and other hardware can still set the BSSID
to all-ones.
Driver modifications by Johannes Berg (b43 & iwlwifi), Michael Wu
(rtl8187, adm8211, and p54), Larry Finger (b43legacy), and
Ivo van Doorn (rt2x00).
Signed-off-by: Johannes Berg <johannes@sipsolutions.net>
Signed-off-by: Michael Wu <flamingice@sourmilk.net>
Signed-off-by: Larry Finger <Larry.Finger@lwfinger.net>
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2007-09-17 05:29:23 +00:00
|
|
|
.start = rt2x00mac_start,
|
|
|
|
.stop = rt2x00mac_stop,
|
2007-09-26 00:57:13 +00:00
|
|
|
.add_interface = rt2x00mac_add_interface,
|
|
|
|
.remove_interface = rt2x00mac_remove_interface,
|
|
|
|
.config = rt2x00mac_config,
|
|
|
|
.config_interface = rt2x00mac_config_interface,
|
2008-03-25 13:13:18 +00:00
|
|
|
.configure_filter = rt2x00mac_configure_filter,
|
2007-09-26 00:57:13 +00:00
|
|
|
.get_stats = rt2x00mac_get_stats,
|
|
|
|
.set_retry_limit = rt2400pci_set_retry_limit,
|
2007-12-28 13:32:58 +00:00
|
|
|
.bss_info_changed = rt2x00mac_bss_info_changed,
|
2007-09-26 00:57:13 +00:00
|
|
|
.conf_tx = rt2400pci_conf_tx,
|
|
|
|
.get_tx_stats = rt2x00mac_get_tx_stats,
|
|
|
|
.get_tsf = rt2400pci_get_tsf,
|
2008-02-03 14:54:57 +00:00
|
|
|
.beacon_update = rt2400pci_beacon_update,
|
2007-09-26 00:57:13 +00:00
|
|
|
.tx_last_beacon = rt2400pci_tx_last_beacon,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct rt2x00lib_ops rt2400pci_rt2x00_ops = {
|
|
|
|
.irq_handler = rt2400pci_interrupt,
|
|
|
|
.probe_hw = rt2400pci_probe_hw,
|
|
|
|
.initialize = rt2x00pci_initialize,
|
|
|
|
.uninitialize = rt2x00pci_uninitialize,
|
2008-01-06 22:41:45 +00:00
|
|
|
.init_rxentry = rt2400pci_init_rxentry,
|
|
|
|
.init_txentry = rt2400pci_init_txentry,
|
2007-09-26 00:57:13 +00:00
|
|
|
.set_device_state = rt2400pci_set_device_state,
|
|
|
|
.rfkill_poll = rt2400pci_rfkill_poll,
|
|
|
|
.link_stats = rt2400pci_link_stats,
|
|
|
|
.reset_tuner = rt2400pci_reset_tuner,
|
|
|
|
.link_tuner = rt2400pci_link_tuner,
|
|
|
|
.write_tx_desc = rt2400pci_write_tx_desc,
|
|
|
|
.write_tx_data = rt2x00pci_write_tx_data,
|
|
|
|
.kick_tx_queue = rt2400pci_kick_tx_queue,
|
|
|
|
.fill_rxdone = rt2400pci_fill_rxdone,
|
2008-03-25 13:13:18 +00:00
|
|
|
.config_filter = rt2400pci_config_filter,
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
.config_intf = rt2400pci_config_intf,
|
2008-03-09 21:46:18 +00:00
|
|
|
.config_erp = rt2400pci_config_erp,
|
2007-09-26 00:57:13 +00:00
|
|
|
.config = rt2400pci_config,
|
|
|
|
};
|
|
|
|
|
2008-02-05 21:42:23 +00:00
|
|
|
static const struct data_queue_desc rt2400pci_queue_rx = {
|
|
|
|
.entry_num = RX_ENTRIES,
|
|
|
|
.data_size = DATA_FRAME_SIZE,
|
|
|
|
.desc_size = RXD_DESC_SIZE,
|
2008-05-10 11:46:03 +00:00
|
|
|
.priv_size = sizeof(struct queue_entry_priv_pci),
|
2008-02-05 21:42:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct data_queue_desc rt2400pci_queue_tx = {
|
|
|
|
.entry_num = TX_ENTRIES,
|
|
|
|
.data_size = DATA_FRAME_SIZE,
|
|
|
|
.desc_size = TXD_DESC_SIZE,
|
2008-05-10 11:46:03 +00:00
|
|
|
.priv_size = sizeof(struct queue_entry_priv_pci),
|
2008-02-05 21:42:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct data_queue_desc rt2400pci_queue_bcn = {
|
|
|
|
.entry_num = BEACON_ENTRIES,
|
|
|
|
.data_size = MGMT_FRAME_SIZE,
|
|
|
|
.desc_size = TXD_DESC_SIZE,
|
2008-05-10 11:46:03 +00:00
|
|
|
.priv_size = sizeof(struct queue_entry_priv_pci),
|
2008-02-05 21:42:23 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static const struct data_queue_desc rt2400pci_queue_atim = {
|
|
|
|
.entry_num = ATIM_ENTRIES,
|
|
|
|
.data_size = DATA_FRAME_SIZE,
|
|
|
|
.desc_size = TXD_DESC_SIZE,
|
2008-05-10 11:46:03 +00:00
|
|
|
.priv_size = sizeof(struct queue_entry_priv_pci),
|
2008-02-05 21:42:23 +00:00
|
|
|
};
|
|
|
|
|
2007-09-26 00:57:13 +00:00
|
|
|
static const struct rt2x00_ops rt2400pci_ops = {
|
2007-11-27 20:47:34 +00:00
|
|
|
.name = KBUILD_MODNAME,
|
rt2x00: Add per-interface structure
Rework the interface handling. Delete the interface structure
and replace it with a per-interface structure. This changes the
way rt2x00 handles the active interface drastically.
Copy ieee80211_bss_conf to the this rt2x00_intf structure during
the bss_info_changed() callback function. This will allow us to
reference it later, and removes the requirement for the device flag
SHORT_PREAMBLE flag which is interface specific.
Drivers receive the option to give the maximum number of virtual
interfaces the device can handle. Virtual interface support:
rt2400pci: 1 sta or 1 ap, * monitor interfaces
rt2500pci: 1 sta or 1 ap, * monitor interfaces
rt2500usb: 1 sta or 1 ap, * monitor interfaces
rt61pci: 1 sta or 4 ap, * monitor interfaces
rt73usb: 1 sta or 4 ap, * monitor interfaces
At the moment none of the drivers support AP and STA interfaces
simultaneously, this is a hardware limitation so future support
will be very unlikely.
Each interface structure receives its dedicated beacon entry,
with this we can easily work with beaconing while multiple master
mode interfaces are currently active.
The configuration handlers for the MAC, BSSID and type are
often called together since they all belong to the interface
configuration. Merge the 3 configuration calls and cleanup
the API between rt2x00lib and the drivers. While we are cleaning
up the interface configuration anyway, we might as well clean up
the configuration handler as well.
Signed-off-by: Ivo van Doorn <IvDoorn@gmail.com>
Signed-off-by: John W. Linville <linville@tuxdriver.com>
2008-02-03 14:49:59 +00:00
|
|
|
.max_sta_intf = 1,
|
|
|
|
.max_ap_intf = 1,
|
2007-09-26 00:57:13 +00:00
|
|
|
.eeprom_size = EEPROM_SIZE,
|
|
|
|
.rf_size = RF_SIZE,
|
2008-05-10 11:43:33 +00:00
|
|
|
.tx_queues = NUM_TX_QUEUES,
|
2008-02-05 21:42:23 +00:00
|
|
|
.rx = &rt2400pci_queue_rx,
|
|
|
|
.tx = &rt2400pci_queue_tx,
|
|
|
|
.bcn = &rt2400pci_queue_bcn,
|
|
|
|
.atim = &rt2400pci_queue_atim,
|
2007-09-26 00:57:13 +00:00
|
|
|
.lib = &rt2400pci_rt2x00_ops,
|
|
|
|
.hw = &rt2400pci_mac80211_ops,
|
|
|
|
#ifdef CONFIG_RT2X00_LIB_DEBUGFS
|
|
|
|
.debugfs = &rt2400pci_rt2x00debug,
|
|
|
|
#endif /* CONFIG_RT2X00_LIB_DEBUGFS */
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RT2400pci module information.
|
|
|
|
*/
|
|
|
|
static struct pci_device_id rt2400pci_device_table[] = {
|
|
|
|
{ PCI_DEVICE(0x1814, 0x0101), PCI_DEVICE_DATA(&rt2400pci_ops) },
|
|
|
|
{ 0, }
|
|
|
|
};
|
|
|
|
|
|
|
|
MODULE_AUTHOR(DRV_PROJECT);
|
|
|
|
MODULE_VERSION(DRV_VERSION);
|
|
|
|
MODULE_DESCRIPTION("Ralink RT2400 PCI & PCMCIA Wireless LAN driver.");
|
|
|
|
MODULE_SUPPORTED_DEVICE("Ralink RT2460 PCI & PCMCIA chipset based cards");
|
|
|
|
MODULE_DEVICE_TABLE(pci, rt2400pci_device_table);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
static struct pci_driver rt2400pci_driver = {
|
2007-11-27 20:47:34 +00:00
|
|
|
.name = KBUILD_MODNAME,
|
2007-09-26 00:57:13 +00:00
|
|
|
.id_table = rt2400pci_device_table,
|
|
|
|
.probe = rt2x00pci_probe,
|
|
|
|
.remove = __devexit_p(rt2x00pci_remove),
|
|
|
|
.suspend = rt2x00pci_suspend,
|
|
|
|
.resume = rt2x00pci_resume,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __init rt2400pci_init(void)
|
|
|
|
{
|
|
|
|
return pci_register_driver(&rt2400pci_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit rt2400pci_exit(void)
|
|
|
|
{
|
|
|
|
pci_unregister_driver(&rt2400pci_driver);
|
|
|
|
}
|
|
|
|
|
|
|
|
module_init(rt2400pci_init);
|
|
|
|
module_exit(rt2400pci_exit);
|