if_bwfm_sdio.c revision 1.13
1 /* $NetBSD: if_bwfm_sdio.c,v 1.13 2020/01/29 06:00:27 thorpej Exp $ */ 2 /* $OpenBSD: if_bwfm_sdio.c,v 1.1 2017/10/11 17:19:50 patrick Exp $ */ 3 /* 4 * Copyright (c) 2010-2016 Broadcom Corporation 5 * Copyright (c) 2016,2017 Patrick Wildt <patrick (at) blueri.se> 6 * 7 * Permission to use, copy, modify, and/or distribute this software for any 8 * purpose with or without fee is hereby granted, provided that the above 9 * copyright notice and this permission notice appear in all copies. 10 * 11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include <sys/param.h> 21 #include <sys/systm.h> 22 #include <sys/buf.h> 23 #include <sys/endian.h> 24 #include <sys/kernel.h> 25 #include <sys/malloc.h> 26 #include <sys/device.h> 27 #include <sys/queue.h> 28 #include <sys/socket.h> 29 #include <sys/mutex.h> 30 31 #include <net/bpf.h> 32 #include <net/if.h> 33 #include <net/if_dl.h> 34 #include <net/if_media.h> 35 #include <net/if_ether.h> 36 37 #include <netinet/in.h> 38 39 #include <dev/ofw/openfirm.h> 40 #include <dev/fdt/fdtvar.h> 41 42 #include <dev/firmload.h> 43 44 #include <net80211/ieee80211_var.h> 45 46 #include <dev/sdmmc/sdmmcdevs.h> 47 #include <dev/sdmmc/sdmmcvar.h> 48 49 #include <dev/ic/bwfmvar.h> 50 #include <dev/ic/bwfmreg.h> 51 #include <dev/sdmmc/if_bwfm_sdio.h> 52 53 #ifdef BWFM_DEBUG 54 #define DPRINTF(x) do { if (bwfm_debug > 0) printf x; } while (0) 55 #define DPRINTFN(n, x) do { if (bwfm_debug >= (n)) printf x; } while (0) 56 static int bwfm_debug = 2; 57 #else 58 #define DPRINTF(x) do { ; } while (0) 59 #define DPRINTFN(n, x) do { ; } while (0) 60 #endif 61 62 #define DEVNAME(sc) device_xname((sc)->sc_sc.sc_dev) 63 64 enum bwfm_sdio_clkstate { 65 CLK_NONE, 66 CLK_SDONLY, 67 CLK_PENDING, 68 CLK_AVAIL 69 }; 70 71 struct bwfm_sdio_softc { 72 struct bwfm_softc sc_sc; 73 kmutex_t sc_lock; 74 kmutex_t sc_intr_lock; 75 76 bool sc_bwfm_attached; 77 78 struct sdmmc_function **sc_sf; 79 size_t sc_sf_size; 80 81 uint32_t sc_bar0; 82 enum bwfm_sdio_clkstate sc_clkstate; 83 bool sc_sr_enabled; 84 bool sc_alp_only; 85 bool sc_sleeping; 86 bool sc_rxskip; 87 88 struct sdmmc_task sc_task; 89 bool sc_task_queued; 90 91 uint8_t sc_tx_seq; 92 uint8_t sc_tx_max_seq; 93 int sc_tx_count; 94 MBUFQ_HEAD() sc_tx_queue; 95 96 struct mbuf *sc_rxctl_queue; 97 kcondvar_t sc_rxctl_cv; 98 99 void *sc_ih; 100 struct bwfm_core *sc_cc; 101 102 char *sc_bounce_buf; 103 size_t sc_bounce_size; 104 105 uint32_t sc_console_addr; 106 char *sc_console_buf; 107 size_t sc_console_buf_size; 108 uint32_t sc_console_readidx; 109 110 int sc_phandle; 111 void *sc_fdtih; 112 }; 113 114 static int bwfm_sdio_match(device_t, cfdata_t, void *); 115 static void bwfm_sdio_attach(device_t, device_t, void *); 116 static int bwfm_sdio_detach(device_t, int); 117 static void bwfm_sdio_attachhook(device_t); 118 static int bwfm_fdt_find_phandle(device_t, device_t); 119 static const char *bwfm_fdt_get_model(void); 120 121 static void bwfm_sdio_backplane(struct bwfm_sdio_softc *, uint32_t); 122 static uint8_t bwfm_sdio_read_1(struct bwfm_sdio_softc *, uint32_t); 123 static uint32_t bwfm_sdio_read_4(struct bwfm_sdio_softc *, uint32_t); 124 static void bwfm_sdio_write_1(struct bwfm_sdio_softc *, uint32_t, 125 uint8_t); 126 static void bwfm_sdio_write_4(struct bwfm_sdio_softc *, uint32_t, 127 uint32_t); 128 129 static uint32_t bwfm_sdio_dev_read(struct bwfm_sdio_softc *, uint32_t); 130 static void bwfm_sdio_dev_write(struct bwfm_sdio_softc *, uint32_t, 131 uint32_t); 132 133 static uint32_t bwfm_sdio_buscore_read(struct bwfm_softc *, uint32_t); 134 static void bwfm_sdio_buscore_write(struct bwfm_softc *, uint32_t, 135 uint32_t); 136 static int bwfm_sdio_buscore_prepare(struct bwfm_softc *); 137 static void bwfm_sdio_buscore_activate(struct bwfm_softc *, uint32_t); 138 139 static int bwfm_sdio_buf_read(struct bwfm_sdio_softc *, 140 struct sdmmc_function *, uint32_t, char *, size_t); 141 static int bwfm_sdio_buf_write(struct bwfm_sdio_softc *, 142 struct sdmmc_function *, uint32_t, char *, size_t); 143 144 static struct mbuf *bwfm_sdio_newbuf(void); 145 static void bwfm_qput(struct mbuf **, struct mbuf *); 146 static struct mbuf *bwfm_qget(struct mbuf **); 147 148 static uint32_t bwfm_sdio_ram_read_write(struct bwfm_sdio_softc *, 149 uint32_t, char *, size_t, int); 150 static uint32_t bwfm_sdio_frame_read_write(struct bwfm_sdio_softc *, 151 char *, size_t, int); 152 153 static int bwfm_sdio_intr1(void *, const char *); 154 static int bwfm_sdio_intr(void *); 155 static void bwfm_sdio_task(void *); 156 static void bwfm_sdio_task1(struct bwfm_sdio_softc *); 157 158 static int bwfm_nvram_convert(u_char *, size_t, size_t *); 159 static int bwfm_sdio_load_microcode(struct bwfm_sdio_softc *, 160 u_char *, size_t, u_char *, size_t); 161 static void bwfm_sdio_clkctl(struct bwfm_sdio_softc *, 162 enum bwfm_sdio_clkstate, bool); 163 static void bwfm_sdio_htclk(struct bwfm_sdio_softc *, bool, bool); 164 165 #ifdef notyet 166 static int bwfm_sdio_bus_sleep(struct bwfm_sdio_softc *, bool, bool); 167 #endif 168 static void bwfm_sdio_drivestrength(struct bwfm_sdio_softc *, unsigned); 169 static void bwfm_sdio_readshared(struct bwfm_sdio_softc *); 170 171 static int bwfm_sdio_txcheck(struct bwfm_softc *); 172 static int bwfm_sdio_txdata(struct bwfm_softc *, struct mbuf **); 173 static int bwfm_sdio_txctl(struct bwfm_softc *, char *, size_t); 174 static int bwfm_sdio_rxctl(struct bwfm_softc *, char *, size_t *); 175 176 static int bwfm_sdio_tx_ok(struct bwfm_sdio_softc *); 177 static void bwfm_sdio_tx_frames(struct bwfm_sdio_softc *); 178 static void bwfm_sdio_tx_ctrlframe(struct bwfm_sdio_softc *, 179 struct mbuf *); 180 static void bwfm_sdio_tx_dataframe(struct bwfm_sdio_softc *, 181 struct mbuf *); 182 183 static void bwfm_sdio_rx_frames(struct bwfm_sdio_softc *); 184 static void bwfm_sdio_rx_glom(struct bwfm_sdio_softc *, 185 uint16_t *, int, uint16_t *); 186 187 #ifdef BWFM_DEBUG 188 static void bwfm_sdio_debug_console(struct bwfm_sdio_softc *); 189 #endif 190 191 struct bwfm_bus_ops bwfm_sdio_bus_ops = { 192 .bs_init = NULL, 193 .bs_stop = NULL, 194 .bs_txcheck = bwfm_sdio_txcheck, 195 .bs_txdata = bwfm_sdio_txdata, 196 .bs_txctl = bwfm_sdio_txctl, 197 .bs_rxctl = bwfm_sdio_rxctl, 198 }; 199 200 struct bwfm_buscore_ops bwfm_sdio_buscore_ops = { 201 .bc_read = bwfm_sdio_buscore_read, 202 .bc_write = bwfm_sdio_buscore_write, 203 .bc_prepare = bwfm_sdio_buscore_prepare, 204 .bc_reset = NULL, 205 .bc_setup = NULL, 206 .bc_activate = bwfm_sdio_buscore_activate, 207 }; 208 209 CFATTACH_DECL_NEW(bwfm_sdio, sizeof(struct bwfm_sdio_softc), 210 bwfm_sdio_match, bwfm_sdio_attach, bwfm_sdio_detach, NULL); 211 212 static const struct bwfm_sdio_product { 213 uint32_t manufacturer; 214 uint32_t product; 215 const char *cisinfo[4]; 216 } bwfm_sdio_products[] = { 217 { 218 SDMMC_VENDOR_BROADCOM, 219 SDMMC_PRODUCT_BROADCOM_BCM4330, 220 SDMMC_CIS_BROADCOM_BCM4330 221 }, 222 { 223 SDMMC_VENDOR_BROADCOM, 224 SDMMC_PRODUCT_BROADCOM_BCM4334, 225 SDMMC_CIS_BROADCOM_BCM4334 226 }, 227 { 228 SDMMC_VENDOR_BROADCOM, 229 SDMMC_PRODUCT_BROADCOM_BCM43143, 230 SDMMC_CIS_BROADCOM_BCM43143 231 }, 232 { 233 SDMMC_VENDOR_BROADCOM, 234 SDMMC_PRODUCT_BROADCOM_BCM43430, 235 SDMMC_CIS_BROADCOM_BCM43430 236 }, 237 { 238 SDMMC_VENDOR_BROADCOM, 239 SDMMC_PRODUCT_BROADCOM_BCM43455, 240 SDMMC_CIS_BROADCOM_BCM43455 241 }, 242 }; 243 244 static const char *compatible[] = { 245 "brcm,bcm4329-fmac", 246 NULL 247 }; 248 249 static int 250 bwfm_sdio_match(device_t parent, cfdata_t match, void *aux) 251 { 252 struct sdmmc_attach_args *saa = aux; 253 struct sdmmc_function *sf = saa->sf; 254 struct sdmmc_cis *cis; 255 const struct bwfm_sdio_product *bsp; 256 int i; 257 258 /* Not SDIO. */ 259 if (sf == NULL) 260 return 0; 261 262 cis = &sf->sc->sc_fn0->cis; 263 for (i = 0; i < __arraycount(bwfm_sdio_products); ++i) { 264 bsp = &bwfm_sdio_products[i]; 265 if (cis->manufacturer == bsp->manufacturer && 266 cis->product == bsp->product) 267 break; 268 } 269 if (i >= __arraycount(bwfm_sdio_products)) 270 return 0; 271 272 /* We need both functions, but ... */ 273 if (sf->sc->sc_function_count <= 1) 274 return 0; 275 276 /* ... only attach for one. */ 277 if (sf->number != 1) 278 return 0; 279 280 return 1; 281 } 282 283 static void 284 bwfm_sdio_attach(device_t parent, device_t self, void *aux) 285 { 286 struct bwfm_sdio_softc *sc = device_private(self); 287 struct sdmmc_attach_args *saa = aux; 288 struct sdmmc_function *sf = saa->sf; 289 struct bwfm_core *core; 290 uint32_t reg; 291 292 sc->sc_sc.sc_dev = self; 293 294 aprint_naive("\n"); 295 aprint_normal("\n"); 296 297 sc->sc_phandle = bwfm_fdt_find_phandle(self, parent); 298 299 mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 300 cv_init(&sc->sc_rxctl_cv, "bwfmctl"); 301 mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_NONE); 302 303 sdmmc_init_task(&sc->sc_task, bwfm_sdio_task, sc); 304 sc->sc_task_queued = false; 305 306 sc->sc_bounce_size = 64 * 1024; 307 sc->sc_bounce_buf = kmem_alloc(sc->sc_bounce_size, KM_SLEEP); 308 sc->sc_tx_seq = 0xff; 309 MBUFQ_INIT(&sc->sc_tx_queue); 310 sc->sc_rxctl_queue = NULL; 311 312 sc->sc_sf_size = (sf->sc->sc_function_count + 1) 313 * sizeof(struct sdmmc_function *); 314 sc->sc_sf = kmem_zalloc(sc->sc_sf_size, KM_SLEEP); 315 316 /* Copy all function pointers. */ 317 SIMPLEQ_FOREACH(sf, &saa->sf->sc->sf_head, sf_list) { 318 sc->sc_sf[sf->number] = sf; 319 } 320 321 sdmmc_io_set_blocklen(sc->sc_sf[1], 64); 322 sdmmc_io_set_blocklen(sc->sc_sf[2], 512); 323 324 /* Enable Function 1. */ 325 if (sdmmc_io_function_enable(sc->sc_sf[1]) != 0) { 326 printf("%s: cannot enable function 1\n", DEVNAME(sc)); 327 return; 328 } 329 330 DPRINTF(("%s: F1 signature read @0x18000000=%x\n", DEVNAME(sc), 331 bwfm_sdio_read_4(sc, 0x18000000))); 332 333 /* Force PLL off */ 334 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, 335 BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_HW_CLKREQ_OFF | 336 BWFM_SDIO_FUNC1_CHIPCLKCSR_ALP_AVAIL_REQ); 337 338 sc->sc_sc.sc_buscore_ops = &bwfm_sdio_buscore_ops; 339 if (bwfm_chip_attach(&sc->sc_sc) != 0) { 340 aprint_error_dev(self, "cannot attach chip\n"); 341 return; 342 } 343 344 sc->sc_cc = bwfm_chip_get_core(&sc->sc_sc, BWFM_AGENT_CORE_CHIPCOMMON); 345 if (sc->sc_cc == NULL) { 346 aprint_error_dev(self, "cannot find chipcommon core\n"); 347 return; 348 } 349 350 core = bwfm_chip_get_core(&sc->sc_sc, BWFM_AGENT_CORE_SDIO_DEV); 351 if (core->co_rev >= 12) { 352 reg = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_SLEEPCSR); 353 if ((reg & BWFM_SDIO_FUNC1_SLEEPCSR_KSO) == 0) { 354 reg |= BWFM_SDIO_FUNC1_SLEEPCSR_KSO; 355 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_SLEEPCSR, reg); 356 } 357 } 358 359 /* Default, override from "brcm,drive-strength" */ 360 bwfm_sdio_drivestrength(sc, 6); 361 362 bwfm_sdio_write_1(sc, BWFM_SDIO_CCCR_CARDCTRL, 363 bwfm_sdio_read_1(sc, BWFM_SDIO_CCCR_CARDCTRL) | 364 BWFM_SDIO_CCCR_CARDCTRL_WLANRESET); 365 366 core = bwfm_chip_get_pmu(&sc->sc_sc); 367 bwfm_sdio_write_4(sc, core->co_base + BWFM_CHIP_REG_PMUCONTROL, 368 bwfm_sdio_read_4(sc, core->co_base + BWFM_CHIP_REG_PMUCONTROL) | 369 (BWFM_CHIP_REG_PMUCONTROL_RES_RELOAD << 370 BWFM_CHIP_REG_PMUCONTROL_RES_SHIFT)); 371 372 sdmmc_io_function_disable(sc->sc_sf[2]); 373 374 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, 0); 375 sc->sc_clkstate = CLK_SDONLY; 376 377 config_mountroot(self, bwfm_sdio_attachhook); 378 } 379 380 static void 381 bwfm_sdio_attachhook(device_t self) 382 { 383 struct bwfm_sdio_softc *sc = device_private(self); 384 struct bwfm_softc *bwfm = &sc->sc_sc; 385 firmware_handle_t fwh; 386 const char *name, *nvname, *model; 387 char *nvnamebuf; 388 u_char *ucode, *nvram; 389 size_t size, nvlen, nvsize; 390 uint32_t reg, clk; 391 int error; 392 393 DPRINTF(("%s: chip 0x%08x rev %u\n", DEVNAME(sc), 394 bwfm->sc_chip.ch_chip, bwfm->sc_chip.ch_chiprev)); 395 switch (bwfm->sc_chip.ch_chip) { 396 case BRCM_CC_4330_CHIP_ID: 397 name = "brcmfmac4330-sdio.bin"; 398 nvname = "brcmfmac4330-sdio.txt"; 399 break; 400 case BRCM_CC_4334_CHIP_ID: 401 name = "brcmfmac4334-sdio.bin"; 402 nvname = "brcmfmac4334-sdio.txt"; 403 break; 404 case BRCM_CC_4345_CHIP_ID: 405 if ((0x200 & __BIT(bwfm->sc_chip.ch_chiprev)) != 0) { 406 name = "brcmfmac43456-sdio.bin"; 407 nvname = "brcmfmac43456-sdio.txt"; 408 } else { 409 name = "brcmfmac43455-sdio.bin"; 410 nvname = "brcmfmac43455-sdio.txt"; 411 } 412 break; 413 case BRCM_CC_43340_CHIP_ID: 414 name = "brcmfmac43340-sdio.bin"; 415 nvname = "brcmfmac43340-sdio.txt"; 416 break; 417 case BRCM_CC_4335_CHIP_ID: 418 if (bwfm->sc_chip.ch_chiprev < 2) { 419 name = "brcmfmac4335-sdio.bin"; 420 nvname = "brcmfmac4335-sdio.txt"; 421 } else { 422 name = "brcmfmac4339-sdio.bin"; 423 nvname = "brcmfmac4339-sdio.txt"; 424 bwfm->sc_chip.ch_chip = BRCM_CC_4339_CHIP_ID; 425 } 426 break; 427 case BRCM_CC_4339_CHIP_ID: 428 name = "brcmfmac4339-sdio.bin"; 429 nvname = "brcmfmac4339-sdio.txt"; 430 break; 431 case BRCM_CC_43430_CHIP_ID: 432 if (bwfm->sc_chip.ch_chiprev == 0) { 433 name = "brcmfmac43430a0-sdio.bin"; 434 nvname = "brcmfmac43430a0-sdio.txt"; 435 } else { 436 name = "brcmfmac43430-sdio.bin"; 437 nvname = "brcmfmac43430-sdio.txt"; 438 } 439 break; 440 case BRCM_CC_4356_CHIP_ID: 441 name = "brcmfmac4356-sdio.bin"; 442 nvname = "brcmfmac4356-sdio.txt"; 443 break; 444 default: 445 printf("%s: unknown firmware for chip %s\n", 446 DEVNAME(sc), bwfm->sc_chip.ch_name); 447 goto err; 448 } 449 450 /* compute a model specific filename for the NV config */ 451 nvnamebuf = NULL; 452 model = bwfm_fdt_get_model(); 453 if (model != NULL) { 454 /* assume nvname ends in ".txt" */ 455 nvnamebuf = kmem_asprintf("%.*s.%s.txt", 456 (int)(strlen(nvname) - 4), 457 nvname, model); 458 } 459 460 aprint_verbose_dev(self, "Firmware %s\n", name); 461 aprint_verbose_dev(self, "Default Config %s\n", nvname); 462 if (nvnamebuf != NULL) 463 aprint_verbose_dev(self, "Model Config %s\n", nvnamebuf); 464 465 if (firmware_open("if_bwfm", name, &fwh) != 0) { 466 printf("%s: failed firmware_open of file %s\n", 467 DEVNAME(sc), name); 468 goto err; 469 } 470 size = firmware_get_size(fwh); 471 ucode = firmware_malloc(size); 472 if (ucode == NULL) { 473 printf("%s: failed firmware_open of file %s\n", 474 DEVNAME(sc), name); 475 firmware_close(fwh); 476 goto err; 477 } 478 error = firmware_read(fwh, 0, ucode, size); 479 firmware_close(fwh); 480 if (error != 0) { 481 printf("%s: failed to read firmware (error %d)\n", 482 DEVNAME(sc), error); 483 goto err1; 484 } 485 486 if ((nvnamebuf == NULL || firmware_open("if_bwfm", nvnamebuf, &fwh) != 0) 487 && firmware_open("if_bwfm", nvname, &fwh) != 0) { 488 printf("%s: failed firmware_open of file %s\n", 489 DEVNAME(sc), nvname); 490 goto err1; 491 } 492 nvlen = firmware_get_size(fwh); 493 nvram = firmware_malloc(nvlen); 494 if (nvram == NULL) { 495 printf("%s: failed firmware_open of file %s\n", 496 DEVNAME(sc), name); 497 firmware_close(fwh); 498 goto err1; 499 } 500 error = firmware_read(fwh, 0, nvram, nvlen); 501 firmware_close(fwh); 502 if (error != 0) { 503 printf("%s: failed to read firmware (error %d)\n", 504 DEVNAME(sc), error); 505 goto err2; 506 } 507 508 if (bwfm_nvram_convert(nvram, nvlen, &nvsize)) { 509 printf("%s: failed to convert nvram\n", DEVNAME(sc)); 510 goto err2; 511 } 512 513 sc->sc_alp_only = true; 514 if (bwfm_sdio_load_microcode(sc, ucode, size, nvram, nvsize) != 0) { 515 printf("%s: could not load microcode\n", 516 DEVNAME(sc)); 517 goto err2; 518 } 519 sc->sc_alp_only = false; 520 521 firmware_free(nvram, nvlen); 522 firmware_free(ucode, size); 523 if (nvnamebuf != NULL) 524 kmem_free(nvnamebuf, strlen(nvnamebuf)+1); 525 526 sdmmc_pause(hztoms(1)*1000, NULL); 527 528 bwfm_sdio_clkctl(sc, CLK_AVAIL, false); 529 if (sc->sc_clkstate != CLK_AVAIL) { 530 printf("%s: could not access clock\n", 531 DEVNAME(sc)); 532 goto err; 533 } 534 535 clk = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR); 536 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, 537 clk | BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_HT); 538 539 bwfm_sdio_dev_write(sc, SDPCMD_TOSBMAILBOXDATA, 540 SDPCM_PROT_VERSION << SDPCM_PROT_VERSION_SHIFT); 541 if (sdmmc_io_function_enable(sc->sc_sf[2])) { 542 printf("%s: cannot enable function 2\n", DEVNAME(sc)); 543 goto err; 544 } 545 546 // bwfm_sdio_dev_write(sc, SDPCMD_HOSTINTMASK, 547 // SDPCMD_INTSTATUS_HMB_SW_MASK | SDPCMD_INTSTATUS_CHIPACTIVE); 548 bwfm_sdio_dev_write(sc, SDPCMD_HOSTINTMASK, 0xffffffff); 549 bwfm_sdio_write_1(sc, BWFM_SDIO_WATERMARK, 8); 550 551 if (bwfm_chip_sr_capable(bwfm)) { 552 reg = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_WAKEUPCTRL); 553 reg |= BWFM_SDIO_FUNC1_WAKEUPCTRL_HTWAIT; 554 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_WAKEUPCTRL, reg); 555 bwfm_sdio_write_1(sc, BWFM_SDIO_CCCR_CARDCAP, 556 BWFM_SDIO_CCCR_CARDCAP_CMD14_SUPPORT | 557 BWFM_SDIO_CCCR_CARDCAP_CMD14_EXT); 558 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, 559 BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_HT); 560 sc->sc_sr_enabled = 1; 561 } else { 562 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, clk); 563 } 564 565 #ifdef notyet 566 if (sc->sc_phandle >= 0) { 567 sc->sc_fdtih = fdtbus_intr_establish(sc->sc_phandle, 568 0, IPL_SDMMC, IST_LEVEL, bwfm_sdio_intr, sc); 569 } 570 #endif 571 if (sc->sc_fdtih != NULL) { 572 aprint_normal_dev(self, "enabling GPIO interrupt\n"); 573 } else { 574 sc->sc_ih = sdmmc_intr_establish(device_parent(self), 575 bwfm_sdio_intr, sc, DEVNAME(sc)); 576 } 577 578 if (sc->sc_ih == NULL && sc->sc_fdtih == NULL) { 579 aprint_error_dev(self, "could not establish interrupt\n"); 580 bwfm_sdio_clkctl(sc, CLK_NONE, false); 581 return; 582 } 583 sdmmc_intr_enable(sc->sc_sf[1]); 584 585 sdmmc_pause(100000, NULL); 586 587 sc->sc_sc.sc_bus_ops = &bwfm_sdio_bus_ops; 588 sc->sc_sc.sc_proto_ops = &bwfm_proto_bcdc_ops; 589 bwfm_attach(&sc->sc_sc); 590 sc->sc_bwfm_attached = true; 591 592 return; 593 594 err2: 595 firmware_free(nvram, nvlen); 596 err1: 597 firmware_free(ucode, size); 598 if (nvnamebuf != NULL) 599 kmem_free(nvnamebuf, strlen(nvnamebuf)+1); 600 err: 601 return; 602 } 603 604 static int 605 bwfm_fdt_find_phandle(device_t self, device_t parent) 606 { 607 prop_dictionary_t dict; 608 device_t dev; 609 const char *str; 610 int phandle; 611 612 /* locate in FDT */ 613 dict = device_properties(self); 614 if (prop_dictionary_get_cstring_nocopy(dict, "fdt-path", &str)) { 615 /* search in FDT */ 616 phandle = OF_finddevice(str); 617 } else { 618 619 /* parent parent is sdhc controller */ 620 dev = device_parent(parent); 621 if (dev == NULL) 622 return -1; 623 /* locate in FDT */ 624 dict = device_properties(dev); 625 if (!prop_dictionary_get_cstring_nocopy(dict, "fdt-path", &str)) 626 return -1; 627 628 /* are we the only FDT child ? */ 629 phandle = OF_child(OF_finddevice(str)); 630 } 631 632 if (!of_match_compatible(phandle, compatible)) 633 return -1; 634 635 return phandle; 636 } 637 638 static const char * 639 bwfm_fdt_get_model(void) 640 { 641 int phandle; 642 643 phandle = OF_finddevice("/"); 644 return fdtbus_get_string_index(phandle, "compatible", 0); 645 } 646 647 static int 648 bwfm_sdio_detach(device_t self, int flags) 649 { 650 struct bwfm_sdio_softc *sc = (struct bwfm_sdio_softc *)self; 651 652 #ifdef BWFM_DEBUG 653 bwfm_sdio_debug_console(sc); 654 #endif 655 656 if (sc->sc_ih || sc->sc_fdtih) { 657 sdmmc_intr_disable(sc->sc_sf[1]); 658 if (sc->sc_ih) 659 sdmmc_intr_disestablish(sc->sc_ih); 660 if (sc->sc_fdtih) 661 fdtbus_intr_disestablish(sc->sc_phandle, sc->sc_fdtih); 662 } 663 if (sc->sc_bwfm_attached) 664 bwfm_detach(&sc->sc_sc, flags); 665 666 kmem_free(sc->sc_sf, sc->sc_sf_size); 667 kmem_free(sc->sc_bounce_buf, sc->sc_bounce_size); 668 669 mutex_destroy(&sc->sc_intr_lock); 670 cv_destroy(&sc->sc_rxctl_cv); 671 mutex_destroy(&sc->sc_lock); 672 673 return 0; 674 } 675 676 static void 677 bwfm_sdio_backplane(struct bwfm_sdio_softc *sc, uint32_t addr) 678 { 679 uint32_t bar0 = addr & ~BWFM_SDIO_SB_OFT_ADDR_MASK; 680 681 if (sc->sc_bar0 == bar0) 682 return; 683 684 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_SBADDRLOW, 685 (bar0 >> 8) & 0xff); 686 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_SBADDRMID, 687 (bar0 >> 16) & 0xff); 688 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_SBADDRHIGH, 689 (bar0 >> 24) & 0xff); 690 sc->sc_bar0 = bar0; 691 } 692 693 static uint8_t 694 bwfm_sdio_read_1(struct bwfm_sdio_softc *sc, uint32_t addr) 695 { 696 struct sdmmc_function *sf; 697 uint8_t rv; 698 699 /* 700 * figure out how to read the register based on address range 701 * 0x00 ~ 0x7FF: function 0 CCCR and FBR 702 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers 703 * The rest: function 1 silicon backplane core registers 704 */ 705 if ((addr & ~0x7ff) == 0) 706 sf = sc->sc_sf[0]; 707 else 708 sf = sc->sc_sf[1]; 709 710 rv = sdmmc_io_read_1(sf, addr); 711 return rv; 712 } 713 714 static uint32_t 715 bwfm_sdio_read_4(struct bwfm_sdio_softc *sc, uint32_t addr) 716 { 717 struct sdmmc_function *sf; 718 uint32_t rv; 719 720 bwfm_sdio_backplane(sc, addr); 721 722 addr &= BWFM_SDIO_SB_OFT_ADDR_MASK; 723 addr |= BWFM_SDIO_SB_ACCESS_2_4B_FLAG; 724 725 /* 726 * figure out how to read the register based on address range 727 * 0x00 ~ 0x7FF: function 0 CCCR and FBR 728 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers 729 * The rest: function 1 silicon backplane core registers 730 */ 731 if ((addr & ~0x7ff) == 0) 732 sf = sc->sc_sf[0]; 733 else 734 sf = sc->sc_sf[1]; 735 736 rv = sdmmc_io_read_4(sf, addr); 737 return rv; 738 } 739 740 static void 741 bwfm_sdio_write_1(struct bwfm_sdio_softc *sc, uint32_t addr, uint8_t data) 742 { 743 struct sdmmc_function *sf; 744 745 /* 746 * figure out how to read the register based on address range 747 * 0x00 ~ 0x7FF: function 0 CCCR and FBR 748 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers 749 * The rest: function 1 silicon backplane core registers 750 */ 751 if ((addr & ~0x7ff) == 0) 752 sf = sc->sc_sf[0]; 753 else 754 sf = sc->sc_sf[1]; 755 756 sdmmc_io_write_1(sf, addr, data); 757 } 758 759 static void 760 bwfm_sdio_write_4(struct bwfm_sdio_softc *sc, uint32_t addr, uint32_t data) 761 { 762 struct sdmmc_function *sf; 763 764 bwfm_sdio_backplane(sc, addr); 765 766 addr &= BWFM_SDIO_SB_OFT_ADDR_MASK; 767 addr |= BWFM_SDIO_SB_ACCESS_2_4B_FLAG; 768 769 /* 770 * figure out how to read the register based on address range 771 * 0x00 ~ 0x7FF: function 0 CCCR and FBR 772 * 0x10000 ~ 0x1FFFF: function 1 miscellaneous registers 773 * The rest: function 1 silicon backplane core registers 774 */ 775 if ((addr & ~0x7ff) == 0) 776 sf = sc->sc_sf[0]; 777 else 778 sf = sc->sc_sf[1]; 779 780 sdmmc_io_write_4(sf, addr, data); 781 } 782 783 static int 784 bwfm_sdio_buf_read(struct bwfm_sdio_softc *sc, struct sdmmc_function *sf, 785 uint32_t reg, char *data, size_t size) 786 { 787 int err; 788 789 KASSERT(((vaddr_t)data & 0x3) == 0); 790 KASSERT((size & 0x3) == 0); 791 792 if (sf == sc->sc_sf[1]) 793 err = sdmmc_io_read_region_1(sf, reg, data, size); 794 else 795 err = sdmmc_io_read_multi_1(sf, reg, data, size); 796 797 if (err) 798 printf("%s: error %d\n", __func__, err); 799 800 return err; 801 } 802 803 static int 804 bwfm_sdio_buf_write(struct bwfm_sdio_softc *sc, struct sdmmc_function *sf, 805 uint32_t reg, char *data, size_t size) 806 { 807 int err; 808 809 KASSERT(((vaddr_t)data & 0x3) == 0); 810 KASSERT((size & 0x3) == 0); 811 812 err = sdmmc_io_write_region_1(sf, reg, data, size); 813 814 if (err) 815 printf("%s: error %d\n", __func__, err); 816 817 return err; 818 } 819 820 static uint32_t 821 bwfm_sdio_ram_read_write(struct bwfm_sdio_softc *sc, uint32_t reg, 822 char *data, size_t left, int write) 823 { 824 uint32_t sbaddr, sdaddr, off; 825 size_t size; 826 int err; 827 828 err = off = 0; 829 while (left > 0) { 830 sbaddr = reg + off; 831 bwfm_sdio_backplane(sc, sbaddr); 832 833 sdaddr = sbaddr & BWFM_SDIO_SB_OFT_ADDR_MASK; 834 size = ulmin(left, (BWFM_SDIO_SB_OFT_ADDR_PAGE - sdaddr)); 835 sdaddr |= BWFM_SDIO_SB_ACCESS_2_4B_FLAG; 836 837 if (write) { 838 memcpy(sc->sc_bounce_buf, data + off, size); 839 if (roundup(size, 4) != size) 840 memset(sc->sc_bounce_buf + size, 0, 841 roundup(size, 4) - size); 842 err = bwfm_sdio_buf_write(sc, sc->sc_sf[1], sdaddr, 843 sc->sc_bounce_buf, roundup(size, 4)); 844 } else { 845 err = bwfm_sdio_buf_read(sc, sc->sc_sf[1], sdaddr, 846 sc->sc_bounce_buf, roundup(size, 4)); 847 memcpy(data + off, sc->sc_bounce_buf, size); 848 } 849 if (err) 850 break; 851 852 off += size; 853 left -= size; 854 } 855 856 if (err) 857 printf("%s: error %d\n", __func__, err); 858 859 return err; 860 } 861 862 static uint32_t 863 bwfm_sdio_frame_read_write(struct bwfm_sdio_softc *sc, 864 char *data, size_t size, int write) 865 { 866 uint32_t addr; 867 int err; 868 869 addr = sc->sc_cc->co_base; 870 bwfm_sdio_backplane(sc, addr); 871 872 addr &= BWFM_SDIO_SB_OFT_ADDR_MASK; 873 addr |= BWFM_SDIO_SB_ACCESS_2_4B_FLAG; 874 875 if (write) 876 err = bwfm_sdio_buf_write(sc, sc->sc_sf[2], addr, data, size); 877 else 878 err = bwfm_sdio_buf_read(sc, sc->sc_sf[2], addr, data, size); 879 880 if (err) 881 printf("%s: error %d\n", __func__, err); 882 883 return err; 884 } 885 886 static uint32_t 887 bwfm_sdio_dev_read(struct bwfm_sdio_softc *sc, uint32_t reg) 888 { 889 struct bwfm_core *core; 890 uint32_t val; 891 892 core = bwfm_chip_get_core(&sc->sc_sc, BWFM_AGENT_CORE_SDIO_DEV); 893 val = bwfm_sdio_read_4(sc, core->co_base + reg); 894 /* TODO: Workaround for 4335/4339 */ 895 896 return val; 897 } 898 899 static void 900 bwfm_sdio_dev_write(struct bwfm_sdio_softc *sc, uint32_t reg, uint32_t val) 901 { 902 struct bwfm_core *core; 903 904 core = bwfm_chip_get_core(&sc->sc_sc, BWFM_AGENT_CORE_SDIO_DEV); 905 bwfm_sdio_write_4(sc, core->co_base + reg, val); 906 } 907 908 static uint32_t 909 bwfm_sdio_buscore_read(struct bwfm_softc *bwfm, uint32_t reg) 910 { 911 struct bwfm_sdio_softc *sc = (void *)bwfm; 912 uint32_t val; 913 914 mutex_enter(&sc->sc_lock); 915 val = bwfm_sdio_read_4(sc, reg); 916 /* TODO: Workaround for 4335/4339 */ 917 mutex_exit(&sc->sc_lock); 918 919 return val; 920 } 921 922 static void 923 bwfm_sdio_buscore_write(struct bwfm_softc *bwfm, uint32_t reg, uint32_t val) 924 { 925 struct bwfm_sdio_softc *sc = (void *)bwfm; 926 927 mutex_enter(&sc->sc_lock); 928 bwfm_sdio_write_4(sc, reg, val); 929 mutex_exit(&sc->sc_lock); 930 } 931 932 static int 933 bwfm_sdio_buscore_prepare(struct bwfm_softc *bwfm) 934 { 935 struct bwfm_sdio_softc *sc = (void *)bwfm; 936 uint8_t clkval, clkset, clkmask; 937 int i, error = 0; 938 939 mutex_enter(&sc->sc_lock); 940 941 clkset = BWFM_SDIO_FUNC1_CHIPCLKCSR_ALP_AVAIL_REQ | 942 BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_HW_CLKREQ_OFF; 943 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, clkset); 944 945 clkmask = BWFM_SDIO_FUNC1_CHIPCLKCSR_ALP_AVAIL | 946 BWFM_SDIO_FUNC1_CHIPCLKCSR_HT_AVAIL; 947 clkval = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR); 948 949 if ((clkval & ~clkmask) != clkset) { 950 printf("%s: wrote 0x%02x read 0x%02x\n", DEVNAME(sc), 951 clkset, clkval); 952 error = 1; 953 goto done; 954 } 955 956 for (i = 1000; i > 0; i--) { 957 clkval = bwfm_sdio_read_1(sc, 958 BWFM_SDIO_FUNC1_CHIPCLKCSR); 959 if (clkval & clkmask) 960 break; 961 } 962 if (i == 0) { 963 printf("%s: timeout on ALPAV wait, clkval 0x%02x\n", 964 DEVNAME(sc), clkval); 965 error = 1; 966 goto done; 967 } 968 969 clkset = BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_HW_CLKREQ_OFF | 970 BWFM_SDIO_FUNC1_CHIPCLKCSR_FORCE_ALP; 971 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, clkset); 972 delay(65); 973 974 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_SDIOPULLUP, 0); 975 976 done: 977 mutex_exit(&sc->sc_lock); 978 979 return error; 980 } 981 982 static void 983 bwfm_sdio_buscore_activate(struct bwfm_softc *bwfm, uint32_t rstvec) 984 { 985 struct bwfm_sdio_softc *sc = (void *)bwfm; 986 struct bwfm_core *core; 987 988 core = bwfm_chip_get_core(&sc->sc_sc, BWFM_AGENT_CORE_SDIO_DEV); 989 bwfm_sdio_buscore_write(&sc->sc_sc, 990 core->co_base + BWFM_SDPCMD_INTSTATUS, 0xFFFFFFFF); 991 992 mutex_enter(&sc->sc_lock); 993 if (rstvec) 994 bwfm_sdio_ram_read_write(sc, 0, (char *)&rstvec, 995 sizeof(rstvec), 1); 996 mutex_exit(&sc->sc_lock); 997 } 998 999 static struct mbuf * 1000 bwfm_sdio_newbuf(void) 1001 { 1002 struct mbuf *m; 1003 1004 MGETHDR(m, M_DONTWAIT, MT_DATA); 1005 if (m == NULL) 1006 return NULL; 1007 1008 MCLGET(m, M_DONTWAIT); 1009 if (!(m->m_flags & M_EXT)) { 1010 m_freem(m); 1011 return NULL; 1012 } 1013 1014 m->m_len = m->m_pkthdr.len = MCLBYTES; 1015 return m; 1016 } 1017 1018 static struct mbuf * 1019 bwfm_qget(struct mbuf **q) 1020 { 1021 struct mbuf *m = NULL; 1022 1023 if (*q != NULL) { 1024 m = *q; 1025 *q = m->m_next; 1026 m->m_next = NULL; 1027 } 1028 1029 return m; 1030 } 1031 1032 static void 1033 bwfm_qput(struct mbuf **q, struct mbuf *m) 1034 { 1035 1036 if (*q == NULL) 1037 *q = m; 1038 else 1039 m_cat(*q, m); 1040 } 1041 1042 static int 1043 bwfm_sdio_txcheck(struct bwfm_softc *bwfm) 1044 { 1045 struct bwfm_sdio_softc *sc = (void *)bwfm; 1046 int error = 0; 1047 1048 mutex_enter(&sc->sc_lock); 1049 if (sc->sc_tx_count >= 64) 1050 error = ENOBUFS; 1051 mutex_exit(&sc->sc_lock); 1052 1053 return error; 1054 } 1055 1056 1057 static int 1058 bwfm_sdio_txdata(struct bwfm_softc *bwfm, struct mbuf **mp) 1059 { 1060 struct bwfm_sdio_softc *sc = (void *)bwfm; 1061 1062 if (sc->sc_tx_count >= 64) { 1063 printf("%s: tx count limit reached\n",DEVNAME(sc)); 1064 return ENOBUFS; 1065 } 1066 1067 mutex_enter(&sc->sc_lock); 1068 sc->sc_tx_count++; 1069 MBUFQ_ENQUEUE(&sc->sc_tx_queue, *mp); 1070 mutex_exit(&sc->sc_lock); 1071 1072 bwfm_sdio_intr1(sc, "sdio_txdata"); 1073 1074 return 0; 1075 } 1076 1077 static int 1078 bwfm_sdio_txctl(struct bwfm_softc *bwfm, char *buf, size_t len) 1079 { 1080 struct bwfm_sdio_softc *sc = (void *)bwfm; 1081 struct mbuf *m; 1082 1083 KASSERT(len <= MCLBYTES); 1084 1085 MGET(m, M_DONTWAIT, MT_CONTROL); 1086 if (m == NULL) 1087 goto fail; 1088 if (len > MLEN) { 1089 MCLGET(m, M_DONTWAIT); 1090 if (!(m->m_flags & M_EXT)) { 1091 m_freem(m); 1092 goto fail; 1093 } 1094 } 1095 memcpy(mtod(m, char *), buf, len); 1096 m->m_len = len; 1097 1098 mutex_enter(&sc->sc_lock); 1099 MBUFQ_ENQUEUE(&sc->sc_tx_queue, m); 1100 mutex_exit(&sc->sc_lock); 1101 1102 bwfm_sdio_intr1(sc, "sdio_txctl"); 1103 1104 return 0; 1105 1106 fail: 1107 return ENOBUFS; 1108 } 1109 1110 static int 1111 bwfm_nvram_convert(u_char *buf, size_t len, size_t *newlenp) 1112 { 1113 u_char *src, *dst, *end = buf + len; 1114 bool skip = false; 1115 size_t count = 0, pad; 1116 uint32_t token; 1117 1118 for (src = buf, dst = buf; src != end; ++src) { 1119 if (*src == '\n') { 1120 if (count > 0) 1121 *dst++ = '\0'; 1122 count = 0; 1123 skip = false; 1124 continue; 1125 } 1126 if (skip) 1127 continue; 1128 if (*src == '#' && count == 0) { 1129 skip = true; 1130 continue; 1131 } 1132 if (*src == '\r') 1133 continue; 1134 *dst++ = *src; 1135 ++count; 1136 } 1137 1138 count = dst - buf; 1139 pad = roundup(count + 1, 4) - count; 1140 1141 if (count + pad + sizeof(token) > len) 1142 return 1; 1143 1144 memset(dst, 0, pad); 1145 count += pad; 1146 dst += pad; 1147 1148 token = (count / 4) & 0xffff; 1149 token |= ~token << 16; 1150 token = htole32(token); 1151 1152 memcpy(dst, &token, sizeof(token)); 1153 count += sizeof(token); 1154 1155 *newlenp = count ; 1156 1157 return 0; 1158 } 1159 1160 static int 1161 bwfm_sdio_load_microcode(struct bwfm_sdio_softc *sc, u_char *ucode, size_t size, 1162 u_char *nvram, size_t nvlen) 1163 { 1164 struct bwfm_softc *bwfm = &sc->sc_sc; 1165 char *verify = NULL; 1166 int err = 0; 1167 1168 bwfm_sdio_clkctl(sc, CLK_AVAIL, false); 1169 1170 DPRINTF(("ucode %zu bytes to 0x%08lx\n", size, 1171 (u_long)bwfm->sc_chip.ch_rambase)); 1172 /* Upload firmware */ 1173 err = bwfm_sdio_ram_read_write(sc, bwfm->sc_chip.ch_rambase, 1174 ucode, size, 1); 1175 if (err) 1176 goto out; 1177 1178 /* Verify firmware */ 1179 verify = kmem_zalloc(size, KM_SLEEP); 1180 err = bwfm_sdio_ram_read_write(sc, bwfm->sc_chip.ch_rambase, 1181 verify, size, 0); 1182 if (err || memcmp(verify, ucode, size)) { 1183 printf("%s: firmware verification failed\n", 1184 DEVNAME(sc)); 1185 kmem_free(verify, size); 1186 goto out; 1187 } 1188 kmem_free(verify, size); 1189 1190 DPRINTF(("nvram %zu bytes to 0x%08lx\n", nvlen, 1191 (u_long)bwfm->sc_chip.ch_rambase + bwfm->sc_chip.ch_ramsize 1192 - nvlen)); 1193 /* Upload nvram */ 1194 err = bwfm_sdio_ram_read_write(sc, bwfm->sc_chip.ch_rambase + 1195 bwfm->sc_chip.ch_ramsize - nvlen, nvram, nvlen, 1); 1196 if (err) 1197 goto out; 1198 1199 /* Verify nvram */ 1200 verify = kmem_zalloc(nvlen, KM_SLEEP); 1201 err = bwfm_sdio_ram_read_write(sc, bwfm->sc_chip.ch_rambase + 1202 bwfm->sc_chip.ch_ramsize - nvlen, verify, nvlen, 0); 1203 if (err || memcmp(verify, nvram, nvlen)) { 1204 printf("%s: nvram verification failed\n", 1205 DEVNAME(sc)); 1206 kmem_free(verify, nvlen); 1207 goto out; 1208 } 1209 kmem_free(verify, nvlen); 1210 1211 DPRINTF(("Reset core 0x%08x\n", *(uint32_t *)ucode)); 1212 /* Load reset vector from firmware and kickstart core. */ 1213 bwfm_chip_set_active(bwfm, *(uint32_t *)ucode); 1214 1215 out: 1216 bwfm_sdio_clkctl(sc, CLK_SDONLY, false); 1217 return err; 1218 } 1219 1220 static void 1221 bwfm_sdio_clkctl(struct bwfm_sdio_softc *sc, enum bwfm_sdio_clkstate newstate, 1222 bool pendok) 1223 { 1224 enum bwfm_sdio_clkstate oldstate; 1225 1226 oldstate = sc->sc_clkstate; 1227 if (oldstate == newstate) 1228 return; 1229 1230 switch (newstate) { 1231 case CLK_AVAIL: 1232 if (oldstate == CLK_NONE) 1233 sc->sc_clkstate = CLK_SDONLY; /* XXX */ 1234 bwfm_sdio_htclk(sc, true, pendok); 1235 break; 1236 case CLK_SDONLY: 1237 if (oldstate == CLK_NONE) 1238 sc->sc_clkstate = newstate; 1239 else if (oldstate == CLK_AVAIL) 1240 bwfm_sdio_htclk(sc, false, false); 1241 else 1242 printf("%s: clkctl %d -> %d\n", DEVNAME(sc), 1243 sc->sc_clkstate, newstate); 1244 break; 1245 case CLK_NONE: 1246 if (oldstate == CLK_AVAIL) 1247 bwfm_sdio_htclk(sc, false, false); 1248 sc->sc_clkstate = newstate; 1249 break; 1250 default: 1251 break; 1252 } 1253 1254 DPRINTF(("%s: %d -> %d = %d\n", DEVNAME(sc), oldstate, newstate, 1255 sc->sc_clkstate)); 1256 } 1257 1258 static void 1259 bwfm_sdio_htclk(struct bwfm_sdio_softc *sc, bool on, bool pendok) 1260 { 1261 uint32_t clkctl, devctl, req; 1262 int i; 1263 1264 if (sc->sc_sr_enabled) { 1265 if (on) 1266 sc->sc_clkstate = CLK_AVAIL; 1267 else 1268 sc->sc_clkstate = CLK_SDONLY; 1269 return; 1270 } 1271 1272 if (on) { 1273 if (sc->sc_alp_only) 1274 req = BWFM_SDIO_FUNC1_CHIPCLKCSR_ALP_AVAIL_REQ; 1275 else 1276 req = BWFM_SDIO_FUNC1_CHIPCLKCSR_HT_AVAIL_REQ; 1277 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, req); 1278 1279 clkctl = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR); 1280 if (!BWFM_SDIO_FUNC1_CHIPCLKCSR_CLKAV(clkctl, sc->sc_alp_only) 1281 && pendok) { 1282 devctl = bwfm_sdio_read_1(sc, BWFM_SDIO_DEVICE_CTL); 1283 devctl |= BWFM_SDIO_DEVICE_CTL_CA_INT_ONLY; 1284 bwfm_sdio_write_1(sc, BWFM_SDIO_DEVICE_CTL, devctl); 1285 sc->sc_clkstate = CLK_PENDING; 1286 return; 1287 } else if (sc->sc_clkstate == CLK_PENDING) { 1288 devctl = bwfm_sdio_read_1(sc, BWFM_SDIO_DEVICE_CTL); 1289 devctl &= ~BWFM_SDIO_DEVICE_CTL_CA_INT_ONLY; 1290 bwfm_sdio_write_1(sc, BWFM_SDIO_DEVICE_CTL, devctl); 1291 } 1292 1293 for (i = 0; i < 50; i++) { 1294 if (BWFM_SDIO_FUNC1_CHIPCLKCSR_CLKAV(clkctl, 1295 sc->sc_alp_only)) 1296 break; 1297 clkctl = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR 1298 ); 1299 sdmmc_pause(100000, NULL); 1300 } 1301 if (i >= 50) { 1302 printf("%s: HT avail timeout\n", DEVNAME(sc)); 1303 return; 1304 } 1305 1306 sc->sc_clkstate = CLK_AVAIL; 1307 } else { 1308 if (sc->sc_clkstate == CLK_PENDING) { 1309 devctl = bwfm_sdio_read_1(sc, BWFM_SDIO_DEVICE_CTL); 1310 devctl &= ~BWFM_SDIO_DEVICE_CTL_CA_INT_ONLY; 1311 bwfm_sdio_write_1(sc, BWFM_SDIO_DEVICE_CTL, devctl); 1312 } 1313 sc->sc_clkstate = CLK_SDONLY; 1314 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, 0); 1315 } 1316 } 1317 1318 struct bwfm_sdio_dstab { 1319 uint8_t milli; 1320 uint8_t val; 1321 }; 1322 1323 static struct bwfm_sdio_dstab pmu11_1v8[] = { 1324 {32, 0x6}, 1325 {26, 0x7}, 1326 {22, 0x4}, 1327 {16, 0x5}, 1328 {12, 0x2}, 1329 {8, 0x3}, 1330 {4, 0x0}, 1331 {0, 0x1} 1332 }, pmu13_1v8[] = { 1333 {6, 0x7}, 1334 {5, 0x6}, 1335 {4, 0x5}, 1336 {3, 0x4}, 1337 {2, 0x2}, 1338 {1, 0x1}, 1339 {0, 0x0} 1340 }, pmu17_1v8[] = { 1341 {3, 0x3}, 1342 {2, 0x2}, 1343 {1, 0x1}, 1344 {0, 0x0} 1345 }, pmu17_3v3[] = { 1346 {16, 0x7}, 1347 {12, 0x5}, 1348 {8, 0x3}, 1349 {4, 0x1}, 1350 {0, 0x0} 1351 }; 1352 1353 static void 1354 bwfm_sdio_drivestrength(struct bwfm_sdio_softc *sc, unsigned milli) 1355 { 1356 struct bwfm_softc *bwfm = &sc->sc_sc; 1357 struct bwfm_core *core; 1358 struct bwfm_sdio_dstab *tab; 1359 uint32_t tmp, mask; 1360 unsigned i; 1361 1362 if ((bwfm->sc_chip.ch_cc_caps & BWFM_CHIP_REG_CAPABILITIES_PMU) == 0) 1363 return; 1364 1365 switch (bwfm->sc_chip.ch_chip) { 1366 case BRCM_CC_4330_CHIP_ID: 1367 tab = pmu11_1v8; 1368 mask = __BITS(11,13); 1369 break; 1370 case BRCM_CC_4334_CHIP_ID: 1371 tab = pmu17_1v8; 1372 mask = __BITS(11,12); 1373 break; 1374 case BRCM_CC_43143_CHIP_ID: 1375 tab = pmu17_3v3; 1376 mask = __BITS(0,3); 1377 break; 1378 case BRCM_CC_43362_CHIP_ID: 1379 tab = pmu13_1v8; 1380 mask = __BITS(11,13); 1381 break; 1382 default: 1383 return; 1384 } 1385 1386 for (i=0; tab[i].milli != 0; ++i) { 1387 if (milli >= tab[i].milli) 1388 break; 1389 } 1390 if (tab[i].milli == 0) 1391 return; 1392 1393 core = bwfm_chip_get_pmu(&sc->sc_sc); 1394 tmp = bwfm_sdio_read_4(sc, core->co_base + BWFM_CHIP_REG_CHIPCONTROL_ADDR); 1395 tmp &= mask; 1396 tmp |= __SHIFTIN(tab[i].val, mask); 1397 bwfm_sdio_write_4(sc, core->co_base + BWFM_CHIP_REG_CHIPCONTROL_ADDR, tmp); 1398 } 1399 1400 1401 #if notyet 1402 static int 1403 bwfm_sdio_bus_sleep(struct bwfm_sdio_softc *sc, bool sleep, bool pendok) 1404 { 1405 uint32_t clkctl; 1406 1407 if (sc->sleeping == sleep) 1408 return 0; 1409 1410 if (sc->sc_sr_enabled) { 1411 if (sleep) { 1412 clkctl = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR); 1413 if ((clkctl & BWFM_SDIO_FUNC1_CHIPCLKCSR_CSR_MASK) == 0) 1414 bwfm_sdio_write_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR, BWFM_SDIO_FUNC1_CHIPCLKCSR_ALP_AVAIL_REQ); 1415 } 1416 /* kso_ctrl(sc, sleep) */ 1417 } 1418 1419 if (sleep) { 1420 if (!sc->sc_sr_enabled) 1421 bwfm_sdio_clkctl(sc, CLK_NONE, pendok); 1422 } else { 1423 bwfm_sdio_clkctl(sc, CLK_AVAIL, pendok); 1424 } 1425 1426 sc->sleeping = sleep; 1427 1428 return 0; 1429 } 1430 #endif 1431 1432 static void 1433 bwfm_sdio_readshared(struct bwfm_sdio_softc *sc) 1434 { 1435 struct bwfm_softc *bwfm = &sc->sc_sc; 1436 struct bwfm_sdio_sdpcm sdpcm; 1437 uint32_t addr, shaddr; 1438 int err; 1439 1440 bwfm_sdio_clkctl(sc, CLK_AVAIL, false); 1441 if (sc->sc_clkstate != CLK_AVAIL) 1442 return; 1443 1444 shaddr = bwfm->sc_chip.ch_rambase + bwfm->sc_chip.ch_ramsize - 4; 1445 if (!bwfm->sc_chip.ch_rambase && sc->sc_sr_enabled) 1446 shaddr -= bwfm->sc_chip.ch_srsize; 1447 1448 err = bwfm_sdio_ram_read_write(sc, shaddr, (char *)&addr, 1449 sizeof(addr), 0); 1450 if (err) 1451 return; 1452 1453 addr = le32toh(addr); 1454 if (addr == 0 || ((~addr >> 16) & 0xffff) == (addr & 0xffff)) 1455 return; 1456 1457 err = bwfm_sdio_ram_read_write(sc, addr, (char *)&sdpcm, 1458 sizeof(sdpcm), 0); 1459 if (err) 1460 return; 1461 1462 sc->sc_console_addr = le32toh(sdpcm.console_addr); 1463 } 1464 1465 static int 1466 bwfm_sdio_intr1(void *v, const char *name) 1467 { 1468 struct bwfm_sdio_softc *sc = (void *)v; 1469 1470 DPRINTF(("%s: %s\n", DEVNAME(sc), name)); 1471 1472 mutex_enter(&sc->sc_intr_lock); 1473 if (!sdmmc_task_pending(&sc->sc_task)) 1474 sdmmc_add_task(sc->sc_sf[1]->sc, &sc->sc_task); 1475 sc->sc_task_queued = true; 1476 mutex_exit(&sc->sc_intr_lock); 1477 return 1; 1478 } 1479 1480 static int 1481 bwfm_sdio_intr(void *v) 1482 { 1483 return bwfm_sdio_intr1(v, "sdio_intr"); 1484 } 1485 1486 static void 1487 bwfm_sdio_task(void *v) 1488 { 1489 struct bwfm_sdio_softc *sc = (void *)v; 1490 #ifdef BWFM_DEBUG 1491 unsigned count = 0; 1492 #endif 1493 1494 mutex_enter(&sc->sc_intr_lock); 1495 while (sc->sc_task_queued) { 1496 #ifdef BWFM_DEBUG 1497 ++count; 1498 #endif 1499 sc->sc_task_queued = false; 1500 mutex_exit(&sc->sc_intr_lock); 1501 1502 mutex_enter(&sc->sc_lock); 1503 bwfm_sdio_task1(sc); 1504 #ifdef BWFM_DEBUG 1505 bwfm_sdio_debug_console(sc); 1506 #endif 1507 mutex_exit(&sc->sc_lock); 1508 1509 mutex_enter(&sc->sc_intr_lock); 1510 } 1511 mutex_exit(&sc->sc_intr_lock); 1512 1513 #ifdef BWFM_DEBUG 1514 if (count > 1) 1515 DPRINTF(("%s: finished %u tasks\n", DEVNAME(sc), count)); 1516 #endif 1517 } 1518 1519 static void 1520 bwfm_sdio_task1(struct bwfm_sdio_softc *sc) 1521 { 1522 uint32_t clkctl, devctl, intstat, hostint; 1523 bool dorecv, dosend; 1524 1525 if (!sc->sc_sr_enabled && sc->sc_clkstate == CLK_PENDING) { 1526 clkctl = bwfm_sdio_read_1(sc, BWFM_SDIO_FUNC1_CHIPCLKCSR); 1527 if (BWFM_SDIO_FUNC1_CHIPCLKCSR_HTAV(clkctl)) { 1528 devctl = bwfm_sdio_read_1(sc, BWFM_SDIO_DEVICE_CTL); 1529 devctl &= ~BWFM_SDIO_DEVICE_CTL_CA_INT_ONLY; 1530 bwfm_sdio_write_1(sc, BWFM_SDIO_DEVICE_CTL, devctl); 1531 sc->sc_clkstate = CLK_AVAIL; 1532 } 1533 } 1534 1535 dorecv = dosend = sc->sc_clkstate == CLK_AVAIL; 1536 1537 intstat = bwfm_sdio_dev_read(sc, BWFM_SDPCMD_INTSTATUS); 1538 DPRINTF(("%s: intstat 0x%" PRIx32 "\n", DEVNAME(sc), intstat)); 1539 intstat &= (SDPCMD_INTSTATUS_HMB_SW_MASK|SDPCMD_INTSTATUS_CHIPACTIVE); 1540 if (intstat) 1541 bwfm_sdio_dev_write(sc, BWFM_SDPCMD_INTSTATUS, intstat); 1542 1543 if (intstat & SDPCMD_INTSTATUS_CHIPACTIVE) 1544 printf("%s: CHIPACTIVE\n", DEVNAME(sc)); 1545 1546 if (intstat & SDPCMD_INTSTATUS_HMB_HOST_INT) { 1547 hostint = bwfm_sdio_dev_read(sc, SDPCMD_TOHOSTMAILBOXDATA); 1548 DPRINTF(("%s: hostint 0x%" PRIx32 "\n", DEVNAME(sc), hostint)); 1549 bwfm_sdio_dev_write(sc, SDPCMD_TOSBMAILBOX, 1550 SDPCMD_TOSBMAILBOX_INT_ACK); 1551 if (hostint & SDPCMD_TOHOSTMAILBOXDATA_NAKHANDLED) 1552 sc->sc_rxskip = false; 1553 if (hostint & SDPCMD_TOHOSTMAILBOXDATA_DEVREADY || 1554 hostint & SDPCMD_TOHOSTMAILBOXDATA_FWREADY) 1555 bwfm_sdio_readshared(sc); 1556 } 1557 1558 if (intstat & SDPCMD_INTSTATUS_HMB_FRAME_IND) { 1559 /* ignore receive indications while recovering */ 1560 if (dorecv && !sc->sc_rxskip) { 1561 DPRINTF(("%s: recv\n", DEVNAME(sc))); 1562 bwfm_sdio_rx_frames(sc); 1563 } 1564 } 1565 1566 if (intstat & SDPCMD_INTSTATUS_HMB_FC_STATE) 1567 dosend = false; 1568 1569 if (intstat & SDPCMD_INTSTATUS_HMB_FC_CHANGE) { 1570 if (dosend) { 1571 intstat = bwfm_sdio_dev_read(sc, BWFM_SDPCMD_INTSTATUS); 1572 DPRINTF(("%s: intstat2 0x%" PRIx32 "\n", DEVNAME(sc), intstat)); 1573 if (intstat & (SDPCMD_INTSTATUS_HMB_FC_STATE | SDPCMD_INTSTATUS_HMB_FC_CHANGE)) 1574 dosend = false; 1575 } 1576 } 1577 1578 if (!dosend && MBUFQ_FIRST(&sc->sc_tx_queue)) printf("%s: flowctl\n", DEVNAME(sc)); 1579 if (dosend && MBUFQ_FIRST(&sc->sc_tx_queue)) { 1580 DPRINTF(("%s: xmit\n", DEVNAME(sc))); 1581 bwfm_sdio_tx_frames(sc); 1582 } 1583 } 1584 1585 static int 1586 bwfm_sdio_tx_ok(struct bwfm_sdio_softc *sc) 1587 { 1588 return (uint8_t)(sc->sc_tx_max_seq - sc->sc_tx_seq) != 0 && 1589 ((uint8_t)(sc->sc_tx_max_seq - sc->sc_tx_seq) & 0x80) == 0; 1590 } 1591 1592 static void 1593 bwfm_sdio_tx_frames(struct bwfm_sdio_softc *sc) 1594 { 1595 struct mbuf *m; 1596 struct ifnet *ifp = sc->sc_sc.sc_ic.ic_ifp; 1597 bool ifstart = false; 1598 int i; 1599 1600 if (!bwfm_sdio_tx_ok(sc)) 1601 return; 1602 1603 i = uimin((uint8_t)(sc->sc_tx_max_seq - sc->sc_tx_seq), 32); 1604 while (i--) { 1605 MBUFQ_DEQUEUE(&sc->sc_tx_queue, m); 1606 if (m == NULL) 1607 break; 1608 1609 if (m->m_type == MT_CONTROL) 1610 bwfm_sdio_tx_ctrlframe(sc, m); 1611 else { 1612 bwfm_sdio_tx_dataframe(sc, m); 1613 if_statinc(ifp, if_opackets); 1614 ifstart = true; 1615 } 1616 1617 m_freem(m); 1618 } 1619 1620 if (ifstart) { 1621 ifp->if_flags &= ~IFF_OACTIVE; 1622 if_schedule_deferred_start(ifp); 1623 } 1624 } 1625 1626 static void 1627 bwfm_sdio_tx_ctrlframe(struct bwfm_sdio_softc *sc, struct mbuf *m) 1628 { 1629 struct bwfm_sdio_hwhdr *hwhdr; 1630 struct bwfm_sdio_swhdr *swhdr; 1631 size_t len, roundto; 1632 1633 len = sizeof(*hwhdr) + sizeof(*swhdr) + m->m_len; 1634 1635 /* Zero-pad to either block-size or 4-byte alignment. */ 1636 if (len > 512 && (len % 512) != 0) 1637 roundto = 512; 1638 else 1639 roundto = 4; 1640 1641 KASSERT(roundup(len, roundto) <= sc->sc_bounce_size); 1642 1643 hwhdr = (void *)sc->sc_bounce_buf; 1644 hwhdr->frmlen = htole16(len); 1645 hwhdr->cksum = htole16(~len); 1646 1647 swhdr = (void *)&hwhdr[1]; 1648 swhdr->seqnr = sc->sc_tx_seq++; 1649 swhdr->chanflag = BWFM_SDIO_SWHDR_CHANNEL_CONTROL; 1650 swhdr->nextlen = 0; 1651 swhdr->dataoff = sizeof(*hwhdr) + sizeof(*swhdr); 1652 swhdr->maxseqnr = 0; 1653 1654 m_copydata(m, 0, m->m_len, &swhdr[1]); 1655 1656 if (roundup(len, roundto) != len) 1657 memset(sc->sc_bounce_buf + len, 0, 1658 roundup(len, roundto) - len); 1659 1660 bwfm_sdio_frame_read_write(sc, sc->sc_bounce_buf, 1661 roundup(len, roundto), 1); 1662 } 1663 1664 static void 1665 bwfm_sdio_tx_dataframe(struct bwfm_sdio_softc *sc, struct mbuf *m) 1666 { 1667 struct bwfm_sdio_hwhdr *hwhdr; 1668 struct bwfm_sdio_swhdr *swhdr; 1669 struct bwfm_proto_bcdc_hdr *bcdc; 1670 size_t len, roundto; 1671 1672 len = sizeof(*hwhdr) + sizeof(*swhdr) + sizeof(*bcdc) 1673 + m->m_pkthdr.len; 1674 1675 /* Zero-pad to either block-size or 4-byte alignment. */ 1676 if (len > 512 && (len % 512) != 0) 1677 roundto = 512; 1678 else 1679 roundto = 4; 1680 1681 KASSERT(roundup(len, roundto) <= sc->sc_bounce_size); 1682 1683 hwhdr = (void *)sc->sc_bounce_buf; 1684 hwhdr->frmlen = htole16(len); 1685 hwhdr->cksum = htole16(~len); 1686 1687 swhdr = (void *)&hwhdr[1]; 1688 swhdr->seqnr = sc->sc_tx_seq++; 1689 swhdr->chanflag = BWFM_SDIO_SWHDR_CHANNEL_DATA; 1690 swhdr->nextlen = 0; 1691 swhdr->dataoff = sizeof(*hwhdr) + sizeof(*swhdr); 1692 swhdr->maxseqnr = 0; 1693 1694 bcdc = (void *)&swhdr[1]; 1695 bcdc->data_offset = 0; 1696 bcdc->priority = WME_AC_BE; 1697 bcdc->flags = BWFM_BCDC_FLAG_VER(BWFM_BCDC_FLAG_PROTO_VER); 1698 bcdc->flags2 = 0; 1699 1700 m_copydata(m, 0, m->m_pkthdr.len, &bcdc[1]); 1701 1702 if (roundup(len, roundto) != len) 1703 memset(sc->sc_bounce_buf + len, 0, 1704 roundup(len, roundto) - len); 1705 1706 bwfm_sdio_frame_read_write(sc, sc->sc_bounce_buf, 1707 roundup(len, roundto), 1); 1708 1709 sc->sc_tx_count--; 1710 } 1711 1712 static int 1713 bwfm_sdio_rxctl(struct bwfm_softc *bwfm, char *buf, size_t *lenp) 1714 { 1715 struct bwfm_sdio_softc *sc = (void *)bwfm; 1716 struct mbuf *m; 1717 int err = 0; 1718 1719 mutex_enter(&sc->sc_lock); 1720 while ((m = bwfm_qget(&sc->sc_rxctl_queue)) == NULL) { 1721 err = cv_timedwait(&sc->sc_rxctl_cv, &sc->sc_lock, 1722 mstohz(5000)); 1723 if (err == EWOULDBLOCK) 1724 break; 1725 } 1726 mutex_exit(&sc->sc_lock); 1727 1728 if (err) 1729 return 1; 1730 1731 if (m->m_len > *lenp) { 1732 m_freem(m); 1733 return 1; 1734 } 1735 1736 *lenp = m->m_len; 1737 m_copydata(m, 0, m->m_len, buf); 1738 m_freem(m); 1739 return 0; 1740 } 1741 1742 static void 1743 bwfm_sdio_rx_frames(struct bwfm_sdio_softc *sc) 1744 { 1745 struct bwfm_sdio_hwhdr *hwhdr; 1746 struct bwfm_sdio_swhdr *swhdr; 1747 struct bwfm_proto_bcdc_hdr *bcdc; 1748 uint16_t *sublen, nextlen = 0; 1749 struct mbuf *m; 1750 size_t flen, off, hoff; 1751 char *data; 1752 int nsub; 1753 size_t subsize; 1754 1755 hwhdr = (struct bwfm_sdio_hwhdr *)sc->sc_bounce_buf; 1756 swhdr = (struct bwfm_sdio_swhdr *)&hwhdr[1]; 1757 data = (char *)&swhdr[1]; 1758 1759 for (;;) { 1760 /* If we know the next size, just read ahead. */ 1761 if (nextlen) { 1762 if (bwfm_sdio_frame_read_write(sc, sc->sc_bounce_buf, 1763 nextlen, 0)) 1764 break; 1765 nextlen = 0; 1766 } else { 1767 if (bwfm_sdio_frame_read_write(sc, sc->sc_bounce_buf, 1768 sizeof(*hwhdr) + sizeof(*swhdr), 0)) 1769 break; 1770 } 1771 1772 hwhdr->frmlen = le16toh(hwhdr->frmlen); 1773 hwhdr->cksum = le16toh(hwhdr->cksum); 1774 1775 if (hwhdr->frmlen == 0 && hwhdr->cksum == 0) { 1776 break; 1777 } 1778 1779 if ((hwhdr->frmlen ^ hwhdr->cksum) != 0xffff) { 1780 printf("%s: checksum error\n", DEVNAME(sc)); 1781 break; 1782 } 1783 1784 if (hwhdr->frmlen < sizeof(*hwhdr) + sizeof(*swhdr)) { 1785 printf("%s: length error\n", DEVNAME(sc)); 1786 break; 1787 } 1788 1789 if (nextlen && hwhdr->frmlen > nextlen) { 1790 printf("%s: read ahead length error (%u > %u)\n", 1791 DEVNAME(sc), hwhdr->frmlen, nextlen); 1792 break; 1793 } 1794 1795 sc->sc_tx_max_seq = swhdr->maxseqnr; 1796 1797 flen = hwhdr->frmlen - (sizeof(*hwhdr) + sizeof(*swhdr)); 1798 if (flen == 0) { 1799 nextlen = swhdr->nextlen << 4; 1800 continue; 1801 } 1802 1803 if (!nextlen) { 1804 KASSERT(roundup(flen, 4) <= sc->sc_bounce_size - 1805 (sizeof(*hwhdr) + sizeof(*swhdr))); 1806 if (bwfm_sdio_frame_read_write(sc, data, 1807 roundup(flen, 4), 0)) { 1808 printf("%s: I/O error roundup(%zu, 4) bytes\n", 1809 DEVNAME(sc), flen); 1810 break; 1811 } 1812 } 1813 1814 if (swhdr->dataoff < (sizeof(*hwhdr) + sizeof(*swhdr))) { 1815 printf("%s: data offset %u in header\n", 1816 DEVNAME(sc), swhdr->dataoff); 1817 break; 1818 } 1819 1820 off = swhdr->dataoff - (sizeof(*hwhdr) + sizeof(*swhdr)); 1821 if (off > flen) { 1822 printf("%s: offset %zu beyond end %zu\n", 1823 DEVNAME(sc), off, flen); 1824 break; 1825 } 1826 1827 switch (swhdr->chanflag & BWFM_SDIO_SWHDR_CHANNEL_MASK) { 1828 case BWFM_SDIO_SWHDR_CHANNEL_CONTROL: 1829 m = bwfm_sdio_newbuf(); 1830 if (m == NULL) 1831 break; 1832 if (flen - off > m->m_len) { 1833 printf("%s: ctl bigger than anticipated\n", 1834 DEVNAME(sc)); 1835 m_freem(m); 1836 break; 1837 } 1838 m->m_len = m->m_pkthdr.len = flen - off; 1839 memcpy(mtod(m, char *), data + off, flen - off); 1840 bwfm_qput(&sc->sc_rxctl_queue, m); 1841 cv_broadcast(&sc->sc_rxctl_cv); 1842 nextlen = swhdr->nextlen << 4; 1843 break; 1844 case BWFM_SDIO_SWHDR_CHANNEL_EVENT: 1845 case BWFM_SDIO_SWHDR_CHANNEL_DATA: 1846 m = bwfm_sdio_newbuf(); 1847 if (m == NULL) 1848 break; 1849 if (flen - off > m->m_len) { 1850 printf("%s: frame bigger than anticipated\n", 1851 DEVNAME(sc)); 1852 m_freem(m); 1853 break; 1854 } 1855 m->m_len = m->m_pkthdr.len = flen - off; 1856 memcpy(mtod(m, char *), data + off, flen - off); 1857 bcdc = mtod(m, struct bwfm_proto_bcdc_hdr *); 1858 hoff = sizeof(*bcdc) + ((size_t)bcdc->data_offset << 2); 1859 if (m->m_len < hoff) { 1860 printf("%s: short bcdc packet %d < %zu\n", 1861 DEVNAME(sc), m->m_len, hoff); 1862 m_freem(m); 1863 break; 1864 } 1865 m_adj(m, hoff); 1866 /* don't pass empty packet to stack */ 1867 if (m->m_len == 0) { 1868 m_freem(m); 1869 break; 1870 } 1871 bwfm_rx(&sc->sc_sc, m); 1872 nextlen = swhdr->nextlen << 4; 1873 break; 1874 case BWFM_SDIO_SWHDR_CHANNEL_GLOM: 1875 if ((flen % sizeof(uint16_t)) != 0) { 1876 printf("%s: odd length (%zu) glom table\n", 1877 DEVNAME(sc), flen); 1878 break; 1879 } 1880 nsub = flen / sizeof(uint16_t); 1881 subsize = nsub * sizeof(uint16_t); 1882 sublen = NULL; 1883 nextlen = 0; 1884 if (subsize > 0) 1885 sublen = kmem_zalloc(subsize, KM_NOSLEEP); 1886 if (sublen != NULL) { 1887 memcpy(sublen, data, subsize); 1888 bwfm_sdio_rx_glom(sc, sublen, nsub, &nextlen); 1889 kmem_free(sublen, subsize); 1890 } 1891 break; 1892 default: 1893 printf("%s: unknown channel\n", DEVNAME(sc)); 1894 break; 1895 } 1896 } 1897 } 1898 1899 static void 1900 bwfm_sdio_rx_glom(struct bwfm_sdio_softc *sc, uint16_t *sublen, int nsub, 1901 uint16_t *nextlen) 1902 { 1903 struct bwfm_sdio_hwhdr hwhdr; 1904 struct bwfm_sdio_swhdr swhdr; 1905 struct bwfm_proto_bcdc_hdr *bcdc; 1906 struct mbuf *m, *m0; 1907 size_t flen, off, hoff; 1908 int i; 1909 1910 if (nsub == 0) 1911 return; 1912 1913 m0 = NULL; 1914 for (i = 0; i < nsub; i++) { 1915 m = bwfm_sdio_newbuf(); 1916 if (m == NULL) { 1917 m_freem(m0); 1918 return; 1919 } 1920 bwfm_qput(&m0, m); 1921 if (le16toh(sublen[i]) > m->m_len) { 1922 m_freem(m0); 1923 printf("%s: header larger than mbuf\n", DEVNAME(sc)); 1924 return; 1925 } 1926 if (bwfm_sdio_frame_read_write(sc, mtod(m, char *), 1927 le16toh(sublen[i]), 0)) { 1928 m_freem(m0); 1929 printf("%s: frame I/O error\n", DEVNAME(sc)); 1930 return; 1931 } 1932 m->m_len = m->m_pkthdr.len = le16toh(sublen[i]); 1933 } 1934 1935 if (m0->m_len >= sizeof(hwhdr) + sizeof(swhdr)) { 1936 m_copydata(m0, 0, sizeof(hwhdr), &hwhdr); 1937 m_copydata(m0, sizeof(hwhdr), sizeof(swhdr), &swhdr); 1938 1939 /* TODO: Verify actual superframe header */ 1940 1941 /* remove superframe header */ 1942 if (m0->m_len >= swhdr.dataoff) 1943 m_adj(m0, swhdr.dataoff); 1944 } 1945 1946 *nextlen = 0; 1947 while ((m = bwfm_qget(&m0)) != NULL) { 1948 if (m->m_len < sizeof(hwhdr) + sizeof(swhdr)) { 1949 printf("%s: tiny mbuf %d < %zu\n", DEVNAME(sc), 1950 m->m_len, sizeof(hwhdr) + sizeof(swhdr)); 1951 goto drop; 1952 } 1953 1954 m_copydata(m, 0, sizeof(hwhdr), &hwhdr); 1955 m_copydata(m, sizeof(hwhdr), sizeof(swhdr), &swhdr); 1956 1957 hwhdr.frmlen = le16toh(hwhdr.frmlen); 1958 hwhdr.cksum = le16toh(hwhdr.cksum); 1959 1960 if (hwhdr.frmlen == 0 && hwhdr.cksum == 0) 1961 goto drop; 1962 1963 if ((hwhdr.frmlen ^ hwhdr.cksum) != 0xffff) { 1964 printf("%s: checksum error\n", DEVNAME(sc)); 1965 goto drop; 1966 } 1967 1968 1969 if (hwhdr.frmlen < sizeof(hwhdr) + sizeof(swhdr)) { 1970 printf("%s: length error\n", DEVNAME(sc)); 1971 goto drop; 1972 } 1973 1974 flen = hwhdr.frmlen - (sizeof(hwhdr) + sizeof(swhdr)); 1975 if (flen == 0) 1976 goto drop; 1977 1978 if (hwhdr.frmlen > m->m_len) { 1979 printf("%s: short mbuf %d < %zu\n", 1980 DEVNAME(sc),m->m_len,flen); 1981 goto drop; 1982 } 1983 1984 if (swhdr.dataoff < (sizeof(hwhdr) + sizeof(swhdr))) { 1985 printf("%s: data offset %u in header\n", 1986 DEVNAME(sc), swhdr.dataoff); 1987 goto drop; 1988 } 1989 1990 off = swhdr.dataoff - (sizeof(hwhdr) + sizeof(swhdr)); 1991 if (off > flen) { 1992 printf("%s: offset %zu beyond end %zu\n", 1993 DEVNAME(sc), off, flen); 1994 goto drop; 1995 } 1996 1997 m_adj(m, (int)hwhdr.frmlen - m->m_len); 1998 *nextlen = swhdr.nextlen << 4; 1999 2000 switch (swhdr.chanflag & BWFM_SDIO_SWHDR_CHANNEL_MASK) { 2001 case BWFM_SDIO_SWHDR_CHANNEL_CONTROL: 2002 printf("%s: control channel not allowed in glom\n", 2003 DEVNAME(sc)); 2004 goto drop; 2005 case BWFM_SDIO_SWHDR_CHANNEL_EVENT: 2006 case BWFM_SDIO_SWHDR_CHANNEL_DATA: 2007 m_adj(m, swhdr.dataoff); 2008 bcdc = mtod(m, struct bwfm_proto_bcdc_hdr *); 2009 hoff = sizeof(*bcdc) + ((size_t)bcdc->data_offset << 2); 2010 if (m->m_len < hoff) { 2011 printf("%s: short bcdc packet %d < %zu\n", 2012 DEVNAME(sc), m->m_len, hoff); 2013 m_freem(m); 2014 break; 2015 } 2016 m_adj(m, hoff); 2017 /* don't pass empty packet to stack */ 2018 if (m->m_len == 0) { 2019 m_freem(m); 2020 break; 2021 } 2022 bwfm_rx(&sc->sc_sc, m); 2023 break; 2024 case BWFM_SDIO_SWHDR_CHANNEL_GLOM: 2025 printf("%s: glom not allowed in glom\n", 2026 DEVNAME(sc)); 2027 goto drop; 2028 default: 2029 printf("%s: unknown channel\n", DEVNAME(sc)); 2030 goto drop; 2031 } 2032 2033 continue; 2034 drop: 2035 printf("rx dropped %p len %d\n",mtod(m, char *),m->m_pkthdr.len); 2036 m_free(m); 2037 break; 2038 } 2039 } 2040 2041 #ifdef BWFM_DEBUG 2042 static void 2043 bwfm_sdio_debug_console(struct bwfm_sdio_softc *sc) 2044 { 2045 struct bwfm_sdio_console c; 2046 uint32_t newidx; 2047 int err; 2048 2049 if (!sc->sc_console_addr) 2050 return; 2051 2052 err = bwfm_sdio_ram_read_write(sc, sc->sc_console_addr, 2053 (char *)&c, sizeof(c), 0); 2054 if (err) 2055 return; 2056 2057 c.log_buf = le32toh(c.log_buf); 2058 c.log_bufsz = le32toh(c.log_bufsz); 2059 c.log_idx = le32toh(c.log_idx); 2060 2061 if (sc->sc_console_buf == NULL) { 2062 sc->sc_console_buf = malloc(c.log_bufsz, M_DEVBUF, 2063 M_WAITOK|M_ZERO); 2064 sc->sc_console_buf_size = c.log_bufsz; 2065 } 2066 2067 newidx = c.log_idx; 2068 if (newidx >= sc->sc_console_buf_size) 2069 return; 2070 2071 err = bwfm_sdio_ram_read_write(sc, c.log_buf, sc->sc_console_buf, 2072 sc->sc_console_buf_size, 0); 2073 if (err) 2074 return; 2075 2076 if (newidx != sc->sc_console_readidx) 2077 DPRINTFN(3, ("BWFM CONSOLE: ")); 2078 while (newidx != sc->sc_console_readidx) { 2079 uint8_t ch = sc->sc_console_buf[sc->sc_console_readidx]; 2080 sc->sc_console_readidx++; 2081 if (sc->sc_console_readidx == sc->sc_console_buf_size) 2082 sc->sc_console_readidx = 0; 2083 if (ch == '\r') 2084 continue; 2085 DPRINTFN(3, ("%c", ch)); 2086 } 2087 } 2088 #endif 2089
Indexes created Thu Sep 25 16:09:42 GMT 2025