PageRenderTime 61ms CodeModel.GetById 25ms app.highlight 31ms RepoModel.GetById 0ms app.codeStats 0ms

/drivers/net/wireless/rtlwifi/usb.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 1049 lines | 830 code | 142 blank | 77 comment | 79 complexity | 51e572cee8e5f21e9521b4ace1ccfb7a MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
   1/******************************************************************************
   2 *
   3 * Copyright(c) 2009-2011  Realtek Corporation. All rights reserved.
   4 *
   5 * This program is free software; you can redistribute it and/or modify it
   6 * under the terms of version 2 of the GNU General Public License as
   7 * published by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it will be useful, but WITHOUT
  10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  12 * more details.
  13 *
  14 * You should have received a copy of the GNU General Public License along with
  15 * this program; if not, write to the Free Software Foundation, Inc.,
  16 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  17 *
  18 * The full GNU General Public License is included in this distribution in the
  19 * file called LICENSE.
  20 *
  21 * Contact Information:
  22 * wlanfae <wlanfae@realtek.com>
  23 * Realtek Corporation, No. 2, Innovation Road II, Hsinchu Science Park,
  24 * Hsinchu 300, Taiwan.
  25 *
  26 *****************************************************************************/
  27
  28#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  29
  30#include <linux/usb.h>
  31#include "core.h"
  32#include "wifi.h"
  33#include "usb.h"
  34#include "base.h"
  35#include "ps.h"
  36
  37#define	REALTEK_USB_VENQT_READ			0xC0
  38#define	REALTEK_USB_VENQT_WRITE			0x40
  39#define REALTEK_USB_VENQT_CMD_REQ		0x05
  40#define	REALTEK_USB_VENQT_CMD_IDX		0x00
  41
  42#define REALTEK_USB_VENQT_MAX_BUF_SIZE		254
  43
  44static void usbctrl_async_callback(struct urb *urb)
  45{
  46	if (urb)
  47		kfree(urb->context);
  48}
  49
  50static int _usbctrl_vendorreq_async_write(struct usb_device *udev, u8 request,
  51					  u16 value, u16 index, void *pdata,
  52					  u16 len)
  53{
  54	int rc;
  55	unsigned int pipe;
  56	u8 reqtype;
  57	struct usb_ctrlrequest *dr;
  58	struct urb *urb;
  59	struct rtl819x_async_write_data {
  60		u8 data[REALTEK_USB_VENQT_MAX_BUF_SIZE];
  61		struct usb_ctrlrequest dr;
  62	} *buf;
  63
  64	pipe = usb_sndctrlpipe(udev, 0); /* write_out */
  65	reqtype =  REALTEK_USB_VENQT_WRITE;
  66
  67	buf = kmalloc(sizeof(*buf), GFP_ATOMIC);
  68	if (!buf)
  69		return -ENOMEM;
  70
  71	urb = usb_alloc_urb(0, GFP_ATOMIC);
  72	if (!urb) {
  73		kfree(buf);
  74		return -ENOMEM;
  75	}
  76
  77	dr = &buf->dr;
  78
  79	dr->bRequestType = reqtype;
  80	dr->bRequest = request;
  81	dr->wValue = cpu_to_le16(value);
  82	dr->wIndex = cpu_to_le16(index);
  83	dr->wLength = cpu_to_le16(len);
  84	memcpy(buf, pdata, len);
  85	usb_fill_control_urb(urb, udev, pipe,
  86			     (unsigned char *)dr, buf, len,
  87			     usbctrl_async_callback, buf);
  88	rc = usb_submit_urb(urb, GFP_ATOMIC);
  89	if (rc < 0)
  90		kfree(buf);
  91	usb_free_urb(urb);
  92	return rc;
  93}
  94
  95static int _usbctrl_vendorreq_sync_read(struct usb_device *udev, u8 request,
  96					u16 value, u16 index, void *pdata,
  97					u16 len)
  98{
  99	unsigned int pipe;
 100	int status;
 101	u8 reqtype;
 102
 103	pipe = usb_rcvctrlpipe(udev, 0); /* read_in */
 104	reqtype =  REALTEK_USB_VENQT_READ;
 105
 106	status = usb_control_msg(udev, pipe, request, reqtype, value, index,
 107				 pdata, len, 0); /* max. timeout */
 108
 109	if (status < 0)
 110		pr_err("reg 0x%x, usbctrl_vendorreq TimeOut! status:0x%x value=0x%x\n",
 111		       value, status, *(u32 *)pdata);
 112	return status;
 113}
 114
 115static u32 _usb_read_sync(struct usb_device *udev, u32 addr, u16 len)
 116{
 117	u8 request;
 118	u16 wvalue;
 119	u16 index;
 120	u32 *data;
 121	u32 ret;
 122
 123	data = kmalloc(sizeof(u32), GFP_KERNEL);
 124	if (!data)
 125		return -ENOMEM;
 126	request = REALTEK_USB_VENQT_CMD_REQ;
 127	index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */
 128
 129	wvalue = (u16)addr;
 130	_usbctrl_vendorreq_sync_read(udev, request, wvalue, index, data, len);
 131	ret = *data;
 132	kfree(data);
 133	return ret;
 134}
 135
 136static u8 _usb_read8_sync(struct rtl_priv *rtlpriv, u32 addr)
 137{
 138	struct device *dev = rtlpriv->io.dev;
 139
 140	return (u8)_usb_read_sync(to_usb_device(dev), addr, 1);
 141}
 142
 143static u16 _usb_read16_sync(struct rtl_priv *rtlpriv, u32 addr)
 144{
 145	struct device *dev = rtlpriv->io.dev;
 146
 147	return (u16)_usb_read_sync(to_usb_device(dev), addr, 2);
 148}
 149
 150static u32 _usb_read32_sync(struct rtl_priv *rtlpriv, u32 addr)
 151{
 152	struct device *dev = rtlpriv->io.dev;
 153
 154	return _usb_read_sync(to_usb_device(dev), addr, 4);
 155}
 156
 157static void _usb_write_async(struct usb_device *udev, u32 addr, u32 val,
 158			     u16 len)
 159{
 160	u8 request;
 161	u16 wvalue;
 162	u16 index;
 163	u32 data;
 164
 165	request = REALTEK_USB_VENQT_CMD_REQ;
 166	index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */
 167	wvalue = (u16)(addr&0x0000ffff);
 168	data = val;
 169	_usbctrl_vendorreq_async_write(udev, request, wvalue, index, &data,
 170				       len);
 171}
 172
 173static void _usb_write8_async(struct rtl_priv *rtlpriv, u32 addr, u8 val)
 174{
 175	struct device *dev = rtlpriv->io.dev;
 176
 177	_usb_write_async(to_usb_device(dev), addr, val, 1);
 178}
 179
 180static void _usb_write16_async(struct rtl_priv *rtlpriv, u32 addr, u16 val)
 181{
 182	struct device *dev = rtlpriv->io.dev;
 183
 184	_usb_write_async(to_usb_device(dev), addr, val, 2);
 185}
 186
 187static void _usb_write32_async(struct rtl_priv *rtlpriv, u32 addr, u32 val)
 188{
 189	struct device *dev = rtlpriv->io.dev;
 190
 191	_usb_write_async(to_usb_device(dev), addr, val, 4);
 192}
 193
 194static int _usb_nbytes_read_write(struct usb_device *udev, bool read, u32 addr,
 195				  u16 len, u8 *pdata)
 196{
 197	int status;
 198	u8 request;
 199	u16 wvalue;
 200	u16 index;
 201
 202	request = REALTEK_USB_VENQT_CMD_REQ;
 203	index = REALTEK_USB_VENQT_CMD_IDX; /* n/a */
 204	wvalue = (u16)addr;
 205	if (read)
 206		status = _usbctrl_vendorreq_sync_read(udev, request, wvalue,
 207						      index, pdata, len);
 208	else
 209		status = _usbctrl_vendorreq_async_write(udev, request, wvalue,
 210							index, pdata, len);
 211	return status;
 212}
 213
 214static int _usb_readN_sync(struct rtl_priv *rtlpriv, u32 addr, u16 len,
 215			   u8 *pdata)
 216{
 217	struct device *dev = rtlpriv->io.dev;
 218
 219	return _usb_nbytes_read_write(to_usb_device(dev), true, addr, len,
 220				       pdata);
 221}
 222
 223static int _usb_writeN_async(struct rtl_priv *rtlpriv, u32 addr, u16 len,
 224			     u8 *pdata)
 225{
 226	struct device *dev = rtlpriv->io.dev;
 227
 228	return _usb_nbytes_read_write(to_usb_device(dev), false, addr, len,
 229				      pdata);
 230}
 231
 232static void _rtl_usb_io_handler_init(struct device *dev,
 233				     struct ieee80211_hw *hw)
 234{
 235	struct rtl_priv *rtlpriv = rtl_priv(hw);
 236
 237	rtlpriv->io.dev = dev;
 238	mutex_init(&rtlpriv->io.bb_mutex);
 239	rtlpriv->io.write8_async	= _usb_write8_async;
 240	rtlpriv->io.write16_async	= _usb_write16_async;
 241	rtlpriv->io.write32_async	= _usb_write32_async;
 242	rtlpriv->io.writeN_async	= _usb_writeN_async;
 243	rtlpriv->io.read8_sync		= _usb_read8_sync;
 244	rtlpriv->io.read16_sync		= _usb_read16_sync;
 245	rtlpriv->io.read32_sync		= _usb_read32_sync;
 246	rtlpriv->io.readN_sync		= _usb_readN_sync;
 247}
 248
 249static void _rtl_usb_io_handler_release(struct ieee80211_hw *hw)
 250{
 251	struct rtl_priv __maybe_unused *rtlpriv = rtl_priv(hw);
 252
 253	mutex_destroy(&rtlpriv->io.bb_mutex);
 254}
 255
 256/**
 257 *
 258 *	Default aggregation handler. Do nothing and just return the oldest skb.
 259 */
 260static struct sk_buff *_none_usb_tx_aggregate_hdl(struct ieee80211_hw *hw,
 261						  struct sk_buff_head *list)
 262{
 263	return skb_dequeue(list);
 264}
 265
 266#define IS_HIGH_SPEED_USB(udev) \
 267		((USB_SPEED_HIGH == (udev)->speed) ? true : false)
 268
 269static int _rtl_usb_init_tx(struct ieee80211_hw *hw)
 270{
 271	u32 i;
 272	struct rtl_priv *rtlpriv = rtl_priv(hw);
 273	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 274
 275	rtlusb->max_bulk_out_size = IS_HIGH_SPEED_USB(rtlusb->udev)
 276						    ? USB_HIGH_SPEED_BULK_SIZE
 277						    : USB_FULL_SPEED_BULK_SIZE;
 278
 279	RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG, ("USB Max Bulk-out Size=%d\n",
 280		 rtlusb->max_bulk_out_size));
 281
 282	for (i = 0; i < __RTL_TXQ_NUM; i++) {
 283		u32 ep_num = rtlusb->ep_map.ep_mapping[i];
 284		if (!ep_num) {
 285			RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
 286				 ("Invalid endpoint map setting!\n"));
 287			return -EINVAL;
 288		}
 289	}
 290
 291	rtlusb->usb_tx_post_hdl =
 292		 rtlpriv->cfg->usb_interface_cfg->usb_tx_post_hdl;
 293	rtlusb->usb_tx_cleanup	=
 294		 rtlpriv->cfg->usb_interface_cfg->usb_tx_cleanup;
 295	rtlusb->usb_tx_aggregate_hdl =
 296		 (rtlpriv->cfg->usb_interface_cfg->usb_tx_aggregate_hdl)
 297		 ? rtlpriv->cfg->usb_interface_cfg->usb_tx_aggregate_hdl
 298		 : &_none_usb_tx_aggregate_hdl;
 299
 300	init_usb_anchor(&rtlusb->tx_submitted);
 301	for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {
 302		skb_queue_head_init(&rtlusb->tx_skb_queue[i]);
 303		init_usb_anchor(&rtlusb->tx_pending[i]);
 304	}
 305	return 0;
 306}
 307
 308static int _rtl_usb_init_rx(struct ieee80211_hw *hw)
 309{
 310	struct rtl_priv *rtlpriv = rtl_priv(hw);
 311	struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw);
 312	struct rtl_usb *rtlusb = rtl_usbdev(usb_priv);
 313
 314	rtlusb->rx_max_size = rtlpriv->cfg->usb_interface_cfg->rx_max_size;
 315	rtlusb->rx_urb_num = rtlpriv->cfg->usb_interface_cfg->rx_urb_num;
 316	rtlusb->in_ep = rtlpriv->cfg->usb_interface_cfg->in_ep_num;
 317	rtlusb->usb_rx_hdl = rtlpriv->cfg->usb_interface_cfg->usb_rx_hdl;
 318	rtlusb->usb_rx_segregate_hdl =
 319		rtlpriv->cfg->usb_interface_cfg->usb_rx_segregate_hdl;
 320
 321	pr_info("rx_max_size %d, rx_urb_num %d, in_ep %d\n",
 322		rtlusb->rx_max_size, rtlusb->rx_urb_num, rtlusb->in_ep);
 323	init_usb_anchor(&rtlusb->rx_submitted);
 324	return 0;
 325}
 326
 327static int _rtl_usb_init(struct ieee80211_hw *hw)
 328{
 329	struct rtl_priv *rtlpriv = rtl_priv(hw);
 330	struct rtl_usb_priv *usb_priv = rtl_usbpriv(hw);
 331	struct rtl_usb *rtlusb = rtl_usbdev(usb_priv);
 332	int err;
 333	u8 epidx;
 334	struct usb_interface	*usb_intf = rtlusb->intf;
 335	u8 epnums = usb_intf->cur_altsetting->desc.bNumEndpoints;
 336
 337	rtlusb->out_ep_nums = rtlusb->in_ep_nums = 0;
 338	for (epidx = 0; epidx < epnums; epidx++) {
 339		struct usb_endpoint_descriptor *pep_desc;
 340		pep_desc = &usb_intf->cur_altsetting->endpoint[epidx].desc;
 341
 342		if (usb_endpoint_dir_in(pep_desc))
 343			rtlusb->in_ep_nums++;
 344		else if (usb_endpoint_dir_out(pep_desc))
 345			rtlusb->out_ep_nums++;
 346
 347		RT_TRACE(rtlpriv, COMP_INIT, DBG_DMESG,
 348			 ("USB EP(0x%02x), MaxPacketSize=%d ,Interval=%d.\n",
 349			 pep_desc->bEndpointAddress, pep_desc->wMaxPacketSize,
 350			 pep_desc->bInterval));
 351	}
 352	if (rtlusb->in_ep_nums <  rtlpriv->cfg->usb_interface_cfg->in_ep_num)
 353		return -EINVAL ;
 354
 355	/* usb endpoint mapping */
 356	err = rtlpriv->cfg->usb_interface_cfg->usb_endpoint_mapping(hw);
 357	rtlusb->usb_mq_to_hwq =  rtlpriv->cfg->usb_interface_cfg->usb_mq_to_hwq;
 358	_rtl_usb_init_tx(hw);
 359	_rtl_usb_init_rx(hw);
 360	return err;
 361}
 362
 363static int _rtl_usb_init_sw(struct ieee80211_hw *hw)
 364{
 365	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 366	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 367	struct rtl_ps_ctl *ppsc = rtl_psc(rtl_priv(hw));
 368	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 369
 370	rtlhal->hw = hw;
 371	ppsc->inactiveps = false;
 372	ppsc->leisure_ps = false;
 373	ppsc->fwctrl_lps = false;
 374	ppsc->reg_fwctrl_lps = 3;
 375	ppsc->reg_max_lps_awakeintvl = 5;
 376	ppsc->fwctrl_psmode = FW_PS_DTIM_MODE;
 377
 378	 /* IBSS */
 379	mac->beacon_interval = 100;
 380
 381	 /* AMPDU */
 382	mac->min_space_cfg = 0;
 383	mac->max_mss_density = 0;
 384
 385	/* set sane AMPDU defaults */
 386	mac->current_ampdu_density = 7;
 387	mac->current_ampdu_factor = 3;
 388
 389	/* QOS */
 390	rtlusb->acm_method = eAcmWay2_SW;
 391
 392	/* IRQ */
 393	/* HIMR - turn all on */
 394	rtlusb->irq_mask[0] = 0xFFFFFFFF;
 395	/* HIMR_EX - turn all on */
 396	rtlusb->irq_mask[1] = 0xFFFFFFFF;
 397	rtlusb->disableHWSM =  true;
 398	return 0;
 399}
 400
 401#define __RADIO_TAP_SIZE_RSV	32
 402
 403static void _rtl_rx_completed(struct urb *urb);
 404
 405static struct sk_buff *_rtl_prep_rx_urb(struct ieee80211_hw *hw,
 406					struct rtl_usb *rtlusb,
 407					struct urb *urb,
 408					gfp_t gfp_mask)
 409{
 410	struct sk_buff *skb;
 411	struct rtl_priv *rtlpriv = rtl_priv(hw);
 412
 413	skb = __dev_alloc_skb((rtlusb->rx_max_size + __RADIO_TAP_SIZE_RSV),
 414			       gfp_mask);
 415	if (!skb) {
 416		RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 417			 ("Failed to __dev_alloc_skb!!\n"))
 418		return ERR_PTR(-ENOMEM);
 419	}
 420
 421	/* reserve some space for mac80211's radiotap */
 422	skb_reserve(skb, __RADIO_TAP_SIZE_RSV);
 423	usb_fill_bulk_urb(urb, rtlusb->udev,
 424			  usb_rcvbulkpipe(rtlusb->udev, rtlusb->in_ep),
 425			  skb->data, min(skb_tailroom(skb),
 426			  (int)rtlusb->rx_max_size),
 427			  _rtl_rx_completed, skb);
 428
 429	_rtl_install_trx_info(rtlusb, skb, rtlusb->in_ep);
 430	return skb;
 431}
 432
 433#undef __RADIO_TAP_SIZE_RSV
 434
 435static void _rtl_usb_rx_process_agg(struct ieee80211_hw *hw,
 436				    struct sk_buff *skb)
 437{
 438	struct rtl_priv *rtlpriv = rtl_priv(hw);
 439	u8 *rxdesc = skb->data;
 440	struct ieee80211_hdr *hdr;
 441	bool unicast = false;
 442	__le16 fc;
 443	struct ieee80211_rx_status rx_status = {0};
 444	struct rtl_stats stats = {
 445		.signal = 0,
 446		.noise = -98,
 447		.rate = 0,
 448	};
 449
 450	skb_pull(skb, RTL_RX_DESC_SIZE);
 451	rtlpriv->cfg->ops->query_rx_desc(hw, &stats, &rx_status, rxdesc, skb);
 452	skb_pull(skb, (stats.rx_drvinfo_size + stats.rx_bufshift));
 453	hdr = (struct ieee80211_hdr *)(skb->data);
 454	fc = hdr->frame_control;
 455	if (!stats.crc) {
 456		memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
 457
 458		if (is_broadcast_ether_addr(hdr->addr1)) {
 459			/*TODO*/;
 460		} else if (is_multicast_ether_addr(hdr->addr1)) {
 461			/*TODO*/
 462		} else {
 463			unicast = true;
 464			rtlpriv->stats.rxbytesunicast +=  skb->len;
 465		}
 466
 467		rtl_is_special_data(hw, skb, false);
 468
 469		if (ieee80211_is_data(fc)) {
 470			rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX);
 471
 472			if (unicast)
 473				rtlpriv->link_info.num_rx_inperiod++;
 474		}
 475	}
 476}
 477
 478static void _rtl_usb_rx_process_noagg(struct ieee80211_hw *hw,
 479				      struct sk_buff *skb)
 480{
 481	struct rtl_priv *rtlpriv = rtl_priv(hw);
 482	u8 *rxdesc = skb->data;
 483	struct ieee80211_hdr *hdr;
 484	bool unicast = false;
 485	__le16 fc;
 486	struct ieee80211_rx_status rx_status = {0};
 487	struct rtl_stats stats = {
 488		.signal = 0,
 489		.noise = -98,
 490		.rate = 0,
 491	};
 492
 493	skb_pull(skb, RTL_RX_DESC_SIZE);
 494	rtlpriv->cfg->ops->query_rx_desc(hw, &stats, &rx_status, rxdesc, skb);
 495	skb_pull(skb, (stats.rx_drvinfo_size + stats.rx_bufshift));
 496	hdr = (struct ieee80211_hdr *)(skb->data);
 497	fc = hdr->frame_control;
 498	if (!stats.crc) {
 499		memcpy(IEEE80211_SKB_RXCB(skb), &rx_status, sizeof(rx_status));
 500
 501		if (is_broadcast_ether_addr(hdr->addr1)) {
 502			/*TODO*/;
 503		} else if (is_multicast_ether_addr(hdr->addr1)) {
 504			/*TODO*/
 505		} else {
 506			unicast = true;
 507			rtlpriv->stats.rxbytesunicast +=  skb->len;
 508		}
 509
 510		rtl_is_special_data(hw, skb, false);
 511
 512		if (ieee80211_is_data(fc)) {
 513			rtlpriv->cfg->ops->led_control(hw, LED_CTL_RX);
 514
 515			if (unicast)
 516				rtlpriv->link_info.num_rx_inperiod++;
 517		}
 518		if (likely(rtl_action_proc(hw, skb, false))) {
 519			struct sk_buff *uskb = NULL;
 520			u8 *pdata;
 521
 522			uskb = dev_alloc_skb(skb->len + 128);
 523			memcpy(IEEE80211_SKB_RXCB(uskb), &rx_status,
 524			       sizeof(rx_status));
 525			pdata = (u8 *)skb_put(uskb, skb->len);
 526			memcpy(pdata, skb->data, skb->len);
 527			dev_kfree_skb_any(skb);
 528			ieee80211_rx_irqsafe(hw, uskb);
 529		} else {
 530			dev_kfree_skb_any(skb);
 531		}
 532	}
 533}
 534
 535static void _rtl_rx_pre_process(struct ieee80211_hw *hw, struct sk_buff *skb)
 536{
 537	struct sk_buff *_skb;
 538	struct sk_buff_head rx_queue;
 539	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 540
 541	skb_queue_head_init(&rx_queue);
 542	if (rtlusb->usb_rx_segregate_hdl)
 543		rtlusb->usb_rx_segregate_hdl(hw, skb, &rx_queue);
 544	WARN_ON(skb_queue_empty(&rx_queue));
 545	while (!skb_queue_empty(&rx_queue)) {
 546		_skb = skb_dequeue(&rx_queue);
 547		_rtl_usb_rx_process_agg(hw, skb);
 548		ieee80211_rx_irqsafe(hw, skb);
 549	}
 550}
 551
 552static void _rtl_rx_completed(struct urb *_urb)
 553{
 554	struct sk_buff *skb = (struct sk_buff *)_urb->context;
 555	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 556	struct rtl_usb *rtlusb = (struct rtl_usb *)info->rate_driver_data[0];
 557	struct ieee80211_hw *hw = usb_get_intfdata(rtlusb->intf);
 558	struct rtl_priv *rtlpriv = rtl_priv(hw);
 559	int err = 0;
 560
 561	if (unlikely(IS_USB_STOP(rtlusb)))
 562		goto free;
 563
 564	if (likely(0 == _urb->status)) {
 565		/* If this code were moved to work queue, would CPU
 566		 * utilization be improved?  NOTE: We shall allocate another skb
 567		 * and reuse the original one.
 568		 */
 569		skb_put(skb, _urb->actual_length);
 570
 571		if (likely(!rtlusb->usb_rx_segregate_hdl)) {
 572			struct sk_buff *_skb;
 573			_rtl_usb_rx_process_noagg(hw, skb);
 574			_skb = _rtl_prep_rx_urb(hw, rtlusb, _urb, GFP_ATOMIC);
 575			if (IS_ERR(_skb)) {
 576				err = PTR_ERR(_skb);
 577				RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 578					("Can't allocate skb for bulk IN!\n"));
 579				return;
 580			}
 581			skb = _skb;
 582		} else{
 583			/* TO DO */
 584			_rtl_rx_pre_process(hw, skb);
 585			pr_err("rx agg not supported\n");
 586		}
 587		goto resubmit;
 588	}
 589
 590	switch (_urb->status) {
 591	/* disconnect */
 592	case -ENOENT:
 593	case -ECONNRESET:
 594	case -ENODEV:
 595	case -ESHUTDOWN:
 596		goto free;
 597	default:
 598		break;
 599	}
 600
 601resubmit:
 602	skb_reset_tail_pointer(skb);
 603	skb_trim(skb, 0);
 604
 605	usb_anchor_urb(_urb, &rtlusb->rx_submitted);
 606	err = usb_submit_urb(_urb, GFP_ATOMIC);
 607	if (unlikely(err)) {
 608		usb_unanchor_urb(_urb);
 609		goto free;
 610	}
 611	return;
 612
 613free:
 614	dev_kfree_skb_irq(skb);
 615}
 616
 617static int _rtl_usb_receive(struct ieee80211_hw *hw)
 618{
 619	struct urb *urb;
 620	struct sk_buff *skb;
 621	int err;
 622	int i;
 623	struct rtl_priv *rtlpriv = rtl_priv(hw);
 624	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 625
 626	WARN_ON(0 == rtlusb->rx_urb_num);
 627	/* 1600 == 1514 + max WLAN header + rtk info */
 628	WARN_ON(rtlusb->rx_max_size < 1600);
 629
 630	for (i = 0; i < rtlusb->rx_urb_num; i++) {
 631		err = -ENOMEM;
 632		urb = usb_alloc_urb(0, GFP_KERNEL);
 633		if (!urb) {
 634			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 635				 ("Failed to alloc URB!!\n"))
 636			goto err_out;
 637		}
 638
 639		skb = _rtl_prep_rx_urb(hw, rtlusb, urb, GFP_KERNEL);
 640		if (IS_ERR(skb)) {
 641			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 642				 ("Failed to prep_rx_urb!!\n"))
 643			err = PTR_ERR(skb);
 644			goto err_out;
 645		}
 646
 647		usb_anchor_urb(urb, &rtlusb->rx_submitted);
 648		err = usb_submit_urb(urb, GFP_KERNEL);
 649		if (err)
 650			goto err_out;
 651		usb_free_urb(urb);
 652	}
 653	return 0;
 654
 655err_out:
 656	usb_kill_anchored_urbs(&rtlusb->rx_submitted);
 657	return err;
 658}
 659
 660static int rtl_usb_start(struct ieee80211_hw *hw)
 661{
 662	int err;
 663	struct rtl_priv *rtlpriv = rtl_priv(hw);
 664	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 665	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 666
 667	err = rtlpriv->cfg->ops->hw_init(hw);
 668	rtl_init_rx_config(hw);
 669
 670	/* Enable software */
 671	SET_USB_START(rtlusb);
 672	/* should after adapter start and interrupt enable. */
 673	set_hal_start(rtlhal);
 674
 675	/* Start bulk IN */
 676	_rtl_usb_receive(hw);
 677
 678	return err;
 679}
 680/**
 681 *
 682 *
 683 */
 684
 685/*=======================  tx =========================================*/
 686static void rtl_usb_cleanup(struct ieee80211_hw *hw)
 687{
 688	u32 i;
 689	struct sk_buff *_skb;
 690	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 691	struct ieee80211_tx_info *txinfo;
 692
 693	SET_USB_STOP(rtlusb);
 694
 695	/* clean up rx stuff. */
 696	usb_kill_anchored_urbs(&rtlusb->rx_submitted);
 697
 698	/* clean up tx stuff */
 699	for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {
 700		while ((_skb = skb_dequeue(&rtlusb->tx_skb_queue[i]))) {
 701			rtlusb->usb_tx_cleanup(hw, _skb);
 702			txinfo = IEEE80211_SKB_CB(_skb);
 703			ieee80211_tx_info_clear_status(txinfo);
 704			txinfo->flags |= IEEE80211_TX_STAT_ACK;
 705			ieee80211_tx_status_irqsafe(hw, _skb);
 706		}
 707		usb_kill_anchored_urbs(&rtlusb->tx_pending[i]);
 708	}
 709	usb_kill_anchored_urbs(&rtlusb->tx_submitted);
 710}
 711
 712/**
 713 *
 714 * We may add some struct into struct rtl_usb later. Do deinit here.
 715 *
 716 */
 717static void rtl_usb_deinit(struct ieee80211_hw *hw)
 718{
 719	rtl_usb_cleanup(hw);
 720}
 721
 722static void rtl_usb_stop(struct ieee80211_hw *hw)
 723{
 724	struct rtl_priv *rtlpriv = rtl_priv(hw);
 725	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 726	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 727
 728	/* should after adapter start and interrupt enable. */
 729	set_hal_stop(rtlhal);
 730	/* Enable software */
 731	SET_USB_STOP(rtlusb);
 732	rtl_usb_deinit(hw);
 733	rtlpriv->cfg->ops->hw_disable(hw);
 734}
 735
 736static void _rtl_submit_tx_urb(struct ieee80211_hw *hw, struct urb *_urb)
 737{
 738	int err;
 739	struct rtl_priv *rtlpriv = rtl_priv(hw);
 740	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 741
 742	usb_anchor_urb(_urb, &rtlusb->tx_submitted);
 743	err = usb_submit_urb(_urb, GFP_ATOMIC);
 744	if (err < 0) {
 745		struct sk_buff *skb;
 746
 747		RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 748			 ("Failed to submit urb.\n"));
 749		usb_unanchor_urb(_urb);
 750		skb = (struct sk_buff *)_urb->context;
 751		kfree_skb(skb);
 752	}
 753	usb_free_urb(_urb);
 754}
 755
 756static int _usb_tx_post(struct ieee80211_hw *hw, struct urb *urb,
 757			struct sk_buff *skb)
 758{
 759	struct rtl_priv *rtlpriv = rtl_priv(hw);
 760	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 761	struct ieee80211_tx_info *txinfo;
 762
 763	rtlusb->usb_tx_post_hdl(hw, urb, skb);
 764	skb_pull(skb, RTL_TX_HEADER_SIZE);
 765	txinfo = IEEE80211_SKB_CB(skb);
 766	ieee80211_tx_info_clear_status(txinfo);
 767	txinfo->flags |= IEEE80211_TX_STAT_ACK;
 768
 769	if (urb->status) {
 770		RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 771			 ("Urb has error status 0x%X\n", urb->status));
 772		goto out;
 773	}
 774	/*  TODO:	statistics */
 775out:
 776	ieee80211_tx_status_irqsafe(hw, skb);
 777	return urb->status;
 778}
 779
 780static void _rtl_tx_complete(struct urb *urb)
 781{
 782	struct sk_buff *skb = (struct sk_buff *)urb->context;
 783	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 784	struct rtl_usb *rtlusb = (struct rtl_usb *)info->rate_driver_data[0];
 785	struct ieee80211_hw *hw = usb_get_intfdata(rtlusb->intf);
 786	int err;
 787
 788	if (unlikely(IS_USB_STOP(rtlusb)))
 789		return;
 790	err = _usb_tx_post(hw, urb, skb);
 791	if (err) {
 792		/* Ignore error and keep issuiing other urbs */
 793		return;
 794	}
 795}
 796
 797static struct urb *_rtl_usb_tx_urb_setup(struct ieee80211_hw *hw,
 798				struct sk_buff *skb, u32 ep_num)
 799{
 800	struct rtl_priv *rtlpriv = rtl_priv(hw);
 801	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 802	struct urb *_urb;
 803
 804	WARN_ON(NULL == skb);
 805	_urb = usb_alloc_urb(0, GFP_ATOMIC);
 806	if (!_urb) {
 807		RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 808			 ("Can't allocate URB for bulk out!\n"));
 809		kfree_skb(skb);
 810		return NULL;
 811	}
 812	_rtl_install_trx_info(rtlusb, skb, ep_num);
 813	usb_fill_bulk_urb(_urb, rtlusb->udev, usb_sndbulkpipe(rtlusb->udev,
 814			  ep_num), skb->data, skb->len, _rtl_tx_complete, skb);
 815	_urb->transfer_flags |= URB_ZERO_PACKET;
 816	return _urb;
 817}
 818
 819static void _rtl_usb_transmit(struct ieee80211_hw *hw, struct sk_buff *skb,
 820		       enum rtl_txq qnum)
 821{
 822	struct rtl_priv *rtlpriv = rtl_priv(hw);
 823	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 824	u32 ep_num;
 825	struct urb *_urb = NULL;
 826	struct sk_buff *_skb = NULL;
 827	struct sk_buff_head *skb_list;
 828	struct usb_anchor *urb_list;
 829
 830	WARN_ON(NULL == rtlusb->usb_tx_aggregate_hdl);
 831	if (unlikely(IS_USB_STOP(rtlusb))) {
 832		RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,
 833			 ("USB device is stopping...\n"));
 834		kfree_skb(skb);
 835		return;
 836	}
 837	ep_num = rtlusb->ep_map.ep_mapping[qnum];
 838	skb_list = &rtlusb->tx_skb_queue[ep_num];
 839	_skb = skb;
 840	_urb = _rtl_usb_tx_urb_setup(hw, _skb, ep_num);
 841	if (unlikely(!_urb)) {
 842		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
 843			 ("Can't allocate urb. Drop skb!\n"));
 844		return;
 845	}
 846	urb_list = &rtlusb->tx_pending[ep_num];
 847	_rtl_submit_tx_urb(hw, _urb);
 848}
 849
 850static void _rtl_usb_tx_preprocess(struct ieee80211_hw *hw, struct sk_buff *skb,
 851			    u16 hw_queue)
 852{
 853	struct rtl_priv *rtlpriv = rtl_priv(hw);
 854	struct rtl_mac *mac = rtl_mac(rtl_priv(hw));
 855	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 856	struct rtl_tx_desc *pdesc = NULL;
 857	struct rtl_tcb_desc tcb_desc;
 858	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 859	__le16 fc = hdr->frame_control;
 860	u8 *pda_addr = hdr->addr1;
 861	/* ssn */
 862	u8 *qc = NULL;
 863	u8 tid = 0;
 864	u16 seq_number = 0;
 865
 866	memset(&tcb_desc, 0, sizeof(struct rtl_tcb_desc));
 867	if (ieee80211_is_auth(fc)) {
 868		RT_TRACE(rtlpriv, COMP_SEND, DBG_DMESG, ("MAC80211_LINKING\n"));
 869		rtl_ips_nic_on(hw);
 870	}
 871
 872	if (rtlpriv->psc.sw_ps_enabled) {
 873		if (ieee80211_is_data(fc) && !ieee80211_is_nullfunc(fc) &&
 874		    !ieee80211_has_pm(fc))
 875			hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 876	}
 877
 878	rtl_action_proc(hw, skb, true);
 879	if (is_multicast_ether_addr(pda_addr))
 880		rtlpriv->stats.txbytesmulticast += skb->len;
 881	else if (is_broadcast_ether_addr(pda_addr))
 882		rtlpriv->stats.txbytesbroadcast += skb->len;
 883	else
 884		rtlpriv->stats.txbytesunicast += skb->len;
 885	if (ieee80211_is_data_qos(fc)) {
 886		qc = ieee80211_get_qos_ctl(hdr);
 887		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
 888		seq_number = (le16_to_cpu(hdr->seq_ctrl) &
 889			     IEEE80211_SCTL_SEQ) >> 4;
 890		seq_number += 1;
 891		seq_number <<= 4;
 892	}
 893	rtlpriv->cfg->ops->fill_tx_desc(hw, hdr, (u8 *)pdesc, info, skb,
 894					hw_queue, &tcb_desc);
 895	if (!ieee80211_has_morefrags(hdr->frame_control)) {
 896		if (qc)
 897			mac->tids[tid].seq_number = seq_number;
 898	}
 899	if (ieee80211_is_data(fc))
 900		rtlpriv->cfg->ops->led_control(hw, LED_CTL_TX);
 901}
 902
 903static int rtl_usb_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
 904		      struct rtl_tcb_desc *dummy)
 905{
 906	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
 907	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));
 908	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)(skb->data);
 909	__le16 fc = hdr->frame_control;
 910	u16 hw_queue;
 911
 912	if (unlikely(is_hal_stop(rtlhal)))
 913		goto err_free;
 914	hw_queue = rtlusb->usb_mq_to_hwq(fc, skb_get_queue_mapping(skb));
 915	_rtl_usb_tx_preprocess(hw, skb, hw_queue);
 916	_rtl_usb_transmit(hw, skb, hw_queue);
 917	return NETDEV_TX_OK;
 918
 919err_free:
 920	dev_kfree_skb_any(skb);
 921	return NETDEV_TX_OK;
 922}
 923
 924static bool rtl_usb_tx_chk_waitq_insert(struct ieee80211_hw *hw,
 925					struct sk_buff *skb)
 926{
 927	return false;
 928}
 929
 930static struct rtl_intf_ops rtl_usb_ops = {
 931	.adapter_start = rtl_usb_start,
 932	.adapter_stop = rtl_usb_stop,
 933	.adapter_tx = rtl_usb_tx,
 934	.waitq_insert = rtl_usb_tx_chk_waitq_insert,
 935};
 936
 937int __devinit rtl_usb_probe(struct usb_interface *intf,
 938			const struct usb_device_id *id)
 939{
 940	int err;
 941	struct ieee80211_hw *hw = NULL;
 942	struct rtl_priv *rtlpriv = NULL;
 943	struct usb_device	*udev;
 944	struct rtl_usb_priv *usb_priv;
 945
 946	hw = ieee80211_alloc_hw(sizeof(struct rtl_priv) +
 947				sizeof(struct rtl_usb_priv), &rtl_ops);
 948	if (!hw) {
 949		RT_ASSERT(false, ("%s : ieee80211 alloc failed\n", __func__));
 950		return -ENOMEM;
 951	}
 952	rtlpriv = hw->priv;
 953	SET_IEEE80211_DEV(hw, &intf->dev);
 954	udev = interface_to_usbdev(intf);
 955	usb_get_dev(udev);
 956	usb_priv = rtl_usbpriv(hw);
 957	memset(usb_priv, 0, sizeof(*usb_priv));
 958	usb_priv->dev.intf = intf;
 959	usb_priv->dev.udev = udev;
 960	usb_set_intfdata(intf, hw);
 961	/* init cfg & intf_ops */
 962	rtlpriv->rtlhal.interface = INTF_USB;
 963	rtlpriv->cfg = (struct rtl_hal_cfg *)(id->driver_info);
 964	rtlpriv->intf_ops = &rtl_usb_ops;
 965	rtl_dbgp_flag_init(hw);
 966	/* Init IO handler */
 967	_rtl_usb_io_handler_init(&udev->dev, hw);
 968	rtlpriv->cfg->ops->read_chip_version(hw);
 969	/*like read eeprom and so on */
 970	rtlpriv->cfg->ops->read_eeprom_info(hw);
 971	if (rtlpriv->cfg->ops->init_sw_vars(hw)) {
 972		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
 973			 ("Can't init_sw_vars.\n"));
 974		goto error_out;
 975	}
 976	rtlpriv->cfg->ops->init_sw_leds(hw);
 977	err = _rtl_usb_init(hw);
 978	err = _rtl_usb_init_sw(hw);
 979	/* Init mac80211 sw */
 980	err = rtl_init_core(hw);
 981	if (err) {
 982		RT_TRACE(rtlpriv, COMP_ERR, DBG_EMERG,
 983			 ("Can't allocate sw for mac80211.\n"));
 984		goto error_out;
 985	}
 986
 987	/*init rfkill */
 988	/* rtl_init_rfkill(hw); */
 989
 990	err = ieee80211_register_hw(hw);
 991	if (err) {
 992		RT_TRACE(rtlpriv, COMP_INIT, DBG_EMERG,
 993			 ("Can't register mac80211 hw.\n"));
 994		goto error_out;
 995	} else {
 996		rtlpriv->mac80211.mac80211_registered = 1;
 997	}
 998	set_bit(RTL_STATUS_INTERFACE_START, &rtlpriv->status);
 999	return 0;
1000error_out:
1001	rtl_deinit_core(hw);
1002	_rtl_usb_io_handler_release(hw);
1003	ieee80211_free_hw(hw);
1004	usb_put_dev(udev);
1005	return -ENODEV;
1006}
1007EXPORT_SYMBOL(rtl_usb_probe);
1008
1009void rtl_usb_disconnect(struct usb_interface *intf)
1010{
1011	struct ieee80211_hw *hw = usb_get_intfdata(intf);
1012	struct rtl_priv *rtlpriv = rtl_priv(hw);
1013	struct rtl_mac *rtlmac = rtl_mac(rtl_priv(hw));
1014	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));
1015
1016	if (unlikely(!rtlpriv))
1017		return;
1018	/*ieee80211_unregister_hw will call ops_stop */
1019	if (rtlmac->mac80211_registered == 1) {
1020		ieee80211_unregister_hw(hw);
1021		rtlmac->mac80211_registered = 0;
1022	} else {
1023		rtl_deinit_deferred_work(hw);
1024		rtlpriv->intf_ops->adapter_stop(hw);
1025	}
1026	/*deinit rfkill */
1027	/* rtl_deinit_rfkill(hw); */
1028	rtl_usb_deinit(hw);
1029	rtl_deinit_core(hw);
1030	rtlpriv->cfg->ops->deinit_sw_leds(hw);
1031	rtlpriv->cfg->ops->deinit_sw_vars(hw);
1032	_rtl_usb_io_handler_release(hw);
1033	usb_put_dev(rtlusb->udev);
1034	usb_set_intfdata(intf, NULL);
1035	ieee80211_free_hw(hw);
1036}
1037EXPORT_SYMBOL(rtl_usb_disconnect);
1038
1039int rtl_usb_suspend(struct usb_interface *pusb_intf, pm_message_t message)
1040{
1041	return 0;
1042}
1043EXPORT_SYMBOL(rtl_usb_suspend);
1044
1045int rtl_usb_resume(struct usb_interface *pusb_intf)
1046{
1047	return 0;
1048}
1049EXPORT_SYMBOL(rtl_usb_resume);