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