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