if_bwi_sdio.c revision 1.1
1 /* $NetBSD: if_bwi_sdio.c,v 1.1 2025/01/19 00:29:29 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2025 Jared McNeill <jmcneill (at) invisible.ca> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 26 * POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 31 __KERNEL_RCSID(0, "$NetBSD: if_bwi_sdio.c,v 1.1 2025/01/19 00:29:29 jmcneill Exp $"); 32 33 #include <sys/param.h> 34 #include <sys/bus.h> 35 #include <sys/device.h> 36 #include <sys/mutex.h> 37 #include <sys/systm.h> 38 39 #include <net/if.h> 40 #include <net/if_dl.h> 41 #include <net/if_ether.h> 42 #include <net/if_media.h> 43 44 #include <netinet/in.h> 45 46 #include <net80211/ieee80211_node.h> 47 #include <net80211/ieee80211_amrr.h> 48 #include <net80211/ieee80211_radiotap.h> 49 #include <net80211/ieee80211_var.h> 50 51 #include <dev/ic/bwireg.h> 52 #include <dev/ic/bwivar.h> 53 54 #include <dev/pcmcia/pcmciareg.h> 55 56 #include <dev/sdmmc/sdmmcdevs.h> 57 #include <dev/sdmmc/sdmmcvar.h> 58 59 #define BWI_SDIO_FUNC1_SBADDRLOW 0x1000a 60 #define BWI_SDIO_FUNC1_SBADDRMID 0x1000b 61 #define BWI_SDIO_FUNC1_SBADDRHI 0x1000c 62 63 #define BWI_CISTPL_VENDOR 0x80 64 #define BWI_VENDOR_SROMREV 0 65 #define BWI_VENDOR_ID 1 66 #define BWI_VENDOR_BOARDREV 2 67 #define BWI_VENDOR_PA 3 68 #define BWI_VENDOR_OEMNAME 4 69 #define BWI_VENDOR_CCODE 5 70 #define BWI_VENDOR_ANTENNA 6 71 #define BWI_VENDOR_ANTGAIN 7 72 #define BWI_VENDOR_BFLAGS 8 73 #define BWI_VENDOR_LEDS 9 74 75 #define BWI_SDIO_REG_OFFSET(ssc, reg) \ 76 ((reg) | ((ssc)->sc_sel_regwin & 0x7000)) 77 78 #define BWI_SDIO_REG_32BIT_ACCESS 0x8000 79 80 static const struct bwi_sdio_product { 81 uint16_t vendor; 82 uint16_t product; 83 } bwi_sdio_products[] = { 84 { SDMMC_VENDOR_BROADCOM, SDMMC_PRODUCT_BROADCOM_NINTENDO_WII }, 85 }; 86 87 struct bwi_sdio_sprom { 88 uint16_t pa_params[3]; 89 uint16_t board_vendor; 90 uint16_t card_flags; 91 uint8_t srom_rev; 92 uint8_t board_rev; 93 uint8_t idle_tssi; 94 uint8_t max_txpwr; 95 uint8_t country_code; 96 uint8_t ant_avail; 97 uint8_t ant_gain; 98 uint8_t gpio[4]; 99 }; 100 101 struct bwi_sdio_softc { 102 struct bwi_softc sc_base; 103 104 struct sdmmc_function *sc_sf; 105 struct bwi_sdio_sprom sc_sprom; 106 uint32_t sc_sel_regwin; 107 kmutex_t sc_lock; 108 }; 109 110 static int bwi_sdio_match(device_t, cfdata_t, void *); 111 static void bwi_sdio_attach(device_t, device_t, void *); 112 113 static void bwi_sdio_parse_cis(struct bwi_sdio_softc *); 114 115 static int bwi_sdio_intr(void *); 116 117 static void bwi_sdio_conf_write(void *, uint32_t, uint32_t); 118 static uint32_t bwi_sdio_conf_read(void *, uint32_t); 119 static void bwi_sdio_reg_write_2(void *, uint32_t, uint16_t); 120 static uint16_t bwi_sdio_reg_read_2(void *, uint32_t); 121 static void bwi_sdio_reg_write_4(void *, uint32_t, uint32_t); 122 static uint32_t bwi_sdio_reg_read_4(void *, uint32_t); 123 static void bwi_sdio_reg_write_multi_4(void *, uint32_t, const uint32_t *, 124 size_t); 125 static void bwi_sdio_reg_read_multi_4(void *, uint32_t, uint32_t *, 126 size_t); 127 128 CFATTACH_DECL_NEW(bwi_sdio, sizeof(struct bwi_sdio_softc), 129 bwi_sdio_match, bwi_sdio_attach, NULL, NULL); 130 131 static int 132 bwi_sdio_match(device_t parent, cfdata_t cf, void *aux) 133 { 134 struct sdmmc_attach_args * const saa = aux; 135 struct sdmmc_function *sf = saa->sf; 136 struct sdmmc_cis *cis; 137 u_int n; 138 139 if (sf == NULL) { 140 return 0; 141 } 142 cis = &sf->sc->sc_fn0->cis; 143 144 for (n = 0; n < __arraycount(bwi_sdio_products); n++) { 145 const struct bwi_sdio_product *bsp = &bwi_sdio_products[n]; 146 147 if (bsp->vendor == cis->manufacturer && 148 bsp->product == cis->product) { 149 return 1; 150 } 151 } 152 153 return 0; 154 } 155 156 static void 157 bwi_sdio_attach(device_t parent, device_t self, void *aux) 158 { 159 struct bwi_sdio_softc * const ssc = device_private(self); 160 struct bwi_softc * const sc = &ssc->sc_base; 161 struct sdmmc_attach_args * const saa = aux; 162 struct sdmmc_function *sf = saa->sf; 163 struct sdmmc_cis *cis = &sf->sc->sc_fn0->cis; 164 int error; 165 void *ih; 166 167 aprint_naive("\n"); 168 aprint_normal(": Broadcom Wireless\n"); 169 170 sc->sc_dev = self; 171 sc->sc_flags = BWI_F_SDIO | BWI_F_PIO; 172 sc->sc_conf_write = bwi_sdio_conf_write; 173 sc->sc_conf_read = bwi_sdio_conf_read; 174 sc->sc_reg_write_multi_4 = bwi_sdio_reg_write_multi_4; 175 sc->sc_reg_read_multi_4 = bwi_sdio_reg_read_multi_4; 176 sc->sc_reg_write_2 = bwi_sdio_reg_write_2; 177 sc->sc_reg_read_2 = bwi_sdio_reg_read_2; 178 sc->sc_reg_write_4 = bwi_sdio_reg_write_4; 179 sc->sc_reg_read_4 = bwi_sdio_reg_read_4; 180 sc->sc_pci_revid = 0; /* XXX can this come from CIS? */ 181 sc->sc_pci_did = cis->product; 182 sc->sc_pci_subvid = cis->manufacturer; 183 sc->sc_pci_subdid = cis->product; 184 185 ssc->sc_sf = sf; 186 mutex_init(&ssc->sc_lock, MUTEX_DEFAULT, IPL_NONE); 187 188 sdmmc_io_set_blocklen(ssc->sc_sf, 64); 189 if (sdmmc_io_function_enable(ssc->sc_sf) != 0) { 190 aprint_error_dev(self, "couldn't enable function\n"); 191 return; 192 } 193 194 bwi_sdio_parse_cis(ssc); 195 196 ih = sdmmc_intr_establish(parent, bwi_sdio_intr, ssc, 197 device_xname(self)); 198 if (ih == NULL) { 199 aprint_error_dev(self, "couldn't establish interrupt\n"); 200 return; 201 } 202 203 error = bwi_attach(sc); 204 if (error != 0) { 205 sdmmc_intr_disestablish(ih); 206 return; 207 } 208 209 sdmmc_intr_enable(ssc->sc_sf); 210 } 211 212 static void 213 bwi_sdio_parse_cis(struct bwi_sdio_softc *ssc) 214 { 215 struct sdmmc_function *sf0 = ssc->sc_sf->sc->sc_fn0; 216 struct bwi_sdio_sprom *sprom = &ssc->sc_sprom; 217 uint32_t reg; 218 uint8_t tplcode, tpllen; 219 220 reg = sdmmc_cisptr(ssc->sc_sf); 221 for (;;) { 222 tplcode = sdmmc_io_read_1(sf0, reg++); 223 if (tplcode == PCMCIA_CISTPL_NULL) { 224 continue; 225 } 226 tpllen = sdmmc_io_read_1(sf0, reg++); 227 if (tplcode == PCMCIA_CISTPL_END || tpllen == 0) { 228 break; 229 } 230 if (tplcode != BWI_CISTPL_VENDOR) { 231 reg += tpllen; 232 continue; 233 } 234 235 switch (sdmmc_io_read_1(sf0, reg)) { 236 case BWI_VENDOR_SROMREV: 237 sprom->srom_rev = sdmmc_io_read_1(sf0, reg + 1); 238 break; 239 case BWI_VENDOR_ID: 240 sprom->board_vendor = 241 sdmmc_io_read_1(sf0, reg + 1) | 242 ((uint16_t)sdmmc_io_read_1(sf0, reg + 2) << 8); 243 break; 244 case BWI_VENDOR_BOARDREV: 245 sprom->board_rev = 246 sdmmc_io_read_1(sf0, reg + 1); 247 break; 248 case BWI_VENDOR_PA: 249 sprom->pa_params[0] = 250 sdmmc_io_read_1(sf0, reg + 1) | 251 ((uint16_t)sdmmc_io_read_1(sf0, reg + 2) << 8); 252 sprom->pa_params[1] = 253 sdmmc_io_read_1(sf0, reg + 3) | 254 ((uint16_t)sdmmc_io_read_1(sf0, reg + 4) << 8); 255 sprom->pa_params[2] = 256 sdmmc_io_read_1(sf0, reg + 5) | 257 ((uint16_t)sdmmc_io_read_1(sf0, reg + 6) << 8); 258 sprom->idle_tssi = 259 sdmmc_io_read_1(sf0, reg + 7); 260 sprom->max_txpwr = 261 sdmmc_io_read_1(sf0, reg + 8); 262 break; 263 case BWI_VENDOR_CCODE: 264 sprom->country_code = 265 sdmmc_io_read_1(sf0, reg + 1); 266 break; 267 case BWI_VENDOR_ANTGAIN: 268 sprom->ant_gain = sdmmc_io_read_1(sf0, reg + 1); 269 break; 270 case BWI_VENDOR_BFLAGS: 271 sprom->card_flags = 272 sdmmc_io_read_1(sf0, reg + 1) | 273 ((uint16_t)sdmmc_io_read_1(sf0, reg + 2) << 8); 274 break; 275 case BWI_VENDOR_LEDS: 276 sprom->gpio[0] = sdmmc_io_read_1(sf0, reg + 1); 277 sprom->gpio[1] = sdmmc_io_read_1(sf0, reg + 2); 278 sprom->gpio[2] = sdmmc_io_read_1(sf0, reg + 3); 279 sprom->gpio[3] = sdmmc_io_read_1(sf0, reg + 4); 280 break; 281 } 282 283 reg += tpllen; 284 } 285 } 286 287 static int 288 bwi_sdio_intr(void *priv) 289 { 290 struct bwi_sdio_softc * const ssc = priv; 291 292 bwi_intr(&ssc->sc_base); 293 294 return 1; 295 } 296 297 static void 298 bwi_sdio_conf_write(void *priv, uint32_t reg, uint32_t val) 299 { 300 struct bwi_sdio_softc * const ssc = priv; 301 302 KASSERT(reg == BWI_PCIR_SEL_REGWIN); 303 304 mutex_enter(&ssc->sc_lock); 305 if (reg == BWI_PCIR_SEL_REGWIN && ssc->sc_sel_regwin != val) { 306 sdmmc_io_write_1(ssc->sc_sf, BWI_SDIO_FUNC1_SBADDRLOW, 307 (val >> 8) & 0x80); 308 sdmmc_io_write_1(ssc->sc_sf, BWI_SDIO_FUNC1_SBADDRMID, 309 (val >> 16) & 0xff); 310 sdmmc_io_write_1(ssc->sc_sf, BWI_SDIO_FUNC1_SBADDRHI, 311 (val >> 24) & 0xff); 312 ssc->sc_sel_regwin = val; 313 } 314 mutex_exit(&ssc->sc_lock); 315 } 316 317 static uint32_t 318 bwi_sdio_conf_read(void *priv, uint32_t reg) 319 { 320 struct bwi_sdio_softc * const ssc = priv; 321 322 KASSERT(reg == BWI_PCIR_SEL_REGWIN); 323 324 if (reg == BWI_PCIR_SEL_REGWIN) { 325 return ssc->sc_sel_regwin; 326 } else { 327 return 0; 328 } 329 } 330 331 static void 332 bwi_sdio_reg_write_multi_4(void *priv, uint32_t reg, const uint32_t *datap, 333 size_t count) 334 { 335 struct bwi_sdio_softc * const ssc = priv; 336 337 mutex_enter(&ssc->sc_lock); 338 sdmmc_io_write_multi_1(ssc->sc_sf, 339 BWI_SDIO_REG_OFFSET(ssc, reg) | BWI_SDIO_REG_32BIT_ACCESS, 340 (uint8_t *)__UNCONST(datap), count * sizeof(uint32_t)); 341 mutex_exit(&ssc->sc_lock); 342 } 343 344 static void 345 bwi_sdio_reg_read_multi_4(void *priv, uint32_t reg, uint32_t *datap, 346 size_t count) 347 { 348 struct bwi_sdio_softc * const ssc = priv; 349 350 mutex_enter(&ssc->sc_lock); 351 sdmmc_io_read_multi_1(ssc->sc_sf, 352 BWI_SDIO_REG_OFFSET(ssc, reg) | BWI_SDIO_REG_32BIT_ACCESS, 353 (uint8_t *)datap, count * sizeof(uint32_t)); 354 mutex_exit(&ssc->sc_lock); 355 } 356 357 static void 358 bwi_sdio_reg_write_2(void *priv, uint32_t reg, uint16_t val) 359 { 360 struct bwi_sdio_softc * const ssc = priv; 361 362 val = htole16(val); 363 364 mutex_enter(&ssc->sc_lock); 365 sdmmc_io_write_2(ssc->sc_sf, BWI_SDIO_REG_OFFSET(ssc, reg), val); 366 mutex_exit(&ssc->sc_lock); 367 } 368 369 static uint16_t 370 bwi_sdio_reg_read_sprom(struct bwi_sdio_softc *ssc, uint32_t reg) 371 { 372 struct bwi_sdio_sprom *sprom = &ssc->sc_sprom; 373 struct sdmmc_cis *cis = &ssc->sc_sf->cis; 374 375 switch (reg) { 376 case BWI_SPROM_11BG_EADDR ... BWI_SPROM_11BG_EADDR + 4: 377 return *(uint16_t *)&cis->lan_nid[reg - BWI_SPROM_11BG_EADDR]; 378 case BWI_SPROM_11A_EADDR ... BWI_SPROM_11A_EADDR + 4: 379 return *(uint16_t *)&cis->lan_nid[reg - BWI_SPROM_11A_EADDR]; 380 case BWI_SPROM_CARD_INFO: 381 return (uint16_t)sprom->country_code << 8; 382 case BWI_SPROM_PA_PARAM_11BG ... BWI_SPROM_PA_PARAM_11BG + 4: 383 return sprom->pa_params[(reg - BWI_SPROM_PA_PARAM_11BG) / 2]; 384 case BWI_SPROM_PA_PARAM_11A ... BWI_SPROM_PA_PARAM_11A + 4: 385 return sprom->pa_params[(reg - BWI_SPROM_PA_PARAM_11A) / 2]; 386 case BWI_SPROM_GPIO01: 387 return sprom->gpio[0] | ((uint16_t)sprom->gpio[1] << 8); 388 case BWI_SPROM_GPIO23: 389 return sprom->gpio[2] | ((uint16_t)sprom->gpio[3] << 8); 390 case BWI_SPROM_MAX_TXPWR: 391 return sprom->max_txpwr | ((uint16_t)sprom->max_txpwr << 8); 392 case BWI_SPROM_IDLE_TSSI: 393 return sprom->idle_tssi | ((uint16_t)sprom->idle_tssi << 8); 394 case BWI_SPROM_CARD_FLAGS: 395 return sprom->card_flags; 396 case BWI_SPROM_ANT_GAIN: 397 return sprom->ant_gain | ((uint16_t)sprom->ant_gain << 8); 398 default: 399 return 0xffff; 400 } 401 } 402 403 static uint16_t 404 bwi_sdio_reg_read_2(void *priv, uint32_t reg) 405 { 406 struct bwi_sdio_softc * const ssc = priv; 407 uint16_t val; 408 409 /* Emulate SPROM reads */ 410 if (reg >= BWI_SPROM_START && 411 reg <= BWI_SPROM_START + BWI_SPROM_ANT_GAIN) { 412 return bwi_sdio_reg_read_sprom(ssc, reg - BWI_SPROM_START); 413 } 414 415 mutex_enter(&ssc->sc_lock); 416 val = sdmmc_io_read_2(ssc->sc_sf, BWI_SDIO_REG_OFFSET(ssc, reg)); 417 mutex_exit(&ssc->sc_lock); 418 419 val = le16toh(val); 420 421 return val; 422 } 423 424 static void 425 bwi_sdio_reg_write_4(void *priv, uint32_t reg, uint32_t val) 426 { 427 struct bwi_sdio_softc * const ssc = priv; 428 429 val = htole32(val); 430 431 mutex_enter(&ssc->sc_lock); 432 sdmmc_io_write_4(ssc->sc_sf, 433 BWI_SDIO_REG_OFFSET(ssc, reg) | BWI_SDIO_REG_32BIT_ACCESS, val); 434 /* SDIO cards require a read after a 32-bit write */ 435 sdmmc_io_read_4(ssc->sc_sf, 0); 436 mutex_exit(&ssc->sc_lock); 437 } 438 439 static uint32_t 440 bwi_sdio_reg_read_4(void *priv, uint32_t reg) 441 { 442 struct bwi_sdio_softc * const ssc = priv; 443 uint32_t val; 444 445 mutex_enter(&ssc->sc_lock); 446 val = sdmmc_io_read_4(ssc->sc_sf, 447 BWI_SDIO_REG_OFFSET(ssc, reg) | BWI_SDIO_REG_32BIT_ACCESS); 448 mutex_exit(&ssc->sc_lock); 449 450 val = le32toh(val); 451 452 return val; 453 } 454
Indexes created Thu Sep 25 16:09:42 GMT 2025