git.openwrt.org Git - openwrt/staging/blogic.git/blob

1 /*

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 */

17 #include <linux/types.h>

18 #include <linux/netdevice.h>

19 #include <linux/sched.h>

20 #include <defs.h>

22 #include <brcmu_utils.h>

23 #include <brcmu_wifi.h>

25 #include "dngl_stats.h"

26 #include "dhd.h"

27 #include "dhd_proto.h"

28 #include "dhd_bus.h"

29 #include "dhd_dbg.h"

31 struct cdc_ioctl {

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 */

37 };

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)))

55 /*

56 * BDC header - Broadcom specific extension of CDC.

57 * Used on data packets to convey priority across USB.

58 */

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)))

75 struct bdc_header {

76 u8 flags;

77 u8 priority; /* 802.1d Priority, 4:7 flow control info for usb */

78 u8 flags2;

79 u8 rssi;

80 };

83 #ifdef CUSTOMER_HW2

84 int wifi_get_mac_addr(unsigned char *buf);

85 #endif

87 /* Packet alignment for most efficient SDIO (can change based on platform) */

88 #ifndef DHD_SDALIGN

89 #define DHD_SDALIGN 32

90 #endif

91 #if !ISPOWEROF2(DHD_SDALIGN)

92 #error DHD_SDALIGN is not a power of 2!

93 #endif

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.

101 */

102 #define ROUND_UP_MARGIN 2048 /* Biggest SDIO block size possible for

103 * round off at the end of buffer

104 */

105

106 typedef struct dhd_prot {

107 u16 reqid;

108 u8 pending;

109 u32 lastcmd;

110 u8 bus_header[BUS_HEADER_LEN];

111 struct cdc_ioctl msg;

112 unsigned char buf[BRCMF_C_IOCTL_MAXLEN + ROUND_UP_MARGIN];

113 } dhd_prot_t;

114

115 static int brcmf_proto_cdc_msg(dhd_pub_t *dhd)

116 {

117 dhd_prot_t *prot = dhd->prot;

118 int len = le32_to_cpu(prot->msg.len) + sizeof(struct cdc_ioctl);

119

120 DHD_TRACE(("%s: Enter\n", __func__));

121

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

125 */

126 if (len > CDC_MAX_MSG_SIZE)

127 len = CDC_MAX_MSG_SIZE;

128

129 /* Send request */

130 return brcmf_sdbrcm_bus_txctl(dhd->bus, (unsigned char *)&prot->msg,

131 len);

132 }

133

134 static int brcmf_proto_cdc_cmplt(dhd_pub_t *dhd, u32 id, u32 len)

135 {

136 int ret;

137 dhd_prot_t *prot = dhd->prot;

138

139 DHD_TRACE(("%s: Enter\n", __func__));

140

141 do {

142 ret = brcmf_sdbrcm_bus_rxctl(dhd->bus,

143 (unsigned char *)&prot->msg,

144 len + sizeof(struct cdc_ioctl));

145 if (ret < 0)

146 break;

147 } while (CDC_IOC_ID(le32_to_cpu(prot->msg.flags)) != id);

148

149 return ret;

150 }

151

152 int

153 brcmf_proto_cdc_query_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd, void *buf,

154 uint len)

155 {

156 dhd_prot_t *prot = dhd->prot;

157 struct cdc_ioctl *msg = &prot->msg;

158 void *info;

159 int ret = 0, retries = 0;

160 u32 id, flags = 0;

161

162 DHD_TRACE(("%s: Enter\n", __func__));

163 DHD_CTL(("%s: cmd %d len %d\n", __func__, cmd, len));

164

165 /* Respond "bcmerror" and "bcmerrorstr" with local cache */

166 if (cmd == BRCMF_C_GET_VAR && buf) {

167 if (!strcmp((char *)buf, "bcmerrorstr")) {

168 strncpy((char *)buf, "bcm_error",

169 BCME_STRLEN);

170 goto done;

171 } else if (!strcmp((char *)buf, "bcmerror")) {

172 *(int *)buf = dhd->dongle_error;

173 goto done;

174 }

175 }

176

177 memset(msg, 0, sizeof(struct cdc_ioctl));

178

179 msg->cmd = cpu_to_le32(cmd);

180 msg->len = cpu_to_le32(len);

181 msg->flags = (++prot->reqid << CDCF_IOC_ID_SHIFT);

182 CDC_SET_IF_IDX(msg, ifidx);

183 msg->flags = cpu_to_le32(msg->flags);

184

185 if (buf)

186 memcpy(prot->buf, buf, len);

187

188 ret = brcmf_proto_cdc_msg(dhd);

189 if (ret < 0) {

190 DHD_ERROR(("dhdcdc_query_ioctl: dhdcdc_msg failed w/status "

191 "%d\n", ret));

192 goto done;

193 }

194

195 retry:

196 /* wait for interrupt and get first fragment */

197 ret = brcmf_proto_cdc_cmplt(dhd, prot->reqid, len);

198 if (ret < 0)

199 goto done;

200

201 flags = le32_to_cpu(msg->flags);

202 id = (flags & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT;

203

204 if ((id < prot->reqid) && (++retries < RETRIES))

205 goto retry;

206 if (id != prot->reqid) {

207 DHD_ERROR(("%s: %s: unexpected request id %d (expected %d)\n",

208 brcmf_ifname(dhd, ifidx), __func__, id,

209 prot->reqid));

210 ret = -EINVAL;

211 goto done;

212 }

213

214 /* Check info buffer */

215 info = (void *)&msg[1];

216

217 /* Copy info buffer */

218 if (buf) {

219 if (ret < (int)len)

220 len = ret;

221 memcpy(buf, info, len);

222 }

223

224 /* Check the ERROR flag */

225 if (flags & CDCF_IOC_ERROR) {

226 ret = le32_to_cpu(msg->status);

227 /* Cache error from dongle */

228 dhd->dongle_error = ret;

229 }

230

231 done:

232 return ret;

233 }

234

235 int brcmf_proto_cdc_set_ioctl(dhd_pub_t *dhd, int ifidx, uint cmd,

236 void *buf, uint len)

237 {

238 dhd_prot_t *prot = dhd->prot;

239 struct cdc_ioctl *msg = &prot->msg;

240 int ret = 0;

241 u32 flags, id;

242

243 DHD_TRACE(("%s: Enter\n", __func__));

244 DHD_CTL(("%s: cmd %d len %d\n", __func__, cmd, len));

245

246 memset(msg, 0, sizeof(struct cdc_ioctl));

247

248 msg->cmd = cpu_to_le32(cmd);

249 msg->len = cpu_to_le32(len);

250 msg->flags = (++prot->reqid << CDCF_IOC_ID_SHIFT) | CDCF_IOC_SET;

251 CDC_SET_IF_IDX(msg, ifidx);

252 msg->flags = cpu_to_le32(msg->flags);

253

254 if (buf)

255 memcpy(prot->buf, buf, len);

256

257 ret = brcmf_proto_cdc_msg(dhd);

258 if (ret < 0)

259 goto done;

260

261 ret = brcmf_proto_cdc_cmplt(dhd, prot->reqid, len);

262 if (ret < 0)

263 goto done;

264

265 flags = le32_to_cpu(msg->flags);

266 id = (flags & CDCF_IOC_ID_MASK) >> CDCF_IOC_ID_SHIFT;

267

268 if (id != prot->reqid) {

269 DHD_ERROR(("%s: %s: unexpected request id %d (expected %d)\n",

270 brcmf_ifname(dhd, ifidx), __func__, id,

271 prot->reqid));

272 ret = -EINVAL;

273 goto done;

274 }

275

276 /* Check the ERROR flag */

277 if (flags & CDCF_IOC_ERROR) {

278 ret = le32_to_cpu(msg->status);

279 /* Cache error from dongle */

280 dhd->dongle_error = ret;

281 }

282

283 done:

284 return ret;

285 }

286

287 extern int dhd_bus_interface(struct dhd_bus *bus, uint arg, void *arg2);

288 int

289 brcmf_proto_ioctl(dhd_pub_t *dhd, int ifidx, wl_ioctl_t *ioc, void *buf,

290 int len)

291 {

292 dhd_prot_t *prot = dhd->prot;

293 int ret = -1;

294

295 if (dhd->busstate == DHD_BUS_DOWN) {

296 DHD_ERROR(("%s : bus is down. we have nothing to do\n",

297 __func__));

298 return ret;

299 }

300 brcmf_os_proto_block(dhd);

301

302 DHD_TRACE(("%s: Enter\n", __func__));

303

304 ASSERT(len <= BRCMF_C_IOCTL_MAXLEN);

305

306 if (len > BRCMF_C_IOCTL_MAXLEN)

307 goto done;

308

309 if (prot->pending == true) {

310 DHD_TRACE(("CDC packet is pending!!!! cmd=0x%x (%lu) "

311 "lastcmd=0x%x (%lu)\n",

312 ioc->cmd, (unsigned long)ioc->cmd, prot->lastcmd,

313 (unsigned long)prot->lastcmd));

314 if ((ioc->cmd == BRCMF_C_SET_VAR) ||

315 (ioc->cmd == BRCMF_C_GET_VAR))

316 DHD_TRACE(("iovar cmd=%s\n", (char *)buf));

317

318 goto done;

319 }

320

321 prot->pending = true;

322 prot->lastcmd = ioc->cmd;

323 if (ioc->set)

324 ret = brcmf_proto_cdc_set_ioctl(dhd, ifidx, ioc->cmd, buf, len);

325 else {

326 ret = brcmf_proto_cdc_query_ioctl(dhd, ifidx, ioc->cmd,

327 buf, len);

328 if (ret > 0)

329 ioc->used = ret - sizeof(struct cdc_ioctl);

330 }

331

332 /* Too many programs assume ioctl() returns 0 on success */

333 if (ret >= 0)

334 ret = 0;

335 else {

336 struct cdc_ioctl *msg = &prot->msg;

337 /* len == needed when set/query fails from dongle */

338 ioc->needed = le32_to_cpu(msg->len);

339 }

340

341 /* Intercept the wme_dp ioctl here */

342 if (!ret && ioc->cmd == BRCMF_C_SET_VAR &&

343 !strcmp(buf, "wme_dp")) {

344 int slen, val = 0;

345

346 slen = strlen("wme_dp") + 1;

347 if (len >= (int)(slen + sizeof(int)))

348 memcpy(&val, (char *)buf + slen, sizeof(int));

349 dhd->wme_dp = (u8) le32_to_cpu(val);

350 }

351

352 prot->pending = false;

353

354 done:

355 brcmf_os_proto_unblock(dhd);

356

357 return ret;

358 }

359

360 #define PKTSUMNEEDED(skb) \

361 (((struct sk_buff *)(skb))->ip_summed == CHECKSUM_PARTIAL)

362 #define PKTSETSUMGOOD(skb, x) \

363 (((struct sk_buff *)(skb))->ip_summed = \

364 ((x) ? CHECKSUM_UNNECESSARY : CHECKSUM_NONE))

365

366 /* PKTSETSUMNEEDED and PKTSUMGOOD are not possible because

367 skb->ip_summed is overloaded */

368

369 int

370 brcmf_proto_iovar_op(dhd_pub_t *dhdp, const char *name,

371 void *params, int plen, void *arg, int len, bool set)

372 {

373 return -ENOTSUPP;

374 }

375

376 void brcmf_proto_dump(dhd_pub_t *dhdp, struct brcmu_strbuf *strbuf)

377 {

378 brcmu_bprintf(strbuf, "Protocol CDC: reqid %d\n", dhdp->prot->reqid);

379 }

380

381 void brcmf_proto_hdrpush(dhd_pub_t *dhd, int ifidx, struct sk_buff *pktbuf)

382 {

383 struct bdc_header *h;

384

385 DHD_TRACE(("%s: Enter\n", __func__));

386

387 /* Push BDC header used to convey priority for buses that don't */

388

389 skb_push(pktbuf, BDC_HEADER_LEN);

390

391 h = (struct bdc_header *)(pktbuf->data);

392

393 h->flags = (BDC_PROTO_VER << BDC_FLAG_VER_SHIFT);

394 if (PKTSUMNEEDED(pktbuf))

395 h->flags |= BDC_FLAG_SUM_NEEDED;

396

397 h->priority = (pktbuf->priority & BDC_PRIORITY_MASK);

398 h->flags2 = 0;

399 h->rssi = 0;

400 BDC_SET_IF_IDX(h, ifidx);

401 }

402

403 int brcmf_proto_hdrpull(dhd_pub_t *dhd, int *ifidx, struct sk_buff *pktbuf)

404 {

405 struct bdc_header *h;

406

407 DHD_TRACE(("%s: Enter\n", __func__));

408

409 /* Pop BDC header used to convey priority for buses that don't */

410

411 if (pktbuf->len < BDC_HEADER_LEN) {

412 DHD_ERROR(("%s: rx data too short (%d < %d)\n", __func__,

413 pktbuf->len, BDC_HEADER_LEN));

414 return -EBADE;

415 }

416

417 h = (struct bdc_header *)(pktbuf->data);

418

419 *ifidx = BDC_GET_IF_IDX(h);

420 if (*ifidx >= DHD_MAX_IFS) {

421 DHD_ERROR(("%s: rx data ifnum out of range (%d)\n",

422 __func__, *ifidx));

423 return -EBADE;

424 }

425

426 if (((h->flags & BDC_FLAG_VER_MASK) >> BDC_FLAG_VER_SHIFT) !=

427 BDC_PROTO_VER) {

428 DHD_ERROR(("%s: non-BDC packet received, flags 0x%x\n",

429 brcmf_ifname(dhd, *ifidx), h->flags));

430 return -EBADE;

431 }

432

433 if (h->flags & BDC_FLAG_SUM_GOOD) {

434 DHD_INFO(("%s: BDC packet received with good rx-csum, "

435 "flags 0x%x\n",

436 brcmf_ifname(dhd, *ifidx), h->flags));

437 PKTSETSUMGOOD(pktbuf, true);

438 }

439

440 pktbuf->priority = h->priority & BDC_PRIORITY_MASK;

441

442 skb_pull(pktbuf, BDC_HEADER_LEN);

443

444 return 0;

445 }

446

447 int brcmf_proto_attach(dhd_pub_t *dhd)

448 {

449 dhd_prot_t *cdc;

450

451 cdc = kzalloc(sizeof(dhd_prot_t), GFP_ATOMIC);

452 if (!cdc) {

453 DHD_ERROR(("%s: kmalloc failed\n", __func__));

454 goto fail;

455 }

456

457 /* ensure that the msg buf directly follows the cdc msg struct */

458 if ((unsigned long)(&cdc->msg + 1) != (unsigned long)cdc->buf) {

459 DHD_ERROR(("dhd_prot_t is not correctly defined\n"));

460 goto fail;

461 }

462

463 dhd->prot = cdc;

464 dhd->hdrlen += BDC_HEADER_LEN;

465 dhd->maxctl = BRCMF_C_IOCTL_MAXLEN +

466 sizeof(struct cdc_ioctl) + ROUND_UP_MARGIN;

467 return 0;

468

469 fail:

470 kfree(cdc);

471 return -ENOMEM;

472 }

473

474 /* ~NOTE~ What if another thread is waiting on the semaphore? Holding it? */

475 void brcmf_proto_detach(dhd_pub_t *dhd)

476 {

477 kfree(dhd->prot);

478 dhd->prot = NULL;

479 }

480

481 void brcmf_proto_dstats(dhd_pub_t *dhd)

482 {

483 /* No stats from dongle added yet, copy bus stats */

484 dhd->dstats.tx_packets = dhd->tx_packets;

485 dhd->dstats.tx_errors = dhd->tx_errors;

486 dhd->dstats.rx_packets = dhd->rx_packets;

487 dhd->dstats.rx_errors = dhd->rx_errors;

488 dhd->dstats.rx_dropped = dhd->rx_dropped;

489 dhd->dstats.multicast = dhd->rx_multicast;

490 return;

491 }

492

493 int brcmf_proto_init(dhd_pub_t *dhd)

494 {

495 int ret = 0;

496 char buf[128];

497

498 DHD_TRACE(("%s: Enter\n", __func__));

499

500 brcmf_os_proto_block(dhd);

501

502 /* Get the device MAC address */

503 strcpy(buf, "cur_etheraddr");

504 ret = brcmf_proto_cdc_query_ioctl(dhd, 0, BRCMF_C_GET_VAR,

505 buf, sizeof(buf));

506 if (ret < 0) {

507 brcmf_os_proto_unblock(dhd);

508 return ret;

509 }

510 memcpy(dhd->mac, buf, ETH_ALEN);

511

512 brcmf_os_proto_unblock(dhd);

513

514 #ifdef EMBEDDED_PLATFORM

515 ret = brcmf_c_preinit_ioctls(dhd);

516 #endif /* EMBEDDED_PLATFORM */

517

518 /* Always assumes wl for now */

519 dhd->iswl = true;

520

521 return ret;

522 }

523

524 void brcmf_proto_stop(dhd_pub_t *dhd)

525 {

526 /* Nothing to do for CDC */

527 }