main.c 27.1 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
#include <linux/delay.h>
#include <linux/etherdevice.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
12
#include <linux/kthread.h>
13
#include <linux/kfifo.h>
14
#include <linux/slab.h>
15
#include <net/cfg80211.h>
16 17 18 19

#include "host.h"
#include "decl.h"
#include "dev.h"
20
#include "cfg.h"
21
#include "debugfs.h"
22
#include "cmd.h"
23

24
#define DRIVER_RELEASE_VERSION "323.p0"
25
const char lbs_driver_version[] = "COMM-USB8388-" DRIVER_RELEASE_VERSION
26 27 28 29 30
#ifdef  DEBUG
    "-dbg"
#endif
    "";

31 32

/* Module parameters */
33 34 35
unsigned int lbs_debug;
EXPORT_SYMBOL_GPL(lbs_debug);
module_param_named(libertas_debug, lbs_debug, int, 0644);
36 37


38 39 40 41 42
/* This global structure is used to send the confirm_sleep command as
 * fast as possible down to the firmware. */
struct cmd_confirm_sleep confirm_sleep;


43
/**
44
 * the table to keep region code
45
 */
46
u16 lbs_region_code_to_index[MRVDRV_MAX_REGION_CODE] =
47
    { 0x10, 0x20, 0x30, 0x31, 0x32, 0x40 };
48 49

/**
50 51 52
 * 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.
53
 */
54 55 56 57
static u8 fw_data_rates[MAX_RATES] =
    { 0x02, 0x04, 0x0B, 0x16, 0x00, 0x0C, 0x12,
      0x18, 0x24, 0x30, 0x48, 0x60, 0x6C, 0x00
};
58 59

/**
60 61 62 63
 *  @brief use index to get the data rate
 *
 *  @param idx                The index of data rate
 *  @return 	   		data rate or 0
64
 */
65
u32 lbs_fw_index_to_data_rate(u8 idx)
66 67 68 69 70 71 72 73 74 75 76 77
{
	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
 */
78
u8 lbs_data_rate_to_fw_index(u32 rate)
79 80 81 82 83 84 85 86 87 88 89 90
{
	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;
}
91

92

93
/**
94
 *  @brief This function opens the ethX interface
95 96
 *
 *  @param dev     A pointer to net_device structure
97
 *  @return 	   0 or -EBUSY if monitor mode active
98
 */
99
static int lbs_dev_open(struct net_device *dev)
100
{
101
	struct lbs_private *priv = dev->ml_priv;
102
	int ret = 0;
103

104 105
	lbs_deb_enter(LBS_DEB_NET);

106
	spin_lock_irq(&priv->driver_lock);
107

108 109 110 111
	if (priv->connect_status == LBS_CONNECTED)
		netif_carrier_on(dev);
	else
		netif_carrier_off(dev);
112

113 114
	if (!priv->tx_pending_len)
		netif_wake_queue(dev);
115

116
	spin_unlock_irq(&priv->driver_lock);
117
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
118
	return ret;
119 120 121 122 123 124 125 126
}

/**
 *  @brief This function closes the ethX interface
 *
 *  @param dev     A pointer to net_device structure
 *  @return 	   0
 */
127
static int lbs_eth_stop(struct net_device *dev)
128
{
129
	struct lbs_private *priv = dev->ml_priv;
130

131
	lbs_deb_enter(LBS_DEB_NET);
132

133
	spin_lock_irq(&priv->driver_lock);
134 135
	netif_stop_queue(dev);
	spin_unlock_irq(&priv->driver_lock);
136

137 138
	schedule_work(&priv->mcast_work);

139
	lbs_deb_leave(LBS_DEB_NET);
140
	return 0;
141 142
}

143
static void lbs_tx_timeout(struct net_device *dev)
144
{
145
	struct lbs_private *priv = dev->ml_priv;
146

147
	lbs_deb_enter(LBS_DEB_TX);
148

149
	lbs_pr_err("tx watch dog timeout\n");
150

Eric Dumazet's avatar
Eric Dumazet committed
151
	dev->trans_start = jiffies; /* prevent tx timeout */
152

153 154 155
	if (priv->currenttxskb)
		lbs_send_tx_feedback(priv, 0);

156 157 158
	/* XX: Shouldn't we also call into the hw-specific driver
	   to kick it somehow? */
	lbs_host_to_card_done(priv);
159

160 161 162 163 164 165 166
	/* More often than not, this actually happens because the
	   firmware has crapped itself -- rather than just a very
	   busy medium. So send a harmless command, and if/when
	   _that_ times out, we'll kick it in the head. */
	lbs_prepare_and_send_command(priv, CMD_802_11_RSSI, 0,
				     0, 0, NULL);

167
	lbs_deb_leave(LBS_DEB_TX);
168 169
}

170 171
void lbs_host_to_card_done(struct lbs_private *priv)
{
172 173
	unsigned long flags;

174 175
	lbs_deb_enter(LBS_DEB_THREAD);

176
	spin_lock_irqsave(&priv->driver_lock, flags);
177 178 179 180

	priv->dnld_sent = DNLD_RES_RECEIVED;

	/* Wake main thread if commands are pending */
181 182 183 184
	if (!priv->cur_cmd || priv->tx_pending_len > 0) {
		if (!priv->wakeup_dev_required)
			wake_up_interruptible(&priv->waitq);
	}
185

186
	spin_unlock_irqrestore(&priv->driver_lock, flags);
187
	lbs_deb_leave(LBS_DEB_THREAD);
188 189 190
}
EXPORT_SYMBOL_GPL(lbs_host_to_card_done);

191
int lbs_set_mac_address(struct net_device *dev, void *addr)
192 193
{
	int ret = 0;
194
	struct lbs_private *priv = dev->ml_priv;
195
	struct sockaddr *phwaddr = addr;
196
	struct cmd_ds_802_11_mac_address cmd;
197

198
	lbs_deb_enter(LBS_DEB_NET);
199

200
	/* In case it was called from the mesh device */
201
	dev = priv->dev;
202

203 204 205
	cmd.hdr.size = cpu_to_le16(sizeof(cmd));
	cmd.action = cpu_to_le16(CMD_ACT_SET);
	memcpy(cmd.macadd, phwaddr->sa_data, ETH_ALEN);
206

207
	ret = lbs_cmd_with_response(priv, CMD_802_11_MAC_ADDRESS, &cmd);
208
	if (ret) {
209
		lbs_deb_net("set MAC address failed\n");
210 211 212
		goto done;
	}

213 214
	memcpy(priv->current_addr, phwaddr->sa_data, ETH_ALEN);
	memcpy(dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
215
	if (priv->mesh_dev)
216
		memcpy(priv->mesh_dev->dev_addr, phwaddr->sa_data, ETH_ALEN);
217 218

done:
219
	lbs_deb_leave_args(LBS_DEB_NET, "ret %d", ret);
220 221 222
	return ret;
}

223 224 225

static inline int mac_in_list(unsigned char *list, int list_len,
			      unsigned char *mac)
226
{
227 228 229 230 231 232 233 234 235
	while (list_len) {
		if (!memcmp(list, mac, ETH_ALEN))
			return 1;
		list += ETH_ALEN;
		list_len--;
	}
	return 0;
}

236

237 238 239 240
static int lbs_add_mcast_addrs(struct cmd_ds_mac_multicast_adr *cmd,
			       struct net_device *dev, int nr_addrs)
{
	int i = nr_addrs;
241
	struct netdev_hw_addr *ha;
242
	int cnt;
243 244 245 246

	if ((dev->flags & (IFF_UP|IFF_MULTICAST)) != (IFF_UP|IFF_MULTICAST))
		return nr_addrs;

247
	netif_addr_lock_bh(dev);
248
	cnt = netdev_mc_count(dev);
249 250
	netdev_for_each_mc_addr(ha, dev) {
		if (mac_in_list(cmd->maclist, nr_addrs, ha->addr)) {
251
			lbs_deb_net("mcast address %s:%pM skipped\n", dev->name,
252
				    ha->addr);
253
			cnt--;
254 255
			continue;
		}
256

257 258
		if (i == MRVDRV_MAX_MULTICAST_LIST_SIZE)
			break;
259
		memcpy(&cmd->maclist[6*i], ha->addr, ETH_ALEN);
260
		lbs_deb_net("mcast address %s:%pM added to filter\n", dev->name,
261
			    ha->addr);
262
		i++;
263
		cnt--;
264
	}
265
	netif_addr_unlock_bh(dev);
266
	if (cnt)
267 268
		return -EOVERFLOW;

269 270 271
	return i;
}

272
static void lbs_set_mcast_worker(struct work_struct *work)
273
{
274 275 276 277 278
	struct lbs_private *priv = container_of(work, struct lbs_private, mcast_work);
	struct cmd_ds_mac_multicast_adr mcast_cmd;
	int dev_flags;
	int nr_addrs;
	int old_mac_control = priv->mac_control;
279

280
	lbs_deb_enter(LBS_DEB_NET);
281

282 283 284 285 286 287 288 289 290 291 292 293 294 295 296
	dev_flags = priv->dev->flags;
	if (priv->mesh_dev)
		dev_flags |= priv->mesh_dev->flags;

	if (dev_flags & IFF_PROMISC) {
		priv->mac_control |= CMD_ACT_MAC_PROMISCUOUS_ENABLE;
		priv->mac_control &= ~(CMD_ACT_MAC_ALL_MULTICAST_ENABLE |
				       CMD_ACT_MAC_MULTICAST_ENABLE);
		goto out_set_mac_control;
	} else if (dev_flags & IFF_ALLMULTI) {
	do_allmulti:
		priv->mac_control |= CMD_ACT_MAC_ALL_MULTICAST_ENABLE;
		priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
				       CMD_ACT_MAC_MULTICAST_ENABLE);
		goto out_set_mac_control;
297 298
	}

299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
	/* Once for priv->dev, again for priv->mesh_dev if it exists */
	nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->dev, 0);
	if (nr_addrs >= 0 && priv->mesh_dev)
		nr_addrs = lbs_add_mcast_addrs(&mcast_cmd, priv->mesh_dev, nr_addrs);
	if (nr_addrs < 0)
		goto do_allmulti;

	if (nr_addrs) {
		int size = offsetof(struct cmd_ds_mac_multicast_adr,
				    maclist[6*nr_addrs]);

		mcast_cmd.action = cpu_to_le16(CMD_ACT_SET);
		mcast_cmd.hdr.size = cpu_to_le16(size);
		mcast_cmd.nr_of_adrs = cpu_to_le16(nr_addrs);

		lbs_cmd_async(priv, CMD_MAC_MULTICAST_ADR, &mcast_cmd.hdr, size);

		priv->mac_control |= CMD_ACT_MAC_MULTICAST_ENABLE;
	} else
		priv->mac_control &= ~CMD_ACT_MAC_MULTICAST_ENABLE;

	priv->mac_control &= ~(CMD_ACT_MAC_PROMISCUOUS_ENABLE |
			       CMD_ACT_MAC_ALL_MULTICAST_ENABLE);
 out_set_mac_control:
323 324
	if (priv->mac_control != old_mac_control)
		lbs_set_mac_control(priv);
325

326
	lbs_deb_leave(LBS_DEB_NET);
327 328
}

329
void lbs_set_multicast_list(struct net_device *dev)
330
{
331
	struct lbs_private *priv = dev->ml_priv;
332 333 334 335

	schedule_work(&priv->mcast_work);
}

336
/**
337
 *  @brief This function handles the major jobs in the LBS driver.
338 339
 *  It handles all events generated by firmware, RX data received
 *  from firmware and TX data sent from kernel.
340
 *
341
 *  @param data    A pointer to lbs_thread structure
342 343
 *  @return 	   0
 */
344
static int lbs_thread(void *data)
345
{
346
	struct net_device *dev = data;
347
	struct lbs_private *priv = dev->ml_priv;
348 349
	wait_queue_t wait;

350
	lbs_deb_enter(LBS_DEB_THREAD);
351 352 353 354

	init_waitqueue_entry(&wait, current);

	for (;;) {
355
		int shouldsleep;
356
		u8 resp_idx;
357

358 359
		lbs_deb_thread("1: currenttxskb %p, dnld_sent %d\n",
				priv->currenttxskb, priv->dnld_sent);
360

361
		add_wait_queue(&priv->waitq, &wait);
362
		set_current_state(TASK_INTERRUPTIBLE);
363
		spin_lock_irq(&priv->driver_lock);
364

365
		if (kthread_should_stop())
366
			shouldsleep = 0;	/* Bye */
367 368
		else if (priv->surpriseremoved)
			shouldsleep = 1;	/* We need to wait until we're _told_ to die */
369 370
		else if (priv->psstate == PS_STATE_SLEEP)
			shouldsleep = 1;	/* Sleep mode. Nothing we can do till it wakes */
371 372
		else if (priv->cmd_timed_out)
			shouldsleep = 0;	/* Command timed out. Recover */
373 374
		else if (!priv->fw_ready)
			shouldsleep = 1;	/* Firmware not ready. We're waiting for it */
375 376
		else if (priv->dnld_sent)
			shouldsleep = 1;	/* Something is en route to the device already */
377 378
		else if (priv->tx_pending_len > 0)
			shouldsleep = 0;	/* We've a packet to send */
379 380
		else if (priv->resp_len[priv->resp_idx])
			shouldsleep = 0;	/* We have a command response */
381 382
		else if (priv->cur_cmd)
			shouldsleep = 1;	/* Can't send a command; one already running */
383 384
		else if (!list_empty(&priv->cmdpendingq) &&
					!(priv->wakeup_dev_required))
385
			shouldsleep = 0;	/* We have a command to send */
Stefani Seibold's avatar
Stefani Seibold committed
386
		else if (kfifo_len(&priv->event_fifo))
387
			shouldsleep = 0;	/* We have an event to process */
388 389 390 391
		else
			shouldsleep = 1;	/* No command */

		if (shouldsleep) {
392
			lbs_deb_thread("sleeping, connect_status %d, "
393
				"psmode %d, psstate %d\n",
394 395
				priv->connect_status,
				priv->psmode, priv->psstate);
396
			spin_unlock_irq(&priv->driver_lock);
397 398
			schedule();
		} else
399
			spin_unlock_irq(&priv->driver_lock);
400

401 402
		lbs_deb_thread("2: currenttxskb %p, dnld_send %d\n",
			       priv->currenttxskb, priv->dnld_sent);
403 404

		set_current_state(TASK_RUNNING);
405
		remove_wait_queue(&priv->waitq, &wait);
406

407 408
		lbs_deb_thread("3: currenttxskb %p, dnld_sent %d\n",
			       priv->currenttxskb, priv->dnld_sent);
409

410
		if (kthread_should_stop()) {
411
			lbs_deb_thread("break from main thread\n");
412 413 414
			break;
		}

415 416 417 418
		if (priv->surpriseremoved) {
			lbs_deb_thread("adapter removed; waiting to die...\n");
			continue;
		}
419

420 421
		lbs_deb_thread("4: currenttxskb %p, dnld_sent %d\n",
		       priv->currenttxskb, priv->dnld_sent);
422

423
		/* Process any pending command response */
424
		spin_lock_irq(&priv->driver_lock);
425 426
		resp_idx = priv->resp_idx;
		if (priv->resp_len[resp_idx]) {
427
			spin_unlock_irq(&priv->driver_lock);
428 429 430
			lbs_process_command_response(priv,
				priv->resp_buf[resp_idx],
				priv->resp_len[resp_idx]);
431
			spin_lock_irq(&priv->driver_lock);
432
			priv->resp_len[resp_idx] = 0;
433
		}
434
		spin_unlock_irq(&priv->driver_lock);
435

436 437
		/* Process hardware events, e.g. card removed, link lost */
		spin_lock_irq(&priv->driver_lock);
Stefani Seibold's avatar
Stefani Seibold committed
438
		while (kfifo_len(&priv->event_fifo)) {
439
			u32 event;
440

441 442 443 444
			if (kfifo_out(&priv->event_fifo,
				(unsigned char *) &event, sizeof(event)) !=
				sizeof(event))
					break;
445 446 447 448 449 450 451 452 453 454 455 456 457 458
			spin_unlock_irq(&priv->driver_lock);
			lbs_process_event(priv, event);
			spin_lock_irq(&priv->driver_lock);
		}
		spin_unlock_irq(&priv->driver_lock);

		if (priv->wakeup_dev_required) {
			lbs_deb_thread("Waking up device...\n");
			/* Wake up device */
			if (priv->exit_deep_sleep(priv))
				lbs_deb_thread("Wakeup device failed\n");
			continue;
		}

459
		/* command timeout stuff */
460 461 462
		if (priv->cmd_timed_out && priv->cur_cmd) {
			struct cmd_ctrl_node *cmdnode = priv->cur_cmd;

463 464 465 466 467
			lbs_pr_info("Timeout submitting command 0x%04x\n",
				le16_to_cpu(cmdnode->cmdbuf->command));
			lbs_complete_command(priv, cmdnode, -ETIMEDOUT);
			if (priv->reset_card)
				priv->reset_card(priv);
468 469 470
		}
		priv->cmd_timed_out = 0;

471 472 473
		if (!priv->fw_ready)
			continue;

474
		/* Check if we need to confirm Sleep Request received previously */
475 476 477
		if (priv->psstate == PS_STATE_PRE_SLEEP &&
		    !priv->dnld_sent && !priv->cur_cmd) {
			if (priv->connect_status == LBS_CONNECTED) {
478 479 480 481
				lbs_deb_thread("pre-sleep, currenttxskb %p, "
					"dnld_sent %d, cur_cmd %p\n",
					priv->currenttxskb, priv->dnld_sent,
					priv->cur_cmd);
482

483
				lbs_ps_confirm_sleep(priv);
484 485 486 487 488 489
			} else {
				/* workaround for firmware sending
				 * deauth/linkloss event immediately
				 * after sleep request; remove this
				 * after firmware fixes it
				 */
490
				priv->psstate = PS_STATE_AWAKE;
491 492
				lbs_pr_alert("ignore PS_SleepConfirm in "
					"non-connected state\n");
493 494 495 496 497 498
			}
		}

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

503 504 505
		if (priv->is_deep_sleep)
			continue;

506
		/* Execute the next command */
507
		if (!priv->dnld_sent && !priv->cur_cmd)
508
			lbs_execute_next_command(priv);
509 510

		/* Wake-up command waiters which can't sleep in
511
		 * lbs_prepare_and_send_command
512
		 */
513 514
		if (!list_empty(&priv->cmdpendingq))
			wake_up_all(&priv->cmd_pending);
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

		spin_lock_irq(&priv->driver_lock);
		if (!priv->dnld_sent && priv->tx_pending_len > 0) {
			int ret = priv->hw_host_to_card(priv, MVMS_DAT,
							priv->tx_pending_buf,
							priv->tx_pending_len);
			if (ret) {
				lbs_deb_tx("host_to_card failed %d\n", ret);
				priv->dnld_sent = DNLD_RES_RECEIVED;
			}
			priv->tx_pending_len = 0;
			if (!priv->currenttxskb) {
				/* We can wake the queues immediately if we aren't
				   waiting for TX feedback */
				if (priv->connect_status == LBS_CONNECTED)
					netif_wake_queue(priv->dev);
				if (priv->mesh_dev &&
532
				    lbs_mesh_connected(priv))
533 534 535 536
					netif_wake_queue(priv->mesh_dev);
			}
		}
		spin_unlock_irq(&priv->driver_lock);
537 538
	}

539
	del_timer(&priv->command_timer);
540
	del_timer(&priv->auto_deepsleep_timer);
541
	wake_up_all(&priv->cmd_pending);
542

543
	lbs_deb_leave(LBS_DEB_THREAD);
544 545 546
	return 0;
}

547 548 549
static int lbs_ret_host_sleep_activate(struct lbs_private *priv,
		unsigned long dummy,
		struct cmd_header *cmd)
550
{
551
	lbs_deb_enter(LBS_DEB_FW);
552 553
	priv->is_host_sleep_activated = 1;
	wake_up_interruptible(&priv->host_sleep_q);
554
	lbs_deb_leave(LBS_DEB_FW);
555 556 557 558 559 560 561 562
	return 0;
}

int lbs_suspend(struct lbs_private *priv)
{
	struct cmd_header cmd;
	int ret;

563 564
	lbs_deb_enter(LBS_DEB_FW);

565 566 567 568 569 570 571
	if (priv->is_deep_sleep) {
		ret = lbs_set_deep_sleep(priv, 0);
		if (ret) {
			lbs_pr_err("deep sleep cancellation failed: %d\n", ret);
			return ret;
		}
		priv->deep_sleep_required = 1;
572 573
	}

574
	memset(&cmd, 0, sizeof(cmd));
575 576 577 578 579 580 581 582 583 584 585 586
	ret = lbs_host_sleep_cfg(priv, priv->wol_criteria,
						(struct wol_config *)NULL);
	if (ret) {
		lbs_pr_info("Host sleep configuration failed: %d\n", ret);
		return ret;
	}
	if (priv->psstate == PS_STATE_FULL_POWER) {
		ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_ACTIVATE, &cmd,
				sizeof(cmd), lbs_ret_host_sleep_activate, 0);
		if (ret)
			lbs_pr_info("HOST_SLEEP_ACTIVATE failed: %d\n", ret);
	}
587

588 589 590 591 592 593 594 595
	if (!wait_event_interruptible_timeout(priv->host_sleep_q,
				priv->is_host_sleep_activated, (10 * HZ))) {
		lbs_pr_err("host_sleep_q: timer expired\n");
		ret = -1;
	}
	netif_device_detach(priv->dev);
	if (priv->mesh_dev)
		netif_device_detach(priv->mesh_dev);
596

597
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
598 599 600 601
	return ret;
}
EXPORT_SYMBOL_GPL(lbs_suspend);

602
int lbs_resume(struct lbs_private *priv)
603
{
604 605
	int ret;
	uint32_t criteria = EHS_REMOVE_WAKEUP;
606

607
	lbs_deb_enter(LBS_DEB_FW);
608

609
	ret = lbs_host_sleep_cfg(priv, criteria, (struct wol_config *)NULL);
610 611 612 613 614

	netif_device_attach(priv->dev);
	if (priv->mesh_dev)
		netif_device_attach(priv->mesh_dev);

615 616 617 618 619 620 621 622 623
	if (priv->deep_sleep_required) {
		priv->deep_sleep_required = 0;
		ret = lbs_set_deep_sleep(priv, 1);
		if (ret)
			lbs_pr_err("deep sleep activation failed: %d\n", ret);
	}

	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
624 625 626
}
EXPORT_SYMBOL_GPL(lbs_resume);

627
/**
628 629
 * @brief This function gets the HW spec from the firmware and sets
 *        some basic parameters.
630
 *
631
 *  @param priv    A pointer to struct lbs_private structure
632 633
 *  @return 	   0 or -1
 */
634
static int lbs_setup_firmware(struct lbs_private *priv)
635 636
{
	int ret = -1;
637
	s16 curlevel = 0, minlevel = 0, maxlevel = 0;
638 639 640

	lbs_deb_enter(LBS_DEB_FW);

641
	/* Read MAC address from firmware */
642
	memset(priv->current_addr, 0xff, ETH_ALEN);
643
	ret = lbs_update_hw_spec(priv);
644
	if (ret)
645 646
		goto done;

647 648 649 650 651 652 653 654
	/* Read power levels if available */
	ret = lbs_get_tx_power(priv, &curlevel, &minlevel, &maxlevel);
	if (ret == 0) {
		priv->txpower_cur = curlevel;
		priv->txpower_min = minlevel;
		priv->txpower_max = maxlevel;
	}

655 656 657
	/* Send cmd to FW to enable 11D function */
	ret = lbs_set_snmp_mib(priv, SNMP_MIB_OID_11D_ENABLE, 1);

658
	lbs_set_mac_control(priv);
659 660 661 662 663 664 665 666 667
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

/**
 *  This function handles the timeout of command sending.
 *  It will re-send the same command again.
 */
668
static void lbs_cmd_timeout_handler(unsigned long data)
669
{
670
	struct lbs_private *priv = (struct lbs_private *)data;
671 672
	unsigned long flags;

673
	lbs_deb_enter(LBS_DEB_CMD);
674
	spin_lock_irqsave(&priv->driver_lock, flags);
675

676
	if (!priv->cur_cmd)
677
		goto out;
678

679 680
	lbs_pr_info("command 0x%04x timed out\n",
		le16_to_cpu(priv->cur_cmd->cmdbuf->command));
681

682
	priv->cmd_timed_out = 1;
683
	wake_up_interruptible(&priv->waitq);
684
out:
685
	spin_unlock_irqrestore(&priv->driver_lock, flags);
686
	lbs_deb_leave(LBS_DEB_CMD);
687 688
}

689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
/**
 *  This function put the device back to deep sleep mode when timer expires
 *  and no activity (command, event, data etc.) is detected.
 */
static void auto_deepsleep_timer_fn(unsigned long data)
{
	struct lbs_private *priv = (struct lbs_private *)data;
	int ret;

	lbs_deb_enter(LBS_DEB_CMD);

	if (priv->is_activity_detected) {
		priv->is_activity_detected = 0;
	} else {
		if (priv->is_auto_deep_sleep_enabled &&
				(!priv->wakeup_dev_required) &&
				(priv->connect_status != LBS_CONNECTED)) {
			lbs_deb_main("Entering auto deep sleep mode...\n");
			ret = lbs_prepare_and_send_command(priv,
					CMD_802_11_DEEP_SLEEP, 0,
					0, 0, NULL);
710 711
			if (ret)
				lbs_pr_err("Enter Deep Sleep command failed\n");
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
		}
	}
	mod_timer(&priv->auto_deepsleep_timer , jiffies +
				(priv->auto_deep_sleep_timeout * HZ)/1000);
	lbs_deb_leave(LBS_DEB_CMD);
}

int lbs_enter_auto_deep_sleep(struct lbs_private *priv)
{
	lbs_deb_enter(LBS_DEB_SDIO);

	priv->is_auto_deep_sleep_enabled = 1;
	if (priv->is_deep_sleep)
		priv->wakeup_dev_required = 1;
	mod_timer(&priv->auto_deepsleep_timer ,
			jiffies + (priv->auto_deep_sleep_timeout * HZ)/1000);

	lbs_deb_leave(LBS_DEB_SDIO);
	return 0;
}

int lbs_exit_auto_deep_sleep(struct lbs_private *priv)
{
	lbs_deb_enter(LBS_DEB_SDIO);

	priv->is_auto_deep_sleep_enabled = 0;
	priv->auto_deep_sleep_timeout = 0;
	del_timer(&priv->auto_deepsleep_timer);

	lbs_deb_leave(LBS_DEB_SDIO);
	return 0;
}

745
static int lbs_init_adapter(struct lbs_private *priv)
746
{
Kiran Divekar's avatar
Kiran Divekar committed
747
	int ret;
748

749 750
	lbs_deb_enter(LBS_DEB_MAIN);

751
	memset(priv->current_addr, 0xff, ETH_ALEN);
752

753
	priv->connect_status = LBS_DISCONNECTED;
754
	priv->channel = DEFAULT_AD_HOC_CHANNEL;
755
	priv->mac_control = CMD_ACT_MAC_RX_ON | CMD_ACT_MAC_TX_ON;
756
	priv->radio_on = 1;
757 758
	priv->psmode = LBS802_11POWERMODECAM;
	priv->psstate = PS_STATE_FULL_POWER;
759 760
	priv->is_deep_sleep = 0;
	priv->is_auto_deep_sleep_enabled = 0;
761
	priv->deep_sleep_required = 0;
762 763
	priv->wakeup_dev_required = 0;
	init_waitqueue_head(&priv->ds_awake_q);
764
	priv->authtype_auto = 1;
765 766 767
	priv->is_host_sleep_configured = 0;
	priv->is_host_sleep_activated = 0;
	init_waitqueue_head(&priv->host_sleep_q);
768
	mutex_init(&priv->lock);
769

770
	setup_timer(&priv->command_timer, lbs_cmd_timeout_handler,
771
		(unsigned long)priv);
772 773
	setup_timer(&priv->auto_deepsleep_timer, auto_deepsleep_timer_fn,
			(unsigned long)priv);
774

775 776
	INIT_LIST_HEAD(&priv->cmdfreeq);
	INIT_LIST_HEAD(&priv->cmdpendingq);
777

778 779
	spin_lock_init(&priv->driver_lock);
	init_waitqueue_head(&priv->cmd_pending);
780

781
	/* Allocate the command buffers */
782
	if (lbs_allocate_cmd_buffer(priv)) {
783
		lbs_pr_err("Out of memory allocating command buffers\n");
784 785 786 787 788 789 790
		ret = -ENOMEM;
		goto out;
	}
	priv->resp_idx = 0;
	priv->resp_len[0] = priv->resp_len[1] = 0;

	/* Create the event FIFO */
Stefani Seibold's avatar
Stefani Seibold committed
791
	ret = kfifo_alloc(&priv->event_fifo, sizeof(u32) * 16, GFP_KERNEL);
792
	if (ret) {
793 794
		lbs_pr_err("Out of memory allocating event FIFO buffer\n");
		goto out;
795
	}
796

797
out:
798 799
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);

800 801
	return ret;
}
802

803
static void lbs_free_adapter(struct lbs_private *priv)
804
{
805
	lbs_deb_enter(LBS_DEB_MAIN);
806

807
	lbs_free_cmd_buffer(priv);
808
	kfifo_free(&priv->event_fifo);
809
	del_timer(&priv->command_timer);
810
	del_timer(&priv->auto_deepsleep_timer);
811 812

	lbs_deb_leave(LBS_DEB_MAIN);
813 814
}

815 816 817 818 819 820 821 822 823 824 825
static const struct net_device_ops lbs_netdev_ops = {
	.ndo_open 		= lbs_dev_open,
	.ndo_stop		= lbs_eth_stop,
	.ndo_start_xmit		= lbs_hard_start_xmit,
	.ndo_set_mac_address	= lbs_set_mac_address,
	.ndo_tx_timeout 	= lbs_tx_timeout,
	.ndo_set_multicast_list = lbs_set_multicast_list,
	.ndo_change_mtu		= eth_change_mtu,
	.ndo_validate_addr	= eth_validate_addr,
};

826 827
/**
 * @brief This function adds the card. it will probe the
828
 * card, allocate the lbs_priv and initialize the device.
829 830
 *
 *  @param card    A pointer to card
831
 *  @return 	   A pointer to struct lbs_private structure
832
 */
833
struct lbs_private *lbs_add_card(void *card, struct device *dmdev)
834
{
835 836
	struct net_device *dev;
	struct wireless_dev *wdev;
837
	struct lbs_private *priv = NULL;
838

839
	lbs_deb_enter(LBS_DEB_MAIN);
840 841

	/* Allocate an Ethernet device and register it */
842 843 844
	wdev = lbs_cfg_alloc(dmdev);
	if (IS_ERR(wdev)) {
		lbs_pr_err("cfg80211 init failed\n");
845
		goto done;
846
	}
Kiran Divekar's avatar
Kiran Divekar committed
847

848 849 850
	wdev->iftype = NL80211_IFTYPE_STATION;
	priv = wdev_priv(wdev);
	priv->wdev = wdev;
851

852
	if (lbs_init_adapter(priv)) {
853
		lbs_pr_err("failed to initialize adapter structure.\n");
854 855 856 857 858 859 860
		goto err_wdev;
	}

	dev = alloc_netdev(0, "wlan%d", ether_setup);
	if (!dev) {
		dev_err(dmdev, "no memory for network device instance\n");
		goto err_adapter;
861 862
	}

863 864 865 866
	dev->ieee80211_ptr = wdev;
	dev->ml_priv = priv;
	SET_NETDEV_DEV(dev, dmdev);
	wdev->netdev = dev;
867
	priv->dev = dev;
868

869
 	dev->netdev_ops = &lbs_netdev_ops;
870
	dev->watchdog_timeo = 5 * HZ;
871
	dev->ethtool_ops = &lbs_ethtool_ops;
872 873
	dev->flags |= IFF_BROADCAST | IFF_MULTICAST;

874
	priv->card = card;
875

876
	strcpy(dev->name, "wlan%d");
877 878 879

	lbs_deb_thread("Starting main thread...\n");
	init_waitqueue_head(&priv->waitq);
880
	priv->main_thread = kthread_run(lbs_thread, dev, "lbs_main");
881 882
	if (IS_ERR(priv->main_thread)) {
		lbs_deb_thread("Error creating main thread.\n");
883
		goto err_ndev;
884 885
	}

886
	priv->work_thread = create_singlethread_workqueue("lbs_worker");
887
	INIT_WORK(&priv->mcast_work, lbs_set_mcast_worker);
888

889 890
	priv->wol_criteria = 0xffffffff;
	priv->wol_gpio = 0xff;
891
	priv->wol_gap = 20;
892

893 894
	goto done;

895
 err_ndev:
896
	free_netdev(dev);
897 898 899 900 901 902 903

 err_adapter:
	lbs_free_adapter(priv);

 err_wdev:
	lbs_cfg_free(priv);

904
	priv = NULL;
905

906
done:
907
	lbs_deb_leave_args(LBS_DEB_MAIN, "priv %p", priv);
908 909
	return priv;
}
910
EXPORT_SYMBOL_GPL(lbs_add_card);
911

912

913
void lbs_remove_card(struct lbs_private *priv)
914
{
915
	struct net_device *dev = priv->dev;
916 917

	lbs_deb_enter(LBS_DEB_MAIN);
918

919
	lbs_remove_mesh(priv);
Kiran Divekar's avatar
Kiran Divekar committed
920
	lbs_scan_deinit(priv);
921

922
	dev = priv->dev;
923

924
	cancel_work_sync(&priv->mcast_work);
925 926 927 928 929

	/* worker thread destruction blocks on the in-flight command which
	 * should have been cleared already in lbs_stop_card().
	 */
	lbs_deb_main("destroying worker thread\n");
930
	destroy_workqueue(priv->work_thread);
931
	lbs_deb_main("done destroying worker thread\n");
932

933 934
	if (priv->psmode == LBS802_11POWERMODEMAX_PSP) {
		priv->psmode = LBS802_11POWERMODECAM;
935
		lbs_ps_wakeup(priv, CMD_OPTION_WAITFORRSP);
936 937
	}

938 939 940 941 942
	if (priv->is_deep_sleep) {
		priv->is_deep_sleep = 0;
		wake_up_interruptible(&priv->ds_awake_q);
	}

943 944 945 946
	priv->is_host_sleep_configured = 0;
	priv->is_host_sleep_activated = 0;
	wake_up_interruptible(&priv->host_sleep_q);

947
	/* Stop the thread servicing the interrupts */
948
	priv->surpriseremoved = 1;
949 950
	kthread_stop(priv->main_thread);

951
	lbs_free_adapter(priv);
952
	lbs_cfg_free(priv);
953 954 955 956 957 958

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

	lbs_deb_leave(LBS_DEB_MAIN);
}
959
EXPORT_SYMBOL_GPL(lbs_remove_card);
960 961


Kiran Divekar's avatar
Kiran Divekar committed
962
int lbs_rtap_supported(struct lbs_private *priv)
963 964 965 966 967 968 969 970 971 972
{
	if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V5)
		return 1;

	/* newer firmware use a capability mask */
	return ((MRVL_FW_MAJOR_REV(priv->fwrelease) >= MRVL_FW_V10) &&
		(priv->fwcapinfo & MESH_CAPINFO_ENABLE_MASK));
}


973
int lbs_start_card(struct lbs_private *priv)
974 975 976 977 978 979 980
{
	struct net_device *dev = priv->dev;
	int ret = -1;

	lbs_deb_enter(LBS_DEB_MAIN);

	/* poke the firmware */
981
	ret = lbs_setup_firmware(priv);
982 983 984
	if (ret)
		goto done;

985 986
	if (lbs_cfg_register(priv)) {
		lbs_pr_err("cannot register device\n");
987
		goto done;
988
	}
989 990 991

	lbs_update_channel(priv);

992 993
	lbs_init_mesh(priv);

994
	lbs_debugfs_init_one(priv, dev);
995

996 997
	lbs_pr_info("%s: Marvell WLAN 802.11 adapter\n", dev->name);

998
	ret = 0;
999

1000
done:
1001 1002 1003
	lbs_deb_leave_args(LBS_DEB_MAIN, "ret %d", ret);
	return ret;
}
1004
EXPORT_SYMBOL_GPL(lbs_start_card);
1005 1006


1007
void lbs_stop_card(struct lbs_private *priv)
1008
{
1009
	struct net_device *dev;
1010 1011 1012 1013 1014
	struct cmd_ctrl_node *cmdnode;
	unsigned long flags;

	lbs_deb_enter(LBS_DEB_MAIN);

1015 1016
	if (!priv)
		goto out;
1017
	dev = priv->dev;
1018

1019 1020
	netif_stop_queue(dev);
	netif_carrier_off(dev);
1021

1022
	lbs_debugfs_remove_one(priv);
1023 1024
	lbs_deinit_mesh(priv);

1025
	/* Delete the timeout of the currently processing command */
1026
	del_timer_sync(&priv->command_timer);
1027
	del_timer_sync(&priv->auto_deepsleep_timer);
1028 1029

	/* Flush pending command nodes */
1030
	spin_lock_irqsave(&priv->driver_lock, flags);
1031
	lbs_deb_main("clearing pending commands\n");
1032
	list_for_each_entry(cmdnode, &priv->cmdpendingq, list) {
1033
		cmdnode->result = -ENOENT;
1034 1035 1036
		cmdnode->cmdwaitqwoken = 1;
		wake_up_interruptible(&cmdnode->cmdwait_q);
	}
1037 1038 1039 1040 1041 1042 1043 1044 1045

	/* Flush the command the card is currently processing */
	if (priv->cur_cmd) {
		lbs_deb_main("clearing current command\n");
		priv->cur_cmd->result = -ENOENT;
		priv->cur_cmd->cmdwaitqwoken = 1;
		wake_up_interruptible(&priv->cur_cmd->cmdwait_q);
	}
	lbs_deb_main("done clearing commands\n");
1046
	spin_unlock_irqrestore(&priv->driver_lock, flags);
1047 1048 1049

	unregister_netdev(dev);

1050
out:
1051
	lbs_deb_leave(LBS_DEB_MAIN);
1052
}
1053
EXPORT_SYMBOL_GPL(lbs_stop_card);
1054

1055

1056 1057 1058 1059 1060 1061 1062 1063 1064 1065
void lbs_queue_event(struct lbs_private *priv, u32 event)
{
	unsigned long flags;

	lbs_deb_enter(LBS_DEB_THREAD);
	spin_lock_irqsave(&priv->driver_lock, flags);

	if (priv->psstate == PS_STATE_SLEEP)
		priv->psstate = PS_STATE_AWAKE;

1066
	kfifo_in(&priv->event_fifo, (unsigned char *) &event, sizeof(u32));
1067 1068 1069 1070 1071 1072 1073 1074 1075

	wake_up_interruptible(&priv->waitq);

	spin_unlock_irqrestore(&priv->driver_lock, flags);
	lbs_deb_leave(LBS_DEB_THREAD);
}
EXPORT_SYMBOL_GPL(lbs_queue_event);

void lbs_notify_command_response(struct lbs_private *priv, u8 resp_idx)
1076
{
1077
	lbs_deb_enter(LBS_DEB_THREAD);
1078

1079
	if (priv->psstate == PS_STATE_SLEEP)
1080
		priv->psstate = PS_STATE_AWAKE;
1081 1082 1083 1084 1085

	/* Swap buffers by flipping the response index */
	BUG_ON(resp_idx > 1);
	priv->resp_idx = resp_idx;

1086
	wake_up_interruptible(&priv->waitq);
1087

1088
	lbs_deb_leave(LBS_DEB_THREAD);
1089
}
1090
EXPORT_SYMBOL_GPL(lbs_notify_command_response);
1091

1092
static int __init lbs_init_module(void)
1093
{
1094
	lbs_deb_enter(LBS_DEB_MAIN);
1095 1096 1097 1098
	memset(&confirm_sleep, 0, sizeof(confirm_sleep));
	confirm_sleep.hdr.command = cpu_to_le16(CMD_802_11_PS_MODE);
	confirm_sleep.hdr.size = cpu_to_le16(sizeof(confirm_sleep));
	confirm_sleep.action = cpu_to_le16(CMD_SUBCMD_SLEEP_CONFIRMED);
1099
	lbs_debugfs_init();
1100 1101
	lbs_deb_leave(LBS_DEB_MAIN);
	return 0;
1102 1103
}

1104
static void __exit lbs_exit_module(void)
1105
{
1106
	lbs_deb_enter(LBS_DEB_MAIN);
1107
	lbs_debugfs_remove();
1108
	lbs_deb_leave(LBS_DEB_MAIN);
1109 1110
}

1111 1112
module_init(lbs_init_module);
module_exit(lbs_exit_module);
1113

1114
MODULE_DESCRIPTION("Libertas WLAN Driver Library");
1115 1116
MODULE_AUTHOR("Marvell International Ltd.");
MODULE_LICENSE("GPL");