2 * Copyright (c) 2011 Broadcom Corporation
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
11 * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
13 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
14 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/firmware.h>
20 #include <linux/usb.h>
21 #include <linux/vmalloc.h>
23 #include <brcmu_utils.h>
24 #include <brcm_hw_ids.h>
25 #include <brcmu_wifi.h>
35 #define IOCTL_RESP_TIMEOUT msecs_to_jiffies(2000)
37 #define BRCMF_USB_RESET_GETVER_SPINWAIT 100 /* in unit of ms */
38 #define BRCMF_USB_RESET_GETVER_LOOP_CNT 10
40 #define BRCMF_POSTBOOT_ID 0xA123 /* ID to detect if dongle
42 #define BRCMF_USB_NRXQ 50
43 #define BRCMF_USB_NTXQ 50
45 #define BRCMF_USB_CBCTL_WRITE 0
46 #define BRCMF_USB_CBCTL_READ 1
47 #define BRCMF_USB_MAX_PKT_SIZE 1600
49 BRCMF_FW_DEF(43143, "brcmfmac43143.bin");
50 BRCMF_FW_DEF(43236B
, "brcmfmac43236b.bin");
51 BRCMF_FW_DEF(43242A
, "brcmfmac43242a.bin");
52 BRCMF_FW_DEF(43569, "brcmfmac43569.bin");
53 BRCMF_FW_DEF(4373, "brcmfmac4373.bin");
55 static struct brcmf_firmware_mapping brcmf_usb_fwnames
[] = {
56 BRCMF_FW_ENTRY(BRCM_CC_43143_CHIP_ID
, 0xFFFFFFFF, 43143),
57 BRCMF_FW_ENTRY(BRCM_CC_43235_CHIP_ID
, 0x00000008, 43236B
),
58 BRCMF_FW_ENTRY(BRCM_CC_43236_CHIP_ID
, 0x00000008, 43236B
),
59 BRCMF_FW_ENTRY(BRCM_CC_43238_CHIP_ID
, 0x00000008, 43236B
),
60 BRCMF_FW_ENTRY(BRCM_CC_43242_CHIP_ID
, 0xFFFFFFFF, 43242A
),
61 BRCMF_FW_ENTRY(BRCM_CC_43566_CHIP_ID
, 0xFFFFFFFF, 43569),
62 BRCMF_FW_ENTRY(BRCM_CC_43569_CHIP_ID
, 0xFFFFFFFF, 43569),
63 BRCMF_FW_ENTRY(CY_CC_4373_CHIP_ID
, 0xFFFFFFFF, 4373)
66 #define TRX_MAGIC 0x30524448 /* "HDR0" */
67 #define TRX_MAX_OFFSET 3 /* Max number of file offsets */
68 #define TRX_UNCOMP_IMAGE 0x20 /* Trx holds uncompressed img */
69 #define TRX_RDL_CHUNK 1500 /* size of each dl transfer */
70 #define TRX_OFFSETS_DLFWLEN_IDX 0
72 /* Control messages: bRequest values */
73 #define DL_GETSTATE 0 /* returns the rdl_state_t struct */
74 #define DL_CHECK_CRC 1 /* currently unused */
75 #define DL_GO 2 /* execute downloaded image */
76 #define DL_START 3 /* initialize dl state */
77 #define DL_REBOOT 4 /* reboot the device in 2 seconds */
78 #define DL_GETVER 5 /* returns the bootrom_id_t struct */
79 #define DL_GO_PROTECTED 6 /* execute the downloaded code and set reset
80 * event to occur in 2 seconds. It is the
81 * responsibility of the downloaded code to
84 #define DL_EXEC 7 /* jump to a supplied address */
85 #define DL_RESETCFG 8 /* To support single enum on dongle
86 * - Not used by bootloader
88 #define DL_DEFER_RESP_OK 9 /* Potentially defer the response to setup
93 #define DL_WAITING 0 /* waiting to rx first pkt */
94 #define DL_READY 1 /* hdr was good, waiting for more of the
97 #define DL_BAD_HDR 2 /* hdr was corrupted */
98 #define DL_BAD_CRC 3 /* compressed image was corrupted */
99 #define DL_RUNNABLE 4 /* download was successful,waiting for go cmd */
100 #define DL_START_FAIL 5 /* failed to initialize correctly */
101 #define DL_NVRAM_TOOBIG 6 /* host specified nvram data exceeds DL_NVRAM
104 #define DL_IMAGE_TOOBIG 7 /* firmware image too big */
107 struct trx_header_le
{
108 __le32 magic
; /* "HDR0" */
109 __le32 len
; /* Length of file including header */
110 __le32 crc32
; /* CRC from flag_version to end of file */
111 __le32 flag_version
; /* 0:15 flags, 16:31 version */
112 __le32 offsets
[TRX_MAX_OFFSET
]; /* Offsets of partitions from start of
117 struct rdl_state_le
{
122 struct bootrom_id_le
{
123 __le32 chip
; /* Chip id */
124 __le32 chiprev
; /* Chip rev */
125 __le32 ramsize
; /* Size of RAM */
126 __le32 remapbase
; /* Current remap base address */
127 __le32 boardtype
; /* Type of board */
128 __le32 boardrev
; /* Board revision */
131 struct brcmf_usb_image
{
132 struct list_head list
;
138 struct brcmf_usbdev_info
{
139 struct brcmf_usbdev bus_pub
; /* MUST BE FIRST */
141 struct list_head rx_freeq
;
142 struct list_head rx_postq
;
143 struct list_head tx_freeq
;
144 struct list_head tx_postq
;
145 uint rx_pipe
, tx_pipe
;
147 int rx_low_watermark
;
148 int tx_low_watermark
;
149 int tx_high_watermark
;
152 spinlock_t tx_flowblock_lock
;
154 struct brcmf_usbreq
*tx_reqs
;
155 struct brcmf_usbreq
*rx_reqs
;
157 char fw_name
[BRCMF_FW_NAME_LEN
];
158 const u8
*image
; /* buffer for combine fw and nvram */
161 struct usb_device
*usbdev
;
163 struct mutex dev_init_lock
;
165 int ctl_in_pipe
, ctl_out_pipe
;
166 struct urb
*ctl_urb
; /* URB for control endpoint */
167 struct usb_ctrlrequest ctl_write
;
168 struct usb_ctrlrequest ctl_read
;
169 u32 ctl_urb_actual_length
;
172 wait_queue_head_t ioctl_resp_wait
;
176 struct urb
*bulk_urb
; /* used for FW download */
179 struct brcmf_mp_device
*settings
;
182 static void brcmf_usb_rx_refill(struct brcmf_usbdev_info
*devinfo
,
183 struct brcmf_usbreq
*req
);
185 static struct brcmf_usbdev
*brcmf_usb_get_buspub(struct device
*dev
)
187 struct brcmf_bus
*bus_if
= dev_get_drvdata(dev
);
188 return bus_if
->bus_priv
.usb
;
191 static struct brcmf_usbdev_info
*brcmf_usb_get_businfo(struct device
*dev
)
193 return brcmf_usb_get_buspub(dev
)->devinfo
;
196 static int brcmf_usb_ioctl_resp_wait(struct brcmf_usbdev_info
*devinfo
)
198 return wait_event_timeout(devinfo
->ioctl_resp_wait
,
199 devinfo
->ctl_completed
, IOCTL_RESP_TIMEOUT
);
202 static void brcmf_usb_ioctl_resp_wake(struct brcmf_usbdev_info
*devinfo
)
204 wake_up(&devinfo
->ioctl_resp_wait
);
208 brcmf_usb_ctl_complete(struct brcmf_usbdev_info
*devinfo
, int type
, int status
)
210 brcmf_dbg(USB
, "Enter, status=%d\n", status
);
212 if (unlikely(devinfo
== NULL
))
215 if (type
== BRCMF_USB_CBCTL_READ
) {
217 devinfo
->bus_pub
.stats
.rx_ctlpkts
++;
219 devinfo
->bus_pub
.stats
.rx_ctlerrs
++;
220 } else if (type
== BRCMF_USB_CBCTL_WRITE
) {
222 devinfo
->bus_pub
.stats
.tx_ctlpkts
++;
224 devinfo
->bus_pub
.stats
.tx_ctlerrs
++;
227 devinfo
->ctl_urb_status
= status
;
228 devinfo
->ctl_completed
= true;
229 brcmf_usb_ioctl_resp_wake(devinfo
);
233 brcmf_usb_ctlread_complete(struct urb
*urb
)
235 struct brcmf_usbdev_info
*devinfo
=
236 (struct brcmf_usbdev_info
*)urb
->context
;
238 brcmf_dbg(USB
, "Enter\n");
239 devinfo
->ctl_urb_actual_length
= urb
->actual_length
;
240 brcmf_usb_ctl_complete(devinfo
, BRCMF_USB_CBCTL_READ
,
245 brcmf_usb_ctlwrite_complete(struct urb
*urb
)
247 struct brcmf_usbdev_info
*devinfo
=
248 (struct brcmf_usbdev_info
*)urb
->context
;
250 brcmf_dbg(USB
, "Enter\n");
251 brcmf_usb_ctl_complete(devinfo
, BRCMF_USB_CBCTL_WRITE
,
256 brcmf_usb_send_ctl(struct brcmf_usbdev_info
*devinfo
, u8
*buf
, int len
)
261 brcmf_dbg(USB
, "Enter\n");
262 if (devinfo
== NULL
|| buf
== NULL
||
263 len
== 0 || devinfo
->ctl_urb
== NULL
)
267 devinfo
->ctl_write
.wLength
= cpu_to_le16p(&size
);
268 devinfo
->ctl_urb
->transfer_buffer_length
= size
;
269 devinfo
->ctl_urb_status
= 0;
270 devinfo
->ctl_urb_actual_length
= 0;
272 usb_fill_control_urb(devinfo
->ctl_urb
,
274 devinfo
->ctl_out_pipe
,
275 (unsigned char *) &devinfo
->ctl_write
,
277 (usb_complete_t
)brcmf_usb_ctlwrite_complete
,
280 ret
= usb_submit_urb(devinfo
->ctl_urb
, GFP_ATOMIC
);
282 brcmf_err("usb_submit_urb failed %d\n", ret
);
288 brcmf_usb_recv_ctl(struct brcmf_usbdev_info
*devinfo
, u8
*buf
, int len
)
293 brcmf_dbg(USB
, "Enter\n");
294 if ((devinfo
== NULL
) || (buf
== NULL
) || (len
== 0)
295 || (devinfo
->ctl_urb
== NULL
))
299 devinfo
->ctl_read
.wLength
= cpu_to_le16p(&size
);
300 devinfo
->ctl_urb
->transfer_buffer_length
= size
;
302 devinfo
->ctl_read
.bRequestType
= USB_DIR_IN
303 | USB_TYPE_CLASS
| USB_RECIP_INTERFACE
;
304 devinfo
->ctl_read
.bRequest
= 1;
306 usb_fill_control_urb(devinfo
->ctl_urb
,
308 devinfo
->ctl_in_pipe
,
309 (unsigned char *) &devinfo
->ctl_read
,
311 (usb_complete_t
)brcmf_usb_ctlread_complete
,
314 ret
= usb_submit_urb(devinfo
->ctl_urb
, GFP_ATOMIC
);
316 brcmf_err("usb_submit_urb failed %d\n", ret
);
321 static int brcmf_usb_tx_ctlpkt(struct device
*dev
, u8
*buf
, u32 len
)
325 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
327 brcmf_dbg(USB
, "Enter\n");
328 if (devinfo
->bus_pub
.state
!= BRCMFMAC_USB_STATE_UP
)
331 if (test_and_set_bit(0, &devinfo
->ctl_op
))
334 devinfo
->ctl_completed
= false;
335 err
= brcmf_usb_send_ctl(devinfo
, buf
, len
);
337 brcmf_err("fail %d bytes: %d\n", err
, len
);
338 clear_bit(0, &devinfo
->ctl_op
);
341 timeout
= brcmf_usb_ioctl_resp_wait(devinfo
);
342 clear_bit(0, &devinfo
->ctl_op
);
344 brcmf_err("Txctl wait timed out\n");
350 static int brcmf_usb_rx_ctlpkt(struct device
*dev
, u8
*buf
, u32 len
)
354 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
356 brcmf_dbg(USB
, "Enter\n");
357 if (devinfo
->bus_pub
.state
!= BRCMFMAC_USB_STATE_UP
)
360 if (test_and_set_bit(0, &devinfo
->ctl_op
))
363 devinfo
->ctl_completed
= false;
364 err
= brcmf_usb_recv_ctl(devinfo
, buf
, len
);
366 brcmf_err("fail %d bytes: %d\n", err
, len
);
367 clear_bit(0, &devinfo
->ctl_op
);
370 timeout
= brcmf_usb_ioctl_resp_wait(devinfo
);
371 err
= devinfo
->ctl_urb_status
;
372 clear_bit(0, &devinfo
->ctl_op
);
374 brcmf_err("rxctl wait timed out\n");
378 return devinfo
->ctl_urb_actual_length
;
383 static struct brcmf_usbreq
*brcmf_usb_deq(struct brcmf_usbdev_info
*devinfo
,
384 struct list_head
*q
, int *counter
)
387 struct brcmf_usbreq
*req
;
388 spin_lock_irqsave(&devinfo
->qlock
, flags
);
390 spin_unlock_irqrestore(&devinfo
->qlock
, flags
);
393 req
= list_entry(q
->next
, struct brcmf_usbreq
, list
);
394 list_del_init(q
->next
);
397 spin_unlock_irqrestore(&devinfo
->qlock
, flags
);
402 static void brcmf_usb_enq(struct brcmf_usbdev_info
*devinfo
,
403 struct list_head
*q
, struct brcmf_usbreq
*req
,
407 spin_lock_irqsave(&devinfo
->qlock
, flags
);
408 list_add_tail(&req
->list
, q
);
411 spin_unlock_irqrestore(&devinfo
->qlock
, flags
);
414 static struct brcmf_usbreq
*
415 brcmf_usbdev_qinit(struct list_head
*q
, int qsize
)
418 struct brcmf_usbreq
*req
, *reqs
;
420 reqs
= kcalloc(qsize
, sizeof(struct brcmf_usbreq
), GFP_ATOMIC
);
426 for (i
= 0; i
< qsize
; i
++) {
427 req
->urb
= usb_alloc_urb(0, GFP_ATOMIC
);
431 INIT_LIST_HEAD(&req
->list
);
432 list_add_tail(&req
->list
, q
);
437 brcmf_err("fail!\n");
438 while (!list_empty(q
)) {
439 req
= list_entry(q
->next
, struct brcmf_usbreq
, list
);
441 usb_free_urb(req
->urb
);
448 static void brcmf_usb_free_q(struct list_head
*q
, bool pending
)
450 struct brcmf_usbreq
*req
, *next
;
452 list_for_each_entry_safe(req
, next
, q
, list
) {
454 brcmf_err("bad req\n");
459 usb_kill_urb(req
->urb
);
461 usb_free_urb(req
->urb
);
462 list_del_init(&req
->list
);
467 static void brcmf_usb_del_fromq(struct brcmf_usbdev_info
*devinfo
,
468 struct brcmf_usbreq
*req
)
472 spin_lock_irqsave(&devinfo
->qlock
, flags
);
473 list_del_init(&req
->list
);
474 spin_unlock_irqrestore(&devinfo
->qlock
, flags
);
478 static void brcmf_usb_tx_complete(struct urb
*urb
)
480 struct brcmf_usbreq
*req
= (struct brcmf_usbreq
*)urb
->context
;
481 struct brcmf_usbdev_info
*devinfo
= req
->devinfo
;
484 brcmf_dbg(USB
, "Enter, urb->status=%d, skb=%p\n", urb
->status
,
486 brcmf_usb_del_fromq(devinfo
, req
);
488 brcmf_proto_bcdc_txcomplete(devinfo
->dev
, req
->skb
, urb
->status
== 0);
490 brcmf_usb_enq(devinfo
, &devinfo
->tx_freeq
, req
, &devinfo
->tx_freecount
);
491 spin_lock_irqsave(&devinfo
->tx_flowblock_lock
, flags
);
492 if (devinfo
->tx_freecount
> devinfo
->tx_high_watermark
&&
493 devinfo
->tx_flowblock
) {
494 brcmf_proto_bcdc_txflowblock(devinfo
->dev
, false);
495 devinfo
->tx_flowblock
= false;
497 spin_unlock_irqrestore(&devinfo
->tx_flowblock_lock
, flags
);
500 static void brcmf_usb_rx_complete(struct urb
*urb
)
502 struct brcmf_usbreq
*req
= (struct brcmf_usbreq
*)urb
->context
;
503 struct brcmf_usbdev_info
*devinfo
= req
->devinfo
;
506 brcmf_dbg(USB
, "Enter, urb->status=%d\n", urb
->status
);
507 brcmf_usb_del_fromq(devinfo
, req
);
511 /* zero lenght packets indicate usb "failure". Do not refill */
512 if (urb
->status
!= 0 || !urb
->actual_length
) {
513 brcmu_pkt_buf_free_skb(skb
);
514 brcmf_usb_enq(devinfo
, &devinfo
->rx_freeq
, req
, NULL
);
518 if (devinfo
->bus_pub
.state
== BRCMFMAC_USB_STATE_UP
) {
519 skb_put(skb
, urb
->actual_length
);
520 brcmf_rx_frame(devinfo
->dev
, skb
, true);
521 brcmf_usb_rx_refill(devinfo
, req
);
523 brcmu_pkt_buf_free_skb(skb
);
524 brcmf_usb_enq(devinfo
, &devinfo
->rx_freeq
, req
, NULL
);
530 static void brcmf_usb_rx_refill(struct brcmf_usbdev_info
*devinfo
,
531 struct brcmf_usbreq
*req
)
536 if (!req
|| !devinfo
)
539 skb
= dev_alloc_skb(devinfo
->bus_pub
.bus_mtu
);
541 brcmf_usb_enq(devinfo
, &devinfo
->rx_freeq
, req
, NULL
);
546 usb_fill_bulk_urb(req
->urb
, devinfo
->usbdev
, devinfo
->rx_pipe
,
547 skb
->data
, skb_tailroom(skb
), brcmf_usb_rx_complete
,
549 req
->devinfo
= devinfo
;
550 brcmf_usb_enq(devinfo
, &devinfo
->rx_postq
, req
, NULL
);
552 ret
= usb_submit_urb(req
->urb
, GFP_ATOMIC
);
554 brcmf_usb_del_fromq(devinfo
, req
);
555 brcmu_pkt_buf_free_skb(req
->skb
);
557 brcmf_usb_enq(devinfo
, &devinfo
->rx_freeq
, req
, NULL
);
562 static void brcmf_usb_rx_fill_all(struct brcmf_usbdev_info
*devinfo
)
564 struct brcmf_usbreq
*req
;
566 if (devinfo
->bus_pub
.state
!= BRCMFMAC_USB_STATE_UP
) {
567 brcmf_err("bus is not up=%d\n", devinfo
->bus_pub
.state
);
570 while ((req
= brcmf_usb_deq(devinfo
, &devinfo
->rx_freeq
, NULL
)) != NULL
)
571 brcmf_usb_rx_refill(devinfo
, req
);
575 brcmf_usb_state_change(struct brcmf_usbdev_info
*devinfo
, int state
)
577 struct brcmf_bus
*bcmf_bus
= devinfo
->bus_pub
.bus
;
580 brcmf_dbg(USB
, "Enter, current state=%d, new state=%d\n",
581 devinfo
->bus_pub
.state
, state
);
583 if (devinfo
->bus_pub
.state
== state
)
586 old_state
= devinfo
->bus_pub
.state
;
587 devinfo
->bus_pub
.state
= state
;
589 /* update state of upper layer */
590 if (state
== BRCMFMAC_USB_STATE_DOWN
) {
591 brcmf_dbg(USB
, "DBUS is down\n");
592 brcmf_bus_change_state(bcmf_bus
, BRCMF_BUS_DOWN
);
593 } else if (state
== BRCMFMAC_USB_STATE_UP
) {
594 brcmf_dbg(USB
, "DBUS is up\n");
595 brcmf_bus_change_state(bcmf_bus
, BRCMF_BUS_UP
);
597 brcmf_dbg(USB
, "DBUS current state=%d\n", state
);
601 static int brcmf_usb_tx(struct device
*dev
, struct sk_buff
*skb
)
603 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
604 struct brcmf_usbreq
*req
;
608 brcmf_dbg(USB
, "Enter, skb=%p\n", skb
);
609 if (devinfo
->bus_pub
.state
!= BRCMFMAC_USB_STATE_UP
) {
614 req
= brcmf_usb_deq(devinfo
, &devinfo
->tx_freeq
,
615 &devinfo
->tx_freecount
);
617 brcmf_err("no req to send\n");
623 req
->devinfo
= devinfo
;
624 usb_fill_bulk_urb(req
->urb
, devinfo
->usbdev
, devinfo
->tx_pipe
,
625 skb
->data
, skb
->len
, brcmf_usb_tx_complete
, req
);
626 req
->urb
->transfer_flags
|= URB_ZERO_PACKET
;
627 brcmf_usb_enq(devinfo
, &devinfo
->tx_postq
, req
, NULL
);
628 ret
= usb_submit_urb(req
->urb
, GFP_ATOMIC
);
630 brcmf_err("brcmf_usb_tx usb_submit_urb FAILED\n");
631 brcmf_usb_del_fromq(devinfo
, req
);
633 brcmf_usb_enq(devinfo
, &devinfo
->tx_freeq
, req
,
634 &devinfo
->tx_freecount
);
638 spin_lock_irqsave(&devinfo
->tx_flowblock_lock
, flags
);
639 if (devinfo
->tx_freecount
< devinfo
->tx_low_watermark
&&
640 !devinfo
->tx_flowblock
) {
641 brcmf_proto_bcdc_txflowblock(dev
, true);
642 devinfo
->tx_flowblock
= true;
644 spin_unlock_irqrestore(&devinfo
->tx_flowblock_lock
, flags
);
652 static int brcmf_usb_up(struct device
*dev
)
654 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
656 brcmf_dbg(USB
, "Enter\n");
657 if (devinfo
->bus_pub
.state
== BRCMFMAC_USB_STATE_UP
)
660 /* Success, indicate devinfo is fully up */
661 brcmf_usb_state_change(devinfo
, BRCMFMAC_USB_STATE_UP
);
663 if (devinfo
->ctl_urb
) {
664 devinfo
->ctl_in_pipe
= usb_rcvctrlpipe(devinfo
->usbdev
, 0);
665 devinfo
->ctl_out_pipe
= usb_sndctrlpipe(devinfo
->usbdev
, 0);
668 devinfo
->ctl_write
.bRequestType
=
669 USB_DIR_OUT
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
;
670 devinfo
->ctl_write
.bRequest
= 0;
671 devinfo
->ctl_write
.wValue
= cpu_to_le16(0);
672 devinfo
->ctl_write
.wIndex
= cpu_to_le16(devinfo
->ifnum
);
675 devinfo
->ctl_read
.bRequestType
=
676 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
;
677 devinfo
->ctl_read
.bRequest
= 1;
678 devinfo
->ctl_read
.wValue
= cpu_to_le16(0);
679 devinfo
->ctl_read
.wIndex
= cpu_to_le16(devinfo
->ifnum
);
681 brcmf_usb_rx_fill_all(devinfo
);
685 static void brcmf_cancel_all_urbs(struct brcmf_usbdev_info
*devinfo
)
687 if (devinfo
->ctl_urb
)
688 usb_kill_urb(devinfo
->ctl_urb
);
689 if (devinfo
->bulk_urb
)
690 usb_kill_urb(devinfo
->bulk_urb
);
691 brcmf_usb_free_q(&devinfo
->tx_postq
, true);
692 brcmf_usb_free_q(&devinfo
->rx_postq
, true);
695 static void brcmf_usb_down(struct device
*dev
)
697 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
699 brcmf_dbg(USB
, "Enter\n");
703 if (devinfo
->bus_pub
.state
== BRCMFMAC_USB_STATE_DOWN
)
706 brcmf_usb_state_change(devinfo
, BRCMFMAC_USB_STATE_DOWN
);
708 brcmf_cancel_all_urbs(devinfo
);
712 brcmf_usb_sync_complete(struct urb
*urb
)
714 struct brcmf_usbdev_info
*devinfo
=
715 (struct brcmf_usbdev_info
*)urb
->context
;
717 devinfo
->ctl_completed
= true;
718 brcmf_usb_ioctl_resp_wake(devinfo
);
721 static int brcmf_usb_dl_cmd(struct brcmf_usbdev_info
*devinfo
, u8 cmd
,
722 void *buffer
, int buflen
)
728 if ((!devinfo
) || (devinfo
->ctl_urb
== NULL
))
731 tmpbuf
= kmalloc(buflen
, GFP_ATOMIC
);
736 devinfo
->ctl_urb
->transfer_buffer_length
= size
;
738 devinfo
->ctl_read
.wLength
= cpu_to_le16p(&size
);
739 devinfo
->ctl_read
.bRequestType
= USB_DIR_IN
| USB_TYPE_VENDOR
|
741 devinfo
->ctl_read
.bRequest
= cmd
;
743 usb_fill_control_urb(devinfo
->ctl_urb
,
745 usb_rcvctrlpipe(devinfo
->usbdev
, 0),
746 (unsigned char *) &devinfo
->ctl_read
,
747 (void *) tmpbuf
, size
,
748 (usb_complete_t
)brcmf_usb_sync_complete
, devinfo
);
750 devinfo
->ctl_completed
= false;
751 ret
= usb_submit_urb(devinfo
->ctl_urb
, GFP_ATOMIC
);
753 brcmf_err("usb_submit_urb failed %d\n", ret
);
757 if (!brcmf_usb_ioctl_resp_wait(devinfo
)) {
758 usb_kill_urb(devinfo
->ctl_urb
);
761 memcpy(buffer
, tmpbuf
, buflen
);
770 brcmf_usb_dlneeded(struct brcmf_usbdev_info
*devinfo
)
772 struct bootrom_id_le id
;
775 brcmf_dbg(USB
, "Enter\n");
780 /* Check if firmware downloaded already by querying runtime ID */
781 id
.chip
= cpu_to_le32(0xDEAD);
782 brcmf_usb_dl_cmd(devinfo
, DL_GETVER
, &id
, sizeof(id
));
784 chipid
= le32_to_cpu(id
.chip
);
785 chiprev
= le32_to_cpu(id
.chiprev
);
787 if ((chipid
& 0x4300) == 0x4300)
788 brcmf_dbg(USB
, "chip %x rev 0x%x\n", chipid
, chiprev
);
790 brcmf_dbg(USB
, "chip %d rev 0x%x\n", chipid
, chiprev
);
791 if (chipid
== BRCMF_POSTBOOT_ID
) {
792 brcmf_dbg(USB
, "firmware already downloaded\n");
793 brcmf_usb_dl_cmd(devinfo
, DL_RESETCFG
, &id
, sizeof(id
));
796 devinfo
->bus_pub
.devid
= chipid
;
797 devinfo
->bus_pub
.chiprev
= chiprev
;
803 brcmf_usb_resetcfg(struct brcmf_usbdev_info
*devinfo
)
805 struct bootrom_id_le id
;
809 brcmf_dbg(USB
, "Enter\n");
813 mdelay(BRCMF_USB_RESET_GETVER_SPINWAIT
);
815 id
.chip
= cpu_to_le32(0xDEAD); /* Get the ID */
816 err
= brcmf_usb_dl_cmd(devinfo
, DL_GETVER
, &id
, sizeof(id
));
817 if ((err
) && (err
!= -ETIMEDOUT
))
819 if (id
.chip
== cpu_to_le32(BRCMF_POSTBOOT_ID
))
821 } while (loop_cnt
< BRCMF_USB_RESET_GETVER_LOOP_CNT
);
823 if (id
.chip
== cpu_to_le32(BRCMF_POSTBOOT_ID
)) {
824 brcmf_dbg(USB
, "postboot chip 0x%x/rev 0x%x\n",
825 le32_to_cpu(id
.chip
), le32_to_cpu(id
.chiprev
));
827 brcmf_usb_dl_cmd(devinfo
, DL_RESETCFG
, &id
, sizeof(id
));
830 brcmf_err("Cannot talk to Dongle. Firmware is not UP, %d ms\n",
831 BRCMF_USB_RESET_GETVER_SPINWAIT
* loop_cnt
);
838 brcmf_usb_dl_send_bulk(struct brcmf_usbdev_info
*devinfo
, void *buffer
, int len
)
842 if ((devinfo
== NULL
) || (devinfo
->bulk_urb
== NULL
))
845 /* Prepare the URB */
846 usb_fill_bulk_urb(devinfo
->bulk_urb
, devinfo
->usbdev
,
847 devinfo
->tx_pipe
, buffer
, len
,
848 (usb_complete_t
)brcmf_usb_sync_complete
, devinfo
);
850 devinfo
->bulk_urb
->transfer_flags
|= URB_ZERO_PACKET
;
852 devinfo
->ctl_completed
= false;
853 ret
= usb_submit_urb(devinfo
->bulk_urb
, GFP_ATOMIC
);
855 brcmf_err("usb_submit_urb failed %d\n", ret
);
858 ret
= brcmf_usb_ioctl_resp_wait(devinfo
);
863 brcmf_usb_dl_writeimage(struct brcmf_usbdev_info
*devinfo
, u8
*fw
, int fwlen
)
865 unsigned int sendlen
, sent
, dllen
;
866 char *bulkchunk
= NULL
, *dlpos
;
867 struct rdl_state_le state
;
868 u32 rdlstate
, rdlbytes
;
871 brcmf_dbg(USB
, "Enter, fw %p, len %d\n", fw
, fwlen
);
873 bulkchunk
= kmalloc(TRX_RDL_CHUNK
, GFP_ATOMIC
);
874 if (bulkchunk
== NULL
) {
879 /* 1) Prepare USB boot loader for runtime image */
880 brcmf_usb_dl_cmd(devinfo
, DL_START
, &state
, sizeof(state
));
882 rdlstate
= le32_to_cpu(state
.state
);
883 rdlbytes
= le32_to_cpu(state
.bytes
);
885 /* 2) Check we are in the Waiting state */
886 if (rdlstate
!= DL_WAITING
) {
887 brcmf_err("Failed to DL_START\n");
895 /* Get chip id and rev */
896 while (rdlbytes
!= dllen
) {
897 /* Wait until the usb device reports it received all
898 * the bytes we sent */
899 if ((rdlbytes
== sent
) && (rdlbytes
!= dllen
)) {
900 if ((dllen
-sent
) < TRX_RDL_CHUNK
)
901 sendlen
= dllen
-sent
;
903 sendlen
= TRX_RDL_CHUNK
;
905 /* simply avoid having to send a ZLP by ensuring we
913 memcpy(bulkchunk
, dlpos
, sendlen
);
914 if (brcmf_usb_dl_send_bulk(devinfo
, bulkchunk
,
916 brcmf_err("send_bulk failed\n");
924 err
= brcmf_usb_dl_cmd(devinfo
, DL_GETSTATE
, &state
,
927 brcmf_err("DL_GETSTATE Failed\n");
931 rdlstate
= le32_to_cpu(state
.state
);
932 rdlbytes
= le32_to_cpu(state
.bytes
);
934 /* restart if an error is reported */
935 if (rdlstate
== DL_BAD_HDR
|| rdlstate
== DL_BAD_CRC
) {
936 brcmf_err("Bad Hdr or Bad CRC state %d\n",
945 brcmf_dbg(USB
, "Exit, err=%d\n", err
);
949 static int brcmf_usb_dlstart(struct brcmf_usbdev_info
*devinfo
, u8
*fw
, int len
)
953 brcmf_dbg(USB
, "Enter\n");
958 if (devinfo
->bus_pub
.devid
== 0xDEAD)
961 err
= brcmf_usb_dl_writeimage(devinfo
, fw
, len
);
963 devinfo
->bus_pub
.state
= BRCMFMAC_USB_STATE_DL_DONE
;
965 devinfo
->bus_pub
.state
= BRCMFMAC_USB_STATE_DL_FAIL
;
966 brcmf_dbg(USB
, "Exit, err=%d\n", err
);
971 static int brcmf_usb_dlrun(struct brcmf_usbdev_info
*devinfo
)
973 struct rdl_state_le state
;
975 brcmf_dbg(USB
, "Enter\n");
979 if (devinfo
->bus_pub
.devid
== 0xDEAD)
982 /* Check we are runnable */
984 brcmf_usb_dl_cmd(devinfo
, DL_GETSTATE
, &state
, sizeof(state
));
986 /* Start the image */
987 if (state
.state
== cpu_to_le32(DL_RUNNABLE
)) {
988 if (brcmf_usb_dl_cmd(devinfo
, DL_GO
, &state
, sizeof(state
)))
990 if (brcmf_usb_resetcfg(devinfo
))
992 /* The Dongle may go for re-enumeration. */
994 brcmf_err("Dongle not runnable\n");
997 brcmf_dbg(USB
, "Exit\n");
1002 brcmf_usb_fw_download(struct brcmf_usbdev_info
*devinfo
)
1006 brcmf_dbg(USB
, "Enter\n");
1007 if (devinfo
== NULL
)
1010 if (!devinfo
->image
) {
1011 brcmf_err("No firmware!\n");
1015 err
= brcmf_usb_dlstart(devinfo
,
1016 (u8
*)devinfo
->image
, devinfo
->image_len
);
1018 err
= brcmf_usb_dlrun(devinfo
);
1023 static void brcmf_usb_detach(struct brcmf_usbdev_info
*devinfo
)
1025 brcmf_dbg(USB
, "Enter, devinfo %p\n", devinfo
);
1028 brcmf_usb_free_q(&devinfo
->rx_freeq
, false);
1029 brcmf_usb_free_q(&devinfo
->tx_freeq
, false);
1031 usb_free_urb(devinfo
->ctl_urb
);
1032 usb_free_urb(devinfo
->bulk_urb
);
1034 kfree(devinfo
->tx_reqs
);
1035 kfree(devinfo
->rx_reqs
);
1037 if (devinfo
->settings
)
1038 brcmf_release_module_param(devinfo
->settings
);
1042 static int check_file(const u8
*headers
)
1044 struct trx_header_le
*trx
;
1045 int actual_len
= -1;
1047 brcmf_dbg(USB
, "Enter\n");
1048 /* Extract trx header */
1049 trx
= (struct trx_header_le
*) headers
;
1050 if (trx
->magic
!= cpu_to_le32(TRX_MAGIC
))
1053 headers
+= sizeof(struct trx_header_le
);
1055 if (le32_to_cpu(trx
->flag_version
) & TRX_UNCOMP_IMAGE
) {
1056 actual_len
= le32_to_cpu(trx
->offsets
[TRX_OFFSETS_DLFWLEN_IDX
]);
1057 return actual_len
+ sizeof(struct trx_header_le
);
1064 struct brcmf_usbdev
*brcmf_usb_attach(struct brcmf_usbdev_info
*devinfo
,
1067 brcmf_dbg(USB
, "Enter\n");
1069 devinfo
->bus_pub
.nrxq
= nrxq
;
1070 devinfo
->rx_low_watermark
= nrxq
/ 2;
1071 devinfo
->bus_pub
.devinfo
= devinfo
;
1072 devinfo
->bus_pub
.ntxq
= ntxq
;
1073 devinfo
->bus_pub
.state
= BRCMFMAC_USB_STATE_DOWN
;
1075 /* flow control when too many tx urbs posted */
1076 devinfo
->tx_low_watermark
= ntxq
/ 4;
1077 devinfo
->tx_high_watermark
= devinfo
->tx_low_watermark
* 3;
1078 devinfo
->bus_pub
.bus_mtu
= BRCMF_USB_MAX_PKT_SIZE
;
1080 /* Initialize other structure content */
1081 init_waitqueue_head(&devinfo
->ioctl_resp_wait
);
1083 /* Initialize the spinlocks */
1084 spin_lock_init(&devinfo
->qlock
);
1085 spin_lock_init(&devinfo
->tx_flowblock_lock
);
1087 INIT_LIST_HEAD(&devinfo
->rx_freeq
);
1088 INIT_LIST_HEAD(&devinfo
->rx_postq
);
1090 INIT_LIST_HEAD(&devinfo
->tx_freeq
);
1091 INIT_LIST_HEAD(&devinfo
->tx_postq
);
1093 devinfo
->tx_flowblock
= false;
1095 devinfo
->rx_reqs
= brcmf_usbdev_qinit(&devinfo
->rx_freeq
, nrxq
);
1096 if (!devinfo
->rx_reqs
)
1099 devinfo
->tx_reqs
= brcmf_usbdev_qinit(&devinfo
->tx_freeq
, ntxq
);
1100 if (!devinfo
->tx_reqs
)
1102 devinfo
->tx_freecount
= ntxq
;
1104 devinfo
->ctl_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1105 if (!devinfo
->ctl_urb
)
1107 devinfo
->bulk_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
1108 if (!devinfo
->bulk_urb
)
1111 return &devinfo
->bus_pub
;
1114 brcmf_err("failed!\n");
1115 brcmf_usb_detach(devinfo
);
1119 static void brcmf_usb_wowl_config(struct device
*dev
, bool enabled
)
1121 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
1123 brcmf_dbg(USB
, "Configuring WOWL, enabled=%d\n", enabled
);
1124 devinfo
->wowl_enabled
= enabled
;
1126 device_set_wakeup_enable(devinfo
->dev
, true);
1128 device_set_wakeup_enable(devinfo
->dev
, false);
1131 static int brcmf_usb_get_fwname(struct device
*dev
, u32 chip
, u32 chiprev
,
1134 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(dev
);
1137 if (devinfo
->fw_name
[0] != '\0')
1138 strlcpy(fw_name
, devinfo
->fw_name
, BRCMF_FW_NAME_LEN
);
1140 ret
= brcmf_fw_map_chip_to_name(chip
, chiprev
,
1142 ARRAY_SIZE(brcmf_usb_fwnames
),
1148 static const struct brcmf_bus_ops brcmf_usb_bus_ops
= {
1149 .txdata
= brcmf_usb_tx
,
1150 .stop
= brcmf_usb_down
,
1151 .txctl
= brcmf_usb_tx_ctlpkt
,
1152 .rxctl
= brcmf_usb_rx_ctlpkt
,
1153 .wowl_config
= brcmf_usb_wowl_config
,
1154 .get_fwname
= brcmf_usb_get_fwname
,
1157 static int brcmf_usb_bus_setup(struct brcmf_usbdev_info
*devinfo
)
1161 /* Attach to the common driver interface */
1162 ret
= brcmf_attach(devinfo
->dev
, devinfo
->settings
);
1164 brcmf_err("brcmf_attach failed\n");
1168 ret
= brcmf_usb_up(devinfo
->dev
);
1172 ret
= brcmf_bus_started(devinfo
->dev
);
1178 brcmf_detach(devinfo
->dev
);
1182 static void brcmf_usb_probe_phase2(struct device
*dev
, int ret
,
1183 const struct firmware
*fw
,
1184 void *nvram
, u32 nvlen
)
1186 struct brcmf_bus
*bus
= dev_get_drvdata(dev
);
1187 struct brcmf_usbdev_info
*devinfo
= bus
->bus_priv
.usb
->devinfo
;
1192 brcmf_dbg(USB
, "Start fw downloading\n");
1194 ret
= check_file(fw
->data
);
1196 brcmf_err("invalid firmware\n");
1197 release_firmware(fw
);
1201 devinfo
->image
= fw
->data
;
1202 devinfo
->image_len
= fw
->size
;
1204 ret
= brcmf_usb_fw_download(devinfo
);
1205 release_firmware(fw
);
1209 ret
= brcmf_usb_bus_setup(devinfo
);
1213 mutex_unlock(&devinfo
->dev_init_lock
);
1216 brcmf_dbg(TRACE
, "failed: dev=%s, err=%d\n", dev_name(dev
), ret
);
1217 mutex_unlock(&devinfo
->dev_init_lock
);
1218 device_release_driver(dev
);
1221 static int brcmf_usb_probe_cb(struct brcmf_usbdev_info
*devinfo
)
1223 struct brcmf_bus
*bus
= NULL
;
1224 struct brcmf_usbdev
*bus_pub
= NULL
;
1225 struct device
*dev
= devinfo
->dev
;
1228 brcmf_dbg(USB
, "Enter\n");
1229 bus_pub
= brcmf_usb_attach(devinfo
, BRCMF_USB_NRXQ
, BRCMF_USB_NTXQ
);
1233 bus
= kzalloc(sizeof(struct brcmf_bus
), GFP_ATOMIC
);
1241 bus
->bus_priv
.usb
= bus_pub
;
1242 dev_set_drvdata(dev
, bus
);
1243 bus
->ops
= &brcmf_usb_bus_ops
;
1244 bus
->proto_type
= BRCMF_PROTO_BCDC
;
1245 bus
->always_use_fws_queue
= true;
1247 bus
->wowl_supported
= true;
1250 devinfo
->settings
= brcmf_get_module_param(bus
->dev
, BRCMF_BUSTYPE_USB
,
1253 if (!devinfo
->settings
) {
1258 if (!brcmf_usb_dlneeded(devinfo
)) {
1259 ret
= brcmf_usb_bus_setup(devinfo
);
1263 mutex_unlock(&devinfo
->dev_init_lock
);
1266 bus
->chip
= bus_pub
->devid
;
1267 bus
->chiprev
= bus_pub
->chiprev
;
1269 ret
= brcmf_fw_map_chip_to_name(bus_pub
->devid
, bus_pub
->chiprev
,
1271 ARRAY_SIZE(brcmf_usb_fwnames
),
1272 devinfo
->fw_name
, NULL
);
1276 /* request firmware here */
1277 ret
= brcmf_fw_get_firmwares(dev
, 0, devinfo
->fw_name
, NULL
,
1278 brcmf_usb_probe_phase2
);
1280 brcmf_err("firmware request failed: %d\n", ret
);
1287 /* Release resources in reverse order */
1289 brcmf_usb_detach(devinfo
);
1294 brcmf_usb_disconnect_cb(struct brcmf_usbdev_info
*devinfo
)
1298 brcmf_dbg(USB
, "Enter, bus_pub %p\n", devinfo
);
1300 brcmf_detach(devinfo
->dev
);
1301 kfree(devinfo
->bus_pub
.bus
);
1302 brcmf_usb_detach(devinfo
);
1306 brcmf_usb_probe(struct usb_interface
*intf
, const struct usb_device_id
*id
)
1308 struct usb_device
*usb
= interface_to_usbdev(intf
);
1309 struct brcmf_usbdev_info
*devinfo
;
1310 struct usb_interface_descriptor
*desc
;
1311 struct usb_endpoint_descriptor
*endpoint
;
1314 u8 endpoint_num
, ep
;
1316 brcmf_dbg(USB
, "Enter 0x%04x:0x%04x\n", id
->idVendor
, id
->idProduct
);
1318 devinfo
= kzalloc(sizeof(*devinfo
), GFP_ATOMIC
);
1319 if (devinfo
== NULL
)
1322 devinfo
->usbdev
= usb
;
1323 devinfo
->dev
= &usb
->dev
;
1324 /* Take an init lock, to protect for disconnect while still loading.
1325 * Necessary because of the asynchronous firmware load construction
1327 mutex_init(&devinfo
->dev_init_lock
);
1328 mutex_lock(&devinfo
->dev_init_lock
);
1330 usb_set_intfdata(intf
, devinfo
);
1332 /* Check that the device supports only one configuration */
1333 if (usb
->descriptor
.bNumConfigurations
!= 1) {
1334 brcmf_err("Number of configurations: %d not supported\n",
1335 usb
->descriptor
.bNumConfigurations
);
1340 if ((usb
->descriptor
.bDeviceClass
!= USB_CLASS_VENDOR_SPEC
) &&
1341 (usb
->descriptor
.bDeviceClass
!= USB_CLASS_MISC
) &&
1342 (usb
->descriptor
.bDeviceClass
!= USB_CLASS_WIRELESS_CONTROLLER
)) {
1343 brcmf_err("Device class: 0x%x not supported\n",
1344 usb
->descriptor
.bDeviceClass
);
1349 desc
= &intf
->altsetting
[0].desc
;
1350 if ((desc
->bInterfaceClass
!= USB_CLASS_VENDOR_SPEC
) ||
1351 (desc
->bInterfaceSubClass
!= 2) ||
1352 (desc
->bInterfaceProtocol
!= 0xff)) {
1353 brcmf_err("non WLAN interface %d: 0x%x:0x%x:0x%x\n",
1354 desc
->bInterfaceNumber
, desc
->bInterfaceClass
,
1355 desc
->bInterfaceSubClass
, desc
->bInterfaceProtocol
);
1360 num_of_eps
= desc
->bNumEndpoints
;
1361 for (ep
= 0; ep
< num_of_eps
; ep
++) {
1362 endpoint
= &intf
->altsetting
[0].endpoint
[ep
].desc
;
1363 endpoint_num
= usb_endpoint_num(endpoint
);
1364 if (!usb_endpoint_xfer_bulk(endpoint
))
1366 if (usb_endpoint_dir_in(endpoint
)) {
1367 if (!devinfo
->rx_pipe
)
1369 usb_rcvbulkpipe(usb
, endpoint_num
);
1371 if (!devinfo
->tx_pipe
)
1373 usb_sndbulkpipe(usb
, endpoint_num
);
1376 if (devinfo
->rx_pipe
== 0) {
1377 brcmf_err("No RX (in) Bulk EP found\n");
1381 if (devinfo
->tx_pipe
== 0) {
1382 brcmf_err("No TX (out) Bulk EP found\n");
1387 devinfo
->ifnum
= desc
->bInterfaceNumber
;
1389 if (usb
->speed
== USB_SPEED_SUPER_PLUS
)
1390 brcmf_dbg(USB
, "Broadcom super speed plus USB WLAN interface detected\n");
1391 else if (usb
->speed
== USB_SPEED_SUPER
)
1392 brcmf_dbg(USB
, "Broadcom super speed USB WLAN interface detected\n");
1393 else if (usb
->speed
== USB_SPEED_HIGH
)
1394 brcmf_dbg(USB
, "Broadcom high speed USB WLAN interface detected\n");
1396 brcmf_dbg(USB
, "Broadcom full speed USB WLAN interface detected\n");
1398 ret
= brcmf_usb_probe_cb(devinfo
);
1406 mutex_unlock(&devinfo
->dev_init_lock
);
1408 usb_set_intfdata(intf
, NULL
);
1413 brcmf_usb_disconnect(struct usb_interface
*intf
)
1415 struct brcmf_usbdev_info
*devinfo
;
1417 brcmf_dbg(USB
, "Enter\n");
1418 devinfo
= (struct brcmf_usbdev_info
*)usb_get_intfdata(intf
);
1421 mutex_lock(&devinfo
->dev_init_lock
);
1422 /* Make sure that devinfo still exists. Firmware probe routines
1423 * may have released the device and cleared the intfdata.
1425 if (!usb_get_intfdata(intf
))
1428 brcmf_usb_disconnect_cb(devinfo
);
1432 brcmf_dbg(USB
, "Exit\n");
1436 * only need to signal the bus being down and update the state.
1438 static int brcmf_usb_suspend(struct usb_interface
*intf
, pm_message_t state
)
1440 struct usb_device
*usb
= interface_to_usbdev(intf
);
1441 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(&usb
->dev
);
1443 brcmf_dbg(USB
, "Enter\n");
1444 devinfo
->bus_pub
.state
= BRCMFMAC_USB_STATE_SLEEP
;
1445 if (devinfo
->wowl_enabled
)
1446 brcmf_cancel_all_urbs(devinfo
);
1448 brcmf_detach(&usb
->dev
);
1453 * (re-) start the bus.
1455 static int brcmf_usb_resume(struct usb_interface
*intf
)
1457 struct usb_device
*usb
= interface_to_usbdev(intf
);
1458 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(&usb
->dev
);
1460 brcmf_dbg(USB
, "Enter\n");
1461 if (!devinfo
->wowl_enabled
)
1462 return brcmf_usb_bus_setup(devinfo
);
1464 devinfo
->bus_pub
.state
= BRCMFMAC_USB_STATE_UP
;
1465 brcmf_usb_rx_fill_all(devinfo
);
1469 static int brcmf_usb_reset_resume(struct usb_interface
*intf
)
1471 struct usb_device
*usb
= interface_to_usbdev(intf
);
1472 struct brcmf_usbdev_info
*devinfo
= brcmf_usb_get_businfo(&usb
->dev
);
1474 brcmf_dbg(USB
, "Enter\n");
1476 return brcmf_fw_get_firmwares(&usb
->dev
, 0, devinfo
->fw_name
, NULL
,
1477 brcmf_usb_probe_phase2
);
1480 #define BRCMF_USB_DEVICE(dev_id) \
1481 { USB_DEVICE(BRCM_USB_VENDOR_ID_BROADCOM, dev_id) }
1483 #define LINKSYS_USB_DEVICE(dev_id) \
1484 { USB_DEVICE(BRCM_USB_VENDOR_ID_LINKSYS, dev_id) }
1486 #define CYPRESS_USB_DEVICE(dev_id) \
1487 { USB_DEVICE(CY_USB_VENDOR_ID_CYPRESS, dev_id) }
1489 static const struct usb_device_id brcmf_usb_devid_table
[] = {
1490 BRCMF_USB_DEVICE(BRCM_USB_43143_DEVICE_ID
),
1491 BRCMF_USB_DEVICE(BRCM_USB_43236_DEVICE_ID
),
1492 BRCMF_USB_DEVICE(BRCM_USB_43242_DEVICE_ID
),
1493 BRCMF_USB_DEVICE(BRCM_USB_43569_DEVICE_ID
),
1494 LINKSYS_USB_DEVICE(BRCM_USB_43235_LINKSYS_DEVICE_ID
),
1495 CYPRESS_USB_DEVICE(CY_USB_4373_DEVICE_ID
),
1496 { USB_DEVICE(BRCM_USB_VENDOR_ID_LG
, BRCM_USB_43242_LG_DEVICE_ID
) },
1497 /* special entry for device with firmware loaded and running */
1498 BRCMF_USB_DEVICE(BRCM_USB_BCMFW_DEVICE_ID
),
1499 CYPRESS_USB_DEVICE(BRCM_USB_BCMFW_DEVICE_ID
),
1500 { /* end: all zeroes */ }
1503 MODULE_DEVICE_TABLE(usb
, brcmf_usb_devid_table
);
1505 static struct usb_driver brcmf_usbdrvr
= {
1506 .name
= KBUILD_MODNAME
,
1507 .probe
= brcmf_usb_probe
,
1508 .disconnect
= brcmf_usb_disconnect
,
1509 .id_table
= brcmf_usb_devid_table
,
1510 .suspend
= brcmf_usb_suspend
,
1511 .resume
= brcmf_usb_resume
,
1512 .reset_resume
= brcmf_usb_reset_resume
,
1513 .disable_hub_initiated_lpm
= 1,
1516 static int brcmf_usb_reset_device(struct device
*dev
, void *notused
)
1518 /* device past is the usb interface so we
1519 * need to use parent here.
1521 brcmf_dev_reset(dev
->parent
);
1525 void brcmf_usb_exit(void)
1527 struct device_driver
*drv
= &brcmf_usbdrvr
.drvwrap
.driver
;
1530 brcmf_dbg(USB
, "Enter\n");
1531 ret
= driver_for_each_device(drv
, NULL
, NULL
,
1532 brcmf_usb_reset_device
);
1533 usb_deregister(&brcmf_usbdrvr
);
1536 void brcmf_usb_register(void)
1538 brcmf_dbg(USB
, "Enter\n");
1539 usb_register(&brcmf_usbdrvr
);