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