1 /* 2 * Sonics Silicon Backplane 3 * SDIO-Hostbus related functions 4 * 5 * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es> 6 * 7 * Based on drivers/ssb/pcmcia.c 8 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 9 * Copyright 2007-2008 Michael Buesch <m@bues.ch> 10 * 11 * Licensed under the GNU/GPL. See COPYING for details. 12 * 13 */ 14 15 #include <linux/ssb/ssb.h> 16 #include <linux/delay.h> 17 #include <linux/io.h> 18 #include <linux/etherdevice.h> 19 #include <linux/mmc/sdio_func.h> 20 21 #include "ssb_private.h" 22 23 /* Define the following to 1 to enable a printk on each coreswitch. */ 24 #define SSB_VERBOSE_SDIOCORESWITCH_DEBUG 0 25 26 27 /* Hardware invariants CIS tuples */ 28 #define SSB_SDIO_CIS 0x80 29 #define SSB_SDIO_CIS_SROMREV 0x00 30 #define SSB_SDIO_CIS_ID 0x01 31 #define SSB_SDIO_CIS_BOARDREV 0x02 32 #define SSB_SDIO_CIS_PA 0x03 33 #define SSB_SDIO_CIS_PA_PA0B0_LO 0 34 #define SSB_SDIO_CIS_PA_PA0B0_HI 1 35 #define SSB_SDIO_CIS_PA_PA0B1_LO 2 36 #define SSB_SDIO_CIS_PA_PA0B1_HI 3 37 #define SSB_SDIO_CIS_PA_PA0B2_LO 4 38 #define SSB_SDIO_CIS_PA_PA0B2_HI 5 39 #define SSB_SDIO_CIS_PA_ITSSI 6 40 #define SSB_SDIO_CIS_PA_MAXPOW 7 41 #define SSB_SDIO_CIS_OEMNAME 0x04 42 #define SSB_SDIO_CIS_CCODE 0x05 43 #define SSB_SDIO_CIS_ANTENNA 0x06 44 #define SSB_SDIO_CIS_ANTGAIN 0x07 45 #define SSB_SDIO_CIS_BFLAGS 0x08 46 #define SSB_SDIO_CIS_LEDS 0x09 47 48 #define CISTPL_FUNCE_LAN_NODE_ID 0x04 /* same as in PCMCIA */ 49 50 51 /* 52 * Function 1 miscellaneous registers. 53 * 54 * Definitions match src/include/sbsdio.h from the 55 * Android Open Source Project 56 * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git 57 * 58 */ 59 #define SBSDIO_FUNC1_SBADDRLOW 0x1000a /* SB Address window Low (b15) */ 60 #define SBSDIO_FUNC1_SBADDRMID 0x1000b /* SB Address window Mid (b23-b16) */ 61 #define SBSDIO_FUNC1_SBADDRHIGH 0x1000c /* SB Address window High (b24-b31) */ 62 63 /* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */ 64 #define SBSDIO_SBADDRLOW_MASK 0x80 /* Valid address bits in SBADDRLOW */ 65 #define SBSDIO_SBADDRMID_MASK 0xff /* Valid address bits in SBADDRMID */ 66 #define SBSDIO_SBADDRHIGH_MASK 0xff /* Valid address bits in SBADDRHIGH */ 67 68 #define SBSDIO_SB_OFT_ADDR_MASK 0x7FFF /* sb offset addr is <= 15 bits, 32k */ 69 70 /* REVISIT: this flag doesn't seem to matter */ 71 #define SBSDIO_SB_ACCESS_2_4B_FLAG 0x8000 /* forces 32-bit SB access */ 72 73 74 /* 75 * Address map within the SDIO function address space (128K). 76 * 77 * Start End Description 78 * ------- ------- ------------------------------------------ 79 * 0x00000 0x0ffff selected backplane address window (64K) 80 * 0x10000 0x1ffff backplane control registers (max 64K) 81 * 82 * The current address window is configured by writing to registers 83 * SBADDRLOW, SBADDRMID and SBADDRHIGH. 84 * 85 * In order to access the contents of a 32-bit Silicon Backplane address 86 * the backplane address window must be first loaded with the highest 87 * 16 bits of the target address. Then, an access must be done to the 88 * SDIO function address space using the lower 15 bits of the address. 89 * Bit 15 of the address must be set when doing 32 bit accesses. 90 * 91 * 10987654321098765432109876543210 92 * WWWWWWWWWWWWWWWWW SB Address Window 93 * OOOOOOOOOOOOOOOO Offset within SB Address Window 94 * a 32-bit access flag 95 */ 96 97 98 /* 99 * SSB I/O via SDIO. 100 * 101 * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K). 102 */ 103 104 static inline struct device *ssb_sdio_dev(struct ssb_bus *bus) 105 { 106 return &bus->host_sdio->dev; 107 } 108 109 /* host claimed */ 110 static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val) 111 { 112 int error = 0; 113 114 sdio_writeb(bus->host_sdio, val, addr, &error); 115 if (unlikely(error)) { 116 dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n", 117 addr, val, error); 118 } 119 120 return error; 121 } 122 123 #if 0 124 static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr) 125 { 126 u8 val; 127 int error = 0; 128 129 val = sdio_readb(bus->host_sdio, addr, &error); 130 if (unlikely(error)) { 131 dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n", 132 addr, val, error); 133 } 134 135 return val; 136 } 137 #endif 138 139 /* host claimed */ 140 static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address) 141 { 142 int error; 143 144 error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW, 145 (address >> 8) & SBSDIO_SBADDRLOW_MASK); 146 if (error) 147 goto out; 148 error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID, 149 (address >> 16) & SBSDIO_SBADDRMID_MASK); 150 if (error) 151 goto out; 152 error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH, 153 (address >> 24) & SBSDIO_SBADDRHIGH_MASK); 154 if (error) 155 goto out; 156 bus->sdio_sbaddr = address; 157 out: 158 if (error) { 159 dev_dbg(ssb_sdio_dev(bus), "failed to set address window" 160 " to 0x%08x, error %d\n", address, error); 161 } 162 163 return error; 164 } 165 166 /* for enumeration use only */ 167 u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) 168 { 169 u32 val; 170 int error; 171 172 sdio_claim_host(bus->host_sdio); 173 val = sdio_readl(bus->host_sdio, offset, &error); 174 sdio_release_host(bus->host_sdio); 175 if (unlikely(error)) { 176 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 177 bus->sdio_sbaddr >> 16, offset, val, error); 178 } 179 180 return val; 181 } 182 183 /* for enumeration use only */ 184 int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 185 { 186 u32 sbaddr; 187 int error; 188 189 sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 190 sdio_claim_host(bus->host_sdio); 191 error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 192 sdio_release_host(bus->host_sdio); 193 if (error) { 194 dev_err(ssb_sdio_dev(bus), "failed to switch to core %u," 195 " error %d\n", coreidx, error); 196 goto out; 197 } 198 out: 199 return error; 200 } 201 202 /* host must be already claimed */ 203 int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev) 204 { 205 u8 coreidx = dev->core_index; 206 u32 sbaddr; 207 int error = 0; 208 209 sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 210 if (unlikely(bus->sdio_sbaddr != sbaddr)) { 211 #if SSB_VERBOSE_SDIOCORESWITCH_DEBUG 212 dev_info(ssb_sdio_dev(bus), 213 "switching to %s core, index %d\n", 214 ssb_core_name(dev->id.coreid), coreidx); 215 #endif 216 error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 217 if (error) { 218 dev_dbg(ssb_sdio_dev(bus), "failed to switch to" 219 " core %u, error %d\n", coreidx, error); 220 goto out; 221 } 222 bus->mapped_device = dev; 223 } 224 225 out: 226 return error; 227 } 228 229 static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset) 230 { 231 struct ssb_bus *bus = dev->bus; 232 u8 val = 0xff; 233 int error = 0; 234 235 sdio_claim_host(bus->host_sdio); 236 if (unlikely(ssb_sdio_switch_core(bus, dev))) 237 goto out; 238 offset |= bus->sdio_sbaddr & 0xffff; 239 offset &= SBSDIO_SB_OFT_ADDR_MASK; 240 val = sdio_readb(bus->host_sdio, offset, &error); 241 if (error) { 242 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n", 243 bus->sdio_sbaddr >> 16, offset, val, error); 244 } 245 out: 246 sdio_release_host(bus->host_sdio); 247 248 return val; 249 } 250 251 static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset) 252 { 253 struct ssb_bus *bus = dev->bus; 254 u16 val = 0xffff; 255 int error = 0; 256 257 sdio_claim_host(bus->host_sdio); 258 if (unlikely(ssb_sdio_switch_core(bus, dev))) 259 goto out; 260 offset |= bus->sdio_sbaddr & 0xffff; 261 offset &= SBSDIO_SB_OFT_ADDR_MASK; 262 val = sdio_readw(bus->host_sdio, offset, &error); 263 if (error) { 264 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n", 265 bus->sdio_sbaddr >> 16, offset, val, error); 266 } 267 out: 268 sdio_release_host(bus->host_sdio); 269 270 return val; 271 } 272 273 static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset) 274 { 275 struct ssb_bus *bus = dev->bus; 276 u32 val = 0xffffffff; 277 int error = 0; 278 279 sdio_claim_host(bus->host_sdio); 280 if (unlikely(ssb_sdio_switch_core(bus, dev))) 281 goto out; 282 offset |= bus->sdio_sbaddr & 0xffff; 283 offset &= SBSDIO_SB_OFT_ADDR_MASK; 284 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ 285 val = sdio_readl(bus->host_sdio, offset, &error); 286 if (error) { 287 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 288 bus->sdio_sbaddr >> 16, offset, val, error); 289 } 290 out: 291 sdio_release_host(bus->host_sdio); 292 293 return val; 294 } 295 296 #ifdef CONFIG_SSB_BLOCKIO 297 static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer, 298 size_t count, u16 offset, u8 reg_width) 299 { 300 size_t saved_count = count; 301 struct ssb_bus *bus = dev->bus; 302 int error = 0; 303 304 sdio_claim_host(bus->host_sdio); 305 if (unlikely(ssb_sdio_switch_core(bus, dev))) { 306 error = -EIO; 307 memset(buffer, 0xff, count); 308 goto err_out; 309 } 310 offset |= bus->sdio_sbaddr & 0xffff; 311 offset &= SBSDIO_SB_OFT_ADDR_MASK; 312 313 switch (reg_width) { 314 case sizeof(u8): { 315 error = sdio_readsb(bus->host_sdio, buffer, offset, count); 316 break; 317 } 318 case sizeof(u16): { 319 SSB_WARN_ON(count & 1); 320 error = sdio_readsb(bus->host_sdio, buffer, offset, count); 321 break; 322 } 323 case sizeof(u32): { 324 SSB_WARN_ON(count & 3); 325 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ 326 error = sdio_readsb(bus->host_sdio, buffer, offset, count); 327 break; 328 } 329 default: 330 SSB_WARN_ON(1); 331 } 332 if (!error) 333 goto out; 334 335 err_out: 336 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 337 bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 338 out: 339 sdio_release_host(bus->host_sdio); 340 } 341 #endif /* CONFIG_SSB_BLOCKIO */ 342 343 static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val) 344 { 345 struct ssb_bus *bus = dev->bus; 346 int error = 0; 347 348 sdio_claim_host(bus->host_sdio); 349 if (unlikely(ssb_sdio_switch_core(bus, dev))) 350 goto out; 351 offset |= bus->sdio_sbaddr & 0xffff; 352 offset &= SBSDIO_SB_OFT_ADDR_MASK; 353 sdio_writeb(bus->host_sdio, val, offset, &error); 354 if (error) { 355 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n", 356 bus->sdio_sbaddr >> 16, offset, val, error); 357 } 358 out: 359 sdio_release_host(bus->host_sdio); 360 } 361 362 static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val) 363 { 364 struct ssb_bus *bus = dev->bus; 365 int error = 0; 366 367 sdio_claim_host(bus->host_sdio); 368 if (unlikely(ssb_sdio_switch_core(bus, dev))) 369 goto out; 370 offset |= bus->sdio_sbaddr & 0xffff; 371 offset &= SBSDIO_SB_OFT_ADDR_MASK; 372 sdio_writew(bus->host_sdio, val, offset, &error); 373 if (error) { 374 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n", 375 bus->sdio_sbaddr >> 16, offset, val, error); 376 } 377 out: 378 sdio_release_host(bus->host_sdio); 379 } 380 381 static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val) 382 { 383 struct ssb_bus *bus = dev->bus; 384 int error = 0; 385 386 sdio_claim_host(bus->host_sdio); 387 if (unlikely(ssb_sdio_switch_core(bus, dev))) 388 goto out; 389 offset |= bus->sdio_sbaddr & 0xffff; 390 offset &= SBSDIO_SB_OFT_ADDR_MASK; 391 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ 392 sdio_writel(bus->host_sdio, val, offset, &error); 393 if (error) { 394 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n", 395 bus->sdio_sbaddr >> 16, offset, val, error); 396 } 397 if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32) 398 sdio_readl(bus->host_sdio, 0, &error); 399 out: 400 sdio_release_host(bus->host_sdio); 401 } 402 403 #ifdef CONFIG_SSB_BLOCKIO 404 static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer, 405 size_t count, u16 offset, u8 reg_width) 406 { 407 size_t saved_count = count; 408 struct ssb_bus *bus = dev->bus; 409 int error = 0; 410 411 sdio_claim_host(bus->host_sdio); 412 if (unlikely(ssb_sdio_switch_core(bus, dev))) { 413 error = -EIO; 414 memset((void *)buffer, 0xff, count); 415 goto err_out; 416 } 417 offset |= bus->sdio_sbaddr & 0xffff; 418 offset &= SBSDIO_SB_OFT_ADDR_MASK; 419 420 switch (reg_width) { 421 case sizeof(u8): 422 error = sdio_writesb(bus->host_sdio, offset, 423 (void *)buffer, count); 424 break; 425 case sizeof(u16): 426 SSB_WARN_ON(count & 1); 427 error = sdio_writesb(bus->host_sdio, offset, 428 (void *)buffer, count); 429 break; 430 case sizeof(u32): 431 SSB_WARN_ON(count & 3); 432 offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */ 433 error = sdio_writesb(bus->host_sdio, offset, 434 (void *)buffer, count); 435 break; 436 default: 437 SSB_WARN_ON(1); 438 } 439 if (!error) 440 goto out; 441 442 err_out: 443 dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 444 bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 445 out: 446 sdio_release_host(bus->host_sdio); 447 } 448 449 #endif /* CONFIG_SSB_BLOCKIO */ 450 451 /* Not "static", as it's used in main.c */ 452 const struct ssb_bus_ops ssb_sdio_ops = { 453 .read8 = ssb_sdio_read8, 454 .read16 = ssb_sdio_read16, 455 .read32 = ssb_sdio_read32, 456 .write8 = ssb_sdio_write8, 457 .write16 = ssb_sdio_write16, 458 .write32 = ssb_sdio_write32, 459 #ifdef CONFIG_SSB_BLOCKIO 460 .block_read = ssb_sdio_block_read, 461 .block_write = ssb_sdio_block_write, 462 #endif 463 }; 464 465 #define GOTO_ERROR_ON(condition, description) do { \ 466 if (unlikely(condition)) { \ 467 error_description = description; \ 468 goto error; \ 469 } \ 470 } while (0) 471 472 int ssb_sdio_get_invariants(struct ssb_bus *bus, 473 struct ssb_init_invariants *iv) 474 { 475 struct ssb_sprom *sprom = &iv->sprom; 476 struct ssb_boardinfo *bi = &iv->boardinfo; 477 const char *error_description = "none"; 478 struct sdio_func_tuple *tuple; 479 void *mac; 480 481 memset(sprom, 0xFF, sizeof(*sprom)); 482 sprom->boardflags_lo = 0; 483 sprom->boardflags_hi = 0; 484 485 tuple = bus->host_sdio->tuples; 486 while (tuple) { 487 switch (tuple->code) { 488 case 0x22: /* extended function */ 489 switch (tuple->data[0]) { 490 case CISTPL_FUNCE_LAN_NODE_ID: 491 GOTO_ERROR_ON((tuple->size != 7) && 492 (tuple->data[1] != 6), 493 "mac tpl size"); 494 /* fetch the MAC address. */ 495 mac = tuple->data + 2; 496 memcpy(sprom->il0mac, mac, ETH_ALEN); 497 memcpy(sprom->et1mac, mac, ETH_ALEN); 498 break; 499 default: 500 break; 501 } 502 break; 503 case 0x80: /* vendor specific tuple */ 504 switch (tuple->data[0]) { 505 case SSB_SDIO_CIS_SROMREV: 506 GOTO_ERROR_ON(tuple->size != 2, 507 "sromrev tpl size"); 508 sprom->revision = tuple->data[1]; 509 break; 510 case SSB_SDIO_CIS_ID: 511 GOTO_ERROR_ON((tuple->size != 5) && 512 (tuple->size != 7), 513 "id tpl size"); 514 bi->vendor = tuple->data[1] | 515 (tuple->data[2]<<8); 516 break; 517 case SSB_SDIO_CIS_BOARDREV: 518 GOTO_ERROR_ON(tuple->size != 2, 519 "boardrev tpl size"); 520 sprom->board_rev = tuple->data[1]; 521 break; 522 case SSB_SDIO_CIS_PA: 523 GOTO_ERROR_ON((tuple->size != 9) && 524 (tuple->size != 10), 525 "pa tpl size"); 526 sprom->pa0b0 = tuple->data[1] | 527 ((u16)tuple->data[2] << 8); 528 sprom->pa0b1 = tuple->data[3] | 529 ((u16)tuple->data[4] << 8); 530 sprom->pa0b2 = tuple->data[5] | 531 ((u16)tuple->data[6] << 8); 532 sprom->itssi_a = tuple->data[7]; 533 sprom->itssi_bg = tuple->data[7]; 534 sprom->maxpwr_a = tuple->data[8]; 535 sprom->maxpwr_bg = tuple->data[8]; 536 break; 537 case SSB_SDIO_CIS_OEMNAME: 538 /* Not present */ 539 break; 540 case SSB_SDIO_CIS_CCODE: 541 GOTO_ERROR_ON(tuple->size != 2, 542 "ccode tpl size"); 543 sprom->country_code = tuple->data[1]; 544 break; 545 case SSB_SDIO_CIS_ANTENNA: 546 GOTO_ERROR_ON(tuple->size != 2, 547 "ant tpl size"); 548 sprom->ant_available_a = tuple->data[1]; 549 sprom->ant_available_bg = tuple->data[1]; 550 break; 551 case SSB_SDIO_CIS_ANTGAIN: 552 GOTO_ERROR_ON(tuple->size != 2, 553 "antg tpl size"); 554 sprom->antenna_gain.a0 = tuple->data[1]; 555 sprom->antenna_gain.a1 = tuple->data[1]; 556 sprom->antenna_gain.a2 = tuple->data[1]; 557 sprom->antenna_gain.a3 = tuple->data[1]; 558 break; 559 case SSB_SDIO_CIS_BFLAGS: 560 GOTO_ERROR_ON((tuple->size != 3) && 561 (tuple->size != 5), 562 "bfl tpl size"); 563 sprom->boardflags_lo = tuple->data[1] | 564 ((u16)tuple->data[2] << 8); 565 break; 566 case SSB_SDIO_CIS_LEDS: 567 GOTO_ERROR_ON(tuple->size != 5, 568 "leds tpl size"); 569 sprom->gpio0 = tuple->data[1]; 570 sprom->gpio1 = tuple->data[2]; 571 sprom->gpio2 = tuple->data[3]; 572 sprom->gpio3 = tuple->data[4]; 573 break; 574 default: 575 break; 576 } 577 break; 578 default: 579 break; 580 } 581 tuple = tuple->next; 582 } 583 584 return 0; 585 error: 586 dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n", 587 error_description); 588 return -ENODEV; 589 } 590 591 void ssb_sdio_exit(struct ssb_bus *bus) 592 { 593 if (bus->bustype != SSB_BUSTYPE_SDIO) 594 return; 595 /* Nothing to do here. */ 596 } 597 598 int ssb_sdio_init(struct ssb_bus *bus) 599 { 600 if (bus->bustype != SSB_BUSTYPE_SDIO) 601 return 0; 602 603 bus->sdio_sbaddr = ~0; 604 605 return 0; 606 } 607