main.c 36.3 KB
Newer Older
1 2 3 4 5 6
/**
  * This file contains the major functions in WLAN
  * driver. It includes init, exit, open, close and main
  * thread etc..
  */

7
#include <linux/moduleparam.h>
8 9 10 11 12
#include <linux/delay.h>
#include <linux/freezer.h>
#include <linux/etherdevice.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
13
#include <linux/kthread.h>
14 15

#include <net/iw_handler.h>
16
#include <net/ieee80211.h>
17 18 19 20 21 22 23 24

#include "host.h"
#include "decl.h"
#include "dev.h"
#include "wext.h"
#include "debugfs.h"
#include "assoc.h"

25
#define DRIVER_RELEASE_VERSION "322.p1"
26 27 28 29 30 31
const char libertas_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
#ifdef  DEBUG
    "-dbg"
#endif
    "";

32 33 34 35

/* Module parameters */
unsigned int libertas_debug = 0;
module_param(libertas_debug, int, 0644);
36
EXPORT_SYMBOL_GPL(libertas_debug);
37 38


39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
#define WLAN_TX_PWR_DEFAULT		20	/*100mW */
#define WLAN_TX_PWR_US_DEFAULT		20	/*100mW */
#define WLAN_TX_PWR_JP_DEFAULT		16	/*50mW */
#define WLAN_TX_PWR_FR_DEFAULT		20	/*100mW */
#define WLAN_TX_PWR_EMEA_DEFAULT	20	/*100mW */

/* Format { channel, frequency (MHz), maxtxpower } */
/* band: 'B/G', region: USA FCC/Canada IC */
static struct chan_freq_power channel_freq_power_US_BG[] = {
	{1, 2412, WLAN_TX_PWR_US_DEFAULT},
	{2, 2417, WLAN_TX_PWR_US_DEFAULT},
	{3, 2422, WLAN_TX_PWR_US_DEFAULT},
	{4, 2427, WLAN_TX_PWR_US_DEFAULT},
	{5, 2432, WLAN_TX_PWR_US_DEFAULT},
	{6, 2437, WLAN_TX_PWR_US_DEFAULT},
	{7, 2442, WLAN_TX_PWR_US_DEFAULT},
	{8, 2447, WLAN_TX_PWR_US_DEFAULT},
	{9, 2452, WLAN_TX_PWR_US_DEFAULT},
	{10, 2457, WLAN_TX_PWR_US_DEFAULT},
	{11, 2462, WLAN_TX_PWR_US_DEFAULT}
};

/* band: 'B/G', region: Europe ETSI */
static struct chan_freq_power channel_freq_power_EU_BG[] = {
	{1, 2412, WLAN_TX_PWR_EMEA_DEFAULT},
	{2, 2417, WLAN_TX_PWR_EMEA_DEFAULT},
	{3, 2422, WLAN_TX_PWR_EMEA_DEFAULT},
	{4, 2427, WLAN_TX_PWR_EMEA_DEFAULT},
	{5, 2432, WLAN_TX_PWR_EMEA_DEFAULT},
	{6, 2437, WLAN_TX_PWR_EMEA_DEFAULT},
	{7, 2442, WLAN_TX_PWR_EMEA_DEFAULT},
	{8, 2447, WLAN_TX_PWR_EMEA_DEFAULT},
	{9, 2452, WLAN_TX_PWR_EMEA_DEFAULT},
	{10, 2457, WLAN_TX_PWR_EMEA_DEFAULT},
	{11, 2462, WLAN_TX_PWR_EMEA_DEFAULT},
	{12, 2467, WLAN_TX_PWR_EMEA_DEFAULT},
	{13, 2472, WLAN_TX_PWR_EMEA_DEFAULT}
};

/* band: 'B/G', region: Spain */
static struct chan_freq_power channel_freq_power_SPN_BG[] = {
	{10, 2457, WLAN_TX_PWR_DEFAULT},
	{11, 2462, WLAN_TX_PWR_DEFAULT}
};

/* band: 'B/G', region: France */
static struct chan_freq_power channel_freq_power_FR_BG[] = {
	{10, 2457, WLAN_TX_PWR_FR_DEFAULT},
	{11, 2462, WLAN_TX_PWR_FR_DEFAULT},
	{12, 2467, WLAN_TX_PWR_FR_DEFAULT},
	{13, 2472, WLAN_TX_PWR_FR_DEFAULT}
};

/* band: 'B/G', region: Japan */
static struct chan_freq_power channel_freq_power_JPN_BG[] = {
	{1, 2412, WLAN_TX_PWR_JP_DEFAULT},
	{2, 2417, WLAN_TX_PWR_JP_DEFAULT},
	{3, 2422, WLAN_TX_PWR_JP_DEFAULT},
	{4, 2427, WLAN_TX_PWR_JP_DEFAULT},
	{5, 2432, WLAN_TX_PWR_JP_DEFAULT},
	{6, 2437, WLAN_TX_PWR_JP_DEFAULT},
	{7, 2442, WLAN_TX_PWR_JP_DEFAULT},
	{8, 2447, WLAN_TX_PWR_JP_DEFAULT},
	{9, 2452, WLAN_TX_PWR_JP_DEFAULT},
	{10, 2457, WLAN_TX_PWR_JP_DEFAULT},
	{11, 2462, WLAN_TX_PWR_JP_DEFAULT},
	{12, 2467, WLAN_TX_PWR_JP_DEFAULT},
	{13, 2472, WLAN_TX_PWR_JP_DEFAULT},
	{14, 2484, WLAN_TX_PWR_JP_DEFAULT}
};

/**
 * the structure for channel, frequency and power
 */
struct region_cfp_table {
	u8 region;
	struct chan_freq_power *cfp_BG;
	int cfp_no_BG;
};

/**
 * the structure for the mapping between region and CFP
 */
static struct region_cfp_table region_cfp_table[] = {
	{0x10,			/*US FCC */
	 channel_freq_power_US_BG,
	 sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power),
	 }
	,
	{0x20,			/*CANADA IC */
	 channel_freq_power_US_BG,
	 sizeof(channel_freq_power_US_BG) / sizeof(struct chan_freq_power),
	 }
	,
	{0x30, /*EU*/ channel_freq_power_EU_BG,
	 sizeof(channel_freq_power_EU_BG) / sizeof(struct chan_freq_power),
	 }
	,
	{0x31, /*SPAIN*/ channel_freq_power_SPN_BG,
	 sizeof(channel_freq_power_SPN_BG) / sizeof(struct chan_freq_power),
	 }
	,
	{0x32, /*FRANCE*/ channel_freq_power_FR_BG,
	 sizeof(channel_freq_power_FR_BG) / sizeof(struct chan_freq_power),
	 }
	,
	{0x40, /*JAPAN*/ channel_freq_power_JPN_BG,
	 sizeof(channel_freq_power_JPN_BG) / sizeof(struct chan_freq_power),
	 }
	,
/*Add new region here */
};

/**
153
 * the table to keep region code
154
 */
155 156
u16 libertas_region_code_to_index[MRVDRV_MAX_REGION_CODE] =
    { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 };
157 158

/**
159
 * 802.11b/g supported bitrates (in 500Kb/s units)
160
 */
161 162 163
u8 libertas_bg_rates[MAX_RATES] =
    { 0x02, 0x04, 0x0b, 0x16, 0x0c, 0x12, 0x18, 0x24, 0x30, 0x48, 0x60, 0x6c,
0x00, 0x00 };
164 165

/**
166 167 168
 * FW rate table.  FW refers to rates by their index in this table, not by the
 * rate value itself.  Values of 0x00 are
 * reserved positions.
169
 */
170 171 172 173
static u8 fw_data_rates[MAX_RATES] =
    { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12,
      0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00
};
174 175

/**
176 177 178 179
 *  @brief use index to get the data rate
 *
 *  @param idx                The index of data rate
 *  @return 	   		data rate or 0
180
 */
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
u32 libertas_fw_index_to_data_rate(u8 idx)
{
	if (idx >= sizeof(fw_data_rates))
		idx = 0;
	return fw_data_rates[idx];
}

/**
 *  @brief use rate to get the index
 *
 *  @param rate                 data rate
 *  @return 	   		index or 0
 */
u8 libertas_data_rate_to_fw_index(u32 rate)
{
	u8 i;

	if (!rate)
		return 0;

	for (i = 0; i < sizeof(fw_data_rates); i++) {
		if (rate == fw_data_rates[i])
			return i;
	}
	return 0;
}
207 208 209 210 211 212

/**
 * Attributes exported through sysfs
 */

/**
213
 * @brief Get function for sysfs attribute anycast_mask
214
 */
215
static ssize_t libertas_anycast_get(struct device * dev,
D
Dan Williams 已提交
216 217
		struct device_attribute *attr, char * buf)
{
218 219 220 221
	struct cmd_ds_mesh_access mesh_access;

	memset(&mesh_access, 0, sizeof(mesh_access));
	libertas_prepare_and_send_command(to_net_dev(dev)->priv,
222 223 224
			CMD_MESH_ACCESS,
			CMD_ACT_MESH_GET_ANYCAST,
			CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
225

226
	return snprintf(buf, 12, "0x%X\n", le32_to_cpu(mesh_access.data[0]));
227 228 229
}

/**
230
 * @brief Set function for sysfs attribute anycast_mask
231
 */
232
static ssize_t libertas_anycast_set(struct device * dev,
D
Dan Williams 已提交
233 234
		struct device_attribute *attr, const char * buf, size_t count)
{
235
	struct cmd_ds_mesh_access mesh_access;
236
	uint32_t datum;
237 238

	memset(&mesh_access, 0, sizeof(mesh_access));
239
	sscanf(buf, "%x", &datum);
240 241
	mesh_access.data[0] = cpu_to_le32(datum);

242
	libertas_prepare_and_send_command((to_net_dev(dev))->priv,
243 244 245
			CMD_MESH_ACCESS,
			CMD_ACT_MESH_SET_ANYCAST,
			CMD_OPTION_WAITFORRSP, 0, (void *)&mesh_access);
246 247 248 249
	return strlen(buf);
}

/**
250 251
 * anycast_mask attribute to be exported per mshX interface
 * through sysfs (/sys/class/net/mshX/anycast_mask)
252
 */
253
static DEVICE_ATTR(anycast_mask, 0644, libertas_anycast_get, libertas_anycast_set);
254 255 256 257 258 259 260 261 262 263 264 265

/**
 *  @brief Check if the device can be open and wait if necessary.
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 *
 * For USB adapter, on some systems the device open handler will be
 * called before FW ready. Use the following flag check and wait
 * function to work around the issue.
 *
 */
266 267
static int pre_open_check(struct net_device *dev)
{
268 269 270 271 272 273 274 275 276
	wlan_private *priv = (wlan_private *) dev->priv;
	wlan_adapter *adapter = priv->adapter;
	int i = 0;

	while (!adapter->fw_ready && i < 20) {
		i++;
		msleep_interruptible(100);
	}
	if (!adapter->fw_ready) {
277
		lbs_pr_err("firmware not ready\n");
278 279 280 281 282 283 284 285 286 287 288 289
		return -1;
	}

	return 0;
}

/**
 *  @brief This function opens the device
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
290
static int libertas_dev_open(struct net_device *dev)
291 292 293 294
{
	wlan_private *priv = (wlan_private *) dev->priv;
	wlan_adapter *adapter = priv->adapter;

295
	lbs_deb_enter(LBS_DEB_NET);
296 297 298

	priv->open = 1;

299
	if (adapter->connect_status == LIBERTAS_CONNECTED) {
300
		netif_carrier_on(priv->dev);
301 302
		netif_carrier_on(priv->mesh_dev);
	} else {
303
		netif_carrier_off(priv->dev);
304 305
		netif_carrier_off(priv->mesh_dev);
	}
306

307
	lbs_deb_leave(LBS_DEB_NET);
308 309 310 311 312 313 314 315
	return 0;
}
/**
 *  @brief This function opens the mshX interface
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
316
static int libertas_mesh_open(struct net_device *dev)
317 318 319
{
	wlan_private *priv = (wlan_private *) dev->priv ;

320
	if (pre_open_check(dev) == -1)
321 322
		return -1;
	priv->mesh_open = 1 ;
323
	netif_wake_queue(priv->mesh_dev);
324
	if (priv->infra_open == 0)
325
		return libertas_dev_open(priv->dev) ;
326 327 328 329 330 331 332 333 334
	return 0;
}

/**
 *  @brief This function opens the ethX interface
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
335
static int libertas_open(struct net_device *dev)
336 337 338 339 340 341
{
	wlan_private *priv = (wlan_private *) dev->priv ;

	if(pre_open_check(dev) == -1)
		return -1;
	priv->infra_open = 1 ;
342
	netif_wake_queue(priv->dev);
343
	if (priv->open == 0)
344
		return libertas_dev_open(priv->dev) ;
345 346 347
	return 0;
}

348
static int libertas_dev_close(struct net_device *dev)
349 350 351
{
	wlan_private *priv = dev->priv;

352
	lbs_deb_enter(LBS_DEB_NET);
353

354
	netif_carrier_off(priv->dev);
355 356
	priv->open = 0;

357
	lbs_deb_leave(LBS_DEB_NET);
358 359 360 361 362 363 364 365 366
	return 0;
}

/**
 *  @brief This function closes the mshX interface
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
367
static int libertas_mesh_close(struct net_device *dev)
368 369 370 371 372 373
{
	wlan_private *priv = (wlan_private *) (dev->priv);

	priv->mesh_open = 0;
	netif_stop_queue(priv->mesh_dev);
	if (priv->infra_open == 0)
374
		return libertas_dev_close(dev);
375 376 377 378 379 380 381 382 383 384
	else
		return 0;
}

/**
 *  @brief This function closes the ethX interface
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
385
static int libertas_close(struct net_device *dev)
386
{
387 388
	wlan_private *priv = (wlan_private *) dev->priv;

389
	netif_stop_queue(dev);
390 391
	priv->infra_open = 0;
	if (priv->mesh_open == 0)
392
		return libertas_dev_close(dev);
393 394 395 396 397
	else
		return 0;
}


398
static int libertas_hard_start_xmit(struct sk_buff *skb, struct net_device *dev)
399 400 401 402
{
	int ret = 0;
	wlan_private *priv = dev->priv;

403
	lbs_deb_enter(LBS_DEB_NET);
404

405
	if (priv->dnld_sent || priv->adapter->TxLockFlag) {
406 407 408 409
		priv->stats.tx_dropped++;
		goto done;
	}

410
	netif_stop_queue(priv->dev);
411
	netif_stop_queue(priv->mesh_dev);
412 413 414 415

	if (libertas_process_tx(priv, skb) == 0)
		dev->trans_start = jiffies;
done:
416
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
417 418 419 420
	return ret;
}

/**
421
 * @brief Mark mesh packets and handover them to libertas_hard_start_xmit
422 423
 *
 */
424 425
static int libertas_mesh_pre_start_xmit(struct sk_buff *skb,
		struct net_device *dev)
426 427
{
	wlan_private *priv = dev->priv;
428 429 430 431
	int ret;

	lbs_deb_enter(LBS_DEB_MESH);

432 433
	SET_MESH_FRAME(skb);

434
	ret = libertas_hard_start_xmit(skb, priv->dev);
435 436
	lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
	return ret;
437 438 439
}

/**
440
 * @brief Mark non-mesh packets and handover them to libertas_hard_start_xmit
441 442
 *
 */
443
static int libertas_pre_start_xmit(struct sk_buff *skb, struct net_device *dev)
444 445 446 447 448
{
	int ret;

	lbs_deb_enter(LBS_DEB_NET);

449
	UNSET_MESH_FRAME(skb);
450

451
	ret = libertas_hard_start_xmit(skb, dev);
452 453
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
	return ret;
454 455
}

456
static void libertas_tx_timeout(struct net_device *dev)
457 458 459
{
	wlan_private *priv = (wlan_private *) dev->priv;

460
	lbs_deb_enter(LBS_DEB_TX);
461

462
	lbs_pr_err("tx watch dog timeout\n");
463

464
	priv->dnld_sent = DNLD_RES_RECEIVED;
465 466 467 468 469 470 471 472 473
	dev->trans_start = jiffies;

	if (priv->adapter->currenttxskb) {
		if (priv->adapter->radiomode == WLAN_RADIOMODE_RADIOTAP) {
			/* If we are here, we have not received feedback from
			   the previous packet.  Assume TX_FAIL and move on. */
			priv->adapter->eventcause = 0x01000000;
			libertas_send_tx_feedback(priv);
		} else
474
			wake_up_interruptible(&priv->waitq);
475
	} else if (priv->adapter->connect_status == LIBERTAS_CONNECTED) {
476
		netif_wake_queue(priv->dev);
477 478
		netif_wake_queue(priv->mesh_dev);
	}
479

480
	lbs_deb_leave(LBS_DEB_TX);
481 482 483 484 485 486 487 488
}

/**
 *  @brief This function returns the network statistics
 *
 *  @param dev     A pointer to wlan_private structure
 *  @return 	   A pointer to net_device_stats structure
 */
489
static struct net_device_stats *libertas_get_stats(struct net_device *dev)
490 491 492 493 494 495
{
	wlan_private *priv = (wlan_private *) dev->priv;

	return &priv->stats;
}

496
static int libertas_set_mac_address(struct net_device *dev, void *addr)
497 498 499 500 501 502
{
	int ret = 0;
	wlan_private *priv = (wlan_private *) dev->priv;
	wlan_adapter *adapter = priv->adapter;
	struct sockaddr *phwaddr = addr;

503
	lbs_deb_enter(LBS_DEB_NET);
504

505 506 507
	/* In case it was called from the mesh device */
	dev = priv->dev ;

508 509 510 511 512 513 514 515
	memset(adapter->current_addr, 0, ETH_ALEN);

	/* dev->dev_addr is 8 bytes */
	lbs_dbg_hex("dev->dev_addr:", dev->dev_addr, ETH_ALEN);

	lbs_dbg_hex("addr:", phwaddr->sa_data, ETH_ALEN);
	memcpy(adapter->current_addr, phwaddr->sa_data, ETH_ALEN);

516 517 518
	ret = libertas_prepare_and_send_command(priv, CMD_802_11_MAC_ADDRESS,
				    CMD_ACT_SET,
				    CMD_OPTION_WAITFORRSP, 0, NULL);
519 520

	if (ret) {
521
		lbs_deb_net("set MAC address failed\n");
522 523 524 525 526 527
		ret = -1;
		goto done;
	}

	lbs_dbg_hex("adapter->macaddr:", adapter->current_addr, ETH_ALEN);
	memcpy(dev->dev_addr, adapter->current_addr, ETH_ALEN);
528 529
	if (priv->mesh_dev)
		memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN);
530 531

done:
532
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
533 534 535
	return ret;
}

536
static int libertas_copy_multicast_address(wlan_adapter * adapter,
537 538 539 540 541 542 543 544 545 546 547 548 549 550
				     struct net_device *dev)
{
	int i = 0;
	struct dev_mc_list *mcptr = dev->mc_list;

	for (i = 0; i < dev->mc_count; i++) {
		memcpy(&adapter->multicastlist[i], mcptr->dmi_addr, ETH_ALEN);
		mcptr = mcptr->next;
	}

	return i;

}

551
static void libertas_set_multicast_list(struct net_device *dev)
552 553 554 555 556
{
	wlan_private *priv = dev->priv;
	wlan_adapter *adapter = priv->adapter;
	int oldpacketfilter;

557
	lbs_deb_enter(LBS_DEB_NET);
558 559 560 561

	oldpacketfilter = adapter->currentpacketfilter;

	if (dev->flags & IFF_PROMISC) {
562
		lbs_deb_net("enable promiscuous mode\n");
563
		adapter->currentpacketfilter |=
564
		    CMD_ACT_MAC_PROMISCUOUS_ENABLE;
565
		adapter->currentpacketfilter &=
566 567
		    ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
		      CMD_ACT_MAC_MULTICAST_ENABLE);
568 569 570
	} else {
		/* Multicast */
		adapter->currentpacketfilter &=
571
		    ~CMD_ACT_MAC_PROMISCUOUS_ENABLE;
572 573 574

		if (dev->flags & IFF_ALLMULTI || dev->mc_count >
		    MRVDRV_MAX_MULTICAST_LIST_SIZE) {
575
			lbs_deb_net( "enabling all multicast\n");
576
			adapter->currentpacketfilter |=
577
			    CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
578
			adapter->currentpacketfilter &=
579
			    ~CMD_ACT_MAC_MULTICAST_ENABLE;
580 581
		} else {
			adapter->currentpacketfilter &=
582
			    ~CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
583 584

			if (!dev->mc_count) {
585 586
				lbs_deb_net("no multicast addresses, "
				       "disabling multicast\n");
587
				adapter->currentpacketfilter &=
588
				    ~CMD_ACT_MAC_MULTICAST_ENABLE;
589 590 591 592
			} else {
				int i;

				adapter->currentpacketfilter |=
593
				    CMD_ACT_MAC_MULTICAST_ENABLE;
594 595

				adapter->nr_of_multicastmacaddr =
596
				    libertas_copy_multicast_address(adapter, dev);
597

598
				lbs_deb_net("multicast addresses: %d\n",
599 600 601
				       dev->mc_count);

				for (i = 0; i < dev->mc_count; i++) {
602 603
					lbs_deb_net("Multicast address %d:"
					       MAC_FMT "\n", i,
604 605 606 607 608 609 610
					       adapter->multicastlist[i][0],
					       adapter->multicastlist[i][1],
					       adapter->multicastlist[i][2],
					       adapter->multicastlist[i][3],
					       adapter->multicastlist[i][4],
					       adapter->multicastlist[i][5]);
				}
611
				/* send multicast addresses to firmware */
612
				libertas_prepare_and_send_command(priv,
613 614
						      CMD_MAC_MULTICAST_ADR,
						      CMD_ACT_SET, 0, 0,
615 616 617 618 619 620 621 622 623
						      NULL);
			}
		}
	}

	if (adapter->currentpacketfilter != oldpacketfilter) {
		libertas_set_mac_packet_filter(priv);
	}

624
	lbs_deb_leave(LBS_DEB_NET);
625 626 627
}

/**
628 629 630
 *  @brief This function handles the major jobs in the WLAN driver.
 *  It handles all events generated by firmware, RX data received
 *  from firmware and TX data sent from kernel.
631 632 633 634
 *
 *  @param data    A pointer to wlan_thread structure
 *  @return 	   0
 */
635
static int libertas_thread(void *data)
636
{
637 638
	struct net_device *dev = data;
	wlan_private *priv = dev->priv;
639 640 641 642
	wlan_adapter *adapter = priv->adapter;
	wait_queue_t wait;
	u8 ireg = 0;

643
	lbs_deb_enter(LBS_DEB_THREAD);
644 645 646 647

	init_waitqueue_entry(&wait, current);

	for (;;) {
648
		lbs_deb_thread( "main-thread 111: intcounter=%d "
649 650
		       "currenttxskb=%p dnld_sent=%d\n",
		       adapter->intcounter,
651
		       adapter->currenttxskb, priv->dnld_sent);
652

653
		add_wait_queue(&priv->waitq, &wait);
654 655 656 657
		set_current_state(TASK_INTERRUPTIBLE);
		spin_lock_irq(&adapter->driver_lock);
		if ((adapter->psstate == PS_STATE_SLEEP) ||
		    (!adapter->intcounter
658
		     && (priv->dnld_sent || adapter->cur_cmd ||
659
			 list_empty(&adapter->cmdpendingq)))) {
660
			lbs_deb_thread(
661 662 663 664 665 666 667 668 669
			       "main-thread sleeping... Conn=%d IntC=%d PS_mode=%d PS_State=%d\n",
			       adapter->connect_status, adapter->intcounter,
			       adapter->psmode, adapter->psstate);
			spin_unlock_irq(&adapter->driver_lock);
			schedule();
		} else
			spin_unlock_irq(&adapter->driver_lock);


670
		lbs_deb_thread(
671 672
		       "main-thread 222 (waking up): intcounter=%d currenttxskb=%p "
		       "dnld_sent=%d\n", adapter->intcounter,
673
		       adapter->currenttxskb, priv->dnld_sent);
674 675

		set_current_state(TASK_RUNNING);
676
		remove_wait_queue(&priv->waitq, &wait);
677 678
		try_to_freeze();

679
		lbs_deb_thread("main-thread 333: intcounter=%d currenttxskb=%p "
680 681
		       "dnld_sent=%d\n",
		       adapter->intcounter,
682
		       adapter->currenttxskb, priv->dnld_sent);
683 684 685

		if (kthread_should_stop()
		    || adapter->surpriseremoved) {
686
			lbs_deb_thread(
687 688 689 690 691 692 693 694 695 696
			       "main-thread: break from main thread: surpriseremoved=0x%x\n",
			       adapter->surpriseremoved);
			break;
		}


		spin_lock_irq(&adapter->driver_lock);
		if (adapter->intcounter) {
			u8 int_status;
			adapter->intcounter = 0;
697
			int_status = priv->hw_get_int_status(priv, &ireg);
698 699

			if (int_status) {
700
				lbs_deb_thread(
701 702 703 704 705 706 707
				       "main-thread: reading HOST_INT_STATUS_REG failed\n");
				spin_unlock_irq(&adapter->driver_lock);
				continue;
			}
			adapter->hisregcpy |= ireg;
		}

708
		lbs_deb_thread("main-thread 444: intcounter=%d currenttxskb=%p "
709 710
		       "dnld_sent=%d\n",
		       adapter->intcounter,
711
		       adapter->currenttxskb, priv->dnld_sent);
712 713 714

		/* command response? */
		if (adapter->hisregcpy & his_cmdupldrdy) {
715
			lbs_deb_thread("main-thread: cmd response ready\n");
716 717 718 719 720 721 722 723 724

			adapter->hisregcpy &= ~his_cmdupldrdy;
			spin_unlock_irq(&adapter->driver_lock);
			libertas_process_rx_command(priv);
			spin_lock_irq(&adapter->driver_lock);
		}

		/* Any Card Event */
		if (adapter->hisregcpy & his_cardevent) {
725
			lbs_deb_thread("main-thread: Card Event Activity\n");
726 727 728

			adapter->hisregcpy &= ~his_cardevent;

729
			if (priv->hw_read_event_cause(priv)) {
730
				lbs_pr_alert(
731
				       "main-thread: hw_read_event_cause failed\n");
732 733 734 735 736 737 738 739 740 741
				spin_unlock_irq(&adapter->driver_lock);
				continue;
			}
			spin_unlock_irq(&adapter->driver_lock);
			libertas_process_event(priv);
		} else
			spin_unlock_irq(&adapter->driver_lock);

		/* Check if we need to confirm Sleep Request received previously */
		if (adapter->psstate == PS_STATE_PRE_SLEEP) {
742
			if (!priv->dnld_sent && !adapter->cur_cmd) {
743
				if (adapter->connect_status ==
744
				    LIBERTAS_CONNECTED) {
745
					lbs_deb_thread(
746 747 748 749
					       "main_thread: PRE_SLEEP--intcounter=%d currenttxskb=%p "
					       "dnld_sent=%d cur_cmd=%p, confirm now\n",
					       adapter->intcounter,
					       adapter->currenttxskb,
750
					       priv->dnld_sent,
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
					       adapter->cur_cmd);

					libertas_ps_confirm_sleep(priv,
						       (u16) adapter->psmode);
				} else {
					/* workaround for firmware sending
					 * deauth/linkloss event immediately
					 * after sleep request, remove this
					 * after firmware fixes it
					 */
					adapter->psstate = PS_STATE_AWAKE;
					lbs_pr_alert(
					       "main-thread: ignore PS_SleepConfirm in non-connected state\n");
				}
			}
		}

		/* The PS state is changed during processing of Sleep Request
		 * event above
		 */
		if ((priv->adapter->psstate == PS_STATE_SLEEP) ||
		    (priv->adapter->psstate == PS_STATE_PRE_SLEEP))
			continue;

		/* Execute the next command */
776
		if (!priv->dnld_sent && !priv->adapter->cur_cmd)
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
			libertas_execute_next_command(priv);

		/* Wake-up command waiters which can't sleep in
		 * libertas_prepare_and_send_command
		 */
		if (!adapter->nr_cmd_pending)
			wake_up_all(&adapter->cmd_pending);

		libertas_tx_runqueue(priv);
	}

	del_timer(&adapter->command_timer);
	adapter->nr_cmd_pending = 0;
	wake_up_all(&adapter->cmd_pending);

792
	lbs_deb_leave(LBS_DEB_THREAD);
793 794 795
	return 0;
}

H
Holger Schurig 已提交
796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
/**
 *  @brief This function downloads firmware image, gets
 *  HW spec from firmware and set basic parameters to
 *  firmware.
 *
 *  @param priv    A pointer to wlan_private structure
 *  @return 	   0 or -1
 */
static int wlan_setup_station_hw(wlan_private * priv)
{
	int ret = -1;
	wlan_adapter *adapter = priv->adapter;

	lbs_deb_enter(LBS_DEB_FW);

	ret = priv->hw_prog_firmware(priv);

	if (ret) {
		lbs_deb_fw("bootloader in invalid state\n");
		ret = -1;
		goto done;
	}

	/*
	 * Read MAC address from HW
	 */
	memset(adapter->current_addr, 0xff, ETH_ALEN);

	ret = libertas_prepare_and_send_command(priv, CMD_GET_HW_SPEC,
				    0, CMD_OPTION_WAITFORRSP, 0, NULL);

	if (ret) {
		ret = -1;
		goto done;
	}

	libertas_set_mac_packet_filter(priv);

	/* Get the supported Data rates */
	ret = libertas_prepare_and_send_command(priv, CMD_802_11_DATA_RATE,
				    CMD_ACT_GET_TX_RATE,
				    CMD_OPTION_WAITFORRSP, 0, NULL);

	if (ret) {
		ret = -1;
		goto done;
	}

	ret = 0;
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

static void command_timer_fn(unsigned long data);

/**
 *  This function handles the timeout of command sending.
 *  It will re-send the same command again.
 */
static void command_timer_fn(unsigned long data)
{
	wlan_private *priv = (wlan_private *)data;
	wlan_adapter *adapter = priv->adapter;
	struct cmd_ctrl_node *ptempnode;
	struct cmd_ds_command *cmd;
	unsigned long flags;

	ptempnode = adapter->cur_cmd;
	if (ptempnode == NULL) {
		lbs_deb_fw("ptempnode empty\n");
		return;
	}

	cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr;
	if (!cmd) {
		lbs_deb_fw("cmd is NULL\n");
		return;
	}

	lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command);

	if (!adapter->fw_ready)
		return;

	spin_lock_irqsave(&adapter->driver_lock, flags);
	adapter->cur_cmd = NULL;
	spin_unlock_irqrestore(&adapter->driver_lock, flags);

	lbs_deb_fw("re-sending same command because of timeout\n");
	libertas_queue_cmd(adapter, ptempnode, 0);

	wake_up_interruptible(&priv->waitq);

	return;
}

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917
static void libertas_free_adapter(wlan_private * priv)
{
	wlan_adapter *adapter = priv->adapter;

	if (!adapter) {
		lbs_deb_fw("why double free adapter?\n");
		return;
	}

	lbs_deb_fw("free command buffer\n");
	libertas_free_cmd_buffer(priv);

	lbs_deb_fw("free command_timer\n");
	del_timer(&adapter->command_timer);

	lbs_deb_fw("free scan results table\n");
	kfree(adapter->networks);
	adapter->networks = NULL;

	/* Free the adapter object itself */
	lbs_deb_fw("free adapter\n");
	kfree(adapter);
	priv->adapter = NULL;
}

H
Holger Schurig 已提交
918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
static int wlan_allocate_adapter(wlan_private * priv)
{
	size_t bufsize;
	wlan_adapter *adapter = priv->adapter;

	/* Allocate buffer to store the BSSID list */
	bufsize = MAX_NETWORK_COUNT * sizeof(struct bss_descriptor);
	adapter->networks = kzalloc(bufsize, GFP_KERNEL);
	if (!adapter->networks) {
		lbs_pr_err("Out of memory allocating beacons\n");
		libertas_free_adapter(priv);
		return -ENOMEM;
	}

	/* Allocate the command buffers */
	libertas_allocate_cmd_buffer(priv);

	memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
	adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
	adapter->libertas_ps_confirm_sleep.command =
	    cpu_to_le16(CMD_802_11_PS_MODE);
	adapter->libertas_ps_confirm_sleep.size =
	    cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
	adapter->libertas_ps_confirm_sleep.result = 0;
	adapter->libertas_ps_confirm_sleep.action =
	    cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);

	return 0;
}

static void wlan_init_adapter(wlan_private * priv)
{
	wlan_adapter *adapter = priv->adapter;
	int i;

	adapter->scanprobes = 0;

	adapter->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR;
	adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;

	/* ATIM params */
	adapter->atimwindow = 0;

	adapter->connect_status = LIBERTAS_DISCONNECTED;
	memset(adapter->current_addr, 0xff, ETH_ALEN);

	/* scan type */
	adapter->scantype = CMD_SCAN_TYPE_ACTIVE;

	/* scan mode */
	adapter->scanmode = CMD_BSS_TYPE_ANY;

	/* 802.11 specific */
	adapter->secinfo.wep_enabled = 0;
	for (i = 0; i < sizeof(adapter->wep_keys) / sizeof(adapter->wep_keys[0]);
	     i++)
		memset(&adapter->wep_keys[i], 0, sizeof(struct enc_key));
	adapter->wep_tx_keyidx = 0;
	adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
	adapter->mode = IW_MODE_INFRA;

	adapter->pending_assoc_req = NULL;
	adapter->in_progress_assoc_req = NULL;

	/* Initialize scan result lists */
	INIT_LIST_HEAD(&adapter->network_free_list);
	INIT_LIST_HEAD(&adapter->network_list);
	for (i = 0; i < MAX_NETWORK_COUNT; i++) {
		list_add_tail(&adapter->networks[i].list,
			      &adapter->network_free_list);
	}

	mutex_init(&adapter->lock);

	adapter->prescan = 1;

	memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams));
	adapter->curbssparams.channel = DEFAULT_AD_HOC_CHANNEL;

	/* PnP and power profile */
	adapter->surpriseremoved = 0;

	adapter->currentpacketfilter =
	    CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;

	adapter->radioon = RADIO_ON;
	adapter->txantenna = RF_ANTENNA_2;
	adapter->rxantenna = RF_ANTENNA_AUTO;

	adapter->auto_rate = 1;
	adapter->cur_rate = 0;
	adapter->adhoc_grate_enabled = 0;

	adapter->beaconperiod = MRVDRV_BEACON_INTERVAL;

	// set default capabilities
	adapter->capability = WLAN_CAPABILITY_SHORT_PREAMBLE;

	adapter->psmode = WLAN802_11POWERMODECAM;
	adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;

	adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;

	adapter->psstate = PS_STATE_FULL_POWER;
	adapter->needtowakeup = 0;
	adapter->locallisteninterval = 0;	/* default value in firmware will be used */

	adapter->intcounter = 0;

	adapter->currenttxskb = NULL;
	adapter->pkttxctrl = 0;

	memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*));
	adapter->tx_queue_idx = 0;
	spin_lock_init(&adapter->txqueue_lock);

	return;
}

static int libertas_init_fw(wlan_private * priv)
{
	int ret = -1;
	wlan_adapter *adapter = priv->adapter;

	lbs_deb_enter(LBS_DEB_FW);

	/* Allocate adapter structure */
	if ((ret = wlan_allocate_adapter(priv)) != 0)
		goto done;

	/* init adapter structure */
	wlan_init_adapter(priv);

	/* init timer etc. */
	setup_timer(&adapter->command_timer, command_timer_fn,
			(unsigned long)priv);

	/* download fimrware etc. */
	if ((ret = wlan_setup_station_hw(priv)) != 0) {
		del_timer_sync(&adapter->command_timer);
		goto done;
	}

	/* init 802.11d */
	libertas_init_11d(priv);

	ret = 0;
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

1070 1071 1072 1073 1074 1075 1076
/**
 * @brief This function adds the card. it will probe the
 * card, allocate the wlan_priv and initialize the device.
 *
 *  @param card    A pointer to card
 *  @return 	   A pointer to wlan_private structure
 */
1077
wlan_private *libertas_add_card(void *card, struct device *dmdev)
1078 1079 1080 1081
{
	struct net_device *dev = NULL;
	wlan_private *priv = NULL;

1082
	lbs_deb_enter(LBS_DEB_NET);
1083 1084 1085

	/* Allocate an Ethernet device and register it */
	if (!(dev = alloc_etherdev(sizeof(wlan_private)))) {
1086
		lbs_pr_err("init ethX device failed\n");
1087 1088 1089 1090 1091
		return NULL;
	}
	priv = dev->priv;

	/* allocate buffer for wlan_adapter */
1092
	if (!(priv->adapter = kzalloc(sizeof(wlan_adapter), GFP_KERNEL))) {
1093
		lbs_pr_err("allocate buffer for wlan_adapter failed\n");
1094
		goto err_kzalloc;
1095 1096
	}

1097 1098
	priv->dev = dev;
	priv->card = card;
1099 1100 1101 1102 1103 1104
	priv->mesh_open = 0;
	priv->infra_open = 0;

	SET_MODULE_OWNER(dev);

	/* Setup the OS Interface to our functions */
1105 1106 1107 1108 1109 1110
	dev->open = libertas_open;
	dev->hard_start_xmit = libertas_pre_start_xmit;
	dev->stop = libertas_close;
	dev->set_mac_address = libertas_set_mac_address;
	dev->tx_timeout = libertas_tx_timeout;
	dev->get_stats = libertas_get_stats;
1111
	dev->watchdog_timeo = 5 * HZ;
1112 1113 1114 1115 1116 1117 1118
	dev->ethtool_ops = &libertas_ethtool_ops;
#ifdef	WIRELESS_EXT
	dev->wireless_handlers = (struct iw_handler_def *)&libertas_handler_def;
#endif
#define NETIF_F_DYNALLOC 16
	dev->features |= NETIF_F_DYNALLOC;
	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;
1119
	dev->set_multicast_list = libertas_set_multicast_list;
1120

1121 1122
	SET_NETDEV_DEV(dev, dmdev);

1123 1124 1125 1126 1127 1128
	INIT_LIST_HEAD(&priv->adapter->cmdfreeq);
	INIT_LIST_HEAD(&priv->adapter->cmdpendingq);

	spin_lock_init(&priv->adapter->driver_lock);
	init_waitqueue_head(&priv->adapter->cmd_pending);
	priv->adapter->nr_cmd_pending = 0;
1129 1130 1131 1132
	goto done;

err_kzalloc:
	free_netdev(dev);
1133
	priv = NULL;
1134 1135 1136 1137
done:
	lbs_deb_leave_args(LBS_DEB_NET, "priv %p", priv);
	return priv;
}
1138
EXPORT_SYMBOL_GPL(libertas_add_card);
1139

H
Holger Schurig 已提交
1140
int libertas_activate_card(wlan_private *priv)
1141
{
1142
	struct net_device *dev = priv->dev;
1143 1144 1145
	int ret = -1;

	lbs_deb_enter(LBS_DEB_MAIN);
1146

1147 1148 1149 1150 1151 1152 1153
	lbs_deb_thread("Starting main thread...\n");
	init_waitqueue_head(&priv->waitq);
	priv->main_thread = kthread_run(libertas_thread, dev, "libertas_main");
	if (IS_ERR(priv->main_thread)) {
		lbs_deb_thread("Error creating main thread.\n");
		goto done;
	}
1154 1155 1156

	priv->assoc_thread =
		create_singlethread_workqueue("libertas_assoc");
1157
	INIT_DELAYED_WORK(&priv->assoc_work, libertas_association_worker);
1158
	INIT_WORK(&priv->sync_channel, libertas_sync_channel);
1159 1160 1161 1162 1163 1164

	/*
	 * Register the device. Fillup the private data structure with
	 * relevant information from the card and request for the required
	 * IRQ.
	 */
1165
	if (priv->hw_register_dev(priv) < 0) {
1166
		lbs_pr_err("failed to register WLAN device\n");
1167 1168 1169 1170
		goto err_registerdev;
	}

	/* init FW and HW */
H
Holger Schurig 已提交
1171
	if (libertas_init_fw(priv)) {
1172
		lbs_pr_err("firmware init failed\n");
1173 1174 1175 1176
		goto err_registerdev;
	}

	if (register_netdev(dev)) {
1177
		lbs_pr_err("cannot register ethX device\n");
1178 1179 1180
		goto err_init_fw;
	}

1181
	lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name);
1182 1183 1184

	libertas_debugfs_init_one(priv, dev);

1185 1186
	ret = 0;
	goto done;
1187 1188

err_init_fw:
1189
	priv->hw_unregister_dev(priv);
1190 1191 1192
err_registerdev:
	destroy_workqueue(priv->assoc_thread);
	/* Stop the thread servicing the interrupts */
1193 1194
	wake_up_interruptible(&priv->waitq);
	kthread_stop(priv->main_thread);
1195 1196 1197
done:
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
	return ret;
1198
}
1199 1200
EXPORT_SYMBOL_GPL(libertas_activate_card);

1201

1202 1203 1204 1205 1206 1207
/**
 * @brief This function adds mshX interface
 *
 *  @param priv    A pointer to the wlan_private structure
 *  @return 	   0 if successful, -X otherwise
 */
1208
int libertas_add_mesh(wlan_private *priv, struct device *dev)
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
{
	struct net_device *mesh_dev = NULL;
	int ret = 0;

	lbs_deb_enter(LBS_DEB_MESH);

	/* Allocate a virtual mesh device */
	if (!(mesh_dev = alloc_netdev(0, "msh%d", ether_setup))) {
		lbs_deb_mesh("init mshX device failed\n");
		ret = -ENOMEM;
		goto done;
	}
	mesh_dev->priv = priv;
	priv->mesh_dev = mesh_dev;

	SET_MODULE_OWNER(mesh_dev);

1226 1227 1228 1229 1230
	mesh_dev->open = libertas_mesh_open;
	mesh_dev->hard_start_xmit = libertas_mesh_pre_start_xmit;
	mesh_dev->stop = libertas_mesh_close;
	mesh_dev->get_stats = libertas_get_stats;
	mesh_dev->set_mac_address = libertas_set_mac_address;
1231
	mesh_dev->ethtool_ops = &libertas_ethtool_ops;
1232 1233
	memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
			sizeof(priv->dev->dev_addr));
1234

1235 1236
	SET_NETDEV_DEV(priv->mesh_dev, dev);

1237
#ifdef	WIRELESS_EXT
1238
	mesh_dev->wireless_handlers = (struct iw_handler_def *)&mesh_handler_def;
1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
#endif
#define NETIF_F_DYNALLOC 16

	/* Register virtual mesh interface */
	ret = register_netdev(mesh_dev);
	if (ret) {
		lbs_pr_err("cannot register mshX virtual interface\n");
		goto err_free;
	}

1249
	ret = device_create_file(&(mesh_dev->dev), &dev_attr_anycast_mask);
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
	if (ret)
		goto err_unregister;

	/* Everything successful */
	ret = 0;
	goto done;


err_unregister:
	unregister_netdev(mesh_dev);

err_free:
	free_netdev(mesh_dev);

done:
	lbs_deb_leave_args(LBS_DEB_MESH, "ret %d", ret);
	return ret;
}
1268
EXPORT_SYMBOL_GPL(libertas_add_mesh);
1269

1270 1271 1272 1273 1274
static void wake_pending_cmdnodes(wlan_private *priv)
{
	struct cmd_ctrl_node *cmdnode;
	unsigned long flags;

1275 1276
	lbs_deb_enter(LBS_DEB_CMD);

1277 1278 1279 1280 1281 1282 1283 1284 1285
	spin_lock_irqsave(&priv->adapter->driver_lock, flags);
	list_for_each_entry(cmdnode, &priv->adapter->cmdpendingq, list) {
		cmdnode->cmdwaitqwoken = 1;
		wake_up_interruptible(&cmdnode->cmdwait_q);
	}
	spin_unlock_irqrestore(&priv->adapter->driver_lock, flags);
}


1286
int libertas_remove_card(wlan_private *priv)
1287 1288 1289 1290 1291
{
	wlan_adapter *adapter;
	struct net_device *dev;
	union iwreq_data wrqu;

1292
	lbs_deb_enter(LBS_DEB_NET);
1293

1294 1295
	if (!priv)
		goto out;
1296 1297 1298

	adapter = priv->adapter;

1299 1300
	if (!adapter)
		goto out;
1301

1302
	dev = priv->dev;
1303

1304 1305
	netif_stop_queue(priv->dev);
	netif_carrier_off(priv->dev);
1306 1307 1308 1309 1310 1311 1312 1313

	wake_pending_cmdnodes(priv);

	unregister_netdev(dev);

	cancel_delayed_work(&priv->assoc_work);
	destroy_workqueue(priv->assoc_thread);

1314 1315 1316
	if (adapter->psmode == WLAN802_11POWERMODEMAX_PSP) {
		adapter->psmode = WLAN802_11POWERMODECAM;
		libertas_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
1317 1318 1319 1320
	}

	memset(wrqu.ap_addr.sa_data, 0xaa, ETH_ALEN);
	wrqu.ap_addr.sa_family = ARPHRD_ETHER;
1321
	wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
1322 1323 1324 1325

	adapter->surpriseremoved = 1;

	/* Stop the thread servicing the interrupts */
1326
	kthread_stop(priv->main_thread);
1327 1328 1329

	libertas_debugfs_remove_one(priv);

1330
	lbs_deb_net("free adapter\n");
1331 1332
	libertas_free_adapter(priv);

1333
	lbs_deb_net("unregister finish\n");
1334

1335
	priv->dev = NULL;
1336 1337
	free_netdev(dev);

1338 1339
out:
	lbs_deb_leave(LBS_DEB_NET);
1340 1341
	return 0;
}
1342
EXPORT_SYMBOL_GPL(libertas_remove_card);
1343

1344 1345

void libertas_remove_mesh(wlan_private *priv)
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
{
	struct net_device *mesh_dev;

	lbs_deb_enter(LBS_DEB_NET);

	if (!priv)
		goto out;

	mesh_dev = priv->mesh_dev;

	netif_stop_queue(mesh_dev);
1357
	netif_carrier_off(priv->mesh_dev);
1358

1359
	device_remove_file(&(mesh_dev->dev), &dev_attr_anycast_mask);
1360 1361 1362 1363 1364 1365 1366 1367
	unregister_netdev(mesh_dev);

	priv->mesh_dev = NULL ;
	free_netdev(mesh_dev);

out:
	lbs_deb_leave(LBS_DEB_NET);
}
1368
EXPORT_SYMBOL_GPL(libertas_remove_mesh);
1369

1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
/**
 *  @brief This function finds the CFP in
 *  region_cfp_table based on region and band parameter.
 *
 *  @param region  The region code
 *  @param band	   The band
 *  @param cfp_no  A pointer to CFP number
 *  @return 	   A pointer to CFP
 */
struct chan_freq_power *libertas_get_region_cfp_table(u8 region, u8 band, int *cfp_no)
{
	int i, end;

1383
	lbs_deb_enter(LBS_DEB_MAIN);
1384 1385 1386 1387

	end = sizeof(region_cfp_table)/sizeof(struct region_cfp_table);

	for (i = 0; i < end ; i++) {
1388
		lbs_deb_main("region_cfp_table[i].region=%d\n",
1389 1390 1391
			region_cfp_table[i].region);
		if (region_cfp_table[i].region == region) {
			*cfp_no = region_cfp_table[i].cfp_no_BG;
1392
			lbs_deb_leave(LBS_DEB_MAIN);
1393 1394 1395 1396
			return region_cfp_table[i].cfp_BG;
		}
	}

1397
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret NULL");
1398 1399 1400 1401 1402 1403
	return NULL;
}

int libertas_set_regiontable(wlan_private * priv, u8 region, u8 band)
{
	wlan_adapter *adapter = priv->adapter;
1404
	int ret = 0;
1405 1406 1407 1408 1409
	int i = 0;

	struct chan_freq_power *cfp;
	int cfp_no;

1410
	lbs_deb_enter(LBS_DEB_MAIN);
1411 1412 1413 1414 1415 1416 1417 1418 1419

	memset(adapter->region_channel, 0, sizeof(adapter->region_channel));

	{
		cfp = libertas_get_region_cfp_table(region, band, &cfp_no);
		if (cfp != NULL) {
			adapter->region_channel[i].nrcfp = cfp_no;
			adapter->region_channel[i].CFP = cfp;
		} else {
1420
			lbs_deb_main("wrong region code %#x in band B/G\n",
1421
			       region);
1422 1423
			ret = -1;
			goto out;
1424 1425 1426 1427 1428 1429
		}
		adapter->region_channel[i].valid = 1;
		adapter->region_channel[i].region = region;
		adapter->region_channel[i].band = band;
		i++;
	}
1430 1431 1432
out:
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
	return ret;
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446
}

/**
 *  @brief This function handles the interrupt. it will change PS
 *  state if applicable. it will wake up main_thread to handle
 *  the interrupt event as well.
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   n/a
 */
void libertas_interrupt(struct net_device *dev)
{
	wlan_private *priv = dev->priv;

1447
	lbs_deb_enter(LBS_DEB_THREAD);
1448

1449
	lbs_deb_thread("libertas_interrupt: intcounter=%d\n",
1450 1451 1452 1453 1454 1455 1456
	       priv->adapter->intcounter);

	priv->adapter->intcounter++;

	if (priv->adapter->psstate == PS_STATE_SLEEP) {
		priv->adapter->psstate = PS_STATE_AWAKE;
		netif_wake_queue(dev);
1457
		netif_wake_queue(priv->mesh_dev);
1458 1459
	}

1460
	wake_up_interruptible(&priv->waitq);
1461

1462
	lbs_deb_leave(LBS_DEB_THREAD);
1463
}
1464
EXPORT_SYMBOL_GPL(libertas_interrupt);
1465

1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
int libertas_reset_device(wlan_private *priv)
{
	int ret;

	lbs_deb_enter(LBS_DEB_MAIN);
	ret = libertas_prepare_and_send_command(priv, CMD_802_11_RESET,
				    CMD_ACT_HALT, 0, 0, NULL);
	msleep_interruptible(10);

	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
	return ret;
}
EXPORT_SYMBOL_GPL(libertas_reset_device);

1480
static int libertas_init_module(void)
1481
{
1482
	lbs_deb_enter(LBS_DEB_MAIN);
1483
	libertas_debugfs_init();
1484 1485
	lbs_deb_leave(LBS_DEB_MAIN);
	return 0;
1486 1487
}

1488
static void libertas_exit_module(void)
1489
{
1490
	lbs_deb_enter(LBS_DEB_MAIN);
1491 1492 1493

	libertas_debugfs_remove();

1494
	lbs_deb_leave(LBS_DEB_MAIN);
1495 1496
}

1497 1498
module_init(libertas_init_module);
module_exit(libertas_exit_module);
1499

1500
MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1501 1502
MODULE_AUTHOR("Marvell International Ltd.");
MODULE_LICENSE("GPL");