1 /* 2 * Copyright (c) 2010 Broadcom Corporation 3 * 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. 7 * 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. 15 */ 16 17 /******************************************************************************* 18 * Communicates with the dongle by using dcmd codes. 19 * For certain dcmd codes, the dongle interprets string data from the host. 20 ******************************************************************************/ 21 22 #include <linux/types.h> 23 #include <linux/netdevice.h> 24 25 #include <brcmu_utils.h> 26 #include <brcmu_wifi.h> 27 28 #include "core.h" 29 #include "bus.h" 30 #include "fwsignal.h" 31 #include "debug.h" 32 #include "tracepoint.h" 33 #include "proto.h" 34 #include "bcdc.h" 35 36 struct brcmf_proto_bcdc_dcmd { 37 __le32 cmd; /* dongle command value */ 38 __le32 len; /* lower 16: output buflen; 39 * upper 16: input buflen (excludes header) */ 40 __le32 flags; /* flag defns given below */ 41 __le32 status; /* status code returned from the device */ 42 }; 43 44 /* BCDC flag definitions */ 45 #define BCDC_DCMD_ERROR 0x01 /* 1=cmd failed */ 46 #define BCDC_DCMD_SET 0x02 /* 0=get, 1=set cmd */ 47 #define BCDC_DCMD_IF_MASK 0xF000 /* I/F index */ 48 #define BCDC_DCMD_IF_SHIFT 12 49 #define BCDC_DCMD_ID_MASK 0xFFFF0000 /* id an cmd pairing */ 50 #define BCDC_DCMD_ID_SHIFT 16 /* ID Mask shift bits */ 51 #define BCDC_DCMD_ID(flags) \ 52 (((flags) & BCDC_DCMD_ID_MASK) >> BCDC_DCMD_ID_SHIFT) 53 54 /* 55 * BCDC header - Broadcom specific extension of CDC. 56 * Used on data packets to convey priority across USB. 57 */ 58 #define BCDC_HEADER_LEN 4 59 #define BCDC_PROTO_VER 2 /* Protocol version */ 60 #define BCDC_FLAG_VER_MASK 0xf0 /* Protocol version mask */ 61 #define BCDC_FLAG_VER_SHIFT 4 /* Protocol version shift */ 62 #define BCDC_FLAG_SUM_GOOD 0x04 /* Good RX checksums */ 63 #define BCDC_FLAG_SUM_NEEDED 0x08 /* Dongle needs to do TX checksums */ 64 #define BCDC_PRIORITY_MASK 0x7 65 #define BCDC_FLAG2_IF_MASK 0x0f /* packet rx interface in APSTA */ 66 #define BCDC_FLAG2_IF_SHIFT 0 67 68 #define BCDC_GET_IF_IDX(hdr) \ 69 ((int)((((hdr)->flags2) & BCDC_FLAG2_IF_MASK) >> BCDC_FLAG2_IF_SHIFT)) 70 #define BCDC_SET_IF_IDX(hdr, idx) \ 71 ((hdr)->flags2 = (((hdr)->flags2 & ~BCDC_FLAG2_IF_MASK) | \ 72 ((idx) << BCDC_FLAG2_IF_SHIFT))) 73 74 /** 75 * struct brcmf_proto_bcdc_header - BCDC header format 76 * 77 * @flags: flags contain protocol and checksum info. 78 * @priority: 802.1d priority and USB flow control info (bit 4:7). 79 * @flags2: additional flags containing dongle interface index. 80 * @data_offset: start of packet data. header is following by firmware signals. 81 */ 82 struct brcmf_proto_bcdc_header { 83 u8 flags; 84 u8 priority; 85 u8 flags2; 86 u8 data_offset; 87 }; 88 89 /* 90 * maximum length of firmware signal data between 91 * the BCDC header and packet data in the tx path. 92 */ 93 #define BRCMF_PROT_FW_SIGNAL_MAX_TXBYTES 12 94 95 #define RETRIES 2 /* # of retries to retrieve matching dcmd response */ 96 #define BUS_HEADER_LEN (16+64) /* Must be atleast SDPCM_RESERVE 97 * (amount of header tha might be added) 98 * plus any space that might be needed 99 * for bus alignment padding. 100 */ 101 struct brcmf_bcdc { 102 u16 reqid; 103 u8 bus_header[BUS_HEADER_LEN]; 104 struct brcmf_proto_bcdc_dcmd msg; 105 unsigned char buf[BRCMF_DCMD_MAXLEN]; 106 }; 107 108 109 static int 110 brcmf_proto_bcdc_msg(struct brcmf_pub *drvr, int ifidx, uint cmd, void *buf, 111 uint len, bool set) 112 { 113 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd; 114 struct brcmf_proto_bcdc_dcmd *msg = &bcdc->msg; 115 u32 flags; 116 117 brcmf_dbg(BCDC, "Enter\n"); 118 119 memset(msg, 0, sizeof(struct brcmf_proto_bcdc_dcmd)); 120 121 msg->cmd = cpu_to_le32(cmd); 122 msg->len = cpu_to_le32(len); 123 flags = (++bcdc->reqid << BCDC_DCMD_ID_SHIFT); 124 if (set) 125 flags |= BCDC_DCMD_SET; 126 flags = (flags & ~BCDC_DCMD_IF_MASK) | 127 (ifidx << BCDC_DCMD_IF_SHIFT); 128 msg->flags = cpu_to_le32(flags); 129 130 if (buf) 131 memcpy(bcdc->buf, buf, len); 132 133 len += sizeof(*msg); 134 if (len > BRCMF_TX_IOCTL_MAX_MSG_SIZE) 135 len = BRCMF_TX_IOCTL_MAX_MSG_SIZE; 136 137 /* Send request */ 138 return brcmf_bus_txctl(drvr->bus_if, (unsigned char *)&bcdc->msg, len); 139 } 140 141 static int brcmf_proto_bcdc_cmplt(struct brcmf_pub *drvr, u32 id, u32 len) 142 { 143 int ret; 144 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd; 145 146 brcmf_dbg(BCDC, "Enter\n"); 147 len += sizeof(struct brcmf_proto_bcdc_dcmd); 148 do { 149 ret = brcmf_bus_rxctl(drvr->bus_if, (unsigned char *)&bcdc->msg, 150 len); 151 if (ret < 0) 152 break; 153 } while (BCDC_DCMD_ID(le32_to_cpu(bcdc->msg.flags)) != id); 154 155 return ret; 156 } 157 158 static int 159 brcmf_proto_bcdc_query_dcmd(struct brcmf_pub *drvr, int ifidx, uint cmd, 160 void *buf, uint len) 161 { 162 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd; 163 struct brcmf_proto_bcdc_dcmd *msg = &bcdc->msg; 164 void *info; 165 int ret = 0, retries = 0; 166 u32 id, flags; 167 168 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len); 169 170 ret = brcmf_proto_bcdc_msg(drvr, ifidx, cmd, buf, len, false); 171 if (ret < 0) { 172 brcmf_err("brcmf_proto_bcdc_msg failed w/status %d\n", 173 ret); 174 goto done; 175 } 176 177 retry: 178 /* wait for interrupt and get first fragment */ 179 ret = brcmf_proto_bcdc_cmplt(drvr, bcdc->reqid, len); 180 if (ret < 0) 181 goto done; 182 183 flags = le32_to_cpu(msg->flags); 184 id = (flags & BCDC_DCMD_ID_MASK) >> BCDC_DCMD_ID_SHIFT; 185 186 if ((id < bcdc->reqid) && (++retries < RETRIES)) 187 goto retry; 188 if (id != bcdc->reqid) { 189 brcmf_err("%s: unexpected request id %d (expected %d)\n", 190 brcmf_ifname(brcmf_get_ifp(drvr, ifidx)), id, 191 bcdc->reqid); 192 ret = -EINVAL; 193 goto done; 194 } 195 196 /* Check info buffer */ 197 info = (void *)&msg[1]; 198 199 /* Copy info buffer */ 200 if (buf) { 201 if (ret < (int)len) 202 len = ret; 203 memcpy(buf, info, len); 204 } 205 206 /* Check the ERROR flag */ 207 if (flags & BCDC_DCMD_ERROR) 208 ret = le32_to_cpu(msg->status); 209 210 done: 211 return ret; 212 } 213 214 static int 215 brcmf_proto_bcdc_set_dcmd(struct brcmf_pub *drvr, int ifidx, uint cmd, 216 void *buf, uint len) 217 { 218 struct brcmf_bcdc *bcdc = (struct brcmf_bcdc *)drvr->proto->pd; 219 struct brcmf_proto_bcdc_dcmd *msg = &bcdc->msg; 220 int ret = 0; 221 u32 flags, id; 222 223 brcmf_dbg(BCDC, "Enter, cmd %d len %d\n", cmd, len); 224 225 ret = brcmf_proto_bcdc_msg(drvr, ifidx, cmd, buf, len, true); 226 if (ret < 0) 227 goto done; 228 229 ret = brcmf_proto_bcdc_cmplt(drvr, bcdc->reqid, len); 230 if (ret < 0) 231 goto done; 232 233 flags = le32_to_cpu(msg->flags); 234 id = (flags & BCDC_DCMD_ID_MASK) >> BCDC_DCMD_ID_SHIFT; 235 236 if (id != bcdc->reqid) { 237 brcmf_err("%s: unexpected request id %d (expected %d)\n", 238 brcmf_ifname(brcmf_get_ifp(drvr, ifidx)), id, 239 bcdc->reqid); 240 ret = -EINVAL; 241 goto done; 242 } 243 244 /* Check the ERROR flag */ 245 if (flags & BCDC_DCMD_ERROR) 246 ret = le32_to_cpu(msg->status); 247 248 done: 249 return ret; 250 } 251 252 static void 253 brcmf_proto_bcdc_hdrpush(struct brcmf_pub *drvr, int ifidx, u8 offset, 254 struct sk_buff *pktbuf) 255 { 256 struct brcmf_proto_bcdc_header *h; 257 258 brcmf_dbg(BCDC, "Enter\n"); 259 260 /* Push BDC header used to convey priority for buses that don't */ 261 skb_push(pktbuf, BCDC_HEADER_LEN); 262 263 h = (struct brcmf_proto_bcdc_header *)(pktbuf->data); 264 265 h->flags = (BCDC_PROTO_VER << BCDC_FLAG_VER_SHIFT); 266 if (pktbuf->ip_summed == CHECKSUM_PARTIAL) 267 h->flags |= BCDC_FLAG_SUM_NEEDED; 268 269 h->priority = (pktbuf->priority & BCDC_PRIORITY_MASK); 270 h->flags2 = 0; 271 h->data_offset = offset; 272 BCDC_SET_IF_IDX(h, ifidx); 273 trace_brcmf_bcdchdr(pktbuf->data); 274 } 275 276 static int 277 brcmf_proto_bcdc_hdrpull(struct brcmf_pub *drvr, bool do_fws, 278 struct sk_buff *pktbuf, struct brcmf_if **ifp) 279 { 280 struct brcmf_proto_bcdc_header *h; 281 struct brcmf_if *tmp_if; 282 283 brcmf_dbg(BCDC, "Enter\n"); 284 285 /* Pop BCDC header used to convey priority for buses that don't */ 286 if (pktbuf->len <= BCDC_HEADER_LEN) { 287 brcmf_dbg(INFO, "rx data too short (%d <= %d)\n", 288 pktbuf->len, BCDC_HEADER_LEN); 289 return -EBADE; 290 } 291 292 trace_brcmf_bcdchdr(pktbuf->data); 293 h = (struct brcmf_proto_bcdc_header *)(pktbuf->data); 294 295 tmp_if = brcmf_get_ifp(drvr, BCDC_GET_IF_IDX(h)); 296 if (!tmp_if) { 297 brcmf_dbg(INFO, "no matching ifp found\n"); 298 return -EBADE; 299 } 300 if (((h->flags & BCDC_FLAG_VER_MASK) >> BCDC_FLAG_VER_SHIFT) != 301 BCDC_PROTO_VER) { 302 brcmf_err("%s: non-BCDC packet received, flags 0x%x\n", 303 brcmf_ifname(tmp_if), h->flags); 304 return -EBADE; 305 } 306 307 if (h->flags & BCDC_FLAG_SUM_GOOD) { 308 brcmf_dbg(BCDC, "%s: BDC rcv, good checksum, flags 0x%x\n", 309 brcmf_ifname(tmp_if), h->flags); 310 pktbuf->ip_summed = CHECKSUM_UNNECESSARY; 311 } 312 313 pktbuf->priority = h->priority & BCDC_PRIORITY_MASK; 314 315 skb_pull(pktbuf, BCDC_HEADER_LEN); 316 if (do_fws) 317 brcmf_fws_hdrpull(tmp_if, h->data_offset << 2, pktbuf); 318 else 319 skb_pull(pktbuf, h->data_offset << 2); 320 321 if (pktbuf->len == 0) 322 return -ENODATA; 323 324 *ifp = tmp_if; 325 return 0; 326 } 327 328 static int 329 brcmf_proto_bcdc_txdata(struct brcmf_pub *drvr, int ifidx, u8 offset, 330 struct sk_buff *pktbuf) 331 { 332 brcmf_proto_bcdc_hdrpush(drvr, ifidx, offset, pktbuf); 333 return brcmf_bus_txdata(drvr->bus_if, pktbuf); 334 } 335 336 static void 337 brcmf_proto_bcdc_configure_addr_mode(struct brcmf_pub *drvr, int ifidx, 338 enum proto_addr_mode addr_mode) 339 { 340 } 341 342 static void 343 brcmf_proto_bcdc_delete_peer(struct brcmf_pub *drvr, int ifidx, 344 u8 peer[ETH_ALEN]) 345 { 346 } 347 348 static void 349 brcmf_proto_bcdc_add_tdls_peer(struct brcmf_pub *drvr, int ifidx, 350 u8 peer[ETH_ALEN]) 351 { 352 } 353 354 int brcmf_proto_bcdc_attach(struct brcmf_pub *drvr) 355 { 356 struct brcmf_bcdc *bcdc; 357 358 bcdc = kzalloc(sizeof(*bcdc), GFP_ATOMIC); 359 if (!bcdc) 360 goto fail; 361 362 /* ensure that the msg buf directly follows the cdc msg struct */ 363 if ((unsigned long)(&bcdc->msg + 1) != (unsigned long)bcdc->buf) { 364 brcmf_err("struct brcmf_proto_bcdc is not correctly defined\n"); 365 goto fail; 366 } 367 368 drvr->proto->hdrpull = brcmf_proto_bcdc_hdrpull; 369 drvr->proto->query_dcmd = brcmf_proto_bcdc_query_dcmd; 370 drvr->proto->set_dcmd = brcmf_proto_bcdc_set_dcmd; 371 drvr->proto->txdata = brcmf_proto_bcdc_txdata; 372 drvr->proto->configure_addr_mode = brcmf_proto_bcdc_configure_addr_mode; 373 drvr->proto->delete_peer = brcmf_proto_bcdc_delete_peer; 374 drvr->proto->add_tdls_peer = brcmf_proto_bcdc_add_tdls_peer; 375 drvr->proto->pd = bcdc; 376 377 drvr->hdrlen += BCDC_HEADER_LEN + BRCMF_PROT_FW_SIGNAL_MAX_TXBYTES; 378 drvr->bus_if->maxctl = BRCMF_DCMD_MAXLEN + 379 sizeof(struct brcmf_proto_bcdc_dcmd); 380 return 0; 381 382 fail: 383 kfree(bcdc); 384 return -ENOMEM; 385 } 386 387 void brcmf_proto_bcdc_detach(struct brcmf_pub *drvr) 388 { 389 kfree(drvr->proto->pd); 390 drvr->proto->pd = NULL; 391 } 392