1 /* 2 * Sonics Silicon Backplane 3 * PCMCIA-Hostbus related functions 4 * 5 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 6 * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de> 7 * 8 * Licensed under the GNU/GPL. See COPYING for details. 9 */ 10 11 #include <linux/ssb/ssb.h> 12 #include <linux/delay.h> 13 #include <linux/io.h> 14 #include <linux/etherdevice.h> 15 16 #include <pcmcia/cistpl.h> 17 #include <pcmcia/ciscode.h> 18 #include <pcmcia/ds.h> 19 #include <pcmcia/cisreg.h> 20 21 #include "ssb_private.h" 22 23 24 /* Define the following to 1 to enable a printk on each coreswitch. */ 25 #define SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 0 26 27 28 /* PCMCIA configuration registers */ 29 #define SSB_PCMCIA_ADDRESS0 0x2E 30 #define SSB_PCMCIA_ADDRESS1 0x30 31 #define SSB_PCMCIA_ADDRESS2 0x32 32 #define SSB_PCMCIA_MEMSEG 0x34 33 #define SSB_PCMCIA_SPROMCTL 0x36 34 #define SSB_PCMCIA_SPROMCTL_IDLE 0 35 #define SSB_PCMCIA_SPROMCTL_WRITE 1 36 #define SSB_PCMCIA_SPROMCTL_READ 2 37 #define SSB_PCMCIA_SPROMCTL_WRITEEN 4 38 #define SSB_PCMCIA_SPROMCTL_WRITEDIS 7 39 #define SSB_PCMCIA_SPROMCTL_DONE 8 40 #define SSB_PCMCIA_SPROM_DATALO 0x38 41 #define SSB_PCMCIA_SPROM_DATAHI 0x3A 42 #define SSB_PCMCIA_SPROM_ADDRLO 0x3C 43 #define SSB_PCMCIA_SPROM_ADDRHI 0x3E 44 45 /* Hardware invariants CIS tuples */ 46 #define SSB_PCMCIA_CIS 0x80 47 #define SSB_PCMCIA_CIS_ID 0x01 48 #define SSB_PCMCIA_CIS_BOARDREV 0x02 49 #define SSB_PCMCIA_CIS_PA 0x03 50 #define SSB_PCMCIA_CIS_PA_PA0B0_LO 0 51 #define SSB_PCMCIA_CIS_PA_PA0B0_HI 1 52 #define SSB_PCMCIA_CIS_PA_PA0B1_LO 2 53 #define SSB_PCMCIA_CIS_PA_PA0B1_HI 3 54 #define SSB_PCMCIA_CIS_PA_PA0B2_LO 4 55 #define SSB_PCMCIA_CIS_PA_PA0B2_HI 5 56 #define SSB_PCMCIA_CIS_PA_ITSSI 6 57 #define SSB_PCMCIA_CIS_PA_MAXPOW 7 58 #define SSB_PCMCIA_CIS_OEMNAME 0x04 59 #define SSB_PCMCIA_CIS_CCODE 0x05 60 #define SSB_PCMCIA_CIS_ANTENNA 0x06 61 #define SSB_PCMCIA_CIS_ANTGAIN 0x07 62 #define SSB_PCMCIA_CIS_BFLAGS 0x08 63 #define SSB_PCMCIA_CIS_LEDS 0x09 64 65 /* PCMCIA SPROM size. */ 66 #define SSB_PCMCIA_SPROM_SIZE 256 67 #define SSB_PCMCIA_SPROM_SIZE_BYTES (SSB_PCMCIA_SPROM_SIZE * sizeof(u16)) 68 69 70 /* Write to a PCMCIA configuration register. */ 71 static int ssb_pcmcia_cfg_write(struct ssb_bus *bus, u8 offset, u8 value) 72 { 73 int res; 74 75 res = pcmcia_write_config_byte(bus->host_pcmcia, offset, value); 76 if (unlikely(res != 0)) 77 return -EBUSY; 78 79 return 0; 80 } 81 82 /* Read from a PCMCIA configuration register. */ 83 static int ssb_pcmcia_cfg_read(struct ssb_bus *bus, u8 offset, u8 *value) 84 { 85 int res; 86 87 res = pcmcia_read_config_byte(bus->host_pcmcia, offset, value); 88 if (unlikely(res != 0)) 89 return -EBUSY; 90 91 return 0; 92 } 93 94 int ssb_pcmcia_switch_coreidx(struct ssb_bus *bus, 95 u8 coreidx) 96 { 97 int err; 98 int attempts = 0; 99 u32 cur_core; 100 u32 addr; 101 u32 read_addr; 102 u8 val; 103 104 addr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 105 while (1) { 106 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS0, 107 (addr & 0x0000F000) >> 12); 108 if (err) 109 goto error; 110 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS1, 111 (addr & 0x00FF0000) >> 16); 112 if (err) 113 goto error; 114 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_ADDRESS2, 115 (addr & 0xFF000000) >> 24); 116 if (err) 117 goto error; 118 119 read_addr = 0; 120 121 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS0, &val); 122 if (err) 123 goto error; 124 read_addr |= ((u32)(val & 0x0F)) << 12; 125 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS1, &val); 126 if (err) 127 goto error; 128 read_addr |= ((u32)val) << 16; 129 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_ADDRESS2, &val); 130 if (err) 131 goto error; 132 read_addr |= ((u32)val) << 24; 133 134 cur_core = (read_addr - SSB_ENUM_BASE) / SSB_CORE_SIZE; 135 if (cur_core == coreidx) 136 break; 137 138 err = -ETIMEDOUT; 139 if (attempts++ > SSB_BAR0_MAX_RETRIES) 140 goto error; 141 udelay(10); 142 } 143 144 return 0; 145 error: 146 ssb_printk(KERN_ERR PFX "Failed to switch to core %u\n", coreidx); 147 return err; 148 } 149 150 int ssb_pcmcia_switch_core(struct ssb_bus *bus, 151 struct ssb_device *dev) 152 { 153 int err; 154 155 #if SSB_VERBOSE_PCMCIACORESWITCH_DEBUG 156 ssb_printk(KERN_INFO PFX 157 "Switching to %s core, index %d\n", 158 ssb_core_name(dev->id.coreid), 159 dev->core_index); 160 #endif 161 162 err = ssb_pcmcia_switch_coreidx(bus, dev->core_index); 163 if (!err) 164 bus->mapped_device = dev; 165 166 return err; 167 } 168 169 int ssb_pcmcia_switch_segment(struct ssb_bus *bus, u8 seg) 170 { 171 int attempts = 0; 172 int err; 173 u8 val; 174 175 SSB_WARN_ON((seg != 0) && (seg != 1)); 176 while (1) { 177 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_MEMSEG, seg); 178 if (err) 179 goto error; 180 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_MEMSEG, &val); 181 if (err) 182 goto error; 183 if (val == seg) 184 break; 185 186 err = -ETIMEDOUT; 187 if (unlikely(attempts++ > SSB_BAR0_MAX_RETRIES)) 188 goto error; 189 udelay(10); 190 } 191 bus->mapped_pcmcia_seg = seg; 192 193 return 0; 194 error: 195 ssb_printk(KERN_ERR PFX "Failed to switch pcmcia segment\n"); 196 return err; 197 } 198 199 static int select_core_and_segment(struct ssb_device *dev, 200 u16 *offset) 201 { 202 struct ssb_bus *bus = dev->bus; 203 int err; 204 u8 need_segment; 205 206 if (*offset >= 0x800) { 207 *offset -= 0x800; 208 need_segment = 1; 209 } else 210 need_segment = 0; 211 212 if (unlikely(dev != bus->mapped_device)) { 213 err = ssb_pcmcia_switch_core(bus, dev); 214 if (unlikely(err)) 215 return err; 216 } 217 if (unlikely(need_segment != bus->mapped_pcmcia_seg)) { 218 err = ssb_pcmcia_switch_segment(bus, need_segment); 219 if (unlikely(err)) 220 return err; 221 } 222 223 return 0; 224 } 225 226 static u8 ssb_pcmcia_read8(struct ssb_device *dev, u16 offset) 227 { 228 struct ssb_bus *bus = dev->bus; 229 unsigned long flags; 230 int err; 231 u8 value = 0xFF; 232 233 spin_lock_irqsave(&bus->bar_lock, flags); 234 err = select_core_and_segment(dev, &offset); 235 if (likely(!err)) 236 value = readb(bus->mmio + offset); 237 spin_unlock_irqrestore(&bus->bar_lock, flags); 238 239 return value; 240 } 241 242 static u16 ssb_pcmcia_read16(struct ssb_device *dev, u16 offset) 243 { 244 struct ssb_bus *bus = dev->bus; 245 unsigned long flags; 246 int err; 247 u16 value = 0xFFFF; 248 249 spin_lock_irqsave(&bus->bar_lock, flags); 250 err = select_core_and_segment(dev, &offset); 251 if (likely(!err)) 252 value = readw(bus->mmio + offset); 253 spin_unlock_irqrestore(&bus->bar_lock, flags); 254 255 return value; 256 } 257 258 static u32 ssb_pcmcia_read32(struct ssb_device *dev, u16 offset) 259 { 260 struct ssb_bus *bus = dev->bus; 261 unsigned long flags; 262 int err; 263 u32 lo = 0xFFFFFFFF, hi = 0xFFFFFFFF; 264 265 spin_lock_irqsave(&bus->bar_lock, flags); 266 err = select_core_and_segment(dev, &offset); 267 if (likely(!err)) { 268 lo = readw(bus->mmio + offset); 269 hi = readw(bus->mmio + offset + 2); 270 } 271 spin_unlock_irqrestore(&bus->bar_lock, flags); 272 273 return (lo | (hi << 16)); 274 } 275 276 #ifdef CONFIG_SSB_BLOCKIO 277 static void ssb_pcmcia_block_read(struct ssb_device *dev, void *buffer, 278 size_t count, u16 offset, u8 reg_width) 279 { 280 struct ssb_bus *bus = dev->bus; 281 unsigned long flags; 282 void __iomem *addr = bus->mmio + offset; 283 int err; 284 285 spin_lock_irqsave(&bus->bar_lock, flags); 286 err = select_core_and_segment(dev, &offset); 287 if (unlikely(err)) { 288 memset(buffer, 0xFF, count); 289 goto unlock; 290 } 291 switch (reg_width) { 292 case sizeof(u8): { 293 u8 *buf = buffer; 294 295 while (count) { 296 *buf = __raw_readb(addr); 297 buf++; 298 count--; 299 } 300 break; 301 } 302 case sizeof(u16): { 303 __le16 *buf = buffer; 304 305 SSB_WARN_ON(count & 1); 306 while (count) { 307 *buf = (__force __le16)__raw_readw(addr); 308 buf++; 309 count -= 2; 310 } 311 break; 312 } 313 case sizeof(u32): { 314 __le16 *buf = buffer; 315 316 SSB_WARN_ON(count & 3); 317 while (count) { 318 *buf = (__force __le16)__raw_readw(addr); 319 buf++; 320 *buf = (__force __le16)__raw_readw(addr + 2); 321 buf++; 322 count -= 4; 323 } 324 break; 325 } 326 default: 327 SSB_WARN_ON(1); 328 } 329 unlock: 330 spin_unlock_irqrestore(&bus->bar_lock, flags); 331 } 332 #endif /* CONFIG_SSB_BLOCKIO */ 333 334 static void ssb_pcmcia_write8(struct ssb_device *dev, u16 offset, u8 value) 335 { 336 struct ssb_bus *bus = dev->bus; 337 unsigned long flags; 338 int err; 339 340 spin_lock_irqsave(&bus->bar_lock, flags); 341 err = select_core_and_segment(dev, &offset); 342 if (likely(!err)) 343 writeb(value, bus->mmio + offset); 344 mmiowb(); 345 spin_unlock_irqrestore(&bus->bar_lock, flags); 346 } 347 348 static void ssb_pcmcia_write16(struct ssb_device *dev, u16 offset, u16 value) 349 { 350 struct ssb_bus *bus = dev->bus; 351 unsigned long flags; 352 int err; 353 354 spin_lock_irqsave(&bus->bar_lock, flags); 355 err = select_core_and_segment(dev, &offset); 356 if (likely(!err)) 357 writew(value, bus->mmio + offset); 358 mmiowb(); 359 spin_unlock_irqrestore(&bus->bar_lock, flags); 360 } 361 362 static void ssb_pcmcia_write32(struct ssb_device *dev, u16 offset, u32 value) 363 { 364 struct ssb_bus *bus = dev->bus; 365 unsigned long flags; 366 int err; 367 368 spin_lock_irqsave(&bus->bar_lock, flags); 369 err = select_core_and_segment(dev, &offset); 370 if (likely(!err)) { 371 writew((value & 0x0000FFFF), bus->mmio + offset); 372 writew(((value & 0xFFFF0000) >> 16), bus->mmio + offset + 2); 373 } 374 mmiowb(); 375 spin_unlock_irqrestore(&bus->bar_lock, flags); 376 } 377 378 #ifdef CONFIG_SSB_BLOCKIO 379 static void ssb_pcmcia_block_write(struct ssb_device *dev, const void *buffer, 380 size_t count, u16 offset, u8 reg_width) 381 { 382 struct ssb_bus *bus = dev->bus; 383 unsigned long flags; 384 void __iomem *addr = bus->mmio + offset; 385 int err; 386 387 spin_lock_irqsave(&bus->bar_lock, flags); 388 err = select_core_and_segment(dev, &offset); 389 if (unlikely(err)) 390 goto unlock; 391 switch (reg_width) { 392 case sizeof(u8): { 393 const u8 *buf = buffer; 394 395 while (count) { 396 __raw_writeb(*buf, addr); 397 buf++; 398 count--; 399 } 400 break; 401 } 402 case sizeof(u16): { 403 const __le16 *buf = buffer; 404 405 SSB_WARN_ON(count & 1); 406 while (count) { 407 __raw_writew((__force u16)(*buf), addr); 408 buf++; 409 count -= 2; 410 } 411 break; 412 } 413 case sizeof(u32): { 414 const __le16 *buf = buffer; 415 416 SSB_WARN_ON(count & 3); 417 while (count) { 418 __raw_writew((__force u16)(*buf), addr); 419 buf++; 420 __raw_writew((__force u16)(*buf), addr + 2); 421 buf++; 422 count -= 4; 423 } 424 break; 425 } 426 default: 427 SSB_WARN_ON(1); 428 } 429 unlock: 430 mmiowb(); 431 spin_unlock_irqrestore(&bus->bar_lock, flags); 432 } 433 #endif /* CONFIG_SSB_BLOCKIO */ 434 435 /* Not "static", as it's used in main.c */ 436 const struct ssb_bus_ops ssb_pcmcia_ops = { 437 .read8 = ssb_pcmcia_read8, 438 .read16 = ssb_pcmcia_read16, 439 .read32 = ssb_pcmcia_read32, 440 .write8 = ssb_pcmcia_write8, 441 .write16 = ssb_pcmcia_write16, 442 .write32 = ssb_pcmcia_write32, 443 #ifdef CONFIG_SSB_BLOCKIO 444 .block_read = ssb_pcmcia_block_read, 445 .block_write = ssb_pcmcia_block_write, 446 #endif 447 }; 448 449 static int ssb_pcmcia_sprom_command(struct ssb_bus *bus, u8 command) 450 { 451 unsigned int i; 452 int err; 453 u8 value; 454 455 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROMCTL, command); 456 if (err) 457 return err; 458 for (i = 0; i < 1000; i++) { 459 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROMCTL, &value); 460 if (err) 461 return err; 462 if (value & SSB_PCMCIA_SPROMCTL_DONE) 463 return 0; 464 udelay(10); 465 } 466 467 return -ETIMEDOUT; 468 } 469 470 /* offset is the 16bit word offset */ 471 static int ssb_pcmcia_sprom_read(struct ssb_bus *bus, u16 offset, u16 *value) 472 { 473 int err; 474 u8 lo, hi; 475 476 offset *= 2; /* Make byte offset */ 477 478 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO, 479 (offset & 0x00FF)); 480 if (err) 481 return err; 482 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI, 483 (offset & 0xFF00) >> 8); 484 if (err) 485 return err; 486 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_READ); 487 if (err) 488 return err; 489 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATALO, &lo); 490 if (err) 491 return err; 492 err = ssb_pcmcia_cfg_read(bus, SSB_PCMCIA_SPROM_DATAHI, &hi); 493 if (err) 494 return err; 495 *value = (lo | (((u16)hi) << 8)); 496 497 return 0; 498 } 499 500 /* offset is the 16bit word offset */ 501 static int ssb_pcmcia_sprom_write(struct ssb_bus *bus, u16 offset, u16 value) 502 { 503 int err; 504 505 offset *= 2; /* Make byte offset */ 506 507 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRLO, 508 (offset & 0x00FF)); 509 if (err) 510 return err; 511 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_ADDRHI, 512 (offset & 0xFF00) >> 8); 513 if (err) 514 return err; 515 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATALO, 516 (value & 0x00FF)); 517 if (err) 518 return err; 519 err = ssb_pcmcia_cfg_write(bus, SSB_PCMCIA_SPROM_DATAHI, 520 (value & 0xFF00) >> 8); 521 if (err) 522 return err; 523 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITE); 524 if (err) 525 return err; 526 msleep(20); 527 528 return 0; 529 } 530 531 /* Read the SPROM image. bufsize is in 16bit words. */ 532 static int ssb_pcmcia_sprom_read_all(struct ssb_bus *bus, u16 *sprom) 533 { 534 int err, i; 535 536 for (i = 0; i < SSB_PCMCIA_SPROM_SIZE; i++) { 537 err = ssb_pcmcia_sprom_read(bus, i, &sprom[i]); 538 if (err) 539 return err; 540 } 541 542 return 0; 543 } 544 545 /* Write the SPROM image. size is in 16bit words. */ 546 static int ssb_pcmcia_sprom_write_all(struct ssb_bus *bus, const u16 *sprom) 547 { 548 int i, err; 549 bool failed = 0; 550 size_t size = SSB_PCMCIA_SPROM_SIZE; 551 552 ssb_printk(KERN_NOTICE PFX 553 "Writing SPROM. Do NOT turn off the power! " 554 "Please stand by...\n"); 555 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEEN); 556 if (err) { 557 ssb_printk(KERN_NOTICE PFX 558 "Could not enable SPROM write access.\n"); 559 return -EBUSY; 560 } 561 ssb_printk(KERN_NOTICE PFX "[ 0%%"); 562 msleep(500); 563 for (i = 0; i < size; i++) { 564 if (i == size / 4) 565 ssb_printk("25%%"); 566 else if (i == size / 2) 567 ssb_printk("50%%"); 568 else if (i == (size * 3) / 4) 569 ssb_printk("75%%"); 570 else if (i % 2) 571 ssb_printk("."); 572 err = ssb_pcmcia_sprom_write(bus, i, sprom[i]); 573 if (err) { 574 ssb_printk(KERN_NOTICE PFX 575 "Failed to write to SPROM.\n"); 576 failed = 1; 577 break; 578 } 579 } 580 err = ssb_pcmcia_sprom_command(bus, SSB_PCMCIA_SPROMCTL_WRITEDIS); 581 if (err) { 582 ssb_printk(KERN_NOTICE PFX 583 "Could not disable SPROM write access.\n"); 584 failed = 1; 585 } 586 msleep(500); 587 if (!failed) { 588 ssb_printk("100%% ]\n"); 589 ssb_printk(KERN_NOTICE PFX "SPROM written.\n"); 590 } 591 592 return failed ? -EBUSY : 0; 593 } 594 595 static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size) 596 { 597 //TODO 598 return 0; 599 } 600 601 #define GOTO_ERROR_ON(condition, description) do { \ 602 if (unlikely(condition)) { \ 603 error_description = description; \ 604 goto error; \ 605 } \ 606 } while (0) 607 608 static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev, 609 tuple_t *tuple, 610 void *priv) 611 { 612 struct ssb_sprom *sprom = priv; 613 614 if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID) 615 return -EINVAL; 616 if (tuple->TupleDataLen != ETH_ALEN + 2) 617 return -EINVAL; 618 if (tuple->TupleData[1] != ETH_ALEN) 619 return -EINVAL; 620 memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN); 621 return 0; 622 }; 623 624 static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev, 625 tuple_t *tuple, 626 void *priv) 627 { 628 struct ssb_init_invariants *iv = priv; 629 struct ssb_sprom *sprom = &iv->sprom; 630 struct ssb_boardinfo *bi = &iv->boardinfo; 631 const char *error_description; 632 633 GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1"); 634 switch (tuple->TupleData[0]) { 635 case SSB_PCMCIA_CIS_ID: 636 GOTO_ERROR_ON((tuple->TupleDataLen != 5) && 637 (tuple->TupleDataLen != 7), 638 "id tpl size"); 639 bi->vendor = tuple->TupleData[1] | 640 ((u16)tuple->TupleData[2] << 8); 641 break; 642 case SSB_PCMCIA_CIS_BOARDREV: 643 GOTO_ERROR_ON(tuple->TupleDataLen != 2, 644 "boardrev tpl size"); 645 sprom->board_rev = tuple->TupleData[1]; 646 break; 647 case SSB_PCMCIA_CIS_PA: 648 GOTO_ERROR_ON((tuple->TupleDataLen != 9) && 649 (tuple->TupleDataLen != 10), 650 "pa tpl size"); 651 sprom->pa0b0 = tuple->TupleData[1] | 652 ((u16)tuple->TupleData[2] << 8); 653 sprom->pa0b1 = tuple->TupleData[3] | 654 ((u16)tuple->TupleData[4] << 8); 655 sprom->pa0b2 = tuple->TupleData[5] | 656 ((u16)tuple->TupleData[6] << 8); 657 sprom->itssi_a = tuple->TupleData[7]; 658 sprom->itssi_bg = tuple->TupleData[7]; 659 sprom->maxpwr_a = tuple->TupleData[8]; 660 sprom->maxpwr_bg = tuple->TupleData[8]; 661 break; 662 case SSB_PCMCIA_CIS_OEMNAME: 663 /* We ignore this. */ 664 break; 665 case SSB_PCMCIA_CIS_CCODE: 666 GOTO_ERROR_ON(tuple->TupleDataLen != 2, 667 "ccode tpl size"); 668 sprom->country_code = tuple->TupleData[1]; 669 break; 670 case SSB_PCMCIA_CIS_ANTENNA: 671 GOTO_ERROR_ON(tuple->TupleDataLen != 2, 672 "ant tpl size"); 673 sprom->ant_available_a = tuple->TupleData[1]; 674 sprom->ant_available_bg = tuple->TupleData[1]; 675 break; 676 case SSB_PCMCIA_CIS_ANTGAIN: 677 GOTO_ERROR_ON(tuple->TupleDataLen != 2, 678 "antg tpl size"); 679 sprom->antenna_gain.ghz24.a0 = tuple->TupleData[1]; 680 sprom->antenna_gain.ghz24.a1 = tuple->TupleData[1]; 681 sprom->antenna_gain.ghz24.a2 = tuple->TupleData[1]; 682 sprom->antenna_gain.ghz24.a3 = tuple->TupleData[1]; 683 sprom->antenna_gain.ghz5.a0 = tuple->TupleData[1]; 684 sprom->antenna_gain.ghz5.a1 = tuple->TupleData[1]; 685 sprom->antenna_gain.ghz5.a2 = tuple->TupleData[1]; 686 sprom->antenna_gain.ghz5.a3 = tuple->TupleData[1]; 687 break; 688 case SSB_PCMCIA_CIS_BFLAGS: 689 GOTO_ERROR_ON((tuple->TupleDataLen != 3) && 690 (tuple->TupleDataLen != 5), 691 "bfl tpl size"); 692 sprom->boardflags_lo = tuple->TupleData[1] | 693 ((u16)tuple->TupleData[2] << 8); 694 break; 695 case SSB_PCMCIA_CIS_LEDS: 696 GOTO_ERROR_ON(tuple->TupleDataLen != 5, 697 "leds tpl size"); 698 sprom->gpio0 = tuple->TupleData[1]; 699 sprom->gpio1 = tuple->TupleData[2]; 700 sprom->gpio2 = tuple->TupleData[3]; 701 sprom->gpio3 = tuple->TupleData[4]; 702 break; 703 } 704 return -ENOSPC; /* continue with next entry */ 705 706 error: 707 ssb_printk(KERN_ERR PFX 708 "PCMCIA: Failed to fetch device invariants: %s\n", 709 error_description); 710 return -ENODEV; 711 } 712 713 714 int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 715 struct ssb_init_invariants *iv) 716 { 717 struct ssb_sprom *sprom = &iv->sprom; 718 int res; 719 720 memset(sprom, 0xFF, sizeof(*sprom)); 721 sprom->revision = 1; 722 sprom->boardflags_lo = 0; 723 sprom->boardflags_hi = 0; 724 725 /* First fetch the MAC address. */ 726 res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE, 727 ssb_pcmcia_get_mac, sprom); 728 if (res != 0) { 729 ssb_printk(KERN_ERR PFX 730 "PCMCIA: Failed to fetch MAC address\n"); 731 return -ENODEV; 732 } 733 734 /* Fetch the vendor specific tuples. */ 735 res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, 736 ssb_pcmcia_do_get_invariants, iv); 737 if ((res == 0) || (res == -ENOSPC)) 738 return 0; 739 740 ssb_printk(KERN_ERR PFX 741 "PCMCIA: Failed to fetch device invariants\n"); 742 return -ENODEV; 743 } 744 745 static ssize_t ssb_pcmcia_attr_sprom_show(struct device *pcmciadev, 746 struct device_attribute *attr, 747 char *buf) 748 { 749 struct pcmcia_device *pdev = 750 container_of(pcmciadev, struct pcmcia_device, dev); 751 struct ssb_bus *bus; 752 753 bus = ssb_pcmcia_dev_to_bus(pdev); 754 if (!bus) 755 return -ENODEV; 756 757 return ssb_attr_sprom_show(bus, buf, 758 ssb_pcmcia_sprom_read_all); 759 } 760 761 static ssize_t ssb_pcmcia_attr_sprom_store(struct device *pcmciadev, 762 struct device_attribute *attr, 763 const char *buf, size_t count) 764 { 765 struct pcmcia_device *pdev = 766 container_of(pcmciadev, struct pcmcia_device, dev); 767 struct ssb_bus *bus; 768 769 bus = ssb_pcmcia_dev_to_bus(pdev); 770 if (!bus) 771 return -ENODEV; 772 773 return ssb_attr_sprom_store(bus, buf, count, 774 ssb_pcmcia_sprom_check_crc, 775 ssb_pcmcia_sprom_write_all); 776 } 777 778 static DEVICE_ATTR(ssb_sprom, 0600, 779 ssb_pcmcia_attr_sprom_show, 780 ssb_pcmcia_attr_sprom_store); 781 782 static int ssb_pcmcia_cor_setup(struct ssb_bus *bus, u8 cor) 783 { 784 u8 val; 785 int err; 786 787 err = ssb_pcmcia_cfg_read(bus, cor, &val); 788 if (err) 789 return err; 790 val &= ~COR_SOFT_RESET; 791 val |= COR_FUNC_ENA | COR_IREQ_ENA | COR_LEVEL_REQ; 792 err = ssb_pcmcia_cfg_write(bus, cor, val); 793 if (err) 794 return err; 795 msleep(40); 796 797 return 0; 798 } 799 800 /* Initialize the PCMCIA hardware. This is called on Init and Resume. */ 801 int ssb_pcmcia_hardware_setup(struct ssb_bus *bus) 802 { 803 int err; 804 805 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 806 return 0; 807 808 /* Switch segment to a known state and sync 809 * bus->mapped_pcmcia_seg with hardware state. */ 810 ssb_pcmcia_switch_segment(bus, 0); 811 /* Init the COR register. */ 812 err = ssb_pcmcia_cor_setup(bus, CISREG_COR); 813 if (err) 814 return err; 815 /* Some cards also need this register to get poked. */ 816 err = ssb_pcmcia_cor_setup(bus, CISREG_COR + 0x80); 817 if (err) 818 return err; 819 820 return 0; 821 } 822 823 void ssb_pcmcia_exit(struct ssb_bus *bus) 824 { 825 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 826 return; 827 828 device_remove_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom); 829 } 830 831 int ssb_pcmcia_init(struct ssb_bus *bus) 832 { 833 int err; 834 835 if (bus->bustype != SSB_BUSTYPE_PCMCIA) 836 return 0; 837 838 err = ssb_pcmcia_hardware_setup(bus); 839 if (err) 840 goto error; 841 842 bus->sprom_size = SSB_PCMCIA_SPROM_SIZE; 843 mutex_init(&bus->sprom_mutex); 844 err = device_create_file(&bus->host_pcmcia->dev, &dev_attr_ssb_sprom); 845 if (err) 846 goto error; 847 848 return 0; 849 error: 850 ssb_printk(KERN_ERR PFX "Failed to initialize PCMCIA host device\n"); 851 return err; 852 } 853