2 * Copyright (c) 2010 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/types.h>
18 #include <linux/netdevice.h>
19 #include <linux/sched.h>
22 #include <brcmu_utils.h>
23 #include <brcmu_wifi.h>
25 #include "dngl_stats.h"
27 #include "dhd_proto.h"
32 u32 cmd; /* ioctl command value */
33 u32 len; /* lower 16: output buflen;
34 * upper 16: input buflen (excludes header) */
35 u32 flags; /* flag defns given below */
36 u32 status; /* status code returned from the device */
39 /* Max valid buffer size that can be sent to the dongle */
40 #define CDC_MAX_MSG_SIZE (ETH_FRAME_LEN+ETH_FCS_LEN)
42 /* CDC flag definitions */
43 #define CDCF_IOC_ERROR 0x01 /* 1=ioctl cmd failed */
44 #define CDCF_IOC_SET 0x02 /* 0=get, 1=set cmd */
45 #define CDCF_IOC_IF_MASK 0xF000 /* I/F index */
46 #define CDCF_IOC_IF_SHIFT 12
47 #define CDCF_IOC_ID_MASK 0xFFFF0000 /* id an ioctl pairing */
48 #define CDCF_IOC_ID_SHIFT 16 /* ID Mask shift bits */
49 #define CDC_IOC_ID(flags) \
50 (((flags) & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT)
51 #define CDC_SET_IF_IDX(hdr, idx) \
52 ((hdr)->flags = (((hdr)->flags & ~CDCF_IOC_IF_MASK) | \
53 ((idx) << CDCF_IOC_IF_SHIFT)))
57 * Used on data packets to convey priority across USB.
59 #define BDC_HEADER_LEN 4
60 #define BDC_PROTO_VER 1 /* Protocol version */
61 #define BDC_FLAG_VER_MASK 0xf0 /* Protocol version mask */
62 #define BDC_FLAG_VER_SHIFT 4 /* Protocol version shift */
63 #define BDC_FLAG_SUM_GOOD 0x04 /* Good RX checksums */
64 #define BDC_FLAG_SUM_NEEDED 0x08 /* Dongle needs to do TX checksums */
65 #define BDC_PRIORITY_MASK 0x7
66 #define BDC_FLAG2_IF_MASK 0x0f /* packet rx interface in APSTA */
67 #define BDC_FLAG2_IF_SHIFT 0
69 #define BDC_GET_IF_IDX(hdr) \
70 ((int)((((hdr)->flags2) & BDC_FLAG2_IF_MASK) >> BDC_FLAG2_IF_SHIFT))
71 #define BDC_SET_IF_IDX(hdr, idx) \
72 ((hdr)->flags2 = (((hdr)->flags2 & ~BDC_FLAG2_IF_MASK) | \
73 ((idx) << BDC_FLAG2_IF_SHIFT)))
77 u8 priority; /* 802.1d Priority, 4:7 flow control info for usb */
84 int wifi_get_mac_addr(unsigned char *buf);
87 /* Packet alignment for most efficient SDIO (can change based on platform) */
89 #define DHD_SDALIGN 32
91 #if !ISPOWEROF2(DHD_SDALIGN)
92 #error DHD_SDALIGN is not a power of 2!
95 #define RETRIES 2 /* # of retries to retrieve matching ioctl response */
96 #define BUS_HEADER_LEN (16+DHD_SDALIGN) /* Must be atleast SDPCM_RESERVE
97 * defined in dhd_sdio.c
98 * (amount of header tha might be added)
99 * plus any space that might be needed
100 * for alignment padding.
102 #define ROUND_UP_MARGIN 2048 /* Biggest SDIO block size possible for
103 * round off at the end of buffer
106 typedef struct dhd_prot {
110 u8 bus_header[BUS_HEADER_LEN];
111 struct cdc_ioctl msg;
112 unsigned char buf[BRCMF_C_IOCTL_MAXLEN + ROUND_UP_MARGIN];
115 static int dhdcdc_msg(dhd_pub_t *dhd)
117 dhd_prot_t *prot = dhd->prot;
118 int len = le32_to_cpu(prot->msg.len) + sizeof(struct cdc_ioctl);
120 DHD_TRACE(("%s: Enter\n", __func__));
122 /* NOTE : cdc->msg.len holds the desired length of the buffer to be
123 * returned. Only up to CDC_MAX_MSG_SIZE of this buffer area
124 * is actually sent to the dongle
126 if (len > CDC_MAX_MSG_SIZE)
127 len = CDC_MAX_MSG_SIZE;
130 return brcmf_sdbrcm_bus_txctl(dhd->bus, (unsigned char *)&prot->msg,
134 static int dhdcdc_cmplt(dhd_pub_t *dhd, u32 id, u32 len)
137 dhd_prot_t *prot = dhd->prot;
139 DHD_TRACE(("%s: Enter\n", __func__));
142 ret = brcmf_sdbrcm_bus_rxctl(dhd->bus,
143 (unsigned char *)&prot->msg,
144 len + sizeof(struct cdc_ioctl));
147 } while (CDC_IOC_ID(le32_to_cpu(prot->msg.flags)) != id);
153 dhdcdc_query_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd, void *buf, uint len)
155 dhd_prot_t *prot = dhd->prot;
156 struct cdc_ioctl *msg = &prot->msg;
158 int ret = 0, retries = 0;
161 DHD_TRACE(("%s: Enter\n", __func__));
162 DHD_CTL(("%s: cmd %d len %d\n", __func__, cmd, len));
164 /* Respond "bcmerror" and "bcmerrorstr" with local cache */
165 if (cmd == BRCMF_C_GET_VAR && buf) {
166 if (!strcmp((char *)buf, "bcmerrorstr")) {
167 strncpy((char *)buf, "bcm_error",
170 } else if (!strcmp((char *)buf, "bcmerror")) {
171 *(int *)buf = dhd->dongle_error;
176 memset(msg, 0, sizeof(struct cdc_ioctl));
178 msg->cmd = cpu_to_le32(cmd);
179 msg->len = cpu_to_le32(len);
180 msg->flags = (++prot->reqid << CDCF_IOC_ID_SHIFT);
181 CDC_SET_IF_IDX(msg, ifidx);
182 msg->flags = cpu_to_le32(msg->flags);
185 memcpy(prot->buf, buf, len);
187 ret = dhdcdc_msg(dhd);
189 DHD_ERROR(("dhdcdc_query_ioctl: dhdcdc_msg failed w/status "
195 /* wait for interrupt and get first fragment */
196 ret = dhdcdc_cmplt(dhd, prot->reqid, len);
200 flags = le32_to_cpu(msg->flags);
201 id = (flags & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT;
203 if ((id < prot->reqid) && (++retries < RETRIES))
205 if (id != prot->reqid) {
206 DHD_ERROR(("%s: %s: unexpected request id %d (expected %d)\n",
207 brcmf_ifname(dhd, ifidx), __func__, id,
213 /* Check info buffer */
214 info = (void *)&msg[1];
216 /* Copy info buffer */
220 memcpy(buf, info, len);
223 /* Check the ERROR flag */
224 if (flags & CDCF_IOC_ERROR) {
225 ret = le32_to_cpu(msg->status);
226 /* Cache error from dongle */
227 dhd->dongle_error = ret;
234 int dhdcdc_set_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd, void *buf, uint len)
236 dhd_prot_t *prot = dhd->prot;
237 struct cdc_ioctl *msg = &prot->msg;
241 DHD_TRACE(("%s: Enter\n", __func__));
242 DHD_CTL(("%s: cmd %d len %d\n", __func__, cmd, len));
244 memset(msg, 0, sizeof(struct cdc_ioctl));
246 msg->cmd = cpu_to_le32(cmd);
247 msg->len = cpu_to_le32(len);
248 msg->flags = (++prot->reqid << CDCF_IOC_ID_SHIFT) | CDCF_IOC_SET;
249 CDC_SET_IF_IDX(msg, ifidx);
250 msg->flags = cpu_to_le32(msg->flags);
253 memcpy(prot->buf, buf, len);
255 ret = dhdcdc_msg(dhd);
259 ret = dhdcdc_cmplt(dhd, prot->reqid, len);
263 flags = le32_to_cpu(msg->flags);
264 id = (flags & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT;
266 if (id != prot->reqid) {
267 DHD_ERROR(("%s: %s: unexpected request id %d (expected %d)\n",
268 brcmf_ifname(dhd, ifidx), __func__, id,
274 /* Check the ERROR flag */
275 if (flags & CDCF_IOC_ERROR) {
276 ret = le32_to_cpu(msg->status);
277 /* Cache error from dongle */
278 dhd->dongle_error = ret;
285 extern int dhd_bus_interface(struct dhd_bus *bus, uint arg, void *arg2);
287 dhd_prot_ioctl(dhd_pub_t *dhd, int ifidx, wl_ioctl_t *ioc, void *buf, int len)
289 dhd_prot_t *prot = dhd->prot;
292 if (dhd->busstate == DHD_BUS_DOWN) {
293 DHD_ERROR(("%s : bus is down. we have nothing to do\n",
297 brcmf_os_proto_block(dhd);
299 DHD_TRACE(("%s: Enter\n", __func__));
301 ASSERT(len <= BRCMF_C_IOCTL_MAXLEN);
303 if (len > BRCMF_C_IOCTL_MAXLEN)
306 if (prot->pending == true) {
307 DHD_TRACE(("CDC packet is pending!!!! cmd=0x%x (%lu) "
308 "lastcmd=0x%x (%lu)\n",
309 ioc->cmd, (unsigned long)ioc->cmd, prot->lastcmd,
310 (unsigned long)prot->lastcmd));
311 if ((ioc->cmd == BRCMF_C_SET_VAR) ||
312 (ioc->cmd == BRCMF_C_GET_VAR))
313 DHD_TRACE(("iovar cmd=%s\n", (char *)buf));
318 prot->pending = true;
319 prot->lastcmd = ioc->cmd;
321 ret = dhdcdc_set_ioctl(dhd, ifidx, ioc->cmd, buf, len);
323 ret = dhdcdc_query_ioctl(dhd, ifidx, ioc->cmd, buf, len);
325 ioc->used = ret - sizeof(struct cdc_ioctl);
328 /* Too many programs assume ioctl() returns 0 on success */
332 struct cdc_ioctl *msg = &prot->msg;
333 /* len == needed when set/query fails from dongle */
334 ioc->needed = le32_to_cpu(msg->len);
337 /* Intercept the wme_dp ioctl here */
338 if (!ret && ioc->cmd == BRCMF_C_SET_VAR &&
339 !strcmp(buf, "wme_dp")) {
342 slen = strlen("wme_dp") + 1;
343 if (len >= (int)(slen + sizeof(int)))
344 memcpy(&val, (char *)buf + slen, sizeof(int));
345 dhd->wme_dp = (u8) le32_to_cpu(val);
348 prot->pending = false;
351 brcmf_os_proto_unblock(dhd);
356 #define PKTSUMNEEDED(skb) \
357 (((struct sk_buff *)(skb))->ip_summed == CHECKSUM_PARTIAL)
358 #define PKTSETSUMGOOD(skb, x) \
359 (((struct sk_buff *)(skb))->ip_summed = \
360 ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))
362 /* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because
363 skb->ip_summed is overloaded */
366 dhd_prot_iovar_op(dhd_pub_t *dhdp, const char *name,
367 void *params, int plen, void *arg, int len, bool set)
372 void dhd_prot_dump(dhd_pub_t *dhdp, struct brcmu_strbuf *strbuf)
374 brcmu_bprintf(strbuf, "Protocol CDC: reqid %d\n", dhdp->prot->reqid);
377 void dhd_prot_hdrpush(dhd_pub_t *dhd, int ifidx, struct sk_buff *pktbuf)
380 struct bdc_header *h;
383 DHD_TRACE(("%s: Enter\n", __func__));
386 /* Push BDC header used to convey priority for buses that don't */
388 skb_push(pktbuf, BDC_HEADER_LEN);
390 h = (struct bdc_header *)(pktbuf->data);
392 h->flags = (BDC_PROTO_VER << BDC_FLAG_VER_SHIFT);
393 if (PKTSUMNEEDED(pktbuf))
394 h->flags |= BDC_FLAG_SUM_NEEDED;
396 h->priority = (pktbuf->priority & BDC_PRIORITY_MASK);
400 BDC_SET_IF_IDX(h, ifidx);
403 int dhd_prot_hdrpull(dhd_pub_t *dhd, int *ifidx, struct sk_buff *pktbuf)
406 struct bdc_header *h;
409 DHD_TRACE(("%s: Enter\n", __func__));
412 /* Pop BDC header used to convey priority for buses that don't */
414 if (pktbuf->len < BDC_HEADER_LEN) {
415 DHD_ERROR(("%s: rx data too short (%d < %d)\n", __func__,
416 pktbuf->len, BDC_HEADER_LEN));
420 h = (struct bdc_header *)(pktbuf->data);
422 *ifidx = BDC_GET_IF_IDX(h);
423 if (*ifidx >= DHD_MAX_IFS) {
424 DHD_ERROR(("%s: rx data ifnum out of range (%d)\n",
429 if (((h->flags & BDC_FLAG_VER_MASK) >> BDC_FLAG_VER_SHIFT) !=
431 DHD_ERROR(("%s: non-BDC packet received, flags 0x%x\n",
432 brcmf_ifname(dhd, *ifidx), h->flags));
436 if (h->flags & BDC_FLAG_SUM_GOOD) {
437 DHD_INFO(("%s: BDC packet received with good rx-csum, "
439 brcmf_ifname(dhd, *ifidx), h->flags));
440 PKTSETSUMGOOD(pktbuf, true);
443 pktbuf->priority = h->priority & BDC_PRIORITY_MASK;
445 skb_pull(pktbuf, BDC_HEADER_LEN);
451 int dhd_prot_attach(dhd_pub_t *dhd)
455 cdc = kzalloc(sizeof(dhd_prot_t), GFP_ATOMIC);
457 DHD_ERROR(("%s: kmalloc failed\n", __func__));
461 /* ensure that the msg buf directly follows the cdc msg struct */
462 if ((unsigned long)(&cdc->msg + 1) != (unsigned long)cdc->buf) {
463 DHD_ERROR(("dhd_prot_t is not correctly defined\n"));
469 dhd->hdrlen += BDC_HEADER_LEN;
471 dhd->maxctl = BRCMF_C_IOCTL_MAXLEN +
472 sizeof(struct cdc_ioctl) + ROUND_UP_MARGIN;
480 /* ~NOTE~ What if another thread is waiting on the semaphore? Holding it? */
481 void dhd_prot_detach(dhd_pub_t *dhd)
487 void dhd_prot_dstats(dhd_pub_t *dhd)
489 /* No stats from dongle added yet, copy bus stats */
490 dhd->dstats.tx_packets = dhd->tx_packets;
491 dhd->dstats.tx_errors = dhd->tx_errors;
492 dhd->dstats.rx_packets = dhd->rx_packets;
493 dhd->dstats.rx_errors = dhd->rx_errors;
494 dhd->dstats.rx_dropped = dhd->rx_dropped;
495 dhd->dstats.multicast = dhd->rx_multicast;
499 int dhd_prot_init(dhd_pub_t *dhd)
504 DHD_TRACE(("%s: Enter\n", __func__));
506 brcmf_os_proto_block(dhd);
508 /* Get the device MAC address */
509 strcpy(buf, "cur_etheraddr");
510 ret = dhdcdc_query_ioctl(dhd, 0, BRCMF_C_GET_VAR, buf, sizeof(buf));
512 brcmf_os_proto_unblock(dhd);
515 memcpy(dhd->mac, buf, ETH_ALEN);
517 brcmf_os_proto_unblock(dhd);
519 #ifdef EMBEDDED_PLATFORM
520 ret = brcmf_c_preinit_ioctls(dhd);
521 #endif /* EMBEDDED_PLATFORM */
523 /* Always assumes wl for now */
529 void dhd_prot_stop(dhd_pub_t *dhd)
531 /* Nothing to do for CDC */