aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
authorIvo van Doorn <ivdoorn@gmail.com>2008-02-03 09:49:59 -0500
committerJohn W. Linville <linville@tuxdriver.com>2008-02-29 15:19:28 -0500
commit6bb40dd13b458beb55f5c60dba1cb28e814bd640 (patch)
tree9b2aaa0de4a4d72a7afc3550b08572083b111c57 /drivers
parent9404ef34e4747228717d6e22ce3827ed366ccf41 (diff)
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>
Diffstat (limited to 'drivers')
-rw-r--r--drivers/net/wireless/rt2x00/rt2400pci.c84
-rw-r--r--drivers/net/wireless/rt2x00/rt2500pci.c98
-rw-r--r--drivers/net/wireless/rt2x00/rt2500usb.c207
-rw-r--r--drivers/net/wireless/rt2x00/rt2500usb.h1
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00.h113
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00config.c119
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00dev.c154
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00lib.h10
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00mac.c152
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00pci.c32
-rw-r--r--drivers/net/wireless/rt2x00/rt2x00queue.h3
-rw-r--r--drivers/net/wireless/rt2x00/rt61pci.c169
-rw-r--r--drivers/net/wireless/rt2x00/rt61pci.h18
-rw-r--r--drivers/net/wireless/rt2x00/rt73usb.c179
-rw-r--r--drivers/net/wireless/rt2x00/rt73usb.h17
15 files changed, 826 insertions, 530 deletions
diff --git a/drivers/net/wireless/rt2x00/rt2400pci.c b/drivers/net/wireless/rt2x00/rt2400pci.c
index fc161084a8d3..61766ed800e3 100644
--- a/drivers/net/wireless/rt2x00/rt2400pci.c
+++ b/drivers/net/wireless/rt2x00/rt2400pci.c
@@ -246,50 +246,50 @@ static int rt2400pci_rfkill_poll(struct rt2x00_dev *rt2x00dev)
246/* 246/*
247 * Configuration handlers. 247 * Configuration handlers.
248 */ 248 */
249static void rt2400pci_config_mac_addr(struct rt2x00_dev *rt2x00dev, 249static void rt2400pci_config_intf(struct rt2x00_dev *rt2x00dev,
250 __le32 *mac) 250 struct rt2x00_intf *intf,
251 struct rt2x00intf_conf *conf,
252 const unsigned int flags)
251{ 253{
252 rt2x00pci_register_multiwrite(rt2x00dev, CSR3, mac, 254 unsigned int bcn_preload;
253 (2 * sizeof(__le32))); 255 u32 reg;
254}
255 256
256static void rt2400pci_config_bssid(struct rt2x00_dev *rt2x00dev, 257 if (flags & CONFIG_UPDATE_TYPE) {
257 __le32 *bssid) 258 rt2x00pci_register_write(rt2x00dev, CSR14, 0);
258{
259 rt2x00pci_register_multiwrite(rt2x00dev, CSR5, bssid,
260 (2 * sizeof(__le32)));
261}
262 259
263static void rt2400pci_config_type(struct rt2x00_dev *rt2x00dev, const int type, 260 /*
264 const int tsf_sync) 261 * Enable beacon config
265{ 262 */
266 u32 reg; 263 bcn_preload = PREAMBLE + get_duration(IEEE80211_HEADER, 20);
264 rt2x00pci_register_read(rt2x00dev, BCNCSR1, &reg);
265 rt2x00_set_field32(&reg, BCNCSR1_PRELOAD, bcn_preload);
266 rt2x00pci_register_write(rt2x00dev, BCNCSR1, reg);
267 267
268 rt2x00pci_register_write(rt2x00dev, CSR14, 0); 268 /*
269 * Enable synchronisation.
270 */
271 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
272 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1);
273 rt2x00_set_field32(&reg, CSR14_TBCN,
274 (conf->sync == TSF_SYNC_BEACON));
275 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
276 rt2x00_set_field32(&reg, CSR14_TSF_SYNC, conf->sync);
277 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
278 }
269 279
270 /* 280 if (flags & CONFIG_UPDATE_MAC)
271 * Enable beacon config 281 rt2x00pci_register_multiwrite(rt2x00dev, CSR3,
272 */ 282 conf->mac, sizeof(conf->mac));
273 rt2x00pci_register_read(rt2x00dev, BCNCSR1, &reg);
274 rt2x00_set_field32(&reg, BCNCSR1_PRELOAD,
275 PREAMBLE + get_duration(IEEE80211_HEADER, 20));
276 rt2x00pci_register_write(rt2x00dev, BCNCSR1, reg);
277 283
278 /* 284 if (flags & CONFIG_UPDATE_BSSID)
279 * Enable synchronisation. 285 rt2x00pci_register_multiwrite(rt2x00dev, CSR5,
280 */ 286 conf->bssid, sizeof(conf->bssid));
281 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
282 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1);
283 rt2x00_set_field32(&reg, CSR14_TBCN, (tsf_sync == TSF_SYNC_BEACON));
284 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
285 rt2x00_set_field32(&reg, CSR14_TSF_SYNC, tsf_sync);
286 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
287} 287}
288 288
289static void rt2400pci_config_preamble(struct rt2x00_dev *rt2x00dev, 289static int rt2400pci_config_preamble(struct rt2x00_dev *rt2x00dev,
290 const int short_preamble, 290 const int short_preamble,
291 const int ack_timeout, 291 const int ack_timeout,
292 const int ack_consume_time) 292 const int ack_consume_time)
293{ 293{
294 int preamble_mask; 294 int preamble_mask;
295 u32 reg; 295 u32 reg;
@@ -327,6 +327,8 @@ static void rt2400pci_config_preamble(struct rt2x00_dev *rt2x00dev,
327 rt2x00_set_field32(&reg, ARCSR5_SERVICE, 0x84); 327 rt2x00_set_field32(&reg, ARCSR5_SERVICE, 0x84);
328 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 110)); 328 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 110));
329 rt2x00pci_register_write(rt2x00dev, ARCSR5, reg); 329 rt2x00pci_register_write(rt2x00dev, ARCSR5, reg);
330
331 return 0;
330} 332}
331 333
332static void rt2400pci_config_phymode(struct rt2x00_dev *rt2x00dev, 334static void rt2400pci_config_phymode(struct rt2x00_dev *rt2x00dev,
@@ -481,8 +483,8 @@ static void rt2400pci_config_duration(struct rt2x00_dev *rt2x00dev,
481} 483}
482 484
483static void rt2400pci_config(struct rt2x00_dev *rt2x00dev, 485static void rt2400pci_config(struct rt2x00_dev *rt2x00dev,
484 const unsigned int flags, 486 struct rt2x00lib_conf *libconf,
485 struct rt2x00lib_conf *libconf) 487 const unsigned int flags)
486{ 488{
487 if (flags & CONFIG_UPDATE_PHYMODE) 489 if (flags & CONFIG_UPDATE_PHYMODE)
488 rt2400pci_config_phymode(rt2x00dev, libconf->basic_rates); 490 rt2400pci_config_phymode(rt2x00dev, libconf->basic_rates);
@@ -1553,9 +1555,7 @@ static const struct rt2x00lib_ops rt2400pci_rt2x00_ops = {
1553 .write_tx_data = rt2x00pci_write_tx_data, 1555 .write_tx_data = rt2x00pci_write_tx_data,
1554 .kick_tx_queue = rt2400pci_kick_tx_queue, 1556 .kick_tx_queue = rt2400pci_kick_tx_queue,
1555 .fill_rxdone = rt2400pci_fill_rxdone, 1557 .fill_rxdone = rt2400pci_fill_rxdone,
1556 .config_mac_addr = rt2400pci_config_mac_addr, 1558 .config_intf = rt2400pci_config_intf,
1557 .config_bssid = rt2400pci_config_bssid,
1558 .config_type = rt2400pci_config_type,
1559 .config_preamble = rt2400pci_config_preamble, 1559 .config_preamble = rt2400pci_config_preamble,
1560 .config = rt2400pci_config, 1560 .config = rt2400pci_config,
1561}; 1561};
@@ -1590,6 +1590,8 @@ static const struct data_queue_desc rt2400pci_queue_atim = {
1590 1590
1591static const struct rt2x00_ops rt2400pci_ops = { 1591static const struct rt2x00_ops rt2400pci_ops = {
1592 .name = KBUILD_MODNAME, 1592 .name = KBUILD_MODNAME,
1593 .max_sta_intf = 1,
1594 .max_ap_intf = 1,
1593 .eeprom_size = EEPROM_SIZE, 1595 .eeprom_size = EEPROM_SIZE,
1594 .rf_size = RF_SIZE, 1596 .rf_size = RF_SIZE,
1595 .rx = &rt2400pci_queue_rx, 1597 .rx = &rt2400pci_queue_rx,
diff --git a/drivers/net/wireless/rt2x00/rt2500pci.c b/drivers/net/wireless/rt2x00/rt2500pci.c
index 0a54b6512207..6a558bf74f11 100644
--- a/drivers/net/wireless/rt2x00/rt2500pci.c
+++ b/drivers/net/wireless/rt2x00/rt2500pci.c
@@ -246,53 +246,53 @@ static int rt2500pci_rfkill_poll(struct rt2x00_dev *rt2x00dev)
246/* 246/*
247 * Configuration handlers. 247 * Configuration handlers.
248 */ 248 */
249static void rt2500pci_config_mac_addr(struct rt2x00_dev *rt2x00dev, 249static void rt2500pci_config_intf(struct rt2x00_dev *rt2x00dev,
250 __le32 *mac) 250 struct rt2x00_intf *intf,
251{ 251 struct rt2x00intf_conf *conf,
252 rt2x00pci_register_multiwrite(rt2x00dev, CSR3, mac, 252 const unsigned int flags)
253 (2 * sizeof(__le32)));
254}
255
256static void rt2500pci_config_bssid(struct rt2x00_dev *rt2x00dev,
257 __le32 *bssid)
258{
259 rt2x00pci_register_multiwrite(rt2x00dev, CSR5, bssid,
260 (2 * sizeof(__le32)));
261}
262
263static void rt2500pci_config_type(struct rt2x00_dev *rt2x00dev, const int type,
264 const int tsf_sync)
265{ 253{
266 struct data_queue *queue = 254 struct data_queue *queue =
267 rt2x00queue_get_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON); 255 rt2x00queue_get_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON);
256 unsigned int bcn_preload;
268 u32 reg; 257 u32 reg;
269 258
270 rt2x00pci_register_write(rt2x00dev, CSR14, 0); 259 if (flags & CONFIG_UPDATE_TYPE) {
260 rt2x00pci_register_write(rt2x00dev, CSR14, 0);
271 261
272 /* 262 /*
273 * Enable beacon config 263 * Enable beacon config
274 */ 264 */
275 rt2x00pci_register_read(rt2x00dev, BCNCSR1, &reg); 265 bcn_preload = PREAMBLE + get_duration(IEEE80211_HEADER, 20);
276 rt2x00_set_field32(&reg, BCNCSR1_PRELOAD, 266 rt2x00pci_register_read(rt2x00dev, BCNCSR1, &reg);
277 PREAMBLE + get_duration(IEEE80211_HEADER, 20)); 267 rt2x00_set_field32(&reg, BCNCSR1_PRELOAD, bcn_preload);
278 rt2x00_set_field32(&reg, BCNCSR1_BEACON_CWMIN, queue->cw_min); 268 rt2x00_set_field32(&reg, BCNCSR1_BEACON_CWMIN, queue->cw_min);
279 rt2x00pci_register_write(rt2x00dev, BCNCSR1, reg); 269 rt2x00pci_register_write(rt2x00dev, BCNCSR1, reg);
280 270
281 /* 271 /*
282 * Enable synchronisation. 272 * Enable synchronisation.
283 */ 273 */
284 rt2x00pci_register_read(rt2x00dev, CSR14, &reg); 274 rt2x00pci_register_read(rt2x00dev, CSR14, &reg);
285 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1); 275 rt2x00_set_field32(&reg, CSR14_TSF_COUNT, 1);
286 rt2x00_set_field32(&reg, CSR14_TBCN, (tsf_sync == TSF_SYNC_BEACON)); 276 rt2x00_set_field32(&reg, CSR14_TBCN,
287 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0); 277 (conf->sync == TSF_SYNC_BEACON));
288 rt2x00_set_field32(&reg, CSR14_TSF_SYNC, tsf_sync); 278 rt2x00_set_field32(&reg, CSR14_BEACON_GEN, 0);
289 rt2x00pci_register_write(rt2x00dev, CSR14, reg); 279 rt2x00_set_field32(&reg, CSR14_TSF_SYNC, conf->sync);
280 rt2x00pci_register_write(rt2x00dev, CSR14, reg);
281 }
282
283 if (flags & CONFIG_UPDATE_MAC)
284 rt2x00pci_register_multiwrite(rt2x00dev, CSR3,
285 conf->mac, sizeof(conf->mac));
286
287 if (flags & CONFIG_UPDATE_BSSID)
288 rt2x00pci_register_multiwrite(rt2x00dev, CSR5,
289 conf->bssid, sizeof(conf->bssid));
290} 290}
291 291
292static void rt2500pci_config_preamble(struct rt2x00_dev *rt2x00dev, 292static int rt2500pci_config_preamble(struct rt2x00_dev *rt2x00dev,
293 const int short_preamble, 293 const int short_preamble,
294 const int ack_timeout, 294 const int ack_timeout,
295 const int ack_consume_time) 295 const int ack_consume_time)
296{ 296{
297 int preamble_mask; 297 int preamble_mask;
298 u32 reg; 298 u32 reg;
@@ -330,6 +330,8 @@ static void rt2500pci_config_preamble(struct rt2x00_dev *rt2x00dev,
330 rt2x00_set_field32(&reg, ARCSR5_SERVICE, 0x84); 330 rt2x00_set_field32(&reg, ARCSR5_SERVICE, 0x84);
331 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 110)); 331 rt2x00_set_field32(&reg, ARCSR2_LENGTH, get_duration(ACK_SIZE, 110));
332 rt2x00pci_register_write(rt2x00dev, ARCSR5, reg); 332 rt2x00pci_register_write(rt2x00dev, ARCSR5, reg);
333
334 return 0;
333} 335}
334 336
335static void rt2500pci_config_phymode(struct rt2x00_dev *rt2x00dev, 337static void rt2500pci_config_phymode(struct rt2x00_dev *rt2x00dev,
@@ -529,8 +531,8 @@ static void rt2500pci_config_duration(struct rt2x00_dev *rt2x00dev,
529} 531}
530 532
531static void rt2500pci_config(struct rt2x00_dev *rt2x00dev, 533static void rt2500pci_config(struct rt2x00_dev *rt2x00dev,
532 const unsigned int flags, 534 struct rt2x00lib_conf *libconf,
533 struct rt2x00lib_conf *libconf) 535 const unsigned int flags)
534{ 536{
535 if (flags & CONFIG_UPDATE_PHYMODE) 537 if (flags & CONFIG_UPDATE_PHYMODE)
536 rt2500pci_config_phymode(rt2x00dev, libconf->basic_rates); 538 rt2500pci_config_phymode(rt2x00dev, libconf->basic_rates);
@@ -609,9 +611,10 @@ static void rt2500pci_link_tuner(struct rt2x00_dev *rt2x00dev)
609 /* 611 /*
610 * To prevent collisions with MAC ASIC on chipsets 612 * To prevent collisions with MAC ASIC on chipsets
611 * up to version C the link tuning should halt after 20 613 * up to version C the link tuning should halt after 20
612 * seconds. 614 * seconds while being associated.
613 */ 615 */
614 if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D && 616 if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D &&
617 rt2x00dev->intf_associated &&
615 rt2x00dev->link.count > 20) 618 rt2x00dev->link.count > 20)
616 return; 619 return;
617 620
@@ -619,9 +622,12 @@ static void rt2500pci_link_tuner(struct rt2x00_dev *rt2x00dev)
619 622
620 /* 623 /*
621 * Chipset versions C and lower should directly continue 624 * Chipset versions C and lower should directly continue
622 * to the dynamic CCA tuning. 625 * to the dynamic CCA tuning. Chipset version D and higher
626 * should go straight to dynamic CCA tuning when they
627 * are not associated.
623 */ 628 */
624 if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D) 629 if (rt2x00_rev(&rt2x00dev->chip) < RT2560_VERSION_D ||
630 !rt2x00dev->intf_associated)
625 goto dynamic_cca_tune; 631 goto dynamic_cca_tune;
626 632
627 /* 633 /*
@@ -1861,9 +1867,7 @@ static const struct rt2x00lib_ops rt2500pci_rt2x00_ops = {
1861 .write_tx_data = rt2x00pci_write_tx_data, 1867 .write_tx_data = rt2x00pci_write_tx_data,
1862 .kick_tx_queue = rt2500pci_kick_tx_queue, 1868 .kick_tx_queue = rt2500pci_kick_tx_queue,
1863 .fill_rxdone = rt2500pci_fill_rxdone, 1869 .fill_rxdone = rt2500pci_fill_rxdone,
1864 .config_mac_addr = rt2500pci_config_mac_addr, 1870 .config_intf = rt2500pci_config_intf,
1865 .config_bssid = rt2500pci_config_bssid,
1866 .config_type = rt2500pci_config_type,
1867 .config_preamble = rt2500pci_config_preamble, 1871 .config_preamble = rt2500pci_config_preamble,
1868 .config = rt2500pci_config, 1872 .config = rt2500pci_config,
1869}; 1873};
@@ -1898,6 +1902,8 @@ static const struct data_queue_desc rt2500pci_queue_atim = {
1898 1902
1899static const struct rt2x00_ops rt2500pci_ops = { 1903static const struct rt2x00_ops rt2500pci_ops = {
1900 .name = KBUILD_MODNAME, 1904 .name = KBUILD_MODNAME,
1905 .max_sta_intf = 1,
1906 .max_ap_intf = 1,
1901 .eeprom_size = EEPROM_SIZE, 1907 .eeprom_size = EEPROM_SIZE,
1902 .rf_size = RF_SIZE, 1908 .rf_size = RF_SIZE,
1903 .rx = &rt2500pci_queue_rx, 1909 .rx = &rt2500pci_queue_rx,
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.c b/drivers/net/wireless/rt2x00/rt2500usb.c
index edc16a5fc754..31258ee24ee3 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.c
+++ b/drivers/net/wireless/rt2x00/rt2500usb.c
@@ -285,70 +285,65 @@ static const struct rt2x00debug rt2500usb_rt2x00debug = {
285/* 285/*
286 * Configuration handlers. 286 * Configuration handlers.
287 */ 287 */
288static void rt2500usb_config_mac_addr(struct rt2x00_dev *rt2x00dev, 288static void rt2500usb_config_intf(struct rt2x00_dev *rt2x00dev,
289 __le32 *mac) 289 struct rt2x00_intf *intf,
290{ 290 struct rt2x00intf_conf *conf,
291 rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR2, mac, 291 const unsigned int flags)
292 (3 * sizeof(__le16)));
293}
294
295static void rt2500usb_config_bssid(struct rt2x00_dev *rt2x00dev,
296 __le32 *bssid)
297{
298 rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR5, bssid,
299 (3 * sizeof(__le16)));
300}
301
302static void rt2500usb_config_type(struct rt2x00_dev *rt2x00dev, const int type,
303 const int tsf_sync)
304{ 292{
293 unsigned int bcn_preload;
305 u16 reg; 294 u16 reg;
306 295
307 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, 0); 296 if (flags & CONFIG_UPDATE_TYPE) {
297 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, 0);
308 298
309 /* 299 /*
310 * Enable beacon config 300 * Enable beacon config
311 */ 301 */
312 rt2500usb_register_read(rt2x00dev, TXRX_CSR20, &reg); 302 bcn_preload = PREAMBLE + get_duration(IEEE80211_HEADER, 20);
313 rt2x00_set_field16(&reg, TXRX_CSR20_OFFSET, 303 rt2500usb_register_read(rt2x00dev, TXRX_CSR20, &reg);
314 (PREAMBLE + get_duration(IEEE80211_HEADER, 20)) >> 6); 304 rt2x00_set_field16(&reg, TXRX_CSR20_OFFSET, bcn_preload >> 6);
315 if (type == IEEE80211_IF_TYPE_STA) 305 rt2x00_set_field16(&reg, TXRX_CSR20_BCN_EXPECT_WINDOW,
316 rt2x00_set_field16(&reg, TXRX_CSR20_BCN_EXPECT_WINDOW, 0); 306 2 * (conf->type != IEEE80211_IF_TYPE_STA));
317 else 307 rt2500usb_register_write(rt2x00dev, TXRX_CSR20, reg);
318 rt2x00_set_field16(&reg, TXRX_CSR20_BCN_EXPECT_WINDOW, 2);
319 rt2500usb_register_write(rt2x00dev, TXRX_CSR20, reg);
320 308
321 /* 309 /*
322 * Enable synchronisation. 310 * Enable synchronisation.
323 */ 311 */
324 rt2500usb_register_read(rt2x00dev, TXRX_CSR18, &reg); 312 rt2500usb_register_read(rt2x00dev, TXRX_CSR18, &reg);
325 rt2x00_set_field16(&reg, TXRX_CSR18_OFFSET, 0); 313 rt2x00_set_field16(&reg, TXRX_CSR18_OFFSET, 0);
326 rt2500usb_register_write(rt2x00dev, TXRX_CSR18, reg); 314 rt2500usb_register_write(rt2x00dev, TXRX_CSR18, reg);
315
316 rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg);
317 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 1);
318 rt2x00_set_field16(&reg, TXRX_CSR19_TBCN,
319 (conf->sync == TSF_SYNC_BEACON));
320 rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0);
321 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_SYNC, conf->sync);
322 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg);
323 }
327 324
328 rt2500usb_register_read(rt2x00dev, TXRX_CSR19, &reg); 325 if (flags & CONFIG_UPDATE_MAC)
329 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_COUNT, 1); 326 rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR2, conf->mac,
330 rt2x00_set_field16(&reg, TXRX_CSR19_TBCN, 327 (3 * sizeof(__le16)));
331 (tsf_sync == TSF_SYNC_BEACON)); 328
332 rt2x00_set_field16(&reg, TXRX_CSR19_BEACON_GEN, 0); 329 if (flags & CONFIG_UPDATE_BSSID)
333 rt2x00_set_field16(&reg, TXRX_CSR19_TSF_SYNC, tsf_sync); 330 rt2500usb_register_multiwrite(rt2x00dev, MAC_CSR5, conf->bssid,
334 rt2500usb_register_write(rt2x00dev, TXRX_CSR19, reg); 331 (3 * sizeof(__le16)));
335} 332}
336 333
337static void rt2500usb_config_preamble(struct rt2x00_dev *rt2x00dev, 334static int rt2500usb_config_preamble(struct rt2x00_dev *rt2x00dev,
338 const int short_preamble, 335 const int short_preamble,
339 const int ack_timeout, 336 const int ack_timeout,
340 const int ack_consume_time) 337 const int ack_consume_time)
341{ 338{
342 u16 reg; 339 u16 reg;
343 340
344 /* 341 /*
345 * When in atomic context, reschedule and let rt2x00lib 342 * When in atomic context, we should let rt2x00lib
346 * call this function again. 343 * try this configuration again later.
347 */ 344 */
348 if (in_atomic()) { 345 if (in_atomic())
349 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->config_work); 346 return -EAGAIN;
350 return;
351 }
352 347
353 rt2500usb_register_read(rt2x00dev, TXRX_CSR1, &reg); 348 rt2500usb_register_read(rt2x00dev, TXRX_CSR1, &reg);
354 rt2x00_set_field16(&reg, TXRX_CSR1_ACK_TIMEOUT, ack_timeout); 349 rt2x00_set_field16(&reg, TXRX_CSR1_ACK_TIMEOUT, ack_timeout);
@@ -358,6 +353,8 @@ static void rt2500usb_config_preamble(struct rt2x00_dev *rt2x00dev,
358 rt2x00_set_field16(&reg, TXRX_CSR10_AUTORESPOND_PREAMBLE, 353 rt2x00_set_field16(&reg, TXRX_CSR10_AUTORESPOND_PREAMBLE,
359 !!short_preamble); 354 !!short_preamble);
360 rt2500usb_register_write(rt2x00dev, TXRX_CSR10, reg); 355 rt2500usb_register_write(rt2x00dev, TXRX_CSR10, reg);
356
357 return 0;
361} 358}
362 359
363static void rt2500usb_config_phymode(struct rt2x00_dev *rt2x00dev, 360static void rt2500usb_config_phymode(struct rt2x00_dev *rt2x00dev,
@@ -518,8 +515,8 @@ static void rt2500usb_config_duration(struct rt2x00_dev *rt2x00dev,
518} 515}
519 516
520static void rt2500usb_config(struct rt2x00_dev *rt2x00dev, 517static void rt2500usb_config(struct rt2x00_dev *rt2x00dev,
521 const unsigned int flags, 518 struct rt2x00lib_conf *libconf,
522 struct rt2x00lib_conf *libconf) 519 const unsigned int flags)
523{ 520{
524 if (flags & CONFIG_UPDATE_PHYMODE) 521 if (flags & CONFIG_UPDATE_PHYMODE)
525 rt2500usb_config_phymode(rt2x00dev, libconf->phymode, 522 rt2500usb_config_phymode(rt2x00dev, libconf->phymode,
@@ -626,6 +623,24 @@ static void rt2500usb_link_tuner(struct rt2x00_dev *rt2x00dev)
626 u8 low_bound; 623 u8 low_bound;
627 624
628 /* 625 /*
626 * Read current r17 value, as well as the sensitivity values
627 * for the r17 register.
628 */
629 rt2500usb_bbp_read(rt2x00dev, 17, &r17);
630 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R17, &r17_sens);
631
632 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC, &vgc_bound);
633 up_bound = rt2x00_get_field16(vgc_bound, EEPROM_BBPTUNE_VGCUPPER);
634 low_bound = rt2x00_get_field16(vgc_bound, EEPROM_BBPTUNE_VGCLOWER);
635
636 /*
637 * If we are not associated, we should go straight to the
638 * dynamic CCA tuning.
639 */
640 if (!rt2x00dev->intf_associated)
641 goto dynamic_cca_tune;
642
643 /*
629 * Determine the BBP tuning threshold and correctly 644 * Determine the BBP tuning threshold and correctly
630 * set BBP 24, 25 and 61. 645 * set BBP 24, 25 and 61.
631 */ 646 */
@@ -651,13 +666,6 @@ static void rt2500usb_link_tuner(struct rt2x00_dev *rt2x00dev)
651 rt2500usb_bbp_write(rt2x00dev, 61, r61); 666 rt2500usb_bbp_write(rt2x00dev, 61, r61);
652 667
653 /* 668 /*
654 * Read current r17 value, as well as the sensitivity values
655 * for the r17 register.
656 */
657 rt2500usb_bbp_read(rt2x00dev, 17, &r17);
658 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R17, &r17_sens);
659
660 /*
661 * A too low RSSI will cause too much false CCA which will 669 * A too low RSSI will cause too much false CCA which will
662 * then corrupt the R17 tuning. To remidy this the tuning should 670 * then corrupt the R17 tuning. To remidy this the tuning should
663 * be stopped (While making sure the R17 value will not exceed limits) 671 * be stopped (While making sure the R17 value will not exceed limits)
@@ -692,14 +700,9 @@ static void rt2500usb_link_tuner(struct rt2x00_dev *rt2x00dev)
692 * Leave short or middle distance condition, restore r17 700 * Leave short or middle distance condition, restore r17
693 * to the dynamic tuning range. 701 * to the dynamic tuning range.
694 */ 702 */
695 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC, &vgc_bound);
696 vgc_bound = rt2x00_get_field16(vgc_bound, EEPROM_BBPTUNE_VGCUPPER);
697
698 low_bound = 0x32; 703 low_bound = 0x32;
699 if (rssi >= -77) 704 if (rssi < -77)
700 up_bound = vgc_bound; 705 up_bound -= (-77 - rssi);
701 else
702 up_bound = vgc_bound - (-77 - rssi);
703 706
704 if (up_bound < low_bound) 707 if (up_bound < low_bound)
705 up_bound = low_bound; 708 up_bound = low_bound;
@@ -707,7 +710,16 @@ static void rt2500usb_link_tuner(struct rt2x00_dev *rt2x00dev)
707 if (r17 > up_bound) { 710 if (r17 > up_bound) {
708 rt2500usb_bbp_write(rt2x00dev, 17, up_bound); 711 rt2500usb_bbp_write(rt2x00dev, 17, up_bound);
709 rt2x00dev->link.vgc_level = up_bound; 712 rt2x00dev->link.vgc_level = up_bound;
710 } else if (rt2x00dev->link.qual.false_cca > 512 && r17 < up_bound) { 713 return;
714 }
715
716dynamic_cca_tune:
717
718 /*
719 * R17 is inside the dynamic tuning range,
720 * start tuning the link based on the false cca counter.
721 */
722 if (rt2x00dev->link.qual.false_cca > 512 && r17 < up_bound) {
711 rt2500usb_bbp_write(rt2x00dev, 17, ++r17); 723 rt2500usb_bbp_write(rt2x00dev, 17, ++r17);
712 rt2x00dev->link.vgc_level = r17; 724 rt2x00dev->link.vgc_level = r17;
713 } else if (rt2x00dev->link.qual.false_cca < 100 && r17 > low_bound) { 725 } else if (rt2x00dev->link.qual.false_cca < 100 && r17 > low_bound) {
@@ -1203,6 +1215,7 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
1203{ 1215{
1204 u16 word; 1216 u16 word;
1205 u8 *mac; 1217 u8 *mac;
1218 u8 bbp;
1206 1219
1207 rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, EEPROM_SIZE); 1220 rt2x00usb_eeprom_read(rt2x00dev, rt2x00dev->eeprom, EEPROM_SIZE);
1208 1221
@@ -1257,9 +1270,17 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
1257 EEPROM(rt2x00dev, "BBPtune: 0x%04x\n", word); 1270 EEPROM(rt2x00dev, "BBPtune: 0x%04x\n", word);
1258 } 1271 }
1259 1272
1273 /*
1274 * Switch lower vgc bound to current BBP R17 value,
1275 * lower the value a bit for better quality.
1276 */
1277 rt2500usb_bbp_read(rt2x00dev, 17, &bbp);
1278 bbp -= 6;
1279
1260 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC, &word); 1280 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_VGC, &word);
1261 if (word == 0xffff) { 1281 if (word == 0xffff) {
1262 rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCUPPER, 0x40); 1282 rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCUPPER, 0x40);
1283 rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
1263 rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word); 1284 rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
1264 EEPROM(rt2x00dev, "BBPtune vgc: 0x%04x\n", word); 1285 EEPROM(rt2x00dev, "BBPtune vgc: 0x%04x\n", word);
1265 } 1286 }
@@ -1270,6 +1291,9 @@ static int rt2500usb_validate_eeprom(struct rt2x00_dev *rt2x00dev)
1270 rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_HIGH, 0x41); 1291 rt2x00_set_field16(&word, EEPROM_BBPTUNE_R17_HIGH, 0x41);
1271 rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R17, word); 1292 rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_R17, word);
1272 EEPROM(rt2x00dev, "BBPtune r17: 0x%04x\n", word); 1293 EEPROM(rt2x00dev, "BBPtune r17: 0x%04x\n", word);
1294 } else {
1295 rt2x00_set_field16(&word, EEPROM_BBPTUNE_VGCLOWER, bbp);
1296 rt2x00_eeprom_write(rt2x00dev, EEPROM_BBPTUNE_VGC, word);
1273 } 1297 }
1274 1298
1275 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R24, &word); 1299 rt2x00_eeprom_read(rt2x00dev, EEPROM_BBPTUNE_R24, &word);
@@ -1705,40 +1729,40 @@ static int rt2500usb_beacon_update(struct ieee80211_hw *hw,
1705{ 1729{
1706 struct rt2x00_dev *rt2x00dev = hw->priv; 1730 struct rt2x00_dev *rt2x00dev = hw->priv;
1707 struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev); 1731 struct usb_device *usb_dev = rt2x00dev_usb_dev(rt2x00dev);
1732 struct rt2x00_intf *intf = vif_to_intf(control->vif);
1708 struct queue_entry_priv_usb_bcn *priv_bcn; 1733 struct queue_entry_priv_usb_bcn *priv_bcn;
1709 struct skb_frame_desc *skbdesc; 1734 struct skb_frame_desc *skbdesc;
1710 struct data_queue *queue;
1711 struct queue_entry *entry;
1712 int pipe = usb_sndbulkpipe(usb_dev, 1); 1735 int pipe = usb_sndbulkpipe(usb_dev, 1);
1713 int length; 1736 int length;
1714 1737
1715 /* 1738 if (unlikely(!intf->beacon))
1716 * Just in case the ieee80211 doesn't set this, 1739 return -ENOBUFS;
1717 * but we need this queue set for the descriptor 1740
1718 * initialization. 1741 priv_bcn = intf->beacon->priv_data;
1719 */
1720 control->queue = IEEE80211_TX_QUEUE_BEACON;
1721 queue = rt2x00queue_get_queue(rt2x00dev, control->queue);
1722 entry = rt2x00queue_get_entry(queue, Q_INDEX);
1723 priv_bcn = entry->priv_data;
1724 1742
1725 /* 1743 /*
1726 * Add the descriptor in front of the skb. 1744 * Add the descriptor in front of the skb.
1727 */ 1745 */
1728 skb_push(skb, queue->desc_size); 1746 skb_push(skb, intf->beacon->queue->desc_size);
1729 memset(skb->data, 0, queue->desc_size); 1747 memset(skb->data, 0, intf->beacon->queue->desc_size);
1730 1748
1731 /* 1749 /*
1732 * Fill in skb descriptor 1750 * Fill in skb descriptor
1733 */ 1751 */
1734 skbdesc = get_skb_frame_desc(skb); 1752 skbdesc = get_skb_frame_desc(skb);
1735 memset(skbdesc, 0, sizeof(*skbdesc)); 1753 memset(skbdesc, 0, sizeof(*skbdesc));
1736 skbdesc->data = skb->data + queue->desc_size; 1754 skbdesc->data = skb->data + intf->beacon->queue->desc_size;
1737 skbdesc->data_len = queue->data_size; 1755 skbdesc->data_len = skb->len - intf->beacon->queue->desc_size;
1738 skbdesc->desc = skb->data; 1756 skbdesc->desc = skb->data;
1739 skbdesc->desc_len = queue->desc_size; 1757 skbdesc->desc_len = intf->beacon->queue->desc_size;
1740 skbdesc->entry = entry; 1758 skbdesc->entry = intf->beacon;
1741 1759
1760 /*
1761 * Just in case mac80211 doesn't set this correctly,
1762 * but we need this queue set for the descriptor
1763 * initialization.
1764 */
1765 control->queue = IEEE80211_TX_QUEUE_BEACON;
1742 rt2x00lib_write_tx_desc(rt2x00dev, skb, control); 1766 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
1743 1767
1744 /* 1768 /*
@@ -1749,7 +1773,8 @@ static int rt2500usb_beacon_update(struct ieee80211_hw *hw,
1749 length = rt2500usb_get_tx_data_len(rt2x00dev, skb); 1773 length = rt2500usb_get_tx_data_len(rt2x00dev, skb);
1750 1774
1751 usb_fill_bulk_urb(priv_bcn->urb, usb_dev, pipe, 1775 usb_fill_bulk_urb(priv_bcn->urb, usb_dev, pipe,
1752 skb->data, length, rt2500usb_beacondone, entry); 1776 skb->data, length, rt2500usb_beacondone,
1777 intf->beacon);
1753 1778
1754 /* 1779 /*
1755 * Second we need to create the guardian byte. 1780 * Second we need to create the guardian byte.
@@ -1759,7 +1784,7 @@ static int rt2500usb_beacon_update(struct ieee80211_hw *hw,
1759 priv_bcn->guardian_data = 0; 1784 priv_bcn->guardian_data = 0;
1760 usb_fill_bulk_urb(priv_bcn->guardian_urb, usb_dev, pipe, 1785 usb_fill_bulk_urb(priv_bcn->guardian_urb, usb_dev, pipe,
1761 &priv_bcn->guardian_data, 1, rt2500usb_beacondone, 1786 &priv_bcn->guardian_data, 1, rt2500usb_beacondone,
1762 entry); 1787 intf->beacon);
1763 1788
1764 /* 1789 /*
1765 * Send out the guardian byte. 1790 * Send out the guardian byte.
@@ -1769,7 +1794,7 @@ static int rt2500usb_beacon_update(struct ieee80211_hw *hw,
1769 /* 1794 /*
1770 * Enable beacon generation. 1795 * Enable beacon generation.
1771 */ 1796 */
1772 rt2500usb_kick_tx_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON); 1797 rt2500usb_kick_tx_queue(rt2x00dev, control->queue);
1773 1798
1774 return 0; 1799 return 0;
1775} 1800}
@@ -1805,9 +1830,7 @@ static const struct rt2x00lib_ops rt2500usb_rt2x00_ops = {
1805 .get_tx_data_len = rt2500usb_get_tx_data_len, 1830 .get_tx_data_len = rt2500usb_get_tx_data_len,
1806 .kick_tx_queue = rt2500usb_kick_tx_queue, 1831 .kick_tx_queue = rt2500usb_kick_tx_queue,
1807 .fill_rxdone = rt2500usb_fill_rxdone, 1832 .fill_rxdone = rt2500usb_fill_rxdone,
1808 .config_mac_addr = rt2500usb_config_mac_addr, 1833 .config_intf = rt2500usb_config_intf,
1809 .config_bssid = rt2500usb_config_bssid,
1810 .config_type = rt2500usb_config_type,
1811 .config_preamble = rt2500usb_config_preamble, 1834 .config_preamble = rt2500usb_config_preamble,
1812 .config = rt2500usb_config, 1835 .config = rt2500usb_config,
1813}; 1836};
@@ -1842,6 +1865,8 @@ static const struct data_queue_desc rt2500usb_queue_atim = {
1842 1865
1843static const struct rt2x00_ops rt2500usb_ops = { 1866static const struct rt2x00_ops rt2500usb_ops = {
1844 .name = KBUILD_MODNAME, 1867 .name = KBUILD_MODNAME,
1868 .max_sta_intf = 1,
1869 .max_ap_intf = 1,
1845 .eeprom_size = EEPROM_SIZE, 1870 .eeprom_size = EEPROM_SIZE,
1846 .rf_size = RF_SIZE, 1871 .rf_size = RF_SIZE,
1847 .rx = &rt2500usb_queue_rx, 1872 .rx = &rt2500usb_queue_rx,
diff --git a/drivers/net/wireless/rt2x00/rt2500usb.h b/drivers/net/wireless/rt2x00/rt2500usb.h
index e9f2cd90da58..23ba0c15741f 100644
--- a/drivers/net/wireless/rt2x00/rt2500usb.h
+++ b/drivers/net/wireless/rt2x00/rt2500usb.h
@@ -686,6 +686,7 @@
686 */ 686 */
687#define EEPROM_BBPTUNE_VGC 0x0034 687#define EEPROM_BBPTUNE_VGC 0x0034
688#define EEPROM_BBPTUNE_VGCUPPER FIELD16(0x00ff) 688#define EEPROM_BBPTUNE_VGCUPPER FIELD16(0x00ff)
689#define EEPROM_BBPTUNE_VGCLOWER FIELD16(0xff00)
689 690
690/* 691/*
691 * EEPROM BBP R17 Tuning. 692 * EEPROM BBP R17 Tuning.
diff --git a/drivers/net/wireless/rt2x00/rt2x00.h b/drivers/net/wireless/rt2x00/rt2x00.h
index 6a25195816db..2363ca4903cc 100644
--- a/drivers/net/wireless/rt2x00/rt2x00.h
+++ b/drivers/net/wireless/rt2x00/rt2x00.h
@@ -343,20 +343,22 @@ static inline int rt2x00_update_ant_rssi(struct link *link, int rssi)
343 343
344/* 344/*
345 * Interface structure 345 * Interface structure
346 * Configuration details about the current interface. 346 * Per interface configuration details, this structure
347 * is allocated as the private data for ieee80211_vif.
347 */ 348 */
348struct interface { 349struct rt2x00_intf {
349 /* 350 /*
350 * Interface identification. The value is assigned 351 * All fields within the rt2x00_intf structure
351 * to us by the 80211 stack, and is used to request 352 * must be protected with a spinlock.
352 * new beacons.
353 */ 353 */
354 struct ieee80211_vif *id; 354 spinlock_t lock;
355 355
356 /* 356 /*
357 * Current working type (IEEE80211_IF_TYPE_*). 357 * BSS configuration. Copied from the structure
358 * passed to us through the bss_info_changed()
359 * callback funtion.
358 */ 360 */
359 int type; 361 struct ieee80211_bss_conf conf;
360 362
361 /* 363 /*
362 * MAC of the device. 364 * MAC of the device.
@@ -367,16 +369,25 @@ struct interface {
367 * BBSID of the AP to associate with. 369 * BBSID of the AP to associate with.
368 */ 370 */
369 u8 bssid[ETH_ALEN]; 371 u8 bssid[ETH_ALEN];
370};
371 372
372static inline int is_interface_present(struct interface *intf) 373 /*
373{ 374 * Entry in the beacon queue which belongs to
374 return !!intf->id; 375 * this interface. Each interface has its own
375} 376 * dedicated beacon entry.
377 */
378 struct queue_entry *beacon;
376 379
377static inline int is_interface_type(struct interface *intf, int type) 380 /*
381 * Actions that needed rescheduling.
382 */
383 unsigned int delayed_flags;
384#define DELAYED_UPDATE_BEACON 0x00000001
385#define DELAYED_CONFIG_PREAMBLE 0x00000002
386};
387
388static inline struct rt2x00_intf* vif_to_intf(struct ieee80211_vif *vif)
378{ 389{
379 return intf->type == type; 390 return (struct rt2x00_intf *)vif->drv_priv;
380} 391}
381 392
382/* 393/*
@@ -430,6 +441,37 @@ struct rt2x00lib_conf {
430}; 441};
431 442
432/* 443/*
444 * Configuration structure wrapper around the
445 * rt2x00 interface configuration handler.
446 */
447struct rt2x00intf_conf {
448 /*
449 * Interface type
450 */
451 enum ieee80211_if_types type;
452
453 /*
454 * TSF sync value, this is dependant on the operation type.
455 */
456 enum tsf_sync sync;
457
458 /*
459 * The MAC and BSSID addressess are simple array of bytes,
460 * these arrays are little endian, so when sending the addressess
461 * to the drivers, copy the it into a endian-signed variable.
462 *
463 * Note that all devices (except rt2500usb) have 32 bits
464 * register word sizes. This means that whatever variable we
465 * pass _must_ be a multiple of 32 bits. Otherwise the device
466 * might not accept what we are sending to it.
467 * This will also make it easier for the driver to write
468 * the data to the device.
469 */
470 __le32 mac[2];
471 __le32 bssid[2];
472};
473
474/*
433 * rt2x00lib callback functions. 475 * rt2x00lib callback functions.
434 */ 476 */
435struct rt2x00lib_ops { 477struct rt2x00lib_ops {
@@ -495,16 +537,21 @@ struct rt2x00lib_ops {
495 /* 537 /*
496 * Configuration handlers. 538 * Configuration handlers.
497 */ 539 */
498 void (*config_mac_addr) (struct rt2x00_dev *rt2x00dev, __le32 *mac); 540 void (*config_intf) (struct rt2x00_dev *rt2x00dev,
499 void (*config_bssid) (struct rt2x00_dev *rt2x00dev, __le32 *bssid); 541 struct rt2x00_intf *intf,
500 void (*config_type) (struct rt2x00_dev *rt2x00dev, const int type, 542 struct rt2x00intf_conf *conf,
501 const int tsf_sync); 543 const unsigned int flags);
502 void (*config_preamble) (struct rt2x00_dev *rt2x00dev, 544#define CONFIG_UPDATE_TYPE ( 1 << 1 )
503 const int short_preamble, 545#define CONFIG_UPDATE_MAC ( 1 << 2 )
504 const int ack_timeout, 546#define CONFIG_UPDATE_BSSID ( 1 << 3 )
505 const int ack_consume_time); 547
506 void (*config) (struct rt2x00_dev *rt2x00dev, const unsigned int flags, 548 int (*config_preamble) (struct rt2x00_dev *rt2x00dev,
507 struct rt2x00lib_conf *libconf); 549 const int short_preamble,
550 const int ack_timeout,
551 const int ack_consume_time);
552 void (*config) (struct rt2x00_dev *rt2x00dev,
553 struct rt2x00lib_conf *libconf,
554 const unsigned int flags);
508#define CONFIG_UPDATE_PHYMODE ( 1 << 1 ) 555#define CONFIG_UPDATE_PHYMODE ( 1 << 1 )
509#define CONFIG_UPDATE_CHANNEL ( 1 << 2 ) 556#define CONFIG_UPDATE_CHANNEL ( 1 << 2 )
510#define CONFIG_UPDATE_TXPOWER ( 1 << 3 ) 557#define CONFIG_UPDATE_TXPOWER ( 1 << 3 )
@@ -519,6 +566,8 @@ struct rt2x00lib_ops {
519 */ 566 */
520struct rt2x00_ops { 567struct rt2x00_ops {
521 const char *name; 568 const char *name;
569 const unsigned int max_sta_intf;
570 const unsigned int max_ap_intf;
522 const unsigned int eeprom_size; 571 const unsigned int eeprom_size;
523 const unsigned int rf_size; 572 const unsigned int rf_size;
524 const struct data_queue_desc *rx; 573 const struct data_queue_desc *rx;
@@ -550,6 +599,7 @@ enum rt2x00_flags {
550 /* 599 /*
551 * Driver features 600 * Driver features
552 */ 601 */
602 DRIVER_SUPPORT_MIXED_INTERFACES,
553 DRIVER_REQUIRE_FIRMWARE, 603 DRIVER_REQUIRE_FIRMWARE,
554 DRIVER_REQUIRE_FIRMWARE_CRC_ITU_T, 604 DRIVER_REQUIRE_FIRMWARE_CRC_ITU_T,
555 DRIVER_REQUIRE_FIRMWARE_CCITT, 605 DRIVER_REQUIRE_FIRMWARE_CCITT,
@@ -566,7 +616,6 @@ enum rt2x00_flags {
566 CONFIG_EXTERNAL_LNA_BG, 616 CONFIG_EXTERNAL_LNA_BG,
567 CONFIG_DOUBLE_ANTENNA, 617 CONFIG_DOUBLE_ANTENNA,
568 CONFIG_DISABLE_LINK_TUNING, 618 CONFIG_DISABLE_LINK_TUNING,
569 CONFIG_SHORT_PREAMBLE,
570}; 619};
571 620
572/* 621/*
@@ -670,9 +719,14 @@ struct rt2x00_dev {
670 unsigned int packet_filter; 719 unsigned int packet_filter;
671 720
672 /* 721 /*
673 * Interface configuration. 722 * Interface details:
723 * - Open ap interface count.
724 * - Open sta interface count.
725 * - Association count.
674 */ 726 */
675 struct interface interface; 727 unsigned int intf_ap_count;
728 unsigned int intf_sta_count;
729 unsigned int intf_associated;
676 730
677 /* 731 /*
678 * Link quality 732 * Link quality
@@ -738,9 +792,8 @@ struct rt2x00_dev {
738 /* 792 /*
739 * Scheduled work. 793 * Scheduled work.
740 */ 794 */
741 struct work_struct beacon_work; 795 struct work_struct intf_work;
742 struct work_struct filter_work; 796 struct work_struct filter_work;
743 struct work_struct config_work;
744 797
745 /* 798 /*
746 * Data queue arrays for RX, TX and Beacon. 799 * Data queue arrays for RX, TX and Beacon.
diff --git a/drivers/net/wireless/rt2x00/rt2x00config.c b/drivers/net/wireless/rt2x00/rt2x00config.c
index c247ee77b3a3..20231e0c53fa 100644
--- a/drivers/net/wireless/rt2x00/rt2x00config.c
+++ b/drivers/net/wireless/rt2x00/rt2x00config.c
@@ -29,64 +29,89 @@
29#include "rt2x00.h" 29#include "rt2x00.h"
30#include "rt2x00lib.h" 30#include "rt2x00lib.h"
31 31
32 32void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev,
33/* 33 struct rt2x00_intf *intf,
34 * The MAC and BSSID addressess are simple array of bytes, 34 enum ieee80211_if_types type,
35 * these arrays are little endian, so when sending the addressess 35 u8 *mac, u8 *bssid)
36 * to the drivers, copy the it into a endian-signed variable.
37 *
38 * Note that all devices (except rt2500usb) have 32 bits
39 * register word sizes. This means that whatever variable we
40 * pass _must_ be a multiple of 32 bits. Otherwise the device
41 * might not accept what we are sending to it.
42 * This will also make it easier for the driver to write
43 * the data to the device.
44 *
45 * Also note that when NULL is passed as address the
46 * we will send 00:00:00:00:00 to the device to clear the address.
47 * This will prevent the device being confused when it wants
48 * to ACK frames or consideres itself associated.
49 */
50void rt2x00lib_config_mac_addr(struct rt2x00_dev *rt2x00dev, u8 *mac)
51{ 36{
52 __le32 reg[2]; 37 struct rt2x00intf_conf conf;
53 38 unsigned int flags = 0;
54 memset(&reg, 0, sizeof(reg));
55 if (mac)
56 memcpy(&reg, mac, ETH_ALEN);
57
58 rt2x00dev->ops->lib->config_mac_addr(rt2x00dev, &reg[0]);
59}
60 39
61void rt2x00lib_config_bssid(struct rt2x00_dev *rt2x00dev, u8 *bssid) 40 conf.type = type;
62{
63 __le32 reg[2];
64
65 memset(&reg, 0, sizeof(reg));
66 if (bssid)
67 memcpy(&reg, bssid, ETH_ALEN);
68
69 rt2x00dev->ops->lib->config_bssid(rt2x00dev, &reg[0]);
70}
71
72void rt2x00lib_config_type(struct rt2x00_dev *rt2x00dev, const int type)
73{
74 int tsf_sync;
75 41
76 switch (type) { 42 switch (type) {
77 case IEEE80211_IF_TYPE_IBSS: 43 case IEEE80211_IF_TYPE_IBSS:
78 case IEEE80211_IF_TYPE_AP: 44 case IEEE80211_IF_TYPE_AP:
79 tsf_sync = TSF_SYNC_BEACON; 45 conf.sync = TSF_SYNC_BEACON;
80 break; 46 break;
81 case IEEE80211_IF_TYPE_STA: 47 case IEEE80211_IF_TYPE_STA:
82 tsf_sync = TSF_SYNC_INFRA; 48 conf.sync = TSF_SYNC_INFRA;
83 break; 49 break;
84 default: 50 default:
85 tsf_sync = TSF_SYNC_NONE; 51 conf.sync = TSF_SYNC_NONE;
86 break; 52 break;
87 } 53 }
88 54
89 rt2x00dev->ops->lib->config_type(rt2x00dev, type, tsf_sync); 55 /*
56 * Note that when NULL is passed as address we will send
57 * 00:00:00:00:00 to the device to clear the address.
58 * This will prevent the device being confused when it wants
59 * to ACK frames or consideres itself associated.
60 */
61 memset(&conf.mac, 0, sizeof(conf.mac));
62 if (mac)
63 memcpy(&conf.mac, mac, ETH_ALEN);
64
65 memset(&conf.bssid, 0, sizeof(conf.bssid));
66 if (bssid)
67 memcpy(&conf.bssid, bssid, ETH_ALEN);
68
69 flags |= CONFIG_UPDATE_TYPE;
70 if (mac || (!rt2x00dev->intf_ap_count && !rt2x00dev->intf_sta_count))
71 flags |= CONFIG_UPDATE_MAC;
72 if (bssid || (!rt2x00dev->intf_ap_count && !rt2x00dev->intf_sta_count))
73 flags |= CONFIG_UPDATE_BSSID;
74
75 rt2x00dev->ops->lib->config_intf(rt2x00dev, intf, &conf, flags);
76}
77
78void rt2x00lib_config_preamble(struct rt2x00_dev *rt2x00dev,
79 struct rt2x00_intf *intf,
80 const unsigned int short_preamble)
81{
82 int retval;
83 int ack_timeout;
84 int ack_consume_time;
85
86 ack_timeout = PLCP + get_duration(ACK_SIZE, 10);
87 ack_consume_time = SIFS + PLCP + get_duration(ACK_SIZE, 10);
88
89 if (rt2x00dev->hw->conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME)
90 ack_timeout += SHORT_DIFS;
91 else
92 ack_timeout += DIFS;
93
94 if (short_preamble) {
95 ack_timeout += SHORT_PREAMBLE;
96 ack_consume_time += SHORT_PREAMBLE;
97 } else {
98 ack_timeout += PREAMBLE;
99 ack_consume_time += PREAMBLE;
100 }
101
102 retval = rt2x00dev->ops->lib->config_preamble(rt2x00dev,
103 short_preamble,
104 ack_timeout,
105 ack_consume_time);
106
107 spin_lock(&intf->lock);
108
109 if (retval) {
110 intf->delayed_flags |= DELAYED_CONFIG_PREAMBLE;
111 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
112 }
113
114 spin_unlock(&intf->lock);
90} 115}
91 116
92void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev, 117void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev,
@@ -113,7 +138,7 @@ void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev,
113 * The latter is required since we need to recalibrate the 138 * The latter is required since we need to recalibrate the
114 * noise-sensitivity ratio for the new setup. 139 * noise-sensitivity ratio for the new setup.
115 */ 140 */
116 rt2x00dev->ops->lib->config(rt2x00dev, CONFIG_UPDATE_ANTENNA, &libconf); 141 rt2x00dev->ops->lib->config(rt2x00dev, &libconf, CONFIG_UPDATE_ANTENNA);
117 rt2x00lib_reset_link_tuner(rt2x00dev); 142 rt2x00lib_reset_link_tuner(rt2x00dev);
118 143
119 rt2x00dev->link.ant.active.rx = libconf.ant.rx; 144 rt2x00dev->link.ant.active.rx = libconf.ant.rx;
@@ -266,7 +291,7 @@ config:
266 /* 291 /*
267 * Start configuration. 292 * Start configuration.
268 */ 293 */
269 rt2x00dev->ops->lib->config(rt2x00dev, flags, &libconf); 294 rt2x00dev->ops->lib->config(rt2x00dev, &libconf, flags);
270 295
271 /* 296 /*
272 * Some configuration changes affect the link quality 297 * Some configuration changes affect the link quality
diff --git a/drivers/net/wireless/rt2x00/rt2x00dev.c b/drivers/net/wireless/rt2x00/rt2x00dev.c
index bc07c56f89b3..014c307c270c 100644
--- a/drivers/net/wireless/rt2x00/rt2x00dev.c
+++ b/drivers/net/wireless/rt2x00/rt2x00dev.c
@@ -136,12 +136,10 @@ void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
136 /* 136 /*
137 * Stop all scheduled work. 137 * Stop all scheduled work.
138 */ 138 */
139 if (work_pending(&rt2x00dev->beacon_work)) 139 if (work_pending(&rt2x00dev->intf_work))
140 cancel_work_sync(&rt2x00dev->beacon_work); 140 cancel_work_sync(&rt2x00dev->intf_work);
141 if (work_pending(&rt2x00dev->filter_work)) 141 if (work_pending(&rt2x00dev->filter_work))
142 cancel_work_sync(&rt2x00dev->filter_work); 142 cancel_work_sync(&rt2x00dev->filter_work);
143 if (work_pending(&rt2x00dev->config_work))
144 cancel_work_sync(&rt2x00dev->config_work);
145 143
146 /* 144 /*
147 * Stop the TX queues. 145 * Stop the TX queues.
@@ -173,7 +171,7 @@ void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
173 * When we are enabling the RX, we should also start the link tuner. 171 * When we are enabling the RX, we should also start the link tuner.
174 */ 172 */
175 if (state == STATE_RADIO_RX_ON && 173 if (state == STATE_RADIO_RX_ON &&
176 is_interface_present(&rt2x00dev->interface)) 174 (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
177 rt2x00lib_start_link_tuner(rt2x00dev); 175 rt2x00lib_start_link_tuner(rt2x00dev);
178} 176}
179 177
@@ -401,10 +399,10 @@ static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
401 unsigned int filter = rt2x00dev->packet_filter; 399 unsigned int filter = rt2x00dev->packet_filter;
402 400
403 /* 401 /*
404 * Since we had stored the filter inside interface.filter, 402 * Since we had stored the filter inside rt2x00dev->packet_filter,
405 * we should now clear that field. Otherwise the driver will 403 * we should now clear that field. Otherwise the driver will
406 * assume nothing has changed (*total_flags will be compared 404 * assume nothing has changed (*total_flags will be compared
407 * to interface.filter to determine if any action is required). 405 * to rt2x00dev->packet_filter to determine if any action is required).
408 */ 406 */
409 rt2x00dev->packet_filter = 0; 407 rt2x00dev->packet_filter = 0;
410 408
@@ -412,41 +410,72 @@ static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
412 filter, &filter, 0, NULL); 410 filter, &filter, 0, NULL);
413} 411}
414 412
415static void rt2x00lib_configuration_scheduled(struct work_struct *work) 413static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
414 struct ieee80211_vif *vif)
416{ 415{
417 struct rt2x00_dev *rt2x00dev = 416 struct rt2x00_dev *rt2x00dev = data;
418 container_of(work, struct rt2x00_dev, config_work); 417 struct rt2x00_intf *intf = vif_to_intf(vif);
419 struct ieee80211_bss_conf bss_conf; 418 struct sk_buff *skb;
419 struct ieee80211_tx_control control;
420 struct ieee80211_bss_conf conf;
421 int delayed_flags;
422
423 /*
424 * Copy all data we need during this action under the protection
425 * of a spinlock. Otherwise race conditions might occur which results
426 * into an invalid configuration.
427 */
428 spin_lock(&intf->lock);
429
430 memcpy(&conf, &intf->conf, sizeof(conf));
431 delayed_flags = intf->delayed_flags;
432 intf->delayed_flags = 0;
433
434 spin_unlock(&intf->lock);
435
436 if (delayed_flags & DELAYED_UPDATE_BEACON) {
437 skb = ieee80211_beacon_get(rt2x00dev->hw, vif, &control);
438 if (skb) {
439 rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb,
440 &control);
441 dev_kfree_skb(skb);
442 }
443 }
444
445 if (delayed_flags & DELAYED_CONFIG_PREAMBLE)
446 rt2x00lib_config_preamble(rt2x00dev, intf,
447 intf->conf.use_short_preamble);
448}
420 449
421 bss_conf.use_short_preamble = 450static void rt2x00lib_intf_scheduled(struct work_struct *work)
422 test_bit(CONFIG_SHORT_PREAMBLE, &rt2x00dev->flags); 451{
452 struct rt2x00_dev *rt2x00dev =
453 container_of(work, struct rt2x00_dev, intf_work);
423 454
424 /* 455 /*
425 * FIXME: shouldn't invoke it this way because all other contents 456 * Iterate over each interface and perform the
426 * of bss_conf is invalid. 457 * requested configurations.
427 */ 458 */
428 rt2x00mac_bss_info_changed(rt2x00dev->hw, rt2x00dev->interface.id, 459 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
429 &bss_conf, BSS_CHANGED_ERP_PREAMBLE); 460 rt2x00lib_intf_scheduled_iter,
461 rt2x00dev);
430} 462}
431 463
432/* 464/*
433 * Interrupt context handlers. 465 * Interrupt context handlers.
434 */ 466 */
435static void rt2x00lib_beacondone_scheduled(struct work_struct *work) 467static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
468 struct ieee80211_vif *vif)
436{ 469{
437 struct rt2x00_dev *rt2x00dev = 470 struct rt2x00_intf *intf = vif_to_intf(vif);
438 container_of(work, struct rt2x00_dev, beacon_work);
439 struct ieee80211_tx_control control;
440 struct sk_buff *skb;
441 471
442 skb = ieee80211_beacon_get(rt2x00dev->hw, 472 if (vif->type != IEEE80211_IF_TYPE_AP &&
443 rt2x00dev->interface.id, &control); 473 vif->type != IEEE80211_IF_TYPE_IBSS)
444 if (!skb)
445 return; 474 return;
446 475
447 rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb, &control); 476 spin_lock(&intf->lock);
448 477 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
449 dev_kfree_skb(skb); 478 spin_unlock(&intf->lock);
450} 479}
451 480
452void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev) 481void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
@@ -454,7 +483,11 @@ void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
454 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags)) 483 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
455 return; 484 return;
456 485
457 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->beacon_work); 486 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
487 rt2x00lib_beacondone_iter,
488 rt2x00dev);
489
490 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
458} 491}
459EXPORT_SYMBOL_GPL(rt2x00lib_beacondone); 492EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
460 493
@@ -1037,6 +1070,10 @@ int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1037 return retval; 1070 return retval;
1038 } 1071 }
1039 1072
1073 rt2x00dev->intf_ap_count = 0;
1074 rt2x00dev->intf_sta_count = 0;
1075 rt2x00dev->intf_associated = 0;
1076
1040 __set_bit(DEVICE_STARTED, &rt2x00dev->flags); 1077 __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1041 1078
1042 return 0; 1079 return 0;
@@ -1053,6 +1090,10 @@ void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1053 */ 1090 */
1054 rt2x00lib_disable_radio(rt2x00dev); 1091 rt2x00lib_disable_radio(rt2x00dev);
1055 1092
1093 rt2x00dev->intf_ap_count = 0;
1094 rt2x00dev->intf_sta_count = 0;
1095 rt2x00dev->intf_associated = 0;
1096
1056 __clear_bit(DEVICE_STARTED, &rt2x00dev->flags); 1097 __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1057} 1098}
1058 1099
@@ -1064,6 +1105,12 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1064 int retval = -ENOMEM; 1105 int retval = -ENOMEM;
1065 1106
1066 /* 1107 /*
1108 * Make room for rt2x00_intf inside the per-interface
1109 * structure ieee80211_vif.
1110 */
1111 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1112
1113 /*
1067 * Let the driver probe the device to detect the capabilities. 1114 * Let the driver probe the device to detect the capabilities.
1068 */ 1115 */
1069 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev); 1116 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
@@ -1075,17 +1122,11 @@ int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1075 /* 1122 /*
1076 * Initialize configuration work. 1123 * Initialize configuration work.
1077 */ 1124 */
1078 INIT_WORK(&rt2x00dev->beacon_work, rt2x00lib_beacondone_scheduled); 1125 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1079 INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled); 1126 INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
1080 INIT_WORK(&rt2x00dev->config_work, rt2x00lib_configuration_scheduled);
1081 INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner); 1127 INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1082 1128
1083 /* 1129 /*
1084 * Reset current working type.
1085 */
1086 rt2x00dev->interface.type = IEEE80211_IF_TYPE_INVALID;
1087
1088 /*
1089 * Allocate queue array. 1130 * Allocate queue array.
1090 */ 1131 */
1091 retval = rt2x00queue_allocate(rt2x00dev); 1132 retval = rt2x00queue_allocate(rt2x00dev);
@@ -1203,9 +1244,30 @@ exit:
1203} 1244}
1204EXPORT_SYMBOL_GPL(rt2x00lib_suspend); 1245EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1205 1246
1247static void rt2x00lib_resume_intf(void *data, u8 *mac,
1248 struct ieee80211_vif *vif)
1249{
1250 struct rt2x00_dev *rt2x00dev = data;
1251 struct rt2x00_intf *intf = vif_to_intf(vif);
1252
1253 spin_lock(&intf->lock);
1254
1255 rt2x00lib_config_intf(rt2x00dev, intf,
1256 vif->type, intf->mac, intf->bssid);
1257
1258
1259 /*
1260 * Master or Ad-hoc mode require a new beacon update.
1261 */
1262 if (vif->type == IEEE80211_IF_TYPE_AP ||
1263 vif->type == IEEE80211_IF_TYPE_IBSS)
1264 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1265
1266 spin_unlock(&intf->lock);
1267}
1268
1206int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev) 1269int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1207{ 1270{
1208 struct interface *intf = &rt2x00dev->interface;
1209 int retval; 1271 int retval;
1210 1272
1211 NOTICE(rt2x00dev, "Waking up.\n"); 1273 NOTICE(rt2x00dev, "Waking up.\n");
@@ -1235,9 +1297,12 @@ int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1235 if (!rt2x00dev->hw->conf.radio_enabled) 1297 if (!rt2x00dev->hw->conf.radio_enabled)
1236 rt2x00lib_disable_radio(rt2x00dev); 1298 rt2x00lib_disable_radio(rt2x00dev);
1237 1299
1238 rt2x00lib_config_mac_addr(rt2x00dev, intf->mac); 1300 /*
1239 rt2x00lib_config_bssid(rt2x00dev, intf->bssid); 1301 * Iterator over each active interface to
1240 rt2x00lib_config_type(rt2x00dev, intf->type); 1302 * reconfigure the hardware.
1303 */
1304 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1305 rt2x00lib_resume_intf, rt2x00dev);
1241 1306
1242 /* 1307 /*
1243 * We are ready again to receive requests from mac80211. 1308 * We are ready again to receive requests from mac80211.
@@ -1253,12 +1318,11 @@ int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1253 ieee80211_start_queues(rt2x00dev->hw); 1318 ieee80211_start_queues(rt2x00dev->hw);
1254 1319
1255 /* 1320 /*
1256 * When in Master or Ad-hoc mode, 1321 * During interface iteration we might have changed the
1257 * restart Beacon transmitting by faking a beacondone event. 1322 * delayed_flags, time to handles the event by calling
1323 * the work handler directly.
1258 */ 1324 */
1259 if (intf->type == IEEE80211_IF_TYPE_AP || 1325 rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
1260 intf->type == IEEE80211_IF_TYPE_IBSS)
1261 rt2x00lib_beacondone(rt2x00dev);
1262 1326
1263 return 0; 1327 return 0;
1264 1328
diff --git a/drivers/net/wireless/rt2x00/rt2x00lib.h b/drivers/net/wireless/rt2x00/rt2x00lib.h
index 5c835f42a455..f6789fdaaf6e 100644
--- a/drivers/net/wireless/rt2x00/rt2x00lib.h
+++ b/drivers/net/wireless/rt2x00/rt2x00lib.h
@@ -50,9 +50,13 @@ void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev);
50/* 50/*
51 * Configuration handlers. 51 * Configuration handlers.
52 */ 52 */
53void rt2x00lib_config_mac_addr(struct rt2x00_dev *rt2x00dev, u8 *mac); 53void rt2x00lib_config_intf(struct rt2x00_dev *rt2x00dev,
54void rt2x00lib_config_bssid(struct rt2x00_dev *rt2x00dev, u8 *bssid); 54 struct rt2x00_intf *intf,
55void rt2x00lib_config_type(struct rt2x00_dev *rt2x00dev, const int type); 55 enum ieee80211_if_types type,
56 u8 *mac, u8 *bssid);
57void rt2x00lib_config_preamble(struct rt2x00_dev *rt2x00dev,
58 struct rt2x00_intf *intf,
59 const unsigned int short_preamble);
56void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev, 60void rt2x00lib_config_antenna(struct rt2x00_dev *rt2x00dev,
57 enum antenna rx, enum antenna tx); 61 enum antenna rx, enum antenna tx);
58void rt2x00lib_config(struct rt2x00_dev *rt2x00dev, 62void rt2x00lib_config(struct rt2x00_dev *rt2x00dev,
diff --git a/drivers/net/wireless/rt2x00/rt2x00mac.c b/drivers/net/wireless/rt2x00/rt2x00mac.c
index f08c151ee4ba..65a2bcd18aa1 100644
--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
+++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
@@ -52,11 +52,11 @@ static int rt2x00mac_tx_rts_cts(struct rt2x00_dev *rt2x00dev,
52 skb_put(skb, size); 52 skb_put(skb, size);
53 53
54 if (control->flags & IEEE80211_TXCTL_USE_CTS_PROTECT) 54 if (control->flags & IEEE80211_TXCTL_USE_CTS_PROTECT)
55 ieee80211_ctstoself_get(rt2x00dev->hw, rt2x00dev->interface.id, 55 ieee80211_ctstoself_get(rt2x00dev->hw, control->vif,
56 frag_skb->data, frag_skb->len, control, 56 frag_skb->data, frag_skb->len, control,
57 (struct ieee80211_cts *)(skb->data)); 57 (struct ieee80211_cts *)(skb->data));
58 else 58 else
59 ieee80211_rts_get(rt2x00dev->hw, rt2x00dev->interface.id, 59 ieee80211_rts_get(rt2x00dev->hw, control->vif,
60 frag_skb->data, frag_skb->len, control, 60 frag_skb->data, frag_skb->len, control,
61 (struct ieee80211_rts *)(skb->data)); 61 (struct ieee80211_rts *)(skb->data));
62 62
@@ -162,19 +162,67 @@ int rt2x00mac_add_interface(struct ieee80211_hw *hw,
162 struct ieee80211_if_init_conf *conf) 162 struct ieee80211_if_init_conf *conf)
163{ 163{
164 struct rt2x00_dev *rt2x00dev = hw->priv; 164 struct rt2x00_dev *rt2x00dev = hw->priv;
165 struct interface *intf = &rt2x00dev->interface; 165 struct rt2x00_intf *intf = vif_to_intf(conf->vif);
166 struct data_queue *queue =
167 rt2x00queue_get_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON);
168 struct queue_entry *entry = NULL;
169 unsigned int i;
166 170
167 /* 171 /*
168 * Don't allow interfaces to be added while 172 * Don't allow interfaces to be added
169 * either the device has disappeared or when 173 * the device has disappeared.
170 * another interface is already present.
171 */ 174 */
172 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags) || 175 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags) ||
173 is_interface_present(intf)) 176 !test_bit(DEVICE_STARTED, &rt2x00dev->flags))
177 return -ENODEV;
178
179 /*
180 * When we don't support mixed interfaces (a combination
181 * of sta and ap virtual interfaces) then we can only
182 * add this interface when the rival interface count is 0.
183 */
184 if (!test_bit(DRIVER_SUPPORT_MIXED_INTERFACES, &rt2x00dev->flags) &&
185 ((conf->type == IEEE80211_IF_TYPE_AP && rt2x00dev->intf_sta_count) ||
186 (conf->type != IEEE80211_IF_TYPE_AP && rt2x00dev->intf_ap_count)))
187 return -ENOBUFS;
188
189 /*
190 * Check if we exceeded the maximum amount of supported interfaces.
191 */
192 if ((conf->type == IEEE80211_IF_TYPE_AP &&
193 rt2x00dev->intf_ap_count >= rt2x00dev->ops->max_ap_intf) ||
194 (conf->type != IEEE80211_IF_TYPE_AP &&
195 rt2x00dev->intf_sta_count >= rt2x00dev->ops->max_sta_intf))
196 return -ENOBUFS;
197
198 /*
199 * Loop through all beacon queues to find a free
200 * entry. Since there are as much beacon entries
201 * as the maximum interfaces, this search shouldn't
202 * fail.
203 */
204 for (i = 0; i < queue->limit; i++) {
205 entry = &queue->entries[i];
206 if (!__test_and_set_bit(ENTRY_BCN_ASSIGNED, &entry->flags))
207 break;
208 }
209
210 if (unlikely(i == queue->limit))
174 return -ENOBUFS; 211 return -ENOBUFS;
175 212
176 intf->id = conf->vif; 213 /*
177 intf->type = conf->type; 214 * We are now absolutely sure the interface can be created,
215 * increase interface count and start initialization.
216 */
217
218 if (conf->type == IEEE80211_IF_TYPE_AP)
219 rt2x00dev->intf_ap_count++;
220 else
221 rt2x00dev->intf_sta_count++;
222
223 spin_lock_init(&intf->lock);
224 intf->beacon = entry;
225
178 if (conf->type == IEEE80211_IF_TYPE_AP) 226 if (conf->type == IEEE80211_IF_TYPE_AP)
179 memcpy(&intf->bssid, conf->mac_addr, ETH_ALEN); 227 memcpy(&intf->bssid, conf->mac_addr, ETH_ALEN);
180 memcpy(&intf->mac, conf->mac_addr, ETH_ALEN); 228 memcpy(&intf->mac, conf->mac_addr, ETH_ALEN);
@@ -184,8 +232,7 @@ int rt2x00mac_add_interface(struct ieee80211_hw *hw,
184 * has been initialized. Otherwise the device can reset 232 * has been initialized. Otherwise the device can reset
185 * the MAC registers. 233 * the MAC registers.
186 */ 234 */
187 rt2x00lib_config_mac_addr(rt2x00dev, intf->mac); 235 rt2x00lib_config_intf(rt2x00dev, intf, conf->type, intf->mac, NULL);
188 rt2x00lib_config_type(rt2x00dev, conf->type);
189 236
190 return 0; 237 return 0;
191} 238}
@@ -195,7 +242,7 @@ void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
195 struct ieee80211_if_init_conf *conf) 242 struct ieee80211_if_init_conf *conf)
196{ 243{
197 struct rt2x00_dev *rt2x00dev = hw->priv; 244 struct rt2x00_dev *rt2x00dev = hw->priv;
198 struct interface *intf = &rt2x00dev->interface; 245 struct rt2x00_intf *intf = vif_to_intf(conf->vif);
199 246
200 /* 247 /*
201 * Don't allow interfaces to be remove while 248 * Don't allow interfaces to be remove while
@@ -203,21 +250,27 @@ void rt2x00mac_remove_interface(struct ieee80211_hw *hw,
203 * no interface is present. 250 * no interface is present.
204 */ 251 */
205 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags) || 252 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags) ||
206 !is_interface_present(intf)) 253 (conf->type == IEEE80211_IF_TYPE_AP && !rt2x00dev->intf_ap_count) ||
254 (conf->type != IEEE80211_IF_TYPE_AP && !rt2x00dev->intf_sta_count))
207 return; 255 return;
208 256
209 intf->id = NULL; 257 if (conf->type == IEEE80211_IF_TYPE_AP)
210 intf->type = IEEE80211_IF_TYPE_INVALID; 258 rt2x00dev->intf_ap_count--;
211 memset(&intf->bssid, 0x00, ETH_ALEN); 259 else
212 memset(&intf->mac, 0x00, ETH_ALEN); 260 rt2x00dev->intf_sta_count--;
261
262 /*
263 * Release beacon entry so it is available for
264 * new interfaces again.
265 */
266 __clear_bit(ENTRY_BCN_ASSIGNED, &intf->beacon->flags);
213 267
214 /* 268 /*
215 * Make sure the bssid and mac address registers 269 * Make sure the bssid and mac address registers
216 * are cleared to prevent false ACKing of frames. 270 * are cleared to prevent false ACKing of frames.
217 */ 271 */
218 rt2x00lib_config_mac_addr(rt2x00dev, intf->mac); 272 rt2x00lib_config_intf(rt2x00dev, intf,
219 rt2x00lib_config_bssid(rt2x00dev, intf->bssid); 273 IEEE80211_IF_TYPE_INVALID, NULL, NULL);
220 rt2x00lib_config_type(rt2x00dev, intf->type);
221} 274}
222EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface); 275EXPORT_SYMBOL_GPL(rt2x00mac_remove_interface);
223 276
@@ -262,7 +315,7 @@ int rt2x00mac_config_interface(struct ieee80211_hw *hw,
262 struct ieee80211_if_conf *conf) 315 struct ieee80211_if_conf *conf)
263{ 316{
264 struct rt2x00_dev *rt2x00dev = hw->priv; 317 struct rt2x00_dev *rt2x00dev = hw->priv;
265 struct interface *intf = &rt2x00dev->interface; 318 struct rt2x00_intf *intf = vif_to_intf(vif);
266 int status; 319 int status;
267 320
268 /* 321 /*
@@ -272,12 +325,7 @@ int rt2x00mac_config_interface(struct ieee80211_hw *hw,
272 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags)) 325 if (!test_bit(DEVICE_PRESENT, &rt2x00dev->flags))
273 return 0; 326 return 0;
274 327
275 /* 328 spin_lock(&intf->lock);
276 * If the given type does not match the configured type,
277 * there has been a problem.
278 */
279 if (conf->type != intf->type)
280 return -EINVAL;
281 329
282 /* 330 /*
283 * If the interface does not work in master mode, 331 * If the interface does not work in master mode,
@@ -286,7 +334,9 @@ int rt2x00mac_config_interface(struct ieee80211_hw *hw,
286 */ 334 */
287 if (conf->type != IEEE80211_IF_TYPE_AP) 335 if (conf->type != IEEE80211_IF_TYPE_AP)
288 memcpy(&intf->bssid, conf->bssid, ETH_ALEN); 336 memcpy(&intf->bssid, conf->bssid, ETH_ALEN);
289 rt2x00lib_config_bssid(rt2x00dev, intf->bssid); 337 rt2x00lib_config_intf(rt2x00dev, intf, conf->type, NULL, intf->bssid);
338
339 spin_unlock(&intf->lock);
290 340
291 /* 341 /*
292 * We only need to initialize the beacon when master mode is enabled. 342 * We only need to initialize the beacon when master mode is enabled.
@@ -342,35 +392,35 @@ void rt2x00mac_bss_info_changed(struct ieee80211_hw *hw,
342 u32 changes) 392 u32 changes)
343{ 393{
344 struct rt2x00_dev *rt2x00dev = hw->priv; 394 struct rt2x00_dev *rt2x00dev = hw->priv;
345 int short_preamble; 395 struct rt2x00_intf *intf = vif_to_intf(vif);
346 int ack_timeout;
347 int ack_consume_time;
348 int difs;
349 int preamble;
350 396
351 /* 397 /*
352 * We only support changing preamble mode. 398 * When the association status has changed we must reset the link
399 * tuner counter. This is because some drivers determine if they
400 * should perform link tuning based on the number of seconds
401 * while associated or not associated.
353 */ 402 */
354 if (!(changes & BSS_CHANGED_ERP_PREAMBLE)) 403 if (changes & BSS_CHANGED_ASSOC) {
355 return; 404 rt2x00dev->link.count = 0;
356
357 short_preamble = bss_conf->use_short_preamble;
358 preamble = bss_conf->use_short_preamble ?
359 SHORT_PREAMBLE : PREAMBLE;
360 405
361 difs = (hw->conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME) ? 406 if (bss_conf->assoc)
362 SHORT_DIFS : DIFS; 407 rt2x00dev->intf_associated++;
363 ack_timeout = difs + PLCP + preamble + get_duration(ACK_SIZE, 10); 408 else
364 409 rt2x00dev->intf_associated--;
365 ack_consume_time = SIFS + PLCP + preamble + get_duration(ACK_SIZE, 10); 410 }
366 411
367 if (short_preamble) 412 /*
368 __set_bit(CONFIG_SHORT_PREAMBLE, &rt2x00dev->flags); 413 * When the preamble mode has changed, we should perform additional
369 else 414 * configuration steps. For all other changes we are already done.
370 __clear_bit(CONFIG_SHORT_PREAMBLE, &rt2x00dev->flags); 415 */
416 if (changes & BSS_CHANGED_ERP_PREAMBLE) {
417 rt2x00lib_config_preamble(rt2x00dev, intf,
418 bss_conf->use_short_preamble);
371 419
372 rt2x00dev->ops->lib->config_preamble(rt2x00dev, short_preamble, 420 spin_lock(&intf->lock);
373 ack_timeout, ack_consume_time); 421 memcpy(&intf->conf, bss_conf, sizeof(*bss_conf));
422 spin_unlock(&intf->lock);
423 }
374} 424}
375EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed); 425EXPORT_SYMBOL_GPL(rt2x00mac_bss_info_changed);
376 426
diff --git a/drivers/net/wireless/rt2x00/rt2x00pci.c b/drivers/net/wireless/rt2x00/rt2x00pci.c
index 63cfe33e95da..764147dd5aea 100644
--- a/drivers/net/wireless/rt2x00/rt2x00pci.c
+++ b/drivers/net/wireless/rt2x00/rt2x00pci.c
@@ -38,20 +38,14 @@ int rt2x00pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
38 struct ieee80211_tx_control *control) 38 struct ieee80211_tx_control *control)
39{ 39{
40 struct rt2x00_dev *rt2x00dev = hw->priv; 40 struct rt2x00_dev *rt2x00dev = hw->priv;
41 struct rt2x00_intf *intf = vif_to_intf(control->vif);
41 struct queue_entry_priv_pci_tx *priv_tx; 42 struct queue_entry_priv_pci_tx *priv_tx;
42 struct skb_frame_desc *skbdesc; 43 struct skb_frame_desc *skbdesc;
43 struct data_queue *queue;
44 struct queue_entry *entry;
45 44
46 /* 45 if (unlikely(!intf->beacon))
47 * Just in case mac80211 doesn't set this correctly, 46 return -ENOBUFS;
48 * but we need this queue set for the descriptor 47
49 * initialization. 48 priv_tx = intf->beacon->priv_data;
50 */
51 control->queue = IEEE80211_TX_QUEUE_BEACON;
52 queue = rt2x00queue_get_queue(rt2x00dev, control->queue);
53 entry = rt2x00queue_get_entry(queue, Q_INDEX);
54 priv_tx = entry->priv_data;
55 49
56 /* 50 /*
57 * Fill in skb descriptor 51 * Fill in skb descriptor
@@ -59,17 +53,25 @@ int rt2x00pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
59 skbdesc = get_skb_frame_desc(skb); 53 skbdesc = get_skb_frame_desc(skb);
60 memset(skbdesc, 0, sizeof(*skbdesc)); 54 memset(skbdesc, 0, sizeof(*skbdesc));
61 skbdesc->data = skb->data; 55 skbdesc->data = skb->data;
62 skbdesc->data_len = queue->data_size; 56 skbdesc->data_len = skb->len;
63 skbdesc->desc = priv_tx->desc; 57 skbdesc->desc = priv_tx->desc;
64 skbdesc->desc_len = queue->desc_size; 58 skbdesc->desc_len = intf->beacon->queue->desc_size;
65 skbdesc->entry = entry; 59 skbdesc->entry = intf->beacon;
66 60
67 memcpy(priv_tx->data, skb->data, skb->len); 61 /*
62 * Just in case mac80211 doesn't set this correctly,
63 * but we need this queue set for the descriptor
64 * initialization.
65 */
66 control->queue = IEEE80211_TX_QUEUE_BEACON;
68 rt2x00lib_write_tx_desc(rt2x00dev, skb, control); 67 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
69 68
70 /* 69 /*
71 * Enable beacon generation. 70 * Enable beacon generation.
71 * Write entire beacon with descriptor to register,
72 * and kick the beacon generator.
72 */ 73 */
74 memcpy(priv_tx->data, skb->data, skb->len);
73 rt2x00dev->ops->lib->kick_tx_queue(rt2x00dev, control->queue); 75 rt2x00dev->ops->lib->kick_tx_queue(rt2x00dev, control->queue);
74 76
75 return 0; 77 return 0;
diff --git a/drivers/net/wireless/rt2x00/rt2x00queue.h b/drivers/net/wireless/rt2x00/rt2x00queue.h
index 507116c6c9fe..75af48eddc25 100644
--- a/drivers/net/wireless/rt2x00/rt2x00queue.h
+++ b/drivers/net/wireless/rt2x00/rt2x00queue.h
@@ -46,9 +46,6 @@
46 * queue would be sufficient. Although this is almost one third of 46 * queue would be sufficient. Although this is almost one third of
47 * the amount the legacy driver allocated, the queues aren't getting 47 * the amount the legacy driver allocated, the queues aren't getting
48 * filled to the maximum even when working with the maximum rate. 48 * filled to the maximum even when working with the maximum rate.
49 *
50 * FIXME: For virtual interfaces we need a different number
51 * of beacons, since more interfaces require more beacons.
52 */ 49 */
53#define RX_ENTRIES 12 50#define RX_ENTRIES 12
54#define TX_ENTRIES 12 51#define TX_ENTRIES 12
diff --git a/drivers/net/wireless/rt2x00/rt61pci.c b/drivers/net/wireless/rt2x00/rt61pci.c
index b5ab771bbac2..b432cc21d248 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.c
+++ b/drivers/net/wireless/rt2x00/rt61pci.c
@@ -271,63 +271,60 @@ static int rt61pci_rfkill_poll(struct rt2x00_dev *rt2x00dev)
271/* 271/*
272 * Configuration handlers. 272 * Configuration handlers.
273 */ 273 */
274static void rt61pci_config_mac_addr(struct rt2x00_dev *rt2x00dev, __le32 *mac) 274static void rt61pci_config_intf(struct rt2x00_dev *rt2x00dev,
275 struct rt2x00_intf *intf,
276 struct rt2x00intf_conf *conf,
277 const unsigned int flags)
275{ 278{
276 u32 tmp; 279 unsigned int beacon_base;
277 280 u32 reg;
278 tmp = le32_to_cpu(mac[1]);
279 rt2x00_set_field32(&tmp, MAC_CSR3_UNICAST_TO_ME_MASK, 0xff);
280 mac[1] = cpu_to_le32(tmp);
281
282 rt2x00pci_register_multiwrite(rt2x00dev, MAC_CSR2, mac,
283 (2 * sizeof(__le32)));
284}
285 281
286static void rt61pci_config_bssid(struct rt2x00_dev *rt2x00dev, __le32 *bssid) 282 if (flags & CONFIG_UPDATE_TYPE) {
287{ 283 /*
288 u32 tmp; 284 * Clear current synchronisation setup.
285 * For the Beacon base registers we only need to clear
286 * the first byte since that byte contains the VALID and OWNER
287 * bits which (when set to 0) will invalidate the entire beacon.
288 */
289 beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx);
290 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, 0);
291 rt2x00pci_register_write(rt2x00dev, beacon_base, 0);
289 292
290 tmp = le32_to_cpu(bssid[1]); 293 /*
291 rt2x00_set_field32(&tmp, MAC_CSR5_BSS_ID_MASK, 3); 294 * Enable synchronisation.
292 bssid[1] = cpu_to_le32(tmp); 295 */
296 rt2x00pci_register_read(rt2x00dev, TXRX_CSR9, &reg);
297 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
298 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE,
299 (conf->sync == TSF_SYNC_BEACON));
300 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
301 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_SYNC, conf->sync);
302 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, reg);
303 }
293 304
294 rt2x00pci_register_multiwrite(rt2x00dev, MAC_CSR4, bssid, 305 if (flags & CONFIG_UPDATE_MAC) {
295 (2 * sizeof(__le32))); 306 reg = le32_to_cpu(conf->mac[1]);
296} 307 rt2x00_set_field32(&reg, MAC_CSR3_UNICAST_TO_ME_MASK, 0xff);
308 conf->mac[1] = cpu_to_le32(reg);
297 309
298static void rt61pci_config_type(struct rt2x00_dev *rt2x00dev, const int type, 310 rt2x00pci_register_multiwrite(rt2x00dev, MAC_CSR2,
299 const int tsf_sync) 311 conf->mac, sizeof(conf->mac));
300{ 312 }
301 u32 reg;
302 313
303 /* 314 if (flags & CONFIG_UPDATE_BSSID) {
304 * Clear current synchronisation setup. 315 reg = le32_to_cpu(conf->bssid[1]);
305 * For the Beacon base registers we only need to clear 316 rt2x00_set_field32(&reg, MAC_CSR5_BSS_ID_MASK, 3);
306 * the first byte since that byte contains the VALID and OWNER 317 conf->bssid[1] = cpu_to_le32(reg);
307 * bits which (when set to 0) will invalidate the entire beacon.
308 */
309 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, 0);
310 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE0, 0);
311 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE1, 0);
312 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE2, 0);
313 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE3, 0);
314 318
315 /* 319 rt2x00pci_register_multiwrite(rt2x00dev, MAC_CSR4,
316 * Enable synchronisation. 320 conf->bssid, sizeof(conf->bssid));
317 */ 321 }
318 rt2x00pci_register_read(rt2x00dev, TXRX_CSR9, &reg);
319 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
320 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE,
321 (tsf_sync == TSF_SYNC_BEACON));
322 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
323 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_SYNC, tsf_sync);
324 rt2x00pci_register_write(rt2x00dev, TXRX_CSR9, reg);
325} 322}
326 323
327static void rt61pci_config_preamble(struct rt2x00_dev *rt2x00dev, 324static int rt61pci_config_preamble(struct rt2x00_dev *rt2x00dev,
328 const int short_preamble, 325 const int short_preamble,
329 const int ack_timeout, 326 const int ack_timeout,
330 const int ack_consume_time) 327 const int ack_consume_time)
331{ 328{
332 u32 reg; 329 u32 reg;
333 330
@@ -339,6 +336,8 @@ static void rt61pci_config_preamble(struct rt2x00_dev *rt2x00dev,
339 rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE, 336 rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE,
340 !!short_preamble); 337 !!short_preamble);
341 rt2x00pci_register_write(rt2x00dev, TXRX_CSR4, reg); 338 rt2x00pci_register_write(rt2x00dev, TXRX_CSR4, reg);
339
340 return 0;
342} 341}
343 342
344static void rt61pci_config_phymode(struct rt2x00_dev *rt2x00dev, 343static void rt61pci_config_phymode(struct rt2x00_dev *rt2x00dev,
@@ -667,8 +666,8 @@ static void rt61pci_config_duration(struct rt2x00_dev *rt2x00dev,
667} 666}
668 667
669static void rt61pci_config(struct rt2x00_dev *rt2x00dev, 668static void rt61pci_config(struct rt2x00_dev *rt2x00dev,
670 const unsigned int flags, 669 struct rt2x00lib_conf *libconf,
671 struct rt2x00lib_conf *libconf) 670 const unsigned int flags)
672{ 671{
673 if (flags & CONFIG_UPDATE_PHYMODE) 672 if (flags & CONFIG_UPDATE_PHYMODE)
674 rt61pci_config_phymode(rt2x00dev, libconf->basic_rates); 673 rt61pci_config_phymode(rt2x00dev, libconf->basic_rates);
@@ -816,6 +815,13 @@ static void rt61pci_link_tuner(struct rt2x00_dev *rt2x00dev)
816 } 815 }
817 816
818 /* 817 /*
818 * If we are not associated, we should go straight to the
819 * dynamic CCA tuning.
820 */
821 if (!rt2x00dev->intf_associated)
822 goto dynamic_cca_tune;
823
824 /*
819 * Special big-R17 for very short distance 825 * Special big-R17 for very short distance
820 */ 826 */
821 if (rssi >= -35) { 827 if (rssi >= -35) {
@@ -866,6 +872,8 @@ static void rt61pci_link_tuner(struct rt2x00_dev *rt2x00dev)
866 return; 872 return;
867 } 873 }
868 874
875dynamic_cca_tune:
876
869 /* 877 /*
870 * r17 does not yet exceed upper limit, continue and base 878 * r17 does not yet exceed upper limit, continue and base
871 * the r17 tuning on the false CCA count. 879 * the r17 tuning on the false CCA count.
@@ -1215,6 +1223,17 @@ static int rt61pci_init_registers(struct rt2x00_dev *rt2x00dev)
1215 rt2x00pci_register_write(rt2x00dev, AC_TXOP_CSR1, reg); 1223 rt2x00pci_register_write(rt2x00dev, AC_TXOP_CSR1, reg);
1216 1224
1217 /* 1225 /*
1226 * Clear all beacons
1227 * For the Beacon base registers we only need to clear
1228 * the first byte since that byte contains the VALID and OWNER
1229 * bits which (when set to 0) will invalidate the entire beacon.
1230 */
1231 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE0, 0);
1232 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE1, 0);
1233 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE2, 0);
1234 rt2x00pci_register_write(rt2x00dev, HW_BEACON_BASE3, 0);
1235
1236 /*
1218 * We must clear the error counters. 1237 * We must clear the error counters.
1219 * These registers are cleared on read, 1238 * These registers are cleared on read,
1220 * so we may pass a useless variable to store the value. 1239 * so we may pass a useless variable to store the value.
@@ -2378,25 +2397,20 @@ static int rt61pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
2378 struct ieee80211_tx_control *control) 2397 struct ieee80211_tx_control *control)
2379{ 2398{
2380 struct rt2x00_dev *rt2x00dev = hw->priv; 2399 struct rt2x00_dev *rt2x00dev = hw->priv;
2400 struct rt2x00_intf *intf = vif_to_intf(control->vif);
2381 struct skb_frame_desc *skbdesc; 2401 struct skb_frame_desc *skbdesc;
2382 struct data_queue *queue; 2402 unsigned int beacon_base;
2383 struct queue_entry *entry;
2384 2403
2385 /* 2404 if (unlikely(!intf->beacon))
2386 * Just in case the ieee80211 doesn't set this, 2405 return -ENOBUFS;
2387 * but we need this queue set for the descriptor
2388 * initialization.
2389 */
2390 control->queue = IEEE80211_TX_QUEUE_BEACON;
2391 queue = rt2x00queue_get_queue(rt2x00dev, control->queue);
2392 entry = rt2x00queue_get_entry(queue, Q_INDEX);
2393 2406
2394 /* 2407 /*
2395 * We need to append the descriptor in front of the 2408 * We need to append the descriptor in front of the
2396 * beacon frame. 2409 * beacon frame.
2397 */ 2410 */
2398 if (skb_headroom(skb) < queue->desc_size) { 2411 if (skb_headroom(skb) < intf->beacon->queue->desc_size) {
2399 if (pskb_expand_head(skb, queue->desc_size, 0, GFP_ATOMIC)) { 2412 if (pskb_expand_head(skb, intf->beacon->queue->desc_size,
2413 0, GFP_ATOMIC)) {
2400 dev_kfree_skb(skb); 2414 dev_kfree_skb(skb);
2401 return -ENOMEM; 2415 return -ENOMEM;
2402 } 2416 }
@@ -2405,29 +2419,36 @@ static int rt61pci_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
2405 /* 2419 /*
2406 * Add the descriptor in front of the skb. 2420 * Add the descriptor in front of the skb.
2407 */ 2421 */
2408 skb_push(skb, queue->desc_size); 2422 skb_push(skb, intf->beacon->queue->desc_size);
2409 memset(skb->data, 0, queue->desc_size); 2423 memset(skb->data, 0, intf->beacon->queue->desc_size);
2410 2424
2411 /* 2425 /*
2412 * Fill in skb descriptor 2426 * Fill in skb descriptor
2413 */ 2427 */
2414 skbdesc = get_skb_frame_desc(skb); 2428 skbdesc = get_skb_frame_desc(skb);
2415 memset(skbdesc, 0, sizeof(*skbdesc)); 2429 memset(skbdesc, 0, sizeof(*skbdesc));
2416 skbdesc->data = skb->data + queue->desc_size; 2430 skbdesc->data = skb->data + intf->beacon->queue->desc_size;
2417 skbdesc->data_len = queue->data_size; 2431 skbdesc->data_len = skb->len - intf->beacon->queue->desc_size;
2418 skbdesc->desc = skb->data; 2432 skbdesc->desc = skb->data;
2419 skbdesc->desc_len = queue->desc_size; 2433 skbdesc->desc_len = intf->beacon->queue->desc_size;
2420 skbdesc->entry = entry; 2434 skbdesc->entry = intf->beacon;
2421 2435
2436 /*
2437 * Just in case the ieee80211 doesn't set this,
2438 * but we need this queue set for the descriptor
2439 * initialization.
2440 */
2441 control->queue = IEEE80211_TX_QUEUE_BEACON;
2422 rt2x00lib_write_tx_desc(rt2x00dev, skb, control); 2442 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
2423 2443
2424 /* 2444 /*
2425 * Write entire beacon with descriptor to register, 2445 * Write entire beacon with descriptor to register,
2426 * and kick the beacon generator. 2446 * and kick the beacon generator.
2427 */ 2447 */
2428 rt2x00pci_register_multiwrite(rt2x00dev, HW_BEACON_BASE0, 2448 beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx);
2449 rt2x00pci_register_multiwrite(rt2x00dev, beacon_base,
2429 skb->data, skb->len); 2450 skb->data, skb->len);
2430 rt61pci_kick_tx_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON); 2451 rt61pci_kick_tx_queue(rt2x00dev, control->queue);
2431 2452
2432 return 0; 2453 return 0;
2433} 2454}
@@ -2469,9 +2490,7 @@ static const struct rt2x00lib_ops rt61pci_rt2x00_ops = {
2469 .write_tx_data = rt2x00pci_write_tx_data, 2490 .write_tx_data = rt2x00pci_write_tx_data,
2470 .kick_tx_queue = rt61pci_kick_tx_queue, 2491 .kick_tx_queue = rt61pci_kick_tx_queue,
2471 .fill_rxdone = rt61pci_fill_rxdone, 2492 .fill_rxdone = rt61pci_fill_rxdone,
2472 .config_mac_addr = rt61pci_config_mac_addr, 2493 .config_intf = rt61pci_config_intf,
2473 .config_bssid = rt61pci_config_bssid,
2474 .config_type = rt61pci_config_type,
2475 .config_preamble = rt61pci_config_preamble, 2494 .config_preamble = rt61pci_config_preamble,
2476 .config = rt61pci_config, 2495 .config = rt61pci_config,
2477}; 2496};
@@ -2491,7 +2510,7 @@ static const struct data_queue_desc rt61pci_queue_tx = {
2491}; 2510};
2492 2511
2493static const struct data_queue_desc rt61pci_queue_bcn = { 2512static const struct data_queue_desc rt61pci_queue_bcn = {
2494 .entry_num = BEACON_ENTRIES, 2513 .entry_num = 4 * BEACON_ENTRIES,
2495 .data_size = MGMT_FRAME_SIZE, 2514 .data_size = MGMT_FRAME_SIZE,
2496 .desc_size = TXINFO_SIZE, 2515 .desc_size = TXINFO_SIZE,
2497 .priv_size = sizeof(struct queue_entry_priv_pci_tx), 2516 .priv_size = sizeof(struct queue_entry_priv_pci_tx),
@@ -2499,6 +2518,8 @@ static const struct data_queue_desc rt61pci_queue_bcn = {
2499 2518
2500static const struct rt2x00_ops rt61pci_ops = { 2519static const struct rt2x00_ops rt61pci_ops = {
2501 .name = KBUILD_MODNAME, 2520 .name = KBUILD_MODNAME,
2521 .max_sta_intf = 1,
2522 .max_ap_intf = 4,
2502 .eeprom_size = EEPROM_SIZE, 2523 .eeprom_size = EEPROM_SIZE,
2503 .rf_size = RF_SIZE, 2524 .rf_size = RF_SIZE,
2504 .rx = &rt61pci_queue_rx, 2525 .rx = &rt61pci_queue_rx,
diff --git a/drivers/net/wireless/rt2x00/rt61pci.h b/drivers/net/wireless/rt2x00/rt61pci.h
index 10519f8c5783..d291c0fe405c 100644
--- a/drivers/net/wireless/rt2x00/rt61pci.h
+++ b/drivers/net/wireless/rt2x00/rt61pci.h
@@ -161,7 +161,9 @@ struct hw_pairwise_ta_entry {
161#define HW_BEACON_BASE1 0x2d00 161#define HW_BEACON_BASE1 0x2d00
162#define HW_BEACON_BASE2 0x2e00 162#define HW_BEACON_BASE2 0x2e00
163#define HW_BEACON_BASE3 0x2f00 163#define HW_BEACON_BASE3 0x2f00
164#define HW_BEACON_OFFSET 0x0100 164
165#define HW_BEACON_OFFSET(__index) \
166 ( HW_BEACON_BASE0 + (__index * 0x0100) )
165 167
166/* 168/*
167 * HOST-MCU shared memory. 169 * HOST-MCU shared memory.
@@ -234,6 +236,11 @@ struct hw_pairwise_ta_entry {
234 236
235/* 237/*
236 * MAC_CSR3: STA MAC register 1. 238 * MAC_CSR3: STA MAC register 1.
239 * UNICAST_TO_ME_MASK:
240 * Used to mask off bits from byte 5 of the MAC address
241 * to determine the UNICAST_TO_ME bit for RX frames.
242 * The full mask is complemented by BSS_ID_MASK:
243 * MASK = BSS_ID_MASK & UNICAST_TO_ME_MASK
237 */ 244 */
238#define MAC_CSR3 0x300c 245#define MAC_CSR3 0x300c
239#define MAC_CSR3_BYTE4 FIELD32(0x000000ff) 246#define MAC_CSR3_BYTE4 FIELD32(0x000000ff)
@@ -251,7 +258,14 @@ struct hw_pairwise_ta_entry {
251 258
252/* 259/*
253 * MAC_CSR5: BSSID register 1. 260 * MAC_CSR5: BSSID register 1.
254 * BSS_ID_MASK: 3: one BSSID, 0: 4 BSSID, 2 or 1: 2 BSSID. 261 * BSS_ID_MASK:
262 * This mask is used to mask off bits 0 and 1 of byte 5 of the
263 * BSSID. This will make sure that those bits will be ignored
264 * when determining the MY_BSS of RX frames.
265 * 0: 1-BSSID mode (BSS index = 0)
266 * 1: 2-BSSID mode (BSS index: Byte5, bit 0)
267 * 2: 2-BSSID mode (BSS index: byte5, bit 1)
268 * 3: 4-BSSID mode (BSS index: byte5, bit 0 - 1)
255 */ 269 */
256#define MAC_CSR5 0x3014 270#define MAC_CSR5 0x3014
257#define MAC_CSR5_BYTE4 FIELD32(0x000000ff) 271#define MAC_CSR5_BYTE4 FIELD32(0x000000ff)
diff --git a/drivers/net/wireless/rt2x00/rt73usb.c b/drivers/net/wireless/rt2x00/rt73usb.c
index 8ebf3fed9815..7907fd0d4aa5 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.c
+++ b/drivers/net/wireless/rt2x00/rt73usb.c
@@ -281,74 +281,69 @@ static const struct rt2x00debug rt73usb_rt2x00debug = {
281/* 281/*
282 * Configuration handlers. 282 * Configuration handlers.
283 */ 283 */
284static void rt73usb_config_mac_addr(struct rt2x00_dev *rt2x00dev, __le32 *mac) 284static void rt73usb_config_intf(struct rt2x00_dev *rt2x00dev,
285 struct rt2x00_intf *intf,
286 struct rt2x00intf_conf *conf,
287 const unsigned int flags)
285{ 288{
286 u32 tmp; 289 unsigned int beacon_base;
287 290 u32 reg;
288 tmp = le32_to_cpu(mac[1]);
289 rt2x00_set_field32(&tmp, MAC_CSR3_UNICAST_TO_ME_MASK, 0xff);
290 mac[1] = cpu_to_le32(tmp);
291
292 rt73usb_register_multiwrite(rt2x00dev, MAC_CSR2, mac,
293 (2 * sizeof(__le32)));
294}
295 291
296static void rt73usb_config_bssid(struct rt2x00_dev *rt2x00dev, __le32 *bssid) 292 if (flags & CONFIG_UPDATE_TYPE) {
297{ 293 /*
298 u32 tmp; 294 * Clear current synchronisation setup.
295 * For the Beacon base registers we only need to clear
296 * the first byte since that byte contains the VALID and OWNER
297 * bits which (when set to 0) will invalidate the entire beacon.
298 */
299 beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx);
300 rt73usb_register_write(rt2x00dev, TXRX_CSR9, 0);
301 rt73usb_register_write(rt2x00dev, beacon_base, 0);
299 302
300 tmp = le32_to_cpu(bssid[1]); 303 /*
301 rt2x00_set_field32(&tmp, MAC_CSR5_BSS_ID_MASK, 3); 304 * Enable synchronisation.
302 bssid[1] = cpu_to_le32(tmp); 305 */
306 rt73usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
307 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
308 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE,
309 (conf->sync == TSF_SYNC_BEACON));
310 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
311 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_SYNC, conf->sync);
312 rt73usb_register_write(rt2x00dev, TXRX_CSR9, reg);
313 }
303 314
304 rt73usb_register_multiwrite(rt2x00dev, MAC_CSR4, bssid, 315 if (flags & CONFIG_UPDATE_MAC) {
305 (2 * sizeof(__le32))); 316 reg = le32_to_cpu(conf->mac[1]);
306} 317 rt2x00_set_field32(&reg, MAC_CSR3_UNICAST_TO_ME_MASK, 0xff);
318 conf->mac[1] = cpu_to_le32(reg);
307 319
308static void rt73usb_config_type(struct rt2x00_dev *rt2x00dev, const int type, 320 rt73usb_register_multiwrite(rt2x00dev, MAC_CSR2,
309 const int tsf_sync) 321 conf->mac, sizeof(conf->mac));
310{ 322 }
311 u32 reg;
312 323
313 /* 324 if (flags & CONFIG_UPDATE_BSSID) {
314 * Clear current synchronisation setup. 325 reg = le32_to_cpu(conf->bssid[1]);
315 * For the Beacon base registers we only need to clear 326 rt2x00_set_field32(&reg, MAC_CSR5_BSS_ID_MASK, 3);
316 * the first byte since that byte contains the VALID and OWNER 327 conf->bssid[1] = cpu_to_le32(reg);
317 * bits which (when set to 0) will invalidate the entire beacon.
318 */
319 rt73usb_register_write(rt2x00dev, TXRX_CSR9, 0);
320 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE0, 0);
321 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE1, 0);
322 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE2, 0);
323 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE3, 0);
324 328
325 /* 329 rt73usb_register_multiwrite(rt2x00dev, MAC_CSR4,
326 * Enable synchronisation. 330 conf->bssid, sizeof(conf->bssid));
327 */ 331 }
328 rt73usb_register_read(rt2x00dev, TXRX_CSR9, &reg);
329 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_TICKING, 1);
330 rt2x00_set_field32(&reg, TXRX_CSR9_TBTT_ENABLE,
331 (tsf_sync == TSF_SYNC_BEACON));
332 rt2x00_set_field32(&reg, TXRX_CSR9_BEACON_GEN, 0);
333 rt2x00_set_field32(&reg, TXRX_CSR9_TSF_SYNC, tsf_sync);
334 rt73usb_register_write(rt2x00dev, TXRX_CSR9, reg);
335} 332}
336 333
337static void rt73usb_config_preamble(struct rt2x00_dev *rt2x00dev, 334static int rt73usb_config_preamble(struct rt2x00_dev *rt2x00dev,
338 const int short_preamble, 335 const int short_preamble,
339 const int ack_timeout, 336 const int ack_timeout,
340 const int ack_consume_time) 337 const int ack_consume_time)
341{ 338{
342 u32 reg; 339 u32 reg;
343 340
344 /* 341 /*
345 * When in atomic context, reschedule and let rt2x00lib 342 * When in atomic context, we should let rt2x00lib
346 * call this function again. 343 * try this configuration again later.
347 */ 344 */
348 if (in_atomic()) { 345 if (in_atomic())
349 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->config_work); 346 return -EAGAIN;
350 return;
351 }
352 347
353 rt73usb_register_read(rt2x00dev, TXRX_CSR0, &reg); 348 rt73usb_register_read(rt2x00dev, TXRX_CSR0, &reg);
354 rt2x00_set_field32(&reg, TXRX_CSR0_RX_ACK_TIMEOUT, ack_timeout); 349 rt2x00_set_field32(&reg, TXRX_CSR0_RX_ACK_TIMEOUT, ack_timeout);
@@ -358,6 +353,8 @@ static void rt73usb_config_preamble(struct rt2x00_dev *rt2x00dev,
358 rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE, 353 rt2x00_set_field32(&reg, TXRX_CSR4_AUTORESPOND_PREAMBLE,
359 !!short_preamble); 354 !!short_preamble);
360 rt73usb_register_write(rt2x00dev, TXRX_CSR4, reg); 355 rt73usb_register_write(rt2x00dev, TXRX_CSR4, reg);
356
357 return 0;
361} 358}
362 359
363static void rt73usb_config_phymode(struct rt2x00_dev *rt2x00dev, 360static void rt73usb_config_phymode(struct rt2x00_dev *rt2x00dev,
@@ -617,8 +614,8 @@ static void rt73usb_config_duration(struct rt2x00_dev *rt2x00dev,
617} 614}
618 615
619static void rt73usb_config(struct rt2x00_dev *rt2x00dev, 616static void rt73usb_config(struct rt2x00_dev *rt2x00dev,
620 const unsigned int flags, 617 struct rt2x00lib_conf *libconf,
621 struct rt2x00lib_conf *libconf) 618 const unsigned int flags)
622{ 619{
623 if (flags & CONFIG_UPDATE_PHYMODE) 620 if (flags & CONFIG_UPDATE_PHYMODE)
624 rt73usb_config_phymode(rt2x00dev, libconf->basic_rates); 621 rt73usb_config_phymode(rt2x00dev, libconf->basic_rates);
@@ -766,6 +763,13 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev)
766 } 763 }
767 764
768 /* 765 /*
766 * If we are not associated, we should go straight to the
767 * dynamic CCA tuning.
768 */
769 if (!rt2x00dev->intf_associated)
770 goto dynamic_cca_tune;
771
772 /*
769 * Special big-R17 for very short distance 773 * Special big-R17 for very short distance
770 */ 774 */
771 if (rssi > -35) { 775 if (rssi > -35) {
@@ -815,6 +819,8 @@ static void rt73usb_link_tuner(struct rt2x00_dev *rt2x00dev)
815 return; 819 return;
816 } 820 }
817 821
822dynamic_cca_tune:
823
818 /* 824 /*
819 * r17 does not yet exceed upper limit, continue and base 825 * r17 does not yet exceed upper limit, continue and base
820 * the r17 tuning on the false CCA count. 826 * the r17 tuning on the false CCA count.
@@ -1021,6 +1027,17 @@ static int rt73usb_init_registers(struct rt2x00_dev *rt2x00dev)
1021 rt73usb_register_write(rt2x00dev, MAC_CSR9, reg); 1027 rt73usb_register_write(rt2x00dev, MAC_CSR9, reg);
1022 1028
1023 /* 1029 /*
1030 * Clear all beacons
1031 * For the Beacon base registers we only need to clear
1032 * the first byte since that byte contains the VALID and OWNER
1033 * bits which (when set to 0) will invalidate the entire beacon.
1034 */
1035 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE0, 0);
1036 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE1, 0);
1037 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE2, 0);
1038 rt73usb_register_write(rt2x00dev, HW_BEACON_BASE3, 0);
1039
1040 /*
1024 * We must clear the error counters. 1041 * We must clear the error counters.
1025 * These registers are cleared on read, 1042 * These registers are cleared on read,
1026 * so we may pass a useless variable to store the value. 1043 * so we may pass a useless variable to store the value.
@@ -1985,52 +2002,52 @@ static void rt73usb_reset_tsf(struct ieee80211_hw *hw)
1985} 2002}
1986 2003
1987static int rt73usb_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb, 2004static int rt73usb_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb,
1988 struct ieee80211_tx_control *control) 2005 struct ieee80211_tx_control *control)
1989{ 2006{
1990 struct rt2x00_dev *rt2x00dev = hw->priv; 2007 struct rt2x00_dev *rt2x00dev = hw->priv;
2008 struct rt2x00_intf *intf = vif_to_intf(control->vif);
1991 struct skb_frame_desc *skbdesc; 2009 struct skb_frame_desc *skbdesc;
1992 struct data_queue *queue; 2010 unsigned int beacon_base;
1993 struct queue_entry *entry; 2011 unsigned int timeout;
1994 int timeout;
1995 2012
1996 /* 2013 if (unlikely(!intf->beacon))
1997 * Just in case the ieee80211 doesn't set this, 2014 return -ENOBUFS;
1998 * but we need this queue set for the descriptor
1999 * initialization.
2000 */
2001 control->queue = IEEE80211_TX_QUEUE_BEACON;
2002 queue = rt2x00queue_get_queue(rt2x00dev, control->queue);
2003 entry = rt2x00queue_get_entry(queue, Q_INDEX);
2004 2015
2005 /* 2016 /*
2006 * Add the descriptor in front of the skb. 2017 * Add the descriptor in front of the skb.
2007 */ 2018 */
2008 skb_push(skb, queue->desc_size); 2019 skb_push(skb, intf->beacon->queue->desc_size);
2009 memset(skb->data, 0, queue->desc_size); 2020 memset(skb->data, 0, intf->beacon->queue->desc_size);
2010 2021
2011 /* 2022 /*
2012 * Fill in skb descriptor 2023 * Fill in skb descriptor
2013 */ 2024 */
2014 skbdesc = get_skb_frame_desc(skb); 2025 skbdesc = get_skb_frame_desc(skb);
2015 memset(skbdesc, 0, sizeof(*skbdesc)); 2026 memset(skbdesc, 0, sizeof(*skbdesc));
2016 skbdesc->data = skb->data + queue->desc_size; 2027 skbdesc->data = skb->data + intf->beacon->queue->desc_size;
2017 skbdesc->data_len = queue->data_size; 2028 skbdesc->data_len = skb->len - intf->beacon->queue->desc_size;
2018 skbdesc->desc = skb->data; 2029 skbdesc->desc = skb->data;
2019 skbdesc->desc_len = queue->desc_size; 2030 skbdesc->desc_len = intf->beacon->queue->desc_size;
2020 skbdesc->entry = entry; 2031 skbdesc->entry = intf->beacon;
2021 2032
2033 /*
2034 * Just in case the ieee80211 doesn't set this,
2035 * but we need this queue set for the descriptor
2036 * initialization.
2037 */
2038 control->queue = IEEE80211_TX_QUEUE_BEACON;
2022 rt2x00lib_write_tx_desc(rt2x00dev, skb, control); 2039 rt2x00lib_write_tx_desc(rt2x00dev, skb, control);
2023 2040
2024 /* 2041 /*
2025 * Write entire beacon with descriptor to register, 2042 * Write entire beacon with descriptor to register,
2026 * and kick the beacon generator. 2043 * and kick the beacon generator.
2027 */ 2044 */
2045 beacon_base = HW_BEACON_OFFSET(intf->beacon->entry_idx);
2028 timeout = REGISTER_TIMEOUT * (skb->len / sizeof(u32)); 2046 timeout = REGISTER_TIMEOUT * (skb->len / sizeof(u32));
2029 rt2x00usb_vendor_request(rt2x00dev, USB_MULTI_WRITE, 2047 rt2x00usb_vendor_request(rt2x00dev, USB_MULTI_WRITE,
2030 USB_VENDOR_REQUEST_OUT, 2048 USB_VENDOR_REQUEST_OUT, beacon_base, 0,
2031 HW_BEACON_BASE0, 0x0000,
2032 skb->data, skb->len, timeout); 2049 skb->data, skb->len, timeout);
2033 rt73usb_kick_tx_queue(rt2x00dev, IEEE80211_TX_QUEUE_BEACON); 2050 rt73usb_kick_tx_queue(rt2x00dev, control->queue);
2034 2051
2035 return 0; 2052 return 0;
2036} 2053}
@@ -2071,9 +2088,7 @@ static const struct rt2x00lib_ops rt73usb_rt2x00_ops = {
2071 .get_tx_data_len = rt73usb_get_tx_data_len, 2088 .get_tx_data_len = rt73usb_get_tx_data_len,
2072 .kick_tx_queue = rt73usb_kick_tx_queue, 2089 .kick_tx_queue = rt73usb_kick_tx_queue,
2073 .fill_rxdone = rt73usb_fill_rxdone, 2090 .fill_rxdone = rt73usb_fill_rxdone,
2074 .config_mac_addr = rt73usb_config_mac_addr, 2091 .config_intf = rt73usb_config_intf,
2075 .config_bssid = rt73usb_config_bssid,
2076 .config_type = rt73usb_config_type,
2077 .config_preamble = rt73usb_config_preamble, 2092 .config_preamble = rt73usb_config_preamble,
2078 .config = rt73usb_config, 2093 .config = rt73usb_config,
2079}; 2094};
@@ -2093,7 +2108,7 @@ static const struct data_queue_desc rt73usb_queue_tx = {
2093}; 2108};
2094 2109
2095static const struct data_queue_desc rt73usb_queue_bcn = { 2110static const struct data_queue_desc rt73usb_queue_bcn = {
2096 .entry_num = BEACON_ENTRIES, 2111 .entry_num = 4 * BEACON_ENTRIES,
2097 .data_size = MGMT_FRAME_SIZE, 2112 .data_size = MGMT_FRAME_SIZE,
2098 .desc_size = TXINFO_SIZE, 2113 .desc_size = TXINFO_SIZE,
2099 .priv_size = sizeof(struct queue_entry_priv_usb_tx), 2114 .priv_size = sizeof(struct queue_entry_priv_usb_tx),
@@ -2101,6 +2116,8 @@ static const struct data_queue_desc rt73usb_queue_bcn = {
2101 2116
2102static const struct rt2x00_ops rt73usb_ops = { 2117static const struct rt2x00_ops rt73usb_ops = {
2103 .name = KBUILD_MODNAME, 2118 .name = KBUILD_MODNAME,
2119 .max_sta_intf = 1,
2120 .max_ap_intf = 4,
2104 .eeprom_size = EEPROM_SIZE, 2121 .eeprom_size = EEPROM_SIZE,
2105 .rf_size = RF_SIZE, 2122 .rf_size = RF_SIZE,
2106 .rx = &rt73usb_queue_rx, 2123 .rx = &rt73usb_queue_rx,
diff --git a/drivers/net/wireless/rt2x00/rt73usb.h b/drivers/net/wireless/rt2x00/rt73usb.h
index da62b4f091a7..3f9675655eb9 100644
--- a/drivers/net/wireless/rt2x00/rt73usb.h
+++ b/drivers/net/wireless/rt2x00/rt73usb.h
@@ -114,6 +114,9 @@ struct hw_pairwise_ta_entry {
114#define HW_BEACON_BASE2 0x2600 114#define HW_BEACON_BASE2 0x2600
115#define HW_BEACON_BASE3 0x2700 115#define HW_BEACON_BASE3 0x2700
116 116
117#define HW_BEACON_OFFSET(__index) \
118 ( HW_BEACON_BASE0 + (__index * 0x0100) )
119
117/* 120/*
118 * MAC Control/Status Registers(CSR). 121 * MAC Control/Status Registers(CSR).
119 * Some values are set in TU, whereas 1 TU == 1024 us. 122 * Some values are set in TU, whereas 1 TU == 1024 us.
@@ -146,6 +149,11 @@ struct hw_pairwise_ta_entry {
146 149
147/* 150/*
148 * MAC_CSR3: STA MAC register 1. 151 * MAC_CSR3: STA MAC register 1.
152 * UNICAST_TO_ME_MASK:
153 * Used to mask off bits from byte 5 of the MAC address
154 * to determine the UNICAST_TO_ME bit for RX frames.
155 * The full mask is complemented by BSS_ID_MASK:
156 * MASK = BSS_ID_MASK & UNICAST_TO_ME_MASK
149 */ 157 */
150#define MAC_CSR3 0x300c 158#define MAC_CSR3 0x300c
151#define MAC_CSR3_BYTE4 FIELD32(0x000000ff) 159#define MAC_CSR3_BYTE4 FIELD32(0x000000ff)
@@ -163,7 +171,14 @@ struct hw_pairwise_ta_entry {
163 171
164/* 172/*
165 * MAC_CSR5: BSSID register 1. 173 * MAC_CSR5: BSSID register 1.
166 * BSS_ID_MASK: 3: one BSSID, 0: 4 BSSID, 2 or 1: 2 BSSID. 174 * BSS_ID_MASK:
175 * This mask is used to mask off bits 0 and 1 of byte 5 of the
176 * BSSID. This will make sure that those bits will be ignored
177 * when determining the MY_BSS of RX frames.
178 * 0: 1-BSSID mode (BSS index = 0)
179 * 1: 2-BSSID mode (BSS index: Byte5, bit 0)
180 * 2: 2-BSSID mode (BSS index: byte5, bit 1)
181 * 3: 4-BSSID mode (BSS index: byte5, bit 0 - 1)
167 */ 182 */
168#define MAC_CSR5 0x3014 183#define MAC_CSR5 0x3014
169#define MAC_CSR5_BYTE4 FIELD32(0x000000ff) 184#define MAC_CSR5_BYTE4 FIELD32(0x000000ff)
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-27 05:20:43 -0500