usb.c 37.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/*
 * Copyright (c) 2011 Broadcom Corporation
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/usb.h>
21
#include <linux/vmalloc.h>
22 23 24 25 26 27 28 29 30 31 32

#include <brcmu_utils.h>
#include <brcmu_wifi.h>
#include <dhd_bus.h>
#include <dhd_dbg.h>

#include "usb_rdl.h"
#include "usb.h"

#define IOCTL_RESP_TIMEOUT  2000

33 34
#define BRCMF_USB_RESET_GETVER_SPINWAIT	100	/* in unit of ms */
#define BRCMF_USB_RESET_GETVER_LOOP_CNT	10
35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

#define BRCMF_POSTBOOT_ID		0xA123  /* ID to detect if dongle
						   has boot up */
#define BRCMF_USB_NRXQ	50
#define BRCMF_USB_NTXQ	50

#define CONFIGDESC(usb)         (&((usb)->actconfig)->desc)
#define IFPTR(usb, idx)         ((usb)->actconfig->interface[(idx)])
#define IFALTS(usb, idx)        (IFPTR((usb), (idx))->altsetting[0])
#define IFDESC(usb, idx)        IFALTS((usb), (idx)).desc
#define IFEPDESC(usb, idx, ep)  (IFALTS((usb), (idx)).endpoint[(ep)]).desc

#define CONTROL_IF              0
#define BULK_IF                 0

#define BRCMF_USB_CBCTL_WRITE	0
#define BRCMF_USB_CBCTL_READ	1
#define BRCMF_USB_MAX_PKT_SIZE	1600

54
#define BRCMF_USB_43143_FW_NAME	"brcm/brcmfmac43143.bin"
55
#define BRCMF_USB_43236_FW_NAME	"brcm/brcmfmac43236b.bin"
56
#define BRCMF_USB_43242_FW_NAME	"brcm/brcmfmac43242a.bin"
57 58

struct brcmf_usb_image {
59 60 61 62
	struct list_head list;
	s8 *fwname;
	u8 *image;
	int image_len;
63
};
64
static struct list_head fw_image_list;
65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

struct intr_transfer_buf {
	u32 notification;
	u32 reserved;
};

struct brcmf_usbdev_info {
	struct brcmf_usbdev bus_pub; /* MUST BE FIRST */
	spinlock_t qlock;
	struct list_head rx_freeq;
	struct list_head rx_postq;
	struct list_head tx_freeq;
	struct list_head tx_postq;
	uint rx_pipe, tx_pipe, intr_pipe, rx_pipe2;

	int rx_low_watermark;
	int tx_low_watermark;
	int tx_high_watermark;
83 84
	int tx_freecount;
	bool tx_flowblock;
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

	struct brcmf_usbreq *tx_reqs;
	struct brcmf_usbreq *rx_reqs;

	u8 *image;	/* buffer for combine fw and nvram */
	int image_len;

	struct usb_device *usbdev;
	struct device *dev;

	int ctl_in_pipe, ctl_out_pipe;
	struct urb *ctl_urb; /* URB for control endpoint */
	struct usb_ctrlrequest ctl_write;
	struct usb_ctrlrequest ctl_read;
	u32 ctl_urb_actual_length;
	int ctl_urb_status;
	int ctl_completed;
	wait_queue_head_t ioctl_resp_wait;
	ulong ctl_op;

	struct urb *bulk_urb; /* used for FW download */
	struct urb *intr_urb; /* URB for interrupt endpoint */
	int intr_size;          /* Size of interrupt message */
	int interval;           /* Interrupt polling interval */
	struct intr_transfer_buf intr; /* Data buffer for interrupt endpoint */
};

static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo,
				struct brcmf_usbreq  *req);

MODULE_AUTHOR("Broadcom Corporation");
MODULE_DESCRIPTION("Broadcom 802.11n wireless LAN fullmac usb driver.");
MODULE_SUPPORTED_DEVICE("Broadcom 802.11n WLAN fullmac usb cards");
MODULE_LICENSE("Dual BSD/GPL");

static struct brcmf_usbdev *brcmf_usb_get_buspub(struct device *dev)
{
	struct brcmf_bus *bus_if = dev_get_drvdata(dev);
	return bus_if->bus_priv.usb;
}

static struct brcmf_usbdev_info *brcmf_usb_get_businfo(struct device *dev)
{
	return brcmf_usb_get_buspub(dev)->devinfo;
}

131
static int brcmf_usb_ioctl_resp_wait(struct brcmf_usbdev_info *devinfo)
132
{
133 134 135
	return wait_event_timeout(devinfo->ioctl_resp_wait,
				  devinfo->ctl_completed,
				  msecs_to_jiffies(IOCTL_RESP_TIMEOUT));
136 137
}

138
static void brcmf_usb_ioctl_resp_wake(struct brcmf_usbdev_info *devinfo)
139 140
{
	if (waitqueue_active(&devinfo->ioctl_resp_wait))
141
		wake_up(&devinfo->ioctl_resp_wait);
142 143 144 145 146
}

static void
brcmf_usb_ctl_complete(struct brcmf_usbdev_info *devinfo, int type, int status)
{
147
	brcmf_dbg(USB, "Enter, status=%d\n", status);
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174

	if (unlikely(devinfo == NULL))
		return;

	if (type == BRCMF_USB_CBCTL_READ) {
		if (status == 0)
			devinfo->bus_pub.stats.rx_ctlpkts++;
		else
			devinfo->bus_pub.stats.rx_ctlerrs++;
	} else if (type == BRCMF_USB_CBCTL_WRITE) {
		if (status == 0)
			devinfo->bus_pub.stats.tx_ctlpkts++;
		else
			devinfo->bus_pub.stats.tx_ctlerrs++;
	}

	devinfo->ctl_urb_status = status;
	devinfo->ctl_completed = true;
	brcmf_usb_ioctl_resp_wake(devinfo);
}

static void
brcmf_usb_ctlread_complete(struct urb *urb)
{
	struct brcmf_usbdev_info *devinfo =
		(struct brcmf_usbdev_info *)urb->context;

175
	brcmf_dbg(USB, "Enter\n");
176 177 178 179 180 181 182 183 184 185 186
	devinfo->ctl_urb_actual_length = urb->actual_length;
	brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_READ,
		urb->status);
}

static void
brcmf_usb_ctlwrite_complete(struct urb *urb)
{
	struct brcmf_usbdev_info *devinfo =
		(struct brcmf_usbdev_info *)urb->context;

187
	brcmf_dbg(USB, "Enter\n");
188 189 190 191 192 193 194 195 196 197
	brcmf_usb_ctl_complete(devinfo, BRCMF_USB_CBCTL_WRITE,
		urb->status);
}

static int
brcmf_usb_send_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len)
{
	int ret;
	u16 size;

198
	brcmf_dbg(USB, "Enter\n");
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
	if (devinfo == NULL || buf == NULL ||
	    len == 0 || devinfo->ctl_urb == NULL)
		return -EINVAL;

	size = len;
	devinfo->ctl_write.wLength = cpu_to_le16p(&size);
	devinfo->ctl_urb->transfer_buffer_length = size;
	devinfo->ctl_urb_status = 0;
	devinfo->ctl_urb_actual_length = 0;

	usb_fill_control_urb(devinfo->ctl_urb,
		devinfo->usbdev,
		devinfo->ctl_out_pipe,
		(unsigned char *) &devinfo->ctl_write,
		buf, size,
		(usb_complete_t)brcmf_usb_ctlwrite_complete,
		devinfo);

	ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
	if (ret < 0)
219
		brcmf_err("usb_submit_urb failed %d\n", ret);
220 221 222 223 224 225 226 227 228 229

	return ret;
}

static int
brcmf_usb_recv_ctl(struct brcmf_usbdev_info *devinfo, u8 *buf, int len)
{
	int ret;
	u16 size;

230
	brcmf_dbg(USB, "Enter\n");
231 232 233 234 235 236 237 238
	if ((devinfo == NULL) || (buf == NULL) || (len == 0)
		|| (devinfo->ctl_urb == NULL))
		return -EINVAL;

	size = len;
	devinfo->ctl_read.wLength = cpu_to_le16p(&size);
	devinfo->ctl_urb->transfer_buffer_length = size;

239 240 241
	devinfo->ctl_read.bRequestType = USB_DIR_IN
		| USB_TYPE_CLASS | USB_RECIP_INTERFACE;
	devinfo->ctl_read.bRequest = 1;
242 243 244 245 246 247 248 249 250 251 252

	usb_fill_control_urb(devinfo->ctl_urb,
		devinfo->usbdev,
		devinfo->ctl_in_pipe,
		(unsigned char *) &devinfo->ctl_read,
		buf, size,
		(usb_complete_t)brcmf_usb_ctlread_complete,
		devinfo);

	ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
	if (ret < 0)
253
		brcmf_err("usb_submit_urb failed %d\n", ret);
254 255 256 257 258 259 260 261 262 263

	return ret;
}

static int brcmf_usb_tx_ctlpkt(struct device *dev, u8 *buf, u32 len)
{
	int err = 0;
	int timeout = 0;
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);

264
	brcmf_dbg(USB, "Enter\n");
H
Hante Meuleman 已提交
265
	if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP)
266 267 268 269 270
		return -EIO;

	if (test_and_set_bit(0, &devinfo->ctl_op))
		return -EIO;

271
	devinfo->ctl_completed = false;
272 273
	err = brcmf_usb_send_ctl(devinfo, buf, len);
	if (err) {
274
		brcmf_err("fail %d bytes: %d\n", err, len);
275
		clear_bit(0, &devinfo->ctl_op);
276 277
		return err;
	}
278
	timeout = brcmf_usb_ioctl_resp_wait(devinfo);
279 280
	clear_bit(0, &devinfo->ctl_op);
	if (!timeout) {
281
		brcmf_err("Txctl wait timed out\n");
282 283 284 285 286 287 288 289 290 291 292
		err = -EIO;
	}
	return err;
}

static int brcmf_usb_rx_ctlpkt(struct device *dev, u8 *buf, u32 len)
{
	int err = 0;
	int timeout = 0;
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);

293
	brcmf_dbg(USB, "Enter\n");
H
Hante Meuleman 已提交
294
	if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP)
295
		return -EIO;
H
Hante Meuleman 已提交
296

297 298 299
	if (test_and_set_bit(0, &devinfo->ctl_op))
		return -EIO;

300
	devinfo->ctl_completed = false;
301 302
	err = brcmf_usb_recv_ctl(devinfo, buf, len);
	if (err) {
303
		brcmf_err("fail %d bytes: %d\n", err, len);
304
		clear_bit(0, &devinfo->ctl_op);
305 306
		return err;
	}
307
	timeout = brcmf_usb_ioctl_resp_wait(devinfo);
308 309 310
	err = devinfo->ctl_urb_status;
	clear_bit(0, &devinfo->ctl_op);
	if (!timeout) {
311
		brcmf_err("rxctl wait timed out\n");
312 313 314 315 316 317 318 319 320
		err = -EIO;
	}
	if (!err)
		return devinfo->ctl_urb_actual_length;
	else
		return err;
}

static struct brcmf_usbreq *brcmf_usb_deq(struct brcmf_usbdev_info *devinfo,
321
					  struct list_head *q, int *counter)
322 323 324 325 326 327 328 329 330 331
{
	unsigned long flags;
	struct brcmf_usbreq  *req;
	spin_lock_irqsave(&devinfo->qlock, flags);
	if (list_empty(q)) {
		spin_unlock_irqrestore(&devinfo->qlock, flags);
		return NULL;
	}
	req = list_entry(q->next, struct brcmf_usbreq, list);
	list_del_init(q->next);
332 333
	if (counter)
		(*counter)--;
334 335 336 337 338 339
	spin_unlock_irqrestore(&devinfo->qlock, flags);
	return req;

}

static void brcmf_usb_enq(struct brcmf_usbdev_info *devinfo,
340 341
			  struct list_head *q, struct brcmf_usbreq *req,
			  int *counter)
342 343 344 345
{
	unsigned long flags;
	spin_lock_irqsave(&devinfo->qlock, flags);
	list_add_tail(&req->list, q);
346 347
	if (counter)
		(*counter)++;
348 349 350 351 352 353 354 355 356 357 358
	spin_unlock_irqrestore(&devinfo->qlock, flags);
}

static struct brcmf_usbreq *
brcmf_usbdev_qinit(struct list_head *q, int qsize)
{
	int i;
	struct brcmf_usbreq *req, *reqs;

	reqs = kzalloc(sizeof(struct brcmf_usbreq) * qsize, GFP_ATOMIC);
	if (reqs == NULL) {
359
		brcmf_err("fail to allocate memory!\n");
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374
		return NULL;
	}
	req = reqs;

	for (i = 0; i < qsize; i++) {
		req->urb = usb_alloc_urb(0, GFP_ATOMIC);
		if (!req->urb)
			goto fail;

		INIT_LIST_HEAD(&req->list);
		list_add_tail(&req->list, q);
		req++;
	}
	return reqs;
fail:
375
	brcmf_err("fail!\n");
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
	while (!list_empty(q)) {
		req = list_entry(q->next, struct brcmf_usbreq, list);
		if (req && req->urb)
			usb_free_urb(req->urb);
		list_del(q->next);
	}
	return NULL;

}

static void brcmf_usb_free_q(struct list_head *q, bool pending)
{
	struct brcmf_usbreq *req, *next;
	int i = 0;
	list_for_each_entry_safe(req, next, q, list) {
391
		if (!req->urb) {
392
			brcmf_err("bad req\n");
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
			break;
		}
		i++;
		if (pending) {
			usb_kill_urb(req->urb);
		} else {
			usb_free_urb(req->urb);
			list_del_init(&req->list);
		}
	}
}

static void brcmf_usb_del_fromq(struct brcmf_usbdev_info *devinfo,
				struct brcmf_usbreq *req)
{
	unsigned long flags;

	spin_lock_irqsave(&devinfo->qlock, flags);
	list_del_init(&req->list);
	spin_unlock_irqrestore(&devinfo->qlock, flags);
}


static void brcmf_usb_tx_complete(struct urb *urb)
{
	struct brcmf_usbreq *req = (struct brcmf_usbreq *)urb->context;
	struct brcmf_usbdev_info *devinfo = req->devinfo;

421 422
	brcmf_dbg(USB, "Enter, urb->status=%d, skb=%p\n", urb->status,
		  req->skb);
423 424
	brcmf_usb_del_fromq(devinfo, req);
	if (urb->status == 0)
425
		devinfo->bus_pub.bus->dstats.tx_packets++;
426
	else
427
		devinfo->bus_pub.bus->dstats.tx_errors++;
428

429 430
	brcmf_txcomplete(devinfo->dev, req->skb, urb->status == 0);

431
	brcmu_pkt_buf_free_skb(req->skb);
432
	req->skb = NULL;
433 434 435 436 437 438
	brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req, &devinfo->tx_freecount);
	if (devinfo->tx_freecount > devinfo->tx_high_watermark &&
		devinfo->tx_flowblock) {
		brcmf_txflowblock(devinfo->dev, false);
		devinfo->tx_flowblock = false;
	}
439 440 441 442 443 444 445
}

static void brcmf_usb_rx_complete(struct urb *urb)
{
	struct brcmf_usbreq  *req = (struct brcmf_usbreq *)urb->context;
	struct brcmf_usbdev_info *devinfo = req->devinfo;
	struct sk_buff *skb;
446
	struct sk_buff_head skbq;
447

448
	brcmf_dbg(USB, "Enter, urb->status=%d\n", urb->status);
449 450 451 452
	brcmf_usb_del_fromq(devinfo, req);
	skb = req->skb;
	req->skb = NULL;

453 454
	/* zero lenght packets indicate usb "failure". Do not refill */
	if (urb->status == 0 && urb->actual_length) {
455
		devinfo->bus_pub.bus->dstats.rx_packets++;
456
	} else {
457
		devinfo->bus_pub.bus->dstats.rx_errors++;
458
		brcmu_pkt_buf_free_skb(skb);
459
		brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
460 461 462
		return;
	}

H
Hante Meuleman 已提交
463
	if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_UP) {
464 465
		skb_queue_head_init(&skbq);
		skb_queue_tail(&skbq, skb);
466
		skb_put(skb, urb->actual_length);
467 468
		brcmf_rx_frames(devinfo->dev, &skbq);
		brcmf_usb_rx_refill(devinfo, req);
469
	} else {
470
		brcmu_pkt_buf_free_skb(skb);
471
		brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487
	}
	return;

}

static void brcmf_usb_rx_refill(struct brcmf_usbdev_info *devinfo,
				struct brcmf_usbreq  *req)
{
	struct sk_buff *skb;
	int ret;

	if (!req || !devinfo)
		return;

	skb = dev_alloc_skb(devinfo->bus_pub.bus_mtu);
	if (!skb) {
488
		brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
489 490 491 492 493 494 495 496
		return;
	}
	req->skb = skb;

	usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->rx_pipe,
			  skb->data, skb_tailroom(skb), brcmf_usb_rx_complete,
			  req);
	req->devinfo = devinfo;
497
	brcmf_usb_enq(devinfo, &devinfo->rx_postq, req, NULL);
498 499

	ret = usb_submit_urb(req->urb, GFP_ATOMIC);
500 501
	if (ret) {
		brcmf_usb_del_fromq(devinfo, req);
502
		brcmu_pkt_buf_free_skb(req->skb);
503
		req->skb = NULL;
504
		brcmf_usb_enq(devinfo, &devinfo->rx_freeq, req, NULL);
505 506 507 508 509 510 511 512
	}
	return;
}

static void brcmf_usb_rx_fill_all(struct brcmf_usbdev_info *devinfo)
{
	struct brcmf_usbreq *req;

H
Hante Meuleman 已提交
513
	if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP) {
514
		brcmf_err("bus is not up=%d\n", devinfo->bus_pub.state);
515 516
		return;
	}
517
	while ((req = brcmf_usb_deq(devinfo, &devinfo->rx_freeq, NULL)) != NULL)
518 519 520 521 522 523 524 525 526
		brcmf_usb_rx_refill(devinfo, req);
}

static void
brcmf_usb_state_change(struct brcmf_usbdev_info *devinfo, int state)
{
	struct brcmf_bus *bcmf_bus = devinfo->bus_pub.bus;
	int old_state;

527 528
	brcmf_dbg(USB, "Enter, current state=%d, new state=%d\n",
		  devinfo->bus_pub.state, state);
529 530 531 532 533

	if (devinfo->bus_pub.state == state)
		return;

	old_state = devinfo->bus_pub.state;
H
Hante Meuleman 已提交
534
	devinfo->bus_pub.state = state;
535 536

	/* update state of upper layer */
H
Hante Meuleman 已提交
537
	if (state == BRCMFMAC_USB_STATE_DOWN) {
538
		brcmf_dbg(USB, "DBUS is down\n");
539
		bcmf_bus->state = BRCMF_BUS_DOWN;
H
Hante Meuleman 已提交
540 541 542
	} else if (state == BRCMFMAC_USB_STATE_UP) {
		brcmf_dbg(USB, "DBUS is up\n");
		bcmf_bus->state = BRCMF_BUS_DATA;
543
	} else {
544
		brcmf_dbg(USB, "DBUS current state=%d\n", state);
545 546 547 548 549 550 551 552
	}
}

static void
brcmf_usb_intr_complete(struct urb *urb)
{
	struct brcmf_usbdev_info *devinfo =
			(struct brcmf_usbdev_info *)urb->context;
H
Hante Meuleman 已提交
553
	int err;
554

555 556
	brcmf_dbg(USB, "Enter, urb->status=%d\n", urb->status);

557 558 559 560
	if (devinfo == NULL)
		return;

	if (unlikely(urb->status)) {
H
Hante Meuleman 已提交
561 562 563 564 565
		if (urb->status == -ENOENT ||
		    urb->status == -ESHUTDOWN ||
		    urb->status == -ENODEV) {
			brcmf_usb_state_change(devinfo,
					       BRCMFMAC_USB_STATE_DOWN);
566 567 568
		}
	}

H
Hante Meuleman 已提交
569
	if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_DOWN) {
570
		brcmf_err("intr cb when DBUS down, ignoring\n");
571 572 573
		return;
	}

H
Hante Meuleman 已提交
574 575 576
	if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_UP) {
		err = usb_submit_urb(devinfo->intr_urb, GFP_ATOMIC);
		if (err)
577
			brcmf_err("usb_submit_urb, err=%d\n", err);
H
Hante Meuleman 已提交
578
	}
579 580 581 582 583 584 585 586
}

static int brcmf_usb_tx(struct device *dev, struct sk_buff *skb)
{
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
	struct brcmf_usbreq  *req;
	int ret;

587
	brcmf_dbg(USB, "Enter, skb=%p\n", skb);
H
Hante Meuleman 已提交
588
	if (devinfo->bus_pub.state != BRCMFMAC_USB_STATE_UP)
589 590
		return -EIO;

591 592
	req = brcmf_usb_deq(devinfo, &devinfo->tx_freeq,
					&devinfo->tx_freecount);
593
	if (!req) {
594
		brcmu_pkt_buf_free_skb(skb);
595
		brcmf_err("no req to send\n");
596 597 598 599 600 601 602 603
		return -ENOMEM;
	}

	req->skb = skb;
	req->devinfo = devinfo;
	usb_fill_bulk_urb(req->urb, devinfo->usbdev, devinfo->tx_pipe,
			  skb->data, skb->len, brcmf_usb_tx_complete, req);
	req->urb->transfer_flags |= URB_ZERO_PACKET;
604
	brcmf_usb_enq(devinfo, &devinfo->tx_postq, req, NULL);
605
	ret = usb_submit_urb(req->urb, GFP_ATOMIC);
606
	if (ret) {
607
		brcmf_err("brcmf_usb_tx usb_submit_urb FAILED\n");
608 609
		brcmf_usb_del_fromq(devinfo, req);
		brcmu_pkt_buf_free_skb(req->skb);
610
		req->skb = NULL;
611 612 613 614 615 616 617 618
		brcmf_usb_enq(devinfo, &devinfo->tx_freeq, req,
						&devinfo->tx_freecount);
	} else {
		if (devinfo->tx_freecount < devinfo->tx_low_watermark &&
			!devinfo->tx_flowblock) {
			brcmf_txflowblock(dev, true);
			devinfo->tx_flowblock = true;
		}
619 620 621 622 623 624 625 626 627 628
	}

	return ret;
}


static int brcmf_usb_up(struct device *dev)
{
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);
	u16 ifnum;
H
Hante Meuleman 已提交
629
	int ret;
630

631
	brcmf_dbg(USB, "Enter\n");
H
Hante Meuleman 已提交
632
	if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_UP)
633 634
		return 0;

635
	/* Success, indicate devinfo is fully up */
H
Hante Meuleman 已提交
636
	brcmf_usb_state_change(devinfo, BRCMFMAC_USB_STATE_UP);
637 638 639 640 641 642 643 644 645 646 647 648

	if (devinfo->intr_urb) {
		usb_fill_int_urb(devinfo->intr_urb, devinfo->usbdev,
			devinfo->intr_pipe,
			&devinfo->intr,
			devinfo->intr_size,
			(usb_complete_t)brcmf_usb_intr_complete,
			devinfo,
			devinfo->interval);

		ret = usb_submit_urb(devinfo->intr_urb, GFP_ATOMIC);
		if (ret) {
649
			brcmf_err("USB_SUBMIT_URB failed with status %d\n",
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682
				  ret);
			return -EINVAL;
		}
	}

	if (devinfo->ctl_urb) {
		devinfo->ctl_in_pipe = usb_rcvctrlpipe(devinfo->usbdev, 0);
		devinfo->ctl_out_pipe = usb_sndctrlpipe(devinfo->usbdev, 0);

		ifnum = IFDESC(devinfo->usbdev, CONTROL_IF).bInterfaceNumber;

		/* CTL Write */
		devinfo->ctl_write.bRequestType =
			USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
		devinfo->ctl_write.bRequest = 0;
		devinfo->ctl_write.wValue = cpu_to_le16(0);
		devinfo->ctl_write.wIndex = cpu_to_le16p(&ifnum);

		/* CTL Read */
		devinfo->ctl_read.bRequestType =
			USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE;
		devinfo->ctl_read.bRequest = 1;
		devinfo->ctl_read.wValue = cpu_to_le16(0);
		devinfo->ctl_read.wIndex = cpu_to_le16p(&ifnum);
	}
	brcmf_usb_rx_fill_all(devinfo);
	return 0;
}

static void brcmf_usb_down(struct device *dev)
{
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(dev);

683
	brcmf_dbg(USB, "Enter\n");
684 685 686
	if (devinfo == NULL)
		return;

H
Hante Meuleman 已提交
687
	if (devinfo->bus_pub.state == BRCMFMAC_USB_STATE_DOWN)
688 689
		return;

H
Hante Meuleman 已提交
690
	brcmf_usb_state_change(devinfo, BRCMFMAC_USB_STATE_DOWN);
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709
	if (devinfo->intr_urb)
		usb_kill_urb(devinfo->intr_urb);

	if (devinfo->ctl_urb)
		usb_kill_urb(devinfo->ctl_urb);

	if (devinfo->bulk_urb)
		usb_kill_urb(devinfo->bulk_urb);
	brcmf_usb_free_q(&devinfo->tx_postq, true);

	brcmf_usb_free_q(&devinfo->rx_postq, true);
}

static void
brcmf_usb_sync_complete(struct urb *urb)
{
	struct brcmf_usbdev_info *devinfo =
			(struct brcmf_usbdev_info *)urb->context;

710 711
	devinfo->ctl_completed = true;
	brcmf_usb_ioctl_resp_wake(devinfo);
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
}

static bool brcmf_usb_dl_cmd(struct brcmf_usbdev_info *devinfo, u8 cmd,
			     void *buffer, int buflen)
{
	int ret = 0;
	char *tmpbuf;
	u16 size;

	if ((!devinfo) || (devinfo->ctl_urb == NULL))
		return false;

	tmpbuf = kmalloc(buflen, GFP_ATOMIC);
	if (!tmpbuf)
		return false;

	size = buflen;
	devinfo->ctl_urb->transfer_buffer_length = size;

	devinfo->ctl_read.wLength = cpu_to_le16p(&size);
	devinfo->ctl_read.bRequestType = USB_DIR_IN | USB_TYPE_VENDOR |
		USB_RECIP_INTERFACE;
	devinfo->ctl_read.bRequest = cmd;

	usb_fill_control_urb(devinfo->ctl_urb,
		devinfo->usbdev,
		usb_rcvctrlpipe(devinfo->usbdev, 0),
		(unsigned char *) &devinfo->ctl_read,
		(void *) tmpbuf, size,
		(usb_complete_t)brcmf_usb_sync_complete, devinfo);

743
	devinfo->ctl_completed = false;
744 745
	ret = usb_submit_urb(devinfo->ctl_urb, GFP_ATOMIC);
	if (ret < 0) {
746
		brcmf_err("usb_submit_urb failed %d\n", ret);
747 748 749 750
		kfree(tmpbuf);
		return false;
	}

751
	ret = brcmf_usb_ioctl_resp_wait(devinfo);
752 753 754
	memcpy(buffer, tmpbuf, buflen);
	kfree(tmpbuf);

755
	return ret;
756 757 758 759 760 761 762 763
}

static bool
brcmf_usb_dlneeded(struct brcmf_usbdev_info *devinfo)
{
	struct bootrom_id_le id;
	u32 chipid, chiprev;

764
	brcmf_dbg(USB, "Enter\n");
765 766 767 768 769 770

	if (devinfo == NULL)
		return false;

	/* Check if firmware downloaded already by querying runtime ID */
	id.chip = cpu_to_le32(0xDEAD);
771
	brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, sizeof(id));
772 773 774 775 776

	chipid = le32_to_cpu(id.chip);
	chiprev = le32_to_cpu(id.chiprev);

	if ((chipid & 0x4300) == 0x4300)
777
		brcmf_dbg(USB, "chip %x rev 0x%x\n", chipid, chiprev);
778
	else
779
		brcmf_dbg(USB, "chip %d rev 0x%x\n", chipid, chiprev);
780
	if (chipid == BRCMF_POSTBOOT_ID) {
781
		brcmf_dbg(USB, "firmware already downloaded\n");
782
		brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, sizeof(id));
783 784
		return false;
	} else {
785 786
		devinfo->bus_pub.devid = chipid;
		devinfo->bus_pub.chiprev = chiprev;
787 788 789 790 791 792 793 794
	}
	return true;
}

static int
brcmf_usb_resetcfg(struct brcmf_usbdev_info *devinfo)
{
	struct bootrom_id_le id;
795
	u32 loop_cnt;
796

797
	brcmf_dbg(USB, "Enter\n");
798

799 800 801 802
	loop_cnt = 0;
	do {
		mdelay(BRCMF_USB_RESET_GETVER_SPINWAIT);
		loop_cnt++;
803
		id.chip = cpu_to_le32(0xDEAD);       /* Get the ID */
804
		brcmf_usb_dl_cmd(devinfo, DL_GETVER, &id, sizeof(id));
805 806
		if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID))
			break;
807
	} while (loop_cnt < BRCMF_USB_RESET_GETVER_LOOP_CNT);
808 809

	if (id.chip == cpu_to_le32(BRCMF_POSTBOOT_ID)) {
810 811
		brcmf_dbg(USB, "postboot chip 0x%x/rev 0x%x\n",
			  le32_to_cpu(id.chip), le32_to_cpu(id.chiprev));
812

813
		brcmf_usb_dl_cmd(devinfo, DL_RESETCFG, &id, sizeof(id));
814 815
		return 0;
	} else {
816
		brcmf_err("Cannot talk to Dongle. Firmware is not UP, %d ms\n",
817
			  BRCMF_USB_RESET_GETVER_SPINWAIT * loop_cnt);
818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
		return -EINVAL;
	}
}


static int
brcmf_usb_dl_send_bulk(struct brcmf_usbdev_info *devinfo, void *buffer, int len)
{
	int ret;

	if ((devinfo == NULL) || (devinfo->bulk_urb == NULL))
		return -EINVAL;

	/* Prepare the URB */
	usb_fill_bulk_urb(devinfo->bulk_urb, devinfo->usbdev,
			  devinfo->tx_pipe, buffer, len,
			  (usb_complete_t)brcmf_usb_sync_complete, devinfo);

	devinfo->bulk_urb->transfer_flags |= URB_ZERO_PACKET;

838
	devinfo->ctl_completed = false;
839 840
	ret = usb_submit_urb(devinfo->bulk_urb, GFP_ATOMIC);
	if (ret) {
841
		brcmf_err("usb_submit_urb failed %d\n", ret);
842 843
		return ret;
	}
844 845
	ret = brcmf_usb_ioctl_resp_wait(devinfo);
	return (ret == 0);
846 847 848 849 850 851 852 853 854 855
}

static int
brcmf_usb_dl_writeimage(struct brcmf_usbdev_info *devinfo, u8 *fw, int fwlen)
{
	unsigned int sendlen, sent, dllen;
	char *bulkchunk = NULL, *dlpos;
	struct rdl_state_le state;
	u32 rdlstate, rdlbytes;
	int err = 0;
856 857

	brcmf_dbg(USB, "Enter, fw %p, len %d\n", fw, fwlen);
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873

	bulkchunk = kmalloc(RDL_CHUNK, GFP_ATOMIC);
	if (bulkchunk == NULL) {
		err = -ENOMEM;
		goto fail;
	}

	/* 1) Prepare USB boot loader for runtime image */
	brcmf_usb_dl_cmd(devinfo, DL_START, &state,
			 sizeof(struct rdl_state_le));

	rdlstate = le32_to_cpu(state.state);
	rdlbytes = le32_to_cpu(state.bytes);

	/* 2) Check we are in the Waiting state */
	if (rdlstate != DL_WAITING) {
874
		brcmf_err("Failed to DL_START\n");
875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
		err = -EINVAL;
		goto fail;
	}
	sent = 0;
	dlpos = fw;
	dllen = fwlen;

	/* Get chip id and rev */
	while (rdlbytes != dllen) {
		/* Wait until the usb device reports it received all
		 * the bytes we sent */
		if ((rdlbytes == sent) && (rdlbytes != dllen)) {
			if ((dllen-sent) < RDL_CHUNK)
				sendlen = dllen-sent;
			else
				sendlen = RDL_CHUNK;

			/* simply avoid having to send a ZLP by ensuring we
			 * never have an even
			 * multiple of 64
			 */
			if (!(sendlen % 64))
				sendlen -= 4;

			/* send data */
			memcpy(bulkchunk, dlpos, sendlen);
			if (brcmf_usb_dl_send_bulk(devinfo, bulkchunk,
						   sendlen)) {
903
				brcmf_err("send_bulk failed\n");
904 905 906 907 908 909 910 911 912
				err = -EINVAL;
				goto fail;
			}

			dlpos += sendlen;
			sent += sendlen;
		}
		if (!brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state,
				      sizeof(struct rdl_state_le))) {
913
			brcmf_err("DL_GETSTATE Failed xxxx\n");
914 915 916 917 918 919 920 921 922
			err = -EINVAL;
			goto fail;
		}

		rdlstate = le32_to_cpu(state.state);
		rdlbytes = le32_to_cpu(state.bytes);

		/* restart if an error is reported */
		if (rdlstate == DL_BAD_HDR || rdlstate == DL_BAD_CRC) {
923
			brcmf_err("Bad Hdr or Bad CRC state %d\n",
924 925 926 927 928 929 930 931
				  rdlstate);
			err = -EINVAL;
			goto fail;
		}
	}

fail:
	kfree(bulkchunk);
932
	brcmf_dbg(USB, "Exit, err=%d\n", err);
933 934 935 936 937 938 939
	return err;
}

static int brcmf_usb_dlstart(struct brcmf_usbdev_info *devinfo, u8 *fw, int len)
{
	int err;

940
	brcmf_dbg(USB, "Enter\n");
941 942 943 944

	if (devinfo == NULL)
		return -EINVAL;

945
	if (devinfo->bus_pub.devid == 0xDEAD)
946 947 948 949
		return -EINVAL;

	err = brcmf_usb_dl_writeimage(devinfo, fw, len);
	if (err == 0)
H
Hante Meuleman 已提交
950
		devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DL_DONE;
951
	else
H
Hante Meuleman 已提交
952
		devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DL_FAIL;
953
	brcmf_dbg(USB, "Exit, err=%d\n", err);
954 955 956 957 958 959 960 961

	return err;
}

static int brcmf_usb_dlrun(struct brcmf_usbdev_info *devinfo)
{
	struct rdl_state_le state;

962
	brcmf_dbg(USB, "Enter\n");
963 964 965
	if (!devinfo)
		return -EINVAL;

966
	if (devinfo->bus_pub.devid == 0xDEAD)
967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
		return -EINVAL;

	/* Check we are runnable */
	brcmf_usb_dl_cmd(devinfo, DL_GETSTATE, &state,
		sizeof(struct rdl_state_le));

	/* Start the image */
	if (state.state == cpu_to_le32(DL_RUNNABLE)) {
		if (!brcmf_usb_dl_cmd(devinfo, DL_GO, &state,
			sizeof(struct rdl_state_le)))
			return -ENODEV;
		if (brcmf_usb_resetcfg(devinfo))
			return -ENODEV;
		/* The Dongle may go for re-enumeration. */
	} else {
982
		brcmf_err("Dongle not runnable\n");
983 984
		return -EINVAL;
	}
985
	brcmf_dbg(USB, "Exit\n");
986 987 988 989 990 991
	return 0;
}

static bool brcmf_usb_chip_support(int chipid, int chiprev)
{
	switch(chipid) {
992 993
	case 43143:
		return true;
994 995 996 997
	case 43235:
	case 43236:
	case 43238:
		return (chiprev == 3);
998 999
	case 43242:
		return true;
1000 1001 1002 1003 1004 1005 1006 1007 1008
	default:
		break;
	}
	return false;
}

static int
brcmf_usb_fw_download(struct brcmf_usbdev_info *devinfo)
{
1009
	int devid, chiprev;
1010 1011
	int err;

1012
	brcmf_dbg(USB, "Enter\n");
1013 1014 1015
	if (devinfo == NULL)
		return -ENODEV;

1016 1017
	devid = devinfo->bus_pub.devid;
	chiprev = devinfo->bus_pub.chiprev;
1018

1019
	if (!brcmf_usb_chip_support(devid, chiprev)) {
1020
		brcmf_err("unsupported chip %d rev %d\n",
1021
			  devid, chiprev);
1022 1023 1024 1025
		return -EINVAL;
	}

	if (!devinfo->image) {
1026
		brcmf_err("No firmware!\n");
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
		return -ENOENT;
	}

	err = brcmf_usb_dlstart(devinfo,
		devinfo->image, devinfo->image_len);
	if (err == 0)
		err = brcmf_usb_dlrun(devinfo);
	return err;
}


1038
static void brcmf_usb_detach(struct brcmf_usbdev_info *devinfo)
1039
{
1040
	brcmf_dbg(USB, "Enter, devinfo %p\n", devinfo);
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 1070 1071 1072 1073 1074

	/* free the URBS */
	brcmf_usb_free_q(&devinfo->rx_freeq, false);
	brcmf_usb_free_q(&devinfo->tx_freeq, false);

	usb_free_urb(devinfo->intr_urb);
	usb_free_urb(devinfo->ctl_urb);
	usb_free_urb(devinfo->bulk_urb);

	kfree(devinfo->tx_reqs);
	kfree(devinfo->rx_reqs);
}

#define TRX_MAGIC       0x30524448      /* "HDR0" */
#define TRX_VERSION     1               /* Version 1 */
#define TRX_MAX_LEN     0x3B0000        /* Max length */
#define TRX_NO_HEADER   1               /* Do not write TRX header */
#define TRX_MAX_OFFSET  3               /* Max number of individual files */
#define TRX_UNCOMP_IMAGE        0x20    /* Trx contains uncompressed image */

struct trx_header_le {
	__le32 magic;		/* "HDR0" */
	__le32 len;		/* Length of file including header */
	__le32 crc32;		/* CRC from flag_version to end of file */
	__le32 flag_version;	/* 0:15 flags, 16:31 version */
	__le32 offsets[TRX_MAX_OFFSET]; /* Offsets of partitions from start of
					 * header */
};

static int check_file(const u8 *headers)
{
	struct trx_header_le *trx;
	int actual_len = -1;

1075
	brcmf_dbg(USB, "Enter\n");
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	/* Extract trx header */
	trx = (struct trx_header_le *) headers;
	if (trx->magic != cpu_to_le32(TRX_MAGIC))
		return -1;

	headers += sizeof(struct trx_header_le);

	if (le32_to_cpu(trx->flag_version) & TRX_UNCOMP_IMAGE) {
		actual_len = le32_to_cpu(trx->offsets[TRX_OFFSETS_DLFWLEN_IDX]);
		return actual_len + sizeof(struct trx_header_le);
	}
	return -1;
}

static int brcmf_usb_get_fw(struct brcmf_usbdev_info *devinfo)
{
	s8 *fwname;
	const struct firmware *fw;
1094
	struct brcmf_usb_image *fw_image;
1095 1096
	int err;

1097
	brcmf_dbg(USB, "Enter\n");
1098
	switch (devinfo->bus_pub.devid) {
1099 1100 1101
	case 43143:
		fwname = BRCMF_USB_43143_FW_NAME;
		break;
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113
	case 43235:
	case 43236:
	case 43238:
		fwname = BRCMF_USB_43236_FW_NAME;
		break;
	case 43242:
		fwname = BRCMF_USB_43242_FW_NAME;
		break;
	default:
		return -EINVAL;
		break;
	}
1114
	brcmf_dbg(USB, "Loading FW %s\n", fwname);
1115 1116 1117 1118 1119 1120 1121 1122
	list_for_each_entry(fw_image, &fw_image_list, list) {
		if (fw_image->fwname == fwname) {
			devinfo->image = fw_image->image;
			devinfo->image_len = fw_image->image_len;
			return 0;
		}
	}
	/* fw image not yet loaded. Load it now and add to list */
1123 1124
	err = request_firmware(&fw, fwname, devinfo->dev);
	if (!fw) {
1125
		brcmf_err("fail to request firmware %s\n", fwname);
1126 1127 1128
		return err;
	}
	if (check_file(fw->data) < 0) {
1129
		brcmf_err("invalid firmware %s\n", fwname);
1130 1131 1132
		return -EINVAL;
	}

1133 1134 1135 1136 1137 1138 1139 1140
	fw_image = kzalloc(sizeof(*fw_image), GFP_ATOMIC);
	if (!fw_image)
		return -ENOMEM;
	INIT_LIST_HEAD(&fw_image->list);
	list_add_tail(&fw_image->list, &fw_image_list);
	fw_image->fwname = fwname;
	fw_image->image = vmalloc(fw->size);
	if (!fw_image->image)
1141 1142
		return -ENOMEM;

1143 1144
	memcpy(fw_image->image, fw->data, fw->size);
	fw_image->image_len = fw->size;
1145 1146

	release_firmware(fw);
1147 1148 1149 1150

	devinfo->image = fw_image->image;
	devinfo->image_len = fw_image->image_len;

1151 1152 1153 1154 1155
	return 0;
}


static
1156 1157
struct brcmf_usbdev *brcmf_usb_attach(struct brcmf_usbdev_info *devinfo,
				      int nrxq, int ntxq)
1158
{
1159 1160
	brcmf_dbg(USB, "Enter\n");

1161 1162 1163 1164
	devinfo->bus_pub.nrxq = nrxq;
	devinfo->rx_low_watermark = nrxq / 2;
	devinfo->bus_pub.devinfo = devinfo;
	devinfo->bus_pub.ntxq = ntxq;
H
Hante Meuleman 已提交
1165
	devinfo->bus_pub.state = BRCMFMAC_USB_STATE_DOWN;
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183

	/* flow control when too many tx urbs posted */
	devinfo->tx_low_watermark = ntxq / 4;
	devinfo->tx_high_watermark = devinfo->tx_low_watermark * 3;
	devinfo->bus_pub.bus_mtu = BRCMF_USB_MAX_PKT_SIZE;

	/* Initialize other structure content */
	init_waitqueue_head(&devinfo->ioctl_resp_wait);

	/* Initialize the spinlocks */
	spin_lock_init(&devinfo->qlock);

	INIT_LIST_HEAD(&devinfo->rx_freeq);
	INIT_LIST_HEAD(&devinfo->rx_postq);

	INIT_LIST_HEAD(&devinfo->tx_freeq);
	INIT_LIST_HEAD(&devinfo->tx_postq);

1184 1185
	devinfo->tx_flowblock = false;

1186 1187 1188 1189 1190 1191 1192
	devinfo->rx_reqs = brcmf_usbdev_qinit(&devinfo->rx_freeq, nrxq);
	if (!devinfo->rx_reqs)
		goto error;

	devinfo->tx_reqs = brcmf_usbdev_qinit(&devinfo->tx_freeq, ntxq);
	if (!devinfo->tx_reqs)
		goto error;
1193
	devinfo->tx_freecount = ntxq;
1194 1195 1196

	devinfo->intr_urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!devinfo->intr_urb) {
1197
		brcmf_err("usb_alloc_urb (intr) failed\n");
1198 1199 1200 1201
		goto error;
	}
	devinfo->ctl_urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!devinfo->ctl_urb) {
1202
		brcmf_err("usb_alloc_urb (ctl) failed\n");
1203 1204 1205 1206
		goto error;
	}
	devinfo->bulk_urb = usb_alloc_urb(0, GFP_ATOMIC);
	if (!devinfo->bulk_urb) {
1207
		brcmf_err("usb_alloc_urb (bulk) failed\n");
1208 1209 1210 1211 1212 1213
		goto error;
	}

	if (!brcmf_usb_dlneeded(devinfo))
		return &devinfo->bus_pub;

1214
	brcmf_dbg(USB, "Start fw downloading\n");
1215 1216 1217 1218 1219 1220 1221 1222 1223
	if (brcmf_usb_get_fw(devinfo))
		goto error;

	if (brcmf_usb_fw_download(devinfo))
		goto error;

	return &devinfo->bus_pub;

error:
1224
	brcmf_err("failed!\n");
1225
	brcmf_usb_detach(devinfo);
1226 1227 1228
	return NULL;
}

A
Arend van Spriel 已提交
1229 1230 1231 1232 1233 1234 1235 1236
static struct brcmf_bus_ops brcmf_usb_bus_ops = {
	.txdata = brcmf_usb_tx,
	.init = brcmf_usb_up,
	.stop = brcmf_usb_down,
	.txctl = brcmf_usb_tx_ctlpkt,
	.rxctl = brcmf_usb_rx_ctlpkt,
};

H
Hante Meuleman 已提交
1237
static int brcmf_usb_probe_cb(struct brcmf_usbdev_info *devinfo)
1238 1239 1240 1241
{
	struct brcmf_bus *bus = NULL;
	struct brcmf_usbdev *bus_pub = NULL;
	int ret;
1242
	struct device *dev = devinfo->dev;
1243

1244
	brcmf_dbg(USB, "Enter\n");
1245
	bus_pub = brcmf_usb_attach(devinfo, BRCMF_USB_NRXQ, BRCMF_USB_NTXQ);
1246 1247
	if (!bus_pub)
		return -ENODEV;
1248 1249 1250 1251 1252 1253 1254

	bus = kzalloc(sizeof(struct brcmf_bus), GFP_ATOMIC);
	if (!bus) {
		ret = -ENOMEM;
		goto fail;
	}

A
Arend van Spriel 已提交
1255
	bus->dev = dev;
1256 1257 1258
	bus_pub->bus = bus;
	bus->bus_priv.usb = bus_pub;
	dev_set_drvdata(dev, bus);
A
Arend van Spriel 已提交
1259
	bus->ops = &brcmf_usb_bus_ops;
1260 1261

	/* Attach to the common driver interface */
H
Hante Meuleman 已提交
1262
	ret = brcmf_attach(0, dev);
1263
	if (ret) {
1264
		brcmf_err("brcmf_attach failed\n");
1265 1266 1267 1268
		goto fail;
	}

	ret = brcmf_bus_start(dev);
1269
	if (ret) {
1270
		brcmf_err("dongle is not responding\n");
1271 1272 1273 1274 1275 1276 1277 1278
		brcmf_detach(dev);
		goto fail;
	}

	return 0;
fail:
	/* Release resources in reverse order */
	kfree(bus);
1279
	brcmf_usb_detach(devinfo);
1280 1281 1282 1283
	return ret;
}

static void
1284
brcmf_usb_disconnect_cb(struct brcmf_usbdev_info *devinfo)
1285
{
1286
	if (!devinfo)
1287
		return;
1288
	brcmf_dbg(USB, "Enter, bus_pub %p\n", devinfo);
1289

1290 1291 1292
	brcmf_detach(devinfo->dev);
	kfree(devinfo->bus_pub.bus);
	brcmf_usb_detach(devinfo);
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
}

static int
brcmf_usb_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
	int ep;
	struct usb_endpoint_descriptor *endpoint;
	int ret = 0;
	struct usb_device *usb = interface_to_usbdev(intf);
	int num_of_eps;
	u8 endpoint_num;
1304
	struct brcmf_usbdev_info *devinfo;
1305

1306
	brcmf_dbg(USB, "Enter\n");
1307

1308 1309 1310
	devinfo = kzalloc(sizeof(*devinfo), GFP_ATOMIC);
	if (devinfo == NULL)
		return -ENOMEM;
1311

1312 1313
	devinfo->usbdev = usb;
	devinfo->dev = &usb->dev;
1314

1315
	usb_set_intfdata(intf, devinfo);
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344

	/* Check that the device supports only one configuration */
	if (usb->descriptor.bNumConfigurations != 1) {
		ret = -1;
		goto fail;
	}

	if (usb->descriptor.bDeviceClass != USB_CLASS_VENDOR_SPEC) {
		ret = -1;
		goto fail;
	}

	/*
	 * Only the BDC interface configuration is supported:
	 *	Device class: USB_CLASS_VENDOR_SPEC
	 *	if0 class: USB_CLASS_VENDOR_SPEC
	 *	if0/ep0: control
	 *	if0/ep1: bulk in
	 *	if0/ep2: bulk out (ok if swapped with bulk in)
	 */
	if (CONFIGDESC(usb)->bNumInterfaces != 1) {
		ret = -1;
		goto fail;
	}

	/* Check interface */
	if (IFDESC(usb, CONTROL_IF).bInterfaceClass != USB_CLASS_VENDOR_SPEC ||
	    IFDESC(usb, CONTROL_IF).bInterfaceSubClass != 2 ||
	    IFDESC(usb, CONTROL_IF).bInterfaceProtocol != 0xff) {
1345
		brcmf_err("invalid control interface: class %d, subclass %d, proto %d\n",
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
			  IFDESC(usb, CONTROL_IF).bInterfaceClass,
			  IFDESC(usb, CONTROL_IF).bInterfaceSubClass,
			  IFDESC(usb, CONTROL_IF).bInterfaceProtocol);
		ret = -1;
		goto fail;
	}

	/* Check control endpoint */
	endpoint = &IFEPDESC(usb, CONTROL_IF, 0);
	if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK)
		!= USB_ENDPOINT_XFER_INT) {
1357
		brcmf_err("invalid control endpoint %d\n",
1358 1359 1360 1361 1362 1363
			  endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK);
		ret = -1;
		goto fail;
	}

	endpoint_num = endpoint->bEndpointAddress & USB_ENDPOINT_NUMBER_MASK;
1364
	devinfo->intr_pipe = usb_rcvintpipe(usb, endpoint_num);
1365

1366 1367 1368
	devinfo->rx_pipe = 0;
	devinfo->rx_pipe2 = 0;
	devinfo->tx_pipe = 0;
1369 1370 1371 1372 1373 1374 1375
	num_of_eps = IFDESC(usb, BULK_IF).bNumEndpoints - 1;

	/* Check data endpoints and get pipes */
	for (ep = 1; ep <= num_of_eps; ep++) {
		endpoint = &IFEPDESC(usb, BULK_IF, ep);
		if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) !=
		    USB_ENDPOINT_XFER_BULK) {
1376
			brcmf_err("invalid data endpoint %d\n", ep);
1377 1378 1379 1380 1381 1382 1383 1384
			ret = -1;
			goto fail;
		}

		endpoint_num = endpoint->bEndpointAddress &
			       USB_ENDPOINT_NUMBER_MASK;
		if ((endpoint->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
			== USB_DIR_IN) {
1385 1386
			if (!devinfo->rx_pipe) {
				devinfo->rx_pipe =
1387 1388
					usb_rcvbulkpipe(usb, endpoint_num);
			} else {
1389
				devinfo->rx_pipe2 =
1390 1391 1392
					usb_rcvbulkpipe(usb, endpoint_num);
			}
		} else {
1393
			devinfo->tx_pipe = usb_sndbulkpipe(usb, endpoint_num);
1394 1395 1396 1397 1398 1399
		}
	}

	/* Allocate interrupt URB and data buffer */
	/* RNDIS says 8-byte intr, our old drivers used 4-byte */
	if (IFEPDESC(usb, CONTROL_IF, 0).wMaxPacketSize == cpu_to_le16(16))
1400
		devinfo->intr_size = 8;
1401
	else
1402
		devinfo->intr_size = 4;
1403

1404
	devinfo->interval = IFEPDESC(usb, CONTROL_IF, 0).bInterval;
1405 1406

	if (usb->speed == USB_SPEED_HIGH)
1407
		brcmf_dbg(USB, "Broadcom high speed USB wireless device detected\n");
1408
	else
1409
		brcmf_dbg(USB, "Broadcom full speed USB wireless device detected\n");
1410

H
Hante Meuleman 已提交
1411
	ret = brcmf_usb_probe_cb(devinfo);
1412 1413 1414 1415 1416 1417 1418
	if (ret)
		goto fail;

	/* Success */
	return 0;

fail:
1419
	brcmf_err("failed with errno %d\n", ret);
1420
	kfree(devinfo);
1421 1422 1423 1424 1425 1426 1427 1428
	usb_set_intfdata(intf, NULL);
	return ret;

}

static void
brcmf_usb_disconnect(struct usb_interface *intf)
{
1429
	struct brcmf_usbdev_info *devinfo;
1430

1431
	brcmf_dbg(USB, "Enter\n");
1432 1433 1434
	devinfo = (struct brcmf_usbdev_info *)usb_get_intfdata(intf);
	brcmf_usb_disconnect_cb(devinfo);
	kfree(devinfo);
1435
	brcmf_dbg(USB, "Exit\n");
1436 1437 1438
}

/*
H
Hante Meuleman 已提交
1439
 * only need to signal the bus being down and update the state.
1440 1441 1442 1443 1444 1445
 */
static int brcmf_usb_suspend(struct usb_interface *intf, pm_message_t state)
{
	struct usb_device *usb = interface_to_usbdev(intf);
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);

1446
	brcmf_dbg(USB, "Enter\n");
H
Hante Meuleman 已提交
1447 1448
	devinfo->bus_pub.state = BRCMFMAC_USB_STATE_SLEEP;
	brcmf_detach(&usb->dev);
1449 1450 1451 1452
	return 0;
}

/*
H
Hante Meuleman 已提交
1453
 * (re-) start the bus.
1454 1455 1456 1457 1458 1459
 */
static int brcmf_usb_resume(struct usb_interface *intf)
{
	struct usb_device *usb = interface_to_usbdev(intf);
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);

1460
	brcmf_dbg(USB, "Enter\n");
H
Hante Meuleman 已提交
1461 1462 1463
	if (!brcmf_attach(0, devinfo->dev))
		return brcmf_bus_start(&usb->dev);

1464 1465 1466
	return 0;
}

H
Hante Meuleman 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
static int brcmf_usb_reset_resume(struct usb_interface *intf)
{
	struct usb_device *usb = interface_to_usbdev(intf);
	struct brcmf_usbdev_info *devinfo = brcmf_usb_get_businfo(&usb->dev);

	brcmf_dbg(USB, "Enter\n");

	if (!brcmf_usb_fw_download(devinfo))
		return brcmf_usb_resume(intf);

	return -EIO;
}

1480
#define BRCMF_USB_VENDOR_ID_BROADCOM	0x0a5c
1481
#define BRCMF_USB_DEVICE_ID_43143	0xbd1e
1482
#define BRCMF_USB_DEVICE_ID_43236	0xbd17
1483
#define BRCMF_USB_DEVICE_ID_43242	0xbd1f
1484 1485 1486
#define BRCMF_USB_DEVICE_ID_BCMFW	0x0bdc

static struct usb_device_id brcmf_usb_devid_table[] = {
1487
	{ USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43143) },
1488
	{ USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43236) },
1489
	{ USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_43242) },
1490 1491 1492 1493 1494
	/* special entry for device with firmware loaded and running */
	{ USB_DEVICE(BRCMF_USB_VENDOR_ID_BROADCOM, BRCMF_USB_DEVICE_ID_BCMFW) },
	{ }
};
MODULE_DEVICE_TABLE(usb, brcmf_usb_devid_table);
1495
MODULE_FIRMWARE(BRCMF_USB_43143_FW_NAME);
1496
MODULE_FIRMWARE(BRCMF_USB_43236_FW_NAME);
1497
MODULE_FIRMWARE(BRCMF_USB_43242_FW_NAME);
1498 1499 1500 1501 1502 1503 1504 1505

static struct usb_driver brcmf_usbdrvr = {
	.name = KBUILD_MODNAME,
	.probe = brcmf_usb_probe,
	.disconnect = brcmf_usb_disconnect,
	.id_table = brcmf_usb_devid_table,
	.suspend = brcmf_usb_suspend,
	.resume = brcmf_usb_resume,
H
Hante Meuleman 已提交
1506
	.reset_resume = brcmf_usb_reset_resume,
1507
	.supports_autosuspend = 1,
1508
	.disable_hub_initiated_lpm = 1,
1509 1510
};

1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
static void brcmf_release_fw(struct list_head *q)
{
	struct brcmf_usb_image *fw_image, *next;

	list_for_each_entry_safe(fw_image, next, q, list) {
		vfree(fw_image->image);
		list_del_init(&fw_image->list);
	}
}

1521 1522 1523 1524 1525 1526 1527 1528
static int brcmf_usb_reset_device(struct device *dev, void *notused)
{
	/* device past is the usb interface so we
	 * need to use parent here.
	 */
	brcmf_dev_reset(dev->parent);
	return 0;
}
1529

1530 1531
void brcmf_usb_exit(void)
{
1532 1533 1534
	struct device_driver *drv = &brcmf_usbdrvr.drvwrap.driver;
	int ret;

1535
	brcmf_dbg(USB, "Enter\n");
1536 1537
	ret = driver_for_each_device(drv, NULL, NULL,
				     brcmf_usb_reset_device);
1538
	usb_deregister(&brcmf_usbdrvr);
1539
	brcmf_release_fw(&fw_image_list);
1540 1541
}

1542
void brcmf_usb_init(void)
1543
{
1544
	brcmf_dbg(USB, "Enter\n");
1545
	INIT_LIST_HEAD(&fw_image_list);
1546
	usb_register(&brcmf_usbdrvr);
1547
}